@grain/stdlib 0.7.0 → 0.7.2

package/path.md

@@ -28,12 +28,21 @@ No other changes yet.
 from "path" include Path
 ```
 
+```grain
+let p = Path.fromString("./tmp/file.txt")
+```
+
 ## Types
 
 Type declarations included in the Path module.
 
 ### Path.**AbsoluteRoot**
 
+<details disabled>
+<summary tabindex="-1">Added in <code>0.5.5</code></summary>
+No other changes yet.
+</details>
+
 ```grain
 enum AbsoluteRoot {
   Root,
@@ -45,6 +54,11 @@ Represents an absolute path's anchor point.
 
 ### Path.**Relative**
 
+<details disabled>
+<summary tabindex="-1">Added in <code>0.5.5</code></summary>
+No other changes yet.
+</details>
+
 ```grain
 type Relative
 ```
@@ -53,6 +67,11 @@ Represents a relative path.
 
 ### Path.**Absolute**
 
+<details disabled>
+<summary tabindex="-1">Added in <code>0.5.5</code></summary>
+No other changes yet.
+</details>
+
 ```grain
 type Absolute
 ```
@@ -61,6 +80,11 @@ Represents an absolute path.
 
 ### Path.**File**
 
+<details disabled>
+<summary tabindex="-1">Added in <code>0.5.5</code></summary>
+No other changes yet.
+</details>
+
 ```grain
 type File
 ```
@@ -69,6 +93,11 @@ Represents a path referencing a file.
 
 ### Path.**Directory**
 
+<details disabled>
+<summary tabindex="-1">Added in <code>0.5.5</code></summary>
+No other changes yet.
+</details>
+
 ```grain
 type Directory
 ```
@@ -77,6 +106,11 @@ Represents a path referencing a directory.
 
 ### Path.**TypedPath**
 
+<details disabled>
+<summary tabindex="-1">Added in <code>0.5.5</code></summary>
+No other changes yet.
+</details>
+
 ```grain
 type TypedPath<a, b>
 ```
@@ -86,6 +120,11 @@ Represents a path typed on (`Absolute` or `Relative`) and (`File` or
 
 ### Path.**Path**
 
+<details disabled>
+<summary tabindex="-1">Added in <code>0.5.5</code></summary>
+No other changes yet.
+</details>
+
 ```grain
 enum Path {
   AbsoluteFile(TypedPath<Absolute, File>),
@@ -99,6 +138,11 @@ Represents a system path.
 
 ### Path.**Platform**
 
+<details disabled>
+<summary tabindex="-1">Added in <code>0.5.5</code></summary>
+No other changes yet.
+</details>
+
 ```grain
 enum Platform {
   Windows,
@@ -110,6 +154,11 @@ Represents a platform-specific path encoding scheme.
 
 ### Path.**PathOperationError**
 
+<details disabled>
+<summary tabindex="-1">Added in <code>0.5.5</code></summary>
+No other changes yet.
+</details>
+
 ```grain
 enum PathOperationError {
   IncompatiblePathType,
@@ -120,6 +169,11 @@ Represents an error that can occur when finding a property of a path.
 
 ### Path.**AppendError**
 
+<details disabled>
+<summary tabindex="-1">Added in <code>0.5.5</code></summary>
+No other changes yet.
+</details>
+
 ```grain
 enum AppendError {
   AppendToFile,
@@ -131,6 +185,11 @@ Represents an error that can occur when appending paths.
 
 ### Path.**AncestryStatus**
 
+<details disabled>
+<summary tabindex="-1">Added in <code>0.5.5</code></summary>
+No other changes yet.
+</details>
+
 ```grain
 enum AncestryStatus {
   Descendant,
@@ -144,6 +203,11 @@ Represents the status of an ancestry check between two paths.
 
 ### Path.**IncompatibilityError**
 
+<details disabled>
+<summary tabindex="-1">Added in <code>0.5.5</code></summary>
+No other changes yet.
+</details>
+
 ```grain
 enum IncompatibilityError {
   DifferentRoots,
@@ -156,6 +220,11 @@ for an operation.
 
 ### Path.**RelativizationError**
 
+<details disabled>
+<summary tabindex="-1">Added in <code>0.5.5</code></summary>
+No other changes yet.
+</details>
+
 ```grain
 enum RelativizationError {
   Incompatible(IncompatibilityError),
@@ -194,33 +263,33 @@ ambiguity.
 
 Parameters:
 
-|param|type|description|
-|-----|----|-----------|
-|`pathStr`|`String`|The string to parse as a path|
-|`?platform`|`Platform`|The platform whose path separators should be used for parsing|
+| param       | type       | description                                                   |
+| ----------- | ---------- | ------------------------------------------------------------- |
+| `pathStr`   | `String`   | The string to parse as a path                                 |
+| `?platform` | `Platform` | The platform whose path separators should be used for parsing |
 
 Returns:
 
-|type|description|
-|----|-----------|
-|`Path`|The path wrapped with details encoded within the type|
+| type   | description                                           |
+| ------ | ----------------------------------------------------- |
+| `Path` | The path wrapped with details encoded within the type |
 
 Examples:
 
 ```grain
-fromString("file.txt") // a relative Path referencing the file ./file.txt
+Path.fromString("file.txt") // a relative Path referencing the file ./file.txt
 ```
 
 ```grain
-fromString(".") // a relative Path referencing the current directory
+Path.fromString(".") // a relative Path referencing the current directory
 ```
 
 ```grain
-fromString("/bin/", Posix) // an absolute Path referencing the directory /bin/
+Path.fromString("/bin/", Path.Posix) // an absolute Path referencing the directory /bin/
 ```
 
 ```grain
-fromString("C:\\file.txt", Windows) // a relative Path referencing the file C:\file.txt
+Path.fromString("C:\\file.txt", Path.Windows) // a relative Path referencing the file C:\file.txt
 ```
 
 ### Path.**toString**
@@ -247,29 +316,29 @@ A trailing slash is added to directory paths.
 
 Parameters:
 
-|param|type|description|
-|-----|----|-----------|
-|`path`|`Path`|The path to convert to a string|
-|`?platform`|`Platform`|The `Platform` to use to represent the path as a string|
+| param       | type       | description                                             |
+| ----------- | ---------- | ------------------------------------------------------- |
+| `path`      | `Path`     | The path to convert to a string                         |
+| `?platform` | `Platform` | The `Platform` to use to represent the path as a string |
 
 Returns:
 
-|type|description|
-|----|-----------|
-|`String`|A string representing the given path|
+| type     | description                          |
+| -------- | ------------------------------------ |
+| `String` | A string representing the given path |
 
 Examples:
 
 ```grain
-toString(fromString("/file.txt")) == "/file.txt"
+Path.toString(Path.fromString("/file.txt")) == "/file.txt"
 ```
 
 ```grain
-toString(fromString("dir/"), Posix) == "./dir/"
+Path.toString(Path.fromString("dir/"), Path.Posix) == "./dir/"
 ```
 
 ```grain
-toString(fromString("C:/file.txt"), Windows) == "C:\\file.txt"
+Path.toString(Path.fromString("C:/file.txt"), Path.Windows) == "C:\\file.txt"
 ```
 
 ### Path.**isDirectory**
@@ -287,24 +356,24 @@ Determines whether the path is a directory path.
 
 Parameters:
 
-|param|type|description|
-|-----|----|-----------|
-|`path`|`Path`|The path to inspect|
+| param  | type   | description         |
+| ------ | ------ | ------------------- |
+| `path` | `Path` | The path to inspect |
 
 Returns:
 
-|type|description|
-|----|-----------|
-|`Bool`|`true` if the path is a directory path or `false` otherwise|
+| type   | description                                                 |
+| ------ | ----------------------------------------------------------- |
+| `Bool` | `true` if the path is a directory path or `false` otherwise |
 
 Examples:
 
 ```grain
-isDirectory(fromString("file.txt")) == false
+Path.isDirectory(Path.fromString("file.txt")) == false
 ```
 
 ```grain
-isDirectory(fromString("/bin/")) == true
+Path.isDirectory(Path.fromString("/bin/")) == true
 ```
 
 ### Path.**isAbsolute**
@@ -317,24 +386,24 @@ Determines whether the path is an absolute path.
 
 Parameters:
 
-|param|type|description|
-|-----|----|-----------|
-|`path`|`Path`|The path to inspect|
+| param  | type   | description         |
+| ------ | ------ | ------------------- |
+| `path` | `Path` | The path to inspect |
 
 Returns:
 
-|type|description|
-|----|-----------|
-|`Bool`|`true` if the path is absolute or `false` otherwise|
+| type   | description                                         |
+| ------ | --------------------------------------------------- |
+| `Bool` | `true` if the path is absolute or `false` otherwise |
 
 Examples:
 
 ```grain
-isAbsolute(fromString("/Users/me")) == true
+Path.isAbsolute(Path.fromString("/Users/me")) == true
 ```
 
 ```grain
-isAbsolute(fromString("./file.txt")) == false
+Path.isAbsolute(Path.fromString("./file.txt")) == false
 ```
 
 ### Path.**append**
@@ -352,29 +421,29 @@ Creates a new path by appending a relative path segment to a directory path.
 
 Parameters:
 
-|param|type|description|
-|-----|----|-----------|
-|`path`|`Path`|The base path|
-|`toAppend`|`Path`|The relative path to append|
+| param      | type   | description                 |
+| ---------- | ------ | --------------------------- |
+| `path`     | `Path` | The base path               |
+| `toAppend` | `Path` | The relative path to append |
 
 Returns:
 
-|type|description|
-|----|-----------|
-|`Result<Path, AppendError>`|`Ok(path)` combining the base and appended paths or `Err(err)` if the paths are incompatible|
+| type                        | description                                                                                  |
+| --------------------------- | -------------------------------------------------------------------------------------------- |
+| `Result<Path, AppendError>` | `Ok(path)` combining the base and appended paths or `Err(err)` if the paths are incompatible |
 
 Examples:
 
 ```grain
-append(fromString("./dir/"), fromString("file.txt")) == Ok(fromString("./dir/file.txt"))
+Path.append(Path.fromString("./dir/"), Path.fromString("file.txt")) == Ok(Path.fromString("./dir/file.txt"))
 ```
 
 ```grain
-append(fromString("a.txt"), fromString("b.sh")) == Err(AppendToFile) // cannot append to file path
+Path.append(Path.fromString("a.txt"), Path.fromString("b.sh")) == Err(Path.AppendToFile) // cannot append to file path
 ```
 
 ```grain
-append(fromString("./dir/"), fromString("/dir2")) == Err(AppendAbsolute) // cannot append an absolute path
+Path.append(Path.fromString("./dir/"), Path.fromString("/dir2")) == Err(Path.AppendAbsolute) // cannot append an absolute path
 ```
 
 ### Path.**relativeTo**
@@ -392,48 +461,48 @@ Attempts to construct a new relative path which will lead to the destination
 path from the source path.
 
 If the source and destination are incompatible in their bases, the result
-will be `Err(IncompatibilityError)`.
+will be `Err(Path.IncompatibilityError)`.
 
 If the route to the destination cannot be concretely determined from the
-source, the result will be `Err(ImpossibleRelativization)`.
+source, the result will be `Err(Path.ImpossibleRelativization)`.
 
 Parameters:
 
-|param|type|description|
-|-----|----|-----------|
-|`source`|`Path`|The source path|
-|`dest`|`Path`|The destination path to resolve|
+| param    | type   | description                     |
+| -------- | ------ | ------------------------------- |
+| `source` | `Path` | The source path                 |
+| `dest`   | `Path` | The destination path to resolve |
 
 Returns:
 
-|type|description|
-|----|-----------|
-|`Result<Path, RelativizationError>`|`Ok(path)` containing the relative path if successfully resolved or `Err(err)` otherwise|
+| type                                | description                                                                              |
+| ----------------------------------- | ---------------------------------------------------------------------------------------- |
+| `Result<Path, RelativizationError>` | `Ok(path)` containing the relative path if successfully resolved or `Err(err)` otherwise |
 
 Examples:
 
 ```grain
-relativeTo(fromString("/usr"), fromString("/usr/bin")) == Ok(fromString("./bin"))
+Path.relativeTo(Path.fromString("/usr"), Path.fromString("/usr/bin")) == Ok(Path.fromString("./bin"))
 ```
 
 ```grain
-relativeTo(fromString("/home/me"), fromString("/home/me")) == Ok(fromString("."))
+Path.relativeTo(Path.fromString("/home/me"), Path.fromString("/home/me")) == Ok(Path.fromString("."))
 ```
 
 ```grain
-relativeTo(fromString("/file.txt"), fromString("/etc/")) == Ok(fromString("../etc/"))
+Path.relativeTo(Path.fromString("/file.txt"), Path.fromString("/etc/")) == Ok(Path.fromString("../etc/"))
 ```
 
 ```grain
-relativeTo(fromString(".."), fromString("../../thing")) Ok(fromString("../thing"))
+Path.relativeTo(Path.fromString(".."), Path.fromString("../../thing")) Ok(Path.fromString("../thing"))
 ```
 
 ```grain
-relativeTo(fromString("/usr/bin"), fromString("C:/Users")) == Err(Incompatible(DifferentRoots))
+Path.relativeTo(Path.fromString("/usr/bin"), Path.fromString("C:/Users")) == Err(Path.Incompatible(Path.DifferentRoots))
 ```
 
 ```grain
-relativeTo(fromString("../here"), fromString("./there")) == Err(ImpossibleRelativization)
+Path.relativeTo(Path.fromString("../here"), Path.fromString("./there")) == Err(Path.ImpossibleRelativization)
 ```
 
 ### Path.**ancestry**
@@ -448,37 +517,37 @@ ancestry:
   (base: Path, path: Path) => Result<AncestryStatus, IncompatibilityError>
 ```
 
-Determines the relative ancestry betwen two paths.
+Determines the relative ancestry between two paths.
 
 Parameters:
 
-|param|type|description|
-|-----|----|-----------|
-|`base`|`Path`|The first path to consider|
-|`path`|`Path`|The second path to consider|
+| param  | type   | description                 |
+| ------ | ------ | --------------------------- |
+| `base` | `Path` | The first path to consider  |
+| `path` | `Path` | The second path to consider |
 
 Returns:
 
-|type|description|
-|----|-----------|
-|`Result<AncestryStatus, IncompatibilityError>`|`Ok(ancestryStatus)` with the relative ancestry between the paths if they are compatible or `Err(err)` if they are incompatible|
+| type                                           | description                                                                                                                     |
+| ---------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
+| `Result<AncestryStatus, IncompatibilityError>` | `Ok(ancestryStatus)` with the relative ancestry between the paths if they are compatible or `Err(err)` if they are incompatible |
 
 Examples:
 
 ```grain
-ancestry(fromString("/usr"), fromString("/usr/bin/bash")) == Ok(Ancestor)
+Path.ancestry(Path.fromString("/usr"), Path.fromString("/usr/bin/bash")) == Ok(Path.Ancestor)
 ```
 
 ```grain
-ancestry(fromString("/Users/me"), fromString("/Users")) == Ok(Descendant)
+Path.ancestry(Path.fromString("/Users/me"), Path.fromString("/Users")) == Ok(Path.Descendant)
 ```
 
 ```grain
-ancestry(fromString("/usr"), fromString("/etc")) == Ok(Neither)
+Path.ancestry(Path.fromString("/usr"), Path.fromString("/etc")) == Ok(Path.Neither)
 ```
 
 ```grain
-ancestry(fromString("C:/dir1"), fromString("/dir2")) == Err(DifferentRoots)
+Path.ancestry(Path.fromString("C:/dir1"), Path.fromString("/dir2")) == Err(Path.DifferentRoots)
 ```
 
 ### Path.**parent**
@@ -496,24 +565,24 @@ Retrieves the path corresponding to the parent directory of the given path.
 
 Parameters:
 
-|param|type|description|
-|-----|----|-----------|
-|`path`|`Path`|The path to inspect|
+| param  | type   | description         |
+| ------ | ------ | ------------------- |
+| `path` | `Path` | The path to inspect |
 
 Returns:
 
-|type|description|
-|----|-----------|
-|`Path`|A path corresponding to the parent directory of the given path|
+| type   | description                                                    |
+| ------ | -------------------------------------------------------------- |
+| `Path` | A path corresponding to the parent directory of the given path |
 
 Examples:
 
 ```grain
-parent(fromString("./dir/inner")) == fromString("./dir/")
+Path.parent(Path.fromString("./dir/inner")) == Path.fromString("./dir/")
 ```
 
 ```grain
-parent(fromString("/")) == fromString("/")
+Path.parent(Path.fromString("/")) == Path.fromString("/")
 ```
 
 ### Path.**basename**
@@ -531,24 +600,24 @@ Retrieves the basename (named final segment) of a path.
 
 Parameters:
 
-|param|type|description|
-|-----|----|-----------|
-|`path`|`Path`|The path to inspect|
+| param  | type   | description         |
+| ------ | ------ | ------------------- |
+| `path` | `Path` | The path to inspect |
 
 Returns:
 
-|type|description|
-|----|-----------|
-|`Option<String>`|`Some(path)` containing the basename of the path or `None` if the path does not have one|
+| type             | description                                                                              |
+| ---------------- | ---------------------------------------------------------------------------------------- |
+| `Option<String>` | `Some(path)` containing the basename of the path or `None` if the path does not have one |
 
 Examples:
 
 ```grain
-basename(fromString("./dir/file.txt")) == Some("file.txt")
+Path.basename(Path.fromString("./dir/file.txt")) == Some("file.txt")
 ```
 
 ```grain
-basename(fromString(".."))) == None
+Path.basename(Path.fromString(".."))) == None
 ```
 
 ### Path.**stem**
@@ -566,32 +635,32 @@ Retrieves the basename of a file path without the extension.
 
 Parameters:
 
-|param|type|description|
-|-----|----|-----------|
-|`path`|`Path`|The path to inspect|
+| param  | type   | description         |
+| ------ | ------ | ------------------- |
+| `path` | `Path` | The path to inspect |
 
 Returns:
 
-|type|description|
-|----|-----------|
-|`Result<String, PathOperationError>`|`Ok(path)` containing the stem of the file path or `Err(err)` if the path is a directory path|
+| type                                 | description                                                                                   |
+| ------------------------------------ | --------------------------------------------------------------------------------------------- |
+| `Result<String, PathOperationError>` | `Ok(path)` containing the stem of the file path or `Err(err)` if the path is a directory path |
 
 Examples:
 
 ```grain
-stem(fromString("file.txt")) == Ok("file")
+Path.stem(Path.fromString("file.txt")) == Ok("file")
 ```
 
 ```grain
-stem(fromString(".gitignore")) == Ok(".gitignore")
+Path.stem(Path.fromString(".gitignore")) == Ok(".gitignore")
 ```
 
 ```grain
-stem(fromString(".a.tar.gz")) == Ok(".a")
+Path.stem(Path.fromString(".a.tar.gz")) == Ok(".a")
 ```
 
 ```grain
-stem(fromString("/dir/")) == Err(IncompatiblePathType) // can only take stem of a file path
+Path.stem(Path.fromString("/dir/")) == Err(Path.IncompatiblePathType) // can only take stem of a file path
 ```
 
 ### Path.**extension**
@@ -609,32 +678,32 @@ Retrieves the extension on the basename of a file path.
 
 Parameters:
 
-|param|type|description|
-|-----|----|-----------|
-|`path`|`Path`|The path to inspect|
+| param  | type   | description         |
+| ------ | ------ | ------------------- |
+| `path` | `Path` | The path to inspect |
 
 Returns:
 
-|type|description|
-|----|-----------|
-|`Result<String, PathOperationError>`|`Ok(path)` containing the extension of the file path or `Err(err)` if the path is a directory path|
+| type                                 | description                                                                                        |
+| ------------------------------------ | -------------------------------------------------------------------------------------------------- |
+| `Result<String, PathOperationError>` | `Ok(path)` containing the extension of the file path or `Err(err)` if the path is a directory path |
 
 Examples:
 
 ```grain
-extension(fromString("file.txt")) == Ok(".txt")
+Path.extension(Path.fromString("file.txt")) == Ok(".txt")
 ```
 
 ```grain
-extension(fromString(".gitignore")) == Ok("")
+Path.extension(Path.fromString(".gitignore")) == Ok("")
 ```
 
 ```grain
-extension(fromString(".a.tar.gz")) == Ok(".tar.gz")
+Path.extension(Path.fromString(".a.tar.gz")) == Ok(".tar.gz")
 ```
 
 ```grain
-extension(fromString("/dir/")) == Err(IncompatiblePathType) // can only take extension of a file path
+Path.extension(Path.fromString("/dir/")) == Err(Path.IncompatiblePathType) // can only take extension of a file path
 ```
 
 ### Path.**removeExtension**
@@ -652,32 +721,32 @@ Removes the extension from a path, if there is no extension, returns the path as
 
 Parameters:
 
-|param|type|description|
-|-----|----|-----------|
-|`path`|`Path`|The path to modify|
+| param  | type   | description        |
+| ------ | ------ | ------------------ |
+| `path` | `Path` | The path to modify |
 
 Returns:
 
-|type|description|
-|----|-----------|
-|`Path`|The path with the extension removed|
+| type   | description                         |
+| ------ | ----------------------------------- |
+| `Path` | The path with the extension removed |
 
 Examples:
 
 ```grain
-removeExtension(fromString("file.txt")) == fromString("file")
+Path.removeExtension(Path.fromString("file.txt")) == Path.fromString("file")
 ```
 
 ```grain
-removeExtension(fromString(".gitignore")) == fromString(".gitignore")
+Path.removeExtension(Path.fromString(".gitignore")) == Path.fromString(".gitignore")
 ```
 
 ```grain
-removeExtension(fromString("./dir/file")) == fromString("dir/file")
+Path.removeExtension(Path.fromString("./dir/file")) == Path.fromString("dir/file")
 ```
 
 ```grain
-removeExtension(fromString("./dir/")) == fromString("dir/")
+Path.removeExtension(Path.fromString("./dir/")) == Path.fromString("dir/")
 ```
 
 ### Path.**updateExtension**
@@ -695,37 +764,37 @@ Updates the file extension of the given path.
 
 Parameters:
 
-|param|type|description|
-|-----|----|-----------|
-|`path`|`Path`|The path to modify|
-|`extension`|`String`|The new extension|
+| param       | type     | description        |
+| ----------- | -------- | ------------------ |
+| `path`      | `Path`   | The path to modify |
+| `extension` | `String` | The new extension  |
 
 Returns:
 
-|type|description|
-|----|-----------|
-|`Path`|The modified path|
+| type   | description       |
+| ------ | ----------------- |
+| `Path` | The modified path |
 
 Examples:
 
 ```grain
-updateExtension(fromString("file.txt"), "ext") == fromString("file.ext")
+Path.updateExtension(Path.fromString("file.txt"), "ext") == Path.fromString("file.ext")
 ```
 
 ```grain
-updateExtension(fromString("file.txt"), "") == fromString("file.")
+Path.updateExtension(Path.fromString("file.txt"), "") == Path.fromString("file.")
 ```
 
 ```grain
-updateExtension(fromString(".gitignore"), "ext") == fromString(".gitignore.ext")
+Path.updateExtension(Path.fromString(".gitignore"), "ext") == Path.fromString(".gitignore.ext")
 ```
 
 ```grain
-updateExtension(fromString("./dir/file"), "ext") == fromString("dir/file.ext")
+Path.updateExtension(Path.fromString("./dir/file"), "ext") == Path.fromString("dir/file.ext")
 ```
 
 ```grain
-updateExtension(fromString("./dir/"), "ext") == fromString("dir/")
+Path.updateExtension(Path.fromString("./dir/"), "ext") == Path.fromString("dir/")
 ```
 
 ### Path.**root**
@@ -743,27 +812,27 @@ Retrieves the root of the absolute path.
 
 Parameters:
 
-|param|type|description|
-|-----|----|-----------|
-|`path`|`Path`|The path to inspect|
+| param  | type   | description         |
+| ------ | ------ | ------------------- |
+| `path` | `Path` | The path to inspect |
 
 Returns:
 
-|type|description|
-|----|-----------|
-|`Result<AbsoluteRoot, PathOperationError>`|`Ok(root)` containing the root of the path or `Err(err)` if the path is a relative path|
+| type                                       | description                                                                             |
+| ------------------------------------------ | --------------------------------------------------------------------------------------- |
+| `Result<AbsoluteRoot, PathOperationError>` | `Ok(root)` containing the root of the path or `Err(err)` if the path is a relative path |
 
 Examples:
 
 ```grain
-root(fromString("C:/Users/me/")) == Ok(Drive('C'))
+Path.root(Path.fromString("C:/Users/me/")) == Ok(Path.Drive('C'))
 ```
 
 ```grain
-root(fromString("/home/me/")) == Ok(Root)
+Path.root(Path.fromString("/home/me/")) == Ok(Path.Root)
 ```
 
 ```grain
-root(fromString("./file.txt")) == Err(IncompatiblePathType)
+Path.root(Path.fromString("./file.txt")) == Err(Path.IncompatiblePathType)
 ```