 /// protocols mentioned above.
 @inline(never)
 @semantics("stdlib_binary_only")
-public func print<T>(object: T) {
-  var stdoutStream = _Stdout()
-  print(object, &stdoutStream)
-}
-
-/// Writes the textual representation of `object` and a newline character into
+public func print<T>(value: T) {
+  var stdoutStream = _Stdout()
+  print(value, &stdoutStream)
+}
+
+/// Writes the textual representation of `value` and a newline character into
 /// the standard output.
 ///
-/// The textual representation is obtained from the `object` using its protocol
+/// The textual representation is obtained from the `value` using its protocol
 /// conformances, in the following order of preference: `Streamable`,
 /// `Printable`, `DebugPrintable`.
 ///

/// See also: `debugPrintln(x, &target)`
@inline(never)
public func debugPrint<T, TargetStream : OutputStreamType>(
    object: T, inout target: TargetStream
) {
  if let debugPrintableObject = object as? DebugPrintable {
    debugPrintableObject.debugDescription.writeTo(&target)
    return
  }

  if var printableObject = object as? Printable {
    printableObject.description.writeTo(&target)
    return
  }

  if let streamableObject = object as? Streamable {
    streamableObject.writeTo(&target)
    return
  }

  _adHocPrint(object, &target)
}

/// Write to `target` the textual representation of `x` most suitable

/// Do our best to print a value that can not be printed directly, using one of
/// its conformances to `Streamable`, `Printable` or `DebugPrintable`.
func _adHocPrint<T, TargetStream : OutputStreamType>(
    value: T, inout target: TargetStream
) {
  var mirror = reflect(value)
  // Checking the mirror kind is not a good way to implement this, but we don't
  // have a more expressive reflection API now.
  if mirror is _TupleMirror {
