 
     /// True if the path is the root directory.
     public var isRoot: Bool {
-#if os(Windows)
-        return _impl.string.withCString(encodedAs: UTF16.self, PathCchIsRoot)
-#else
-        return _impl == PathImpl.root
-#endif
+        return _impl.isRoot
     }
 
     /// Returns the absolute path with the relative path applied.

        default:
            throw PathValidationError.invalidAbsolutePath(path)
        }
      #endif
    }

    init(validatingRelativePath path: String) throws {
      #if os(Windows)
        let fsr: UnsafePointer<Int8> = path.fileSystemRepresentation
        defer { fsr.deallocate() }

        let realpath: String = String(cString: fsr)
        // Treat a relative path as an invalid relative path...
        if UNIXPath.isAbsolutePath(realpath) ||
                realpath.first == "~" || realpath.first == "\\" {
            throw PathValidationError.invalidRelativePath(path)
        }
        self.init(normalizingRelativePath: path)
      #else
        switch path.first {
        case "/", "~":
            throw PathValidationError.invalidRelativePath(path)
        default:
            self.init(normalizingRelativePath: path)
        }
      #endif
    }

    func suffix(withDot: Bool) -> String? {
#if os(Windows)
        return self.string.withCString(encodedAs: UTF16.self) {
          if let pointer = PathFindExtensionW($0) {
            let substring = String(decodingCString: pointer, as: UTF16.self)
            guard substring.length > 0 else { return nil }
            return withDot ? substring : String(substring.dropFirst(1))
          }
          return nil
        }
#else
        // FIXME: This method seems too complicated; it should be simplified,
        //        if possible, and certainly optimized (using UTF8View).
        // Find the last path separator, if any.

    }

    init(normalizingAbsolutePath path: String) {
        let normalized: UnsafePointer<Int8> = path.fileSystemRepresentation
        defer { normalized.deallocate() }

