 }
 
 extension String {
-
+  //===--- Already provided by String's core ------------------------------===//
+  // - (instancetype)init
+
+  //===--- Initializers that can fail -------------------------------------===//
+  // - (instancetype)
+  //     initWithBytes:(const void *)bytes
+  //     length:(NSUInteger)length
+  //     encoding:(NSStringEncoding)encoding
+
+  /// Creates a new string equivalent to the given bytes interpreted in the
+  /// specified encoding.
+  ///
+  /// - Parameters:
+  ///   - bytes: A sequence of bytes to interpret using `encoding`.
+  ///   - encoding: The ecoding to use to interpret `bytes`.
+  public init? <S: Sequence>(bytes: S, encoding: Encoding)
+    where S.Iterator.Element == UInt8 {
+    let byteArray = Array(bytes)
+    if let ns = NSString(
+      bytes: byteArray, length: byteArray.count, encoding: encoding.rawValue) {
+
+      self = ns as String
+    } else {
+      return nil
+    }
+  }
+
+  // - (instancetype)
+  //     initWithBytesNoCopy:(void *)bytes
+  //     length:(NSUInteger)length
+  //     encoding:(NSStringEncoding)encoding
+  //     freeWhenDone:(BOOL)flag
+
+  /// Creates a new string that contains the specified number of bytes from the
+  /// given buffer, interpreted in the specified encoding, and optionally
+  /// frees the buffer.
+  ///
+  /// - Warning: This initializer is not memory-safe!
+  public init?(
+    bytesNoCopy bytes: UnsafeMutableRawPointer, length: Int,
+    encoding: Encoding, freeWhenDone flag: Bool
+  ) {
+    if let ns = NSString(
+      bytesNoCopy: bytes, length: length, encoding: encoding.rawValue,
+      freeWhenDone: flag) {
+
+      self = ns as String
+    } else {
+      return nil
+    }
+  }
+
+
+  // - (instancetype)
+  //     initWithCharacters:(const unichar *)characters
+  //     length:(NSUInteger)length
+
+  /// Creates a new string that contains the specified number of characters
+  /// from the given C array of Unicode characters.
+  public init(
+    utf16CodeUnits: UnsafePointer<unichar>,
+    count: Int
+  ) {
+    self = NSString(characters: utf16CodeUnits, length: count) as String
+  }
+
+  // - (instancetype)
+  //     initWithCharactersNoCopy:(unichar *)characters
+  //     length:(NSUInteger)length
+  //     freeWhenDone:(BOOL)flag
+
+  /// Creates a new string that contains the specified number of characters
+  /// from the given C array of UTF-16 code units.
+  public init(
+    utf16CodeUnitsNoCopy: UnsafePointer<unichar>,
+    count: Int,
+    freeWhenDone flag: Bool
+  ) {
+    self = NSString(
+      charactersNoCopy: UnsafeMutablePointer(mutating: utf16CodeUnitsNoCopy),
+      length: count,
+      freeWhenDone: flag) as String
+  }
+
+  //===--- Initializers that can fail -------------------------------------===//
+
+  // - (instancetype)
+  //     initWithContentsOfFile:(NSString *)path
+  //     encoding:(NSStringEncoding)enc
+  //     error:(NSError **)error
+  //
+
+  /// Produces a string created by reading data from the file at a
+  /// given path interpreted using a given encoding.
+  public init(
+    contentsOfFile path: String,
+    encoding enc: Encoding
+  ) throws {
+    let ns = try NSString(contentsOfFile: path, encoding: enc.rawValue)
+    self = ns as String
+  }
+
+  // - (instancetype)
+  //     initWithContentsOfFile:(NSString *)path
+  //     usedEncoding:(NSStringEncoding *)enc
+  //     error:(NSError **)error
+
+  /// Produces a string created by reading data from the file at
+  /// a given path and returns by reference the encoding used to
+  /// interpret the file.
+  public init(
+    contentsOfFile path: String,
+    usedEncoding: inout Encoding
+  ) throws {
+    var enc: UInt = 0
+    let ns = try NSString(contentsOfFile: path, usedEncoding: &enc)
+    usedEncoding = Encoding(rawValue: enc)
+    self = ns as String
+  }
+
+  public init(
+    contentsOfFile path: String
+  ) throws {
+    let ns = try NSString(contentsOfFile: path, usedEncoding: nil)
+    self = ns as String
+  }
+
+  // - (instancetype)
+  //     initWithContentsOfURL:(NSURL *)url
+  //     encoding:(NSStringEncoding)enc
+  //     error:(NSError**)error
+
+  /// Produces a string created by reading data from a given URL
+  /// interpreted using a given encoding.  Errors are written into the
+  /// inout `error` argument.
+  public init(
+    contentsOf url: URL,
+    encoding enc: Encoding
+  ) throws {
+    let ns = try NSString(contentsOf: url, encoding: enc.rawValue)
+    self = ns as String
+  }
+
+  // - (instancetype)
+  //     initWithContentsOfURL:(NSURL *)url
+  //     usedEncoding:(NSStringEncoding *)enc
+  //     error:(NSError **)error
+
+  /// Produces a string created by reading data from a given URL
+  /// and returns by reference the encoding used to interpret the
+  /// data.  Errors are written into the inout `error` argument.
+  public init(
+    contentsOf url: URL,
+    usedEncoding: inout Encoding
+  ) throws {
+    var enc: UInt = 0
+    let ns = try NSString(contentsOf: url as URL, usedEncoding: &enc)
+    usedEncoding = Encoding(rawValue: enc)
+    self = ns as String
+  }
+
+  public init(
+    contentsOf url: URL
+  ) throws {
+    let ns = try NSString(contentsOf: url, usedEncoding: nil)
+    self = ns as String
+  }
+
+  // - (instancetype)
+  //     initWithCString:(const char *)nullTerminatedCString
+  //     encoding:(NSStringEncoding)encoding
+
+  /// Produces a string containing the bytes in a given C array,
+  /// interpreted according to a given encoding.
+  public init?(
+    cString: UnsafePointer<CChar>,
+    encoding enc: Encoding
+  ) {
+    if let ns = NSString(cString: cString, encoding: enc.rawValue) {
+      self = ns as String
+    } else {
+      return nil
+    }
+  }
+
+  // FIXME: handle optional locale with default arguments
+
+  // - (instancetype)
+  //     initWithData:(NSData *)data
+  //     encoding:(NSStringEncoding)encoding
+
+  /// Returns a `String` initialized by converting given `data` into
+  /// Unicode characters using a given `encoding`.
+  public init?(data: Data, encoding: Encoding) {
+    guard let s = NSString(data: data, encoding: encoding.rawValue) else { return nil }
+    self = s as String
+  }
+
+  // - (instancetype)initWithFormat:(NSString *)format, ...
+
+  /// Returns a `String` object initialized by using a given
+  /// format string as a template into which the remaining argument
+  /// values are substituted.
+  public init(format: String, _ arguments: CVarArg...) {
+    self = String(format: format, arguments: arguments)
+  }
+
+  // - (instancetype)
+  //     initWithFormat:(NSString *)format
+  //     arguments:(va_list)argList
+
+  /// Returns a `String` object initialized by using a given
+  /// format string as a template into which the remaining argument
+  /// values are substituted according to the user's default locale.
+  public init(format: String, arguments: [CVarArg]) {
+    self = String(format: format, locale: nil, arguments: arguments)
+  }
+
+  // - (instancetype)initWithFormat:(NSString *)format locale:(id)locale, ...
+
+  /// Returns a `String` object initialized by using a given
+  /// format string as a template into which the remaining argument
+  /// values are substituted according to given locale information.
+  public init(format: String, locale: Locale?, _ args: CVarArg...) {
+    self = String(format: format, locale: locale, arguments: args)
+  }
+
+  // - (instancetype)
+  //     initWithFormat:(NSString *)format
+  //     locale:(id)locale
+  //     arguments:(va_list)argList
+
+  /// Returns a `String` object initialized by using a given
+  /// format string as a template into which the remaining argument
+  /// values are substituted according to given locale information.
+  public init(format: String, locale: Locale?, arguments: [CVarArg]) {
+    self = withVaList(arguments) {
+      NSString(format: format, locale: locale, arguments: $0) as String
+    }
+  }
+
+}
+
+extension StringProtocol where Index == String.Index {
   //===--- Bridging Helpers -----------------------------------------------===//
   //===--------------------------------------------------------------------===//
 
   /// The corresponding `NSString` - a convenience for bridging code.
+  // FIXME(strings): There is probably a better way to bridge Self to NSString
   var _ns: NSString {
-    return self as NSString
+    return String(self) as NSString
   }
 
   /// Return an `Index` corresponding to the given offset in our UTF-16

  ) -> Result {
    var utf16Index: Int = 0
    let result = (index != nil ? body(&utf16Index) : body(nil))
    index?.pointee = self._index(utf16Index)
    return result
  }


        range: _toNSRange(range),
        remaining: $0)
    }
  }

  // - (void)
