stdlib: implement new print() API

rdar://20775683

Swift SVN r28309

Author: gribozavr

docs/Arrays.rst

@@ -98,7 +98,7 @@ copies of that array::
   var a = [1, 2, 3]
   let b = a
   a[1] = 42
-  println(b[1]) // prints "42"
+  print(b[1]) // prints "42"
 
 This implies that the elments of an array are notionally not part of
 the array's value, and indeed subscript assignment is a non-mutating
@@ -125,7 +125,7 @@ array to ensure unique ownership before mutating it::
   var a = [1, 2, 3]
   let b = a
   a[1] = 42
-  println(b[1]) // prints "42"
+  print(b[1]) // prints "42"
 
 Shared Subscript Assignment and ``NSArray``
 -------------------------------------------

docs/LangRef.html

@@ -323,7 +323,7 @@ <h4 id="func-signature">Function signatures</h4>
     func accuseSuspect(suspect:PersonOfInterest)
         inRoom(room:Room)
         withWeapon(weapon:Weapon) {
-      println("It was \(suspect) in the \(room) with the \(weapon)")
+      print("It was \(suspect) in the \(room) with the \(weapon)")
     }
 
     <i>// Calling a selector-style function.</i>
@@ -816,14 +816,14 @@ <h4 id="attribute-inout"><tt>inout</tt> Attribute</h4>
     var x = 219
     var f = foo(&x)
     // x is updated to the value of foo's local x at function exit.
-    println("global x = \(x)")
+    print("global x = \(x)")
     // These calls only update the captured local 'x', which is now independent
     // of the inout parameter.
-    println("local x = \(f())")
-    println("local x = \(f())")
-    println("local x = \(f())")
+    print("local x = \(f())")
+    print("local x = \(f())")
+    print("local x = \(f())")
 
-    println("global x = \(x)")
+    print("global x = \(x)")
   </pre>
 
   will print:
@@ -1581,7 +1581,7 @@ <h4 id="expr-ternary">Ternary operator</h4>
     x += a ? b ? y : z : w
 
     for i in 1...101 {
-      println(i % 15      ? "fizzbuzz"
+      print(i % 15      ? "fizzbuzz"
             : i %  3 == 0 ? "fizz"
             : i %  5 == 0 ? "buzz"
             : "\(i)")
@@ -1731,7 +1731,7 @@ <h3 id="expr-literal">Literals</h3>
     func log(message:String,
              file:String = __FILE__,
              line:Int = __LINE__) {
-      println("\(file):\(line): \(message)")
+      print("\(file):\(line): \(message)")
     }
 
     log("Orders received")
@@ -1807,7 +1807,7 @@ <h4 id="expr-generic-disambiguation">Generic disambiguation</h4>
     infix func +-+ &lt;T, U&gt;(t:T.Type, u:U.Type) -&gt; Foo { }
 
     var foo = (Dict&lt;String, Int&gt;) +-+ (Array&lt;UnicodeScalar&gt;)
-    println(foo)
+    print(foo)
   </pre>
 
   <p>On the other hand, some expressions involving <tt>&lt;</tt> and
@@ -2495,7 +2495,7 @@ <h3 id="stmt-for-each">'for-each' Statement</h3>
 
   <pre class="example">
     for i in 0...100 {
-      println(String(i));
+      print(String(i));
     }
  </pre>
 

docs/LangRefNew.rst

@@ -908,7 +908,7 @@ of the parameter is the ``set-name``, if provided, or ``value`` otherwise.
   var vec = BitVector64()
   vec[2] = true
   if vec[3] {
-    println("third bit is set")
+    print("third bit is set")
   }
 
 .. _langref.decl.attribute_list:
@@ -977,21 +977,21 @@ of :ref:`switch statements <langref.stmt.switch>`.  Some examples::
     // Extract the elements of the "point" tuple and bind them to
     // variables x, y, and z.
     var (x, y, z) = point
-    println("x=\(x) y=\(y) z=\(z)")
+    print("x=\(x) y=\(y) z=\(z)")
 
     // Dispatch on the elements of a tuple in a "switch" statement.
     switch point {
     case (0, 0, 0):
-      println("origin")
+      print("origin")
     // The pattern "_" matches any value.
     case (_, 0, 0):
-      println("on the x axis")
+      print("on the x axis")
     case (0, _, 0):
-      println("on the y axis")
+      print("on the y axis")
     case (0, 0, _):
-      println("on the z axis")
+      print("on the z axis")
     case (var x, var y, var z):
-      println("x=\(x) y=\(y) z=\(z)")
+      print("x=\(x) y=\(y) z=\(z)")
     }
 
 
@@ -1061,13 +1061,13 @@ bindings are immutable.
     switch point {
     // Bind x, y, z to the elements of point.
     case (var x, var y, var z):
-      println("x=\(x) y=\(y) z=\(z)")
+      print("x=\(x) y=\(y) z=\(z)")
     }
 
     switch point {
     // Same. 'var' distributes to the identifiers in its subpattern.
     case var (x, y, z):
-      println("x=\(x) y=\(y) z=\(z)")
+      print("x=\(x) y=\(y) z=\(z)")
     }
 
 Outside of a <tt>var</tt> pattern, an identifier behaves as an :ref:`expression
@@ -1080,9 +1080,9 @@ pattern <langref.pattern.expr>` referencing an existing definition.
     // x and z are bound as new variables.
     // zero is a reference to the existing 'zero' variable.
     case (var x, zero, var z):
-      println("point off the y axis: x=\(x) z=\(z)")
+      print("point off the y axis: x=\(x) z=\(z)")
     default:
-      println("on the y axis")
+      print("on the y axis")
     }
 
 The left-hand pattern of a :ref:`var declaration <langref.decl.var>` and the
@@ -1151,11 +1151,11 @@ appear in declarations.
   for b in bs {
     switch b {
     case is B:
-      println("B")
+      print("B")
     case is D1:
-      println("D1")
+      print("D1")
     case is D2:
-      println("D2")
+      print("D2")
     }
   }
 
@@ -1183,11 +1183,11 @@ type, the value of that type can be matched against an optional subpattern.
 
   switch tag {
   case .BR:
-    println("<br>")
+    print("<br>")
   case .IMG(var src, var alt):
-    println("<img src=\"\(escape(src))\" alt=\"\(escape(alt))\">")
+    print("<img src=\"\(escape(src))\" alt=\"\(escape(alt))\">")
   case .A(var href):
-    println("<a href=\"\(escape(href))\">")
+    print("<a href=\"\(escape(href))\">")
   }
 
 Enum element patterns are refutable and thus cannot appear in declarations.
@@ -1213,12 +1213,12 @@ operator may be overloaded like any function.
   switch point {
   // Equality comparison.
   case (0, 0, 0):
-    println("origin")
+    print("origin")
   // Range comparison.
   case (-10...10, -10...10, -10...10):
-    println("close to the origin")
+    print("close to the origin")
   default:
-    println("too far away")
+    print("too far away")
   }
 
   // Define pattern matching of an integer value to a string expression.
@@ -1229,9 +1229,9 @@ operator may be overloaded like any function.
   // Now we can pattern-match strings to integers:
   switch point {
   case ("0", "0", "0"):
-    println("origin")
+    print("origin")
   default:
-    println("not the origin")
+    print("not the origin")
   }
 
 The order of evaluation of expressions in patterns, including whether an
@@ -1347,22 +1347,22 @@ otherwise empty cases in switch statements.
   func classifyPoint(point: (Int, Int)) {
     switch point {
     case (0, 0):
-      println("origin")
+      print("origin")
 
     case (_, 0):
-      println("on the x axis")
+      print("on the x axis")
 
     case (0, _):
-      println("on the y axis")
+      print("on the y axis")
 
     case (var x, var y) where x == y:
-      println("on the y = x diagonal")
+      print("on the y = x diagonal")
 
     case (var x, var y) where -x == y:
-      println("on the y = -x diagonal")
+      print("on the y = -x diagonal")
 
     case (var x, var y):
-      println("length \(sqrt(x*x + y*y))")
+      print("length \(sqrt(x*x + y*y))")
     }
   }
 

docs/SequencesAndCollections.rst

@@ -174,7 +174,7 @@ end.  For example::
   }
 
   let s = String(array("Swift", withSeparator: "|"))
-  println(s)        // "S|w|i|f|t"
+  print(s)        // "S|w|i|f|t"
 
 Because sequences may be volatile, though, you can—in general—only
 make a single traversal.  This capability is quite enough for many

docs/StoredAndComputedVariables.rst

@@ -215,7 +215,7 @@ A computed variable may also be overridden with another computed variable::
         }
       }
       set {
-        println("Sorry, we choose our own colors here.")
+        print("Sorry, we choose our own colors here.")
       }
     }
   }
@@ -231,7 +231,7 @@ A subclass may override the superclass's variable with a new computed variable::
   class ColorBase {
     var color : Color {
       didSet {
-        println("I've been painted \(color)!")
+        print("I've been painted \(color)!")
       }
     }
   }

docs/StringDesign.rst

@@ -350,18 +350,18 @@ end, strings support properties for more-specific segmentations:
           has some advice for us.
 
 .. parsed-literal::
-   |swift| for c in s { println("Extended Grapheme Cluster: \(c)") }
+   |swift| for c in s { print("Extended Grapheme Cluster: \(c)") }
    `Extended Grapheme Cluster: f`
    `Extended Grapheme Cluster: o`
    `Extended Grapheme Cluster: o`
    |swift| for c in s.collationCharacters { 
-             println("Collation Grapheme Cluster: \(c)")
+             print("Collation Grapheme Cluster: \(c)")
            }
    `Collation Grapheme Cluster: f`
    `Collation Grapheme Cluster: o`
    `Collation Grapheme Cluster: o`
    |swift| for c in s.searchCharacters { 
-             println("Search Grapheme Cluster: \(c)")
+             print("Search Grapheme Cluster: \(c)")
            }
    `Search Grapheme Cluster: f`
    `Search Grapheme Cluster: o`
@@ -406,7 +406,7 @@ Strings are **Encoded as UTF-8**
 
 .. parsed-literal::
    |swift| for x in "bump"\ **.bytes** {
-            println(x)
+            print(x)
           }
    98
    117

docs/TextFormatting.rst

@@ -63,8 +63,8 @@ CustomStringConvertible Types
 -----------------------------
 
 ``CustomStringConvertible`` types can be used in string literal interpolations,
-printed with ``print(x)`` and ``println(x)``, and can be converted to
-``String`` with ``x.toString()``.
+printed with ``print(x)``, and can be converted to ``String`` with
+``x.toString()``.
 
 The simple extension story for beginners is as follows: 
 

docs/proposals/Enums.rst

@@ -33,11 +33,11 @@ only the currently inhabited type is ever used::
   var p : Pattern = .Checkers(.Black, .White)
   switch p {
   case .Solid(var c):
-    println("solid \(c)")
+    print("solid \(c)")
   case .Outline(var c):
-    println("outlined \(c)")
+    print("outlined \(c)")
   case .Checkers(var a, var b):
-    println("checkered \(a) and \(b)")
+    print("checkered \(a) and \(b)")
   }
 
 Given the choice between two familiar keywords, we decided to use 'enum' to

docs/proposals/KVO2_Omnibus.rst

@@ -49,7 +49,7 @@ capturing closures that get and set the property, e.g.::
   var x = 0
   let xRef = Ref(getter: { x }, setter: { x = $0 })
   xRef.value = 2
-  println(x)
+  print(x)
 
 which no one would ever want to write by hand. I propose that we extend the
 ``inout`` modifier so that it can also be applied to return types, and
@@ -63,7 +63,7 @@ capturing local variables in the process::
   var x = 0
   let xRef = { &x }
   xRef() = 2
-  println(x)
+  print(x)
 
 When combined with our existing ``@autoclosure`` and ``assignment``
 operator features, we can write a "bind" operator with implicit capture
@@ -287,10 +287,10 @@ semantics::
   // ...or methods with specific arguments...
   button2.setTarget(button2=>.setTitle("Click me again, I dare you"))
   // ...or free functions...
-  button3.setTarget(message=>println)
+  button3.setTarget(message=>print)
   // ...or (context-free) blocks of code!
   button4.setTarget(message => {
-    println("The button so nice, it prints twice: \($0) \($0)")
+    print("The button so nice, it prints twice: \($0) \($0)")
   })
 
 A further refinement on ``@thin`` would be to have ``@static`` function values,
@@ -363,10 +363,10 @@ chaining operator ``?``::
 
 This has the added power of letting you chain closures or free functions::
 
-  x ¿ .sorted(<) ¿ println // prints "[1, 2, 3]"
-  y ¿ .sorted(<) ¿ println // does nothing
+  x ¿ .sorted(<) ¿ print // prints "[1, 2, 3]"
+  y ¿ .sorted(<) ¿ print // does nothing
 
-  x ¿ .sorted(<) ¿ { println($0[0]) } // prints "1"
+  x ¿ .sorted(<) ¿ { print($0[0]) } // prints "1"
 
 Key Paths
 ---------

docs/proposals/ValueSemantics.rst

@@ -222,7 +222,7 @@ classes:
  }
 
  RandomNumberGenerator x = new MersenneTwister()
- println(
+ print(
     cycle_length(x, (x : [inout] RandomNumberGenerator) { x.nextValue() })
  )