@grain/stdlib 0.5.12 → 0.6.0

package/path.gr

@@ -1,30 +1,32 @@
 /**
- * @module Path: Utilities for working with system paths.
- * 
+ * Utilities for working with system paths.
+ *
  * This module treats paths purely as a data representation and does not
  * provide functionality for interacting with the file system.
- * 
+ *
  * This module explicitly encodes whether a path is absolute or relative, and
  * whether it refers to a file or a directory, as part of the `Path` type.
  *
  * Paths in this module abide by a special POSIX-like representation/grammar
  * rather than one defined by a specific operating system. The rules are as
  * follows:
- * 
+ *
  * - Path separators are denoted by `/` for POSIX-like paths
  * - Absolute paths may be rooted either at the POSIX-like root `/` or at Windows-like drive roots like `C:/`
  * - Paths referencing files must not include trailing forward slashes, but paths referencing directories may
  * - The path segment `.` indicates the relative "current" directory of a path, and `..` indicates the parent directory of a path
- * 
- * @example import Path from "path"
- * 
+ *
+ * @example from "path" include Path
+ *
  * @since v0.5.5
  */
-import String from "string"
-import List from "list"
-import Option from "option"
-import Result from "result"
-import Char from "char"
+module Path
+
+from "string" include String
+from "list" include List
+from "option" include Option
+from "result" include Result
+from "char" include Char
 
 // this module is influenced by https://github.com/reasonml/reason-native/blob/a0ddab6ab25237961e32d8732b0a222ec2372d4a/src/fp/Fp.re
 // with some modifications; reason-native license:
@@ -76,22 +78,18 @@ record TFileType<a> {
 }
 
 // Rel(Number) represents the number of directories up from the base point
-enum Base {
+enum rec Base {
   Rel(Number),
   Abs(AbsoluteRoot),
-},
-type PathInfo = (Base, FileType, List<String>),
-record TBase<a> {
+}
+and type PathInfo = (Base, FileType, List<String>)
+and record TBase<a> {
   base: Base,
-},
-/**
- * @section Types: Type declarations included in the Path module.
- */
-
+}
 /**
  * Represents an absolute path's anchor point.
  */
-export enum AbsoluteRoot {
+and provide enum AbsoluteRoot {
   Root,
   Drive(Char),
 }
@@ -101,28 +99,28 @@ export enum AbsoluteRoot {
 /**
  * Represents a relative path.
  */
-record Relative {
+abstract record Relative {
   _rel: Void,
 }
 
 /**
  * Represents an absolute path.
  */
-record Absolute {
+abstract record Absolute {
   _abs: Void,
 }
 
 /**
  * Represents a path referencing a file.
  */
-record File {
+abstract record File {
   _file: Void,
 }
 
 /**
  * Represents a path referencing a directory.
  */
-record Directory {
+abstract record Directory {
   _directory: Void,
 }
 
@@ -130,11 +128,11 @@ record Directory {
  * Represents a path typed on (`Absolute` or `Relative`) and (`File` or
  * `Directory`)
  */
-type TypedPath<a, b> = (TBase<a>, TFileType<b>, List<String>),
+abstract type rec TypedPath<a, b> = (TBase<a>, TFileType<b>, List<String>)
 /**
  * Represents a system path.
  */
-export enum Path {
+and provide enum Path {
   AbsoluteFile(TypedPath<Absolute, File>),
   AbsoluteDir(TypedPath<Absolute, Directory>),
   RelativeFile(TypedPath<Relative, File>),
@@ -144,7 +142,7 @@ export enum Path {
 /**
  * Represents a platform-specific path encoding scheme.
  */
-export enum Platform {
+provide enum Platform {
   Windows,
   Posix,
 }
@@ -152,14 +150,14 @@ export enum Platform {
 /**
  * Represents an error that can occur when finding a property of a path.
  */
-export enum PathOperationError {
+provide enum PathOperationError {
   IncompatiblePathType,
 }
 
 /**
  * Represents an error that can occur when appending paths.
  */
-export enum AppendError {
+provide enum AppendError {
   AppendToFile,
   AppendAbsolute,
 }
@@ -167,7 +165,7 @@ export enum AppendError {
 /**
  * Represents the status of an ancestry check between two paths.
  */
-export enum AncestryStatus {
+provide enum AncestryStatus {
   Descendant,
   Ancestor,
   Self,
@@ -178,7 +176,7 @@ export enum AncestryStatus {
  * Represents an error that can occur when the types of paths are incompatible
  * for an operation.
  */
-export enum IncompatibilityError {
+provide enum IncompatibilityError {
   DifferentRoots,
   DifferentBases,
 }
@@ -186,15 +184,11 @@ export enum IncompatibilityError {
 /**
  * Represents possible errors for the `relativeTo` operation.
  */
-export enum RelativizationError {
+provide enum RelativizationError {
   Incompatible(IncompatibilityError),
   ImpossibleRelativization,
 }
 
-/**
- * @section Values: Functions for working with Paths.
- */
-
 let makeToken = str => {
   match (str) {
     "." => Dot,
@@ -232,7 +226,7 @@ let lexPath = (pathStr, platform) => {
   for (let mut i = 0; i < len; i += 1) {
     if (isSeparator(String.charAt(i, pathStr))) {
       if (segBeginI != i) {
-        let tok = makeToken(String.slice(segBeginI, i, pathStr))
+        let tok = makeToken(String.slice(segBeginI, end=i, pathStr))
         revTokens = [tok, ...revTokens]
       }
       revTokens = [Slash, ...revTokens]
@@ -240,7 +234,7 @@ let lexPath = (pathStr, platform) => {
     }
   }
   if (segBeginI < len) {
-    let lastPart = String.slice(segBeginI, len, pathStr)
+    let lastPart = String.slice(segBeginI, end=len, pathStr)
     revTokens = [makeToken(lastPart), ...revTokens]
   }
   List.reverse(revTokens)
@@ -304,7 +298,7 @@ let parseAbs = (tokens, fileType) => {
   }
 }
 
-// TODO(#1496): expose these functions once module system added
+// TODO(#1496): provide these functions once module system added
 
 let absoluteFile = tokens => {
   let pathOpt = parseAbs(tokens, File)
@@ -359,53 +353,37 @@ let fromStringHelper = (pathStr, platform) => {
   }
   let isDir = !isFilePath(tokens)
 
-  let path = (variant, mkPath, pathType) => {
-    variant(
-      Option.expect("Impossible: failed parse of " ++ pathType, mkPath(tokens))
-    )
+  let path = (mkPath, pathType) => {
+    Option.expect("Impossible: failed parse of " ++ pathType, mkPath(tokens))
   }
 
   match ((isAbs, isDir)) {
-    (true, true) => path(AbsoluteDir, absoluteDir, "absolute dir"),
-    (true, false) => path(AbsoluteFile, absoluteFile, "absolute file"),
-    (false, true) => path(RelativeDir, relativeDir, "relative dir"),
-    (false, false) => path(RelativeFile, relativeFile, "relative file"),
+    (true, true) => AbsoluteDir(path(absoluteDir, "absolute dir")),
+    (true, false) => AbsoluteFile(path(absoluteFile, "absolute file")),
+    (false, true) => RelativeDir(path(relativeDir, "relative dir")),
+    (false, false) => RelativeFile(path(relativeFile, "relative file")),
   }
 }
 
-/**
- * Parses a path string into a `Path`. Paths will be parsed as file paths
- * rather than directory paths if there is ambiguity.
- * 
- * @param pathStr: The string to parse as a path
- * @returns The path wrapped with details encoded within the type
- * 
- * @example fromString("/bin/") // an absolute Path referencing the directory /bin/
- * @example fromString("file.txt") // a relative Path referencing the file ./file.txt
- * @example fromString(".") // a relative Path referencing the current directory
- * 
- * @since v0.5.5
- */
-export let fromString = pathStr => {
-  fromStringHelper(pathStr, Posix)
-}
-
 /**
  * Parses a path string into a `Path` using the path separators appropriate to
  * the given platform (`/` for `Posix` and either `/` or `\` for `Windows`).
  * Paths will be parsed as file paths rather than directory paths if there is
  * ambiguity.
- * 
+ *
  * @param pathStr: The string to parse as a path
  * @param platform: The platform whose path separators should be used for parsing
  * @returns The path wrapped with details encoded within the type
- * 
- * @example fromPlatformString("/bin/", Posix) // an absolute Path referencing the directory /bin/
- * @example fromPlatformString("C:\\file.txt", Windows) // a relative Path referencing the file C:\file.txt
- * 
+ *
+ * @example fromString("file.txt") // a relative Path referencing the file ./file.txt
+ * @example fromString(".") // a relative Path referencing the current directory
+ * @example fromString("/bin/", Posix) // an absolute Path referencing the directory /bin/
+ * @example fromString("C:\\file.txt", Windows) // a relative Path referencing the file C:\file.txt
+ *
  * @since v0.5.5
+ * @history v0.6.0: Merged with `fromPlatformString`; modified signature to accept platform
  */
-export let fromPlatformString = (pathStr, platform) => {
+provide let fromString = (pathStr, platform=Posix) => {
   fromStringHelper(pathStr, platform)
 }
 
@@ -436,66 +414,52 @@ let toStringHelper = (path, platform) => {
   List.join(sep, segs)
 }
 
-/**
- * Converts the given `Path` into a string, using the `/` path separator.
- * A trailing slash is added to directory paths.
- * 
- * @param path: The path to convert to a string
- * @returns A string representing the given path
- * 
- * @example toString(fromString("/file.txt")) == "/file.txt"
- * @example toString(fromString("dir/")) == "./dir/"
- * 
- * @since v0.5.5
- */
-export let toString = path => {
-  toStringHelper(pathInfo(path), Posix)
-}
-
 /**
  * Converts the given `Path` into a string, using the canonical path separator
  * appropriate to the given platform (`/` for `Posix` and `\` for `Windows`).
  * A trailing slash is added to directory paths.
- * 
+ *
  * @param path: The path to convert to a string
  * @param platform: The `Platform` to use to represent the path as a string
  * @returns A string representing the given path
- * 
- * @example toPlatformString(fromString("dir/"), Posix) == "./dir/"
- * @example toPlatformString(fromString("C:/file.txt"), Windows) == "C:\\file.txt"
- * 
+ *
+ * @example toString(fromString("/file.txt")) == "/file.txt"
+ * @example toString(fromString("dir/"), Posix) == "./dir/"
+ * @example toString(fromString("C:/file.txt"), Windows) == "C:\\file.txt"
+ *
  * @since v0.5.5
+ * @history v0.6.0: Merged with `toPlatformString`; modified signature to accept platform
  */
-export let toPlatformString = (path, platform) => {
+provide let toString = (path, platform=Posix) => {
   toStringHelper(pathInfo(path), platform)
 }
 
 /**
  * Determines whether the path is a directory path.
- * 
+ *
  * @param path: The path to inspect
  * @returns `true` if the path is a directory path or `false` otherwise
- * 
+ *
  * @example isDirectory(fromString("file.txt")) == false
  * @example isDirectory(fromString("/bin/")) == true
- * 
+ *
  * @since v0.5.5
  */
-export let isDirectory = path => {
+provide let isDirectory = path => {
   let (_, fileType, _) = pathInfo(path)
   fileType == Dir
 }
 
 /**
  * Determines whether the path is an absolute path.
- * 
+ *
  * @param path: The path to inspect
  * @returns `true` if the path is absolute or `false` otherwise
- * 
+ *
  * @example isAbsolute(fromString("/Users/me")) == true
  * @example isAbsolute(fromString("./file.txt")) == false
  */
-export let isAbsolute = path => {
+provide let isAbsolute = path => {
   let (base, _, _) = pathInfo(path)
   match (base) {
     Abs(_) => true,
@@ -506,32 +470,33 @@ export let isAbsolute = path => {
 // should only be used on relative path appended to directory path
 let rec appendHelper = (path: PathInfo, toAppend: PathInfo) =>
   match (toAppend) {
-    (Rel(up2), ft, s2) =>
-      match (path) {
-        (Rel(up1), _, []) => (Rel(up1 + up2), ft, s2),
-        (Abs(_) as d, _, []) => (d, ft, s2),
-        (d, pft, [_, ...rest] as s1) => {
-          if (up2 > 0) appendHelper((d, pft, rest), (Rel(up2 - 1), ft, s2))
-          else (d, ft, List.append(s2, s1))
-        },
+    (Rel(up2), ft, s2) => match (path) {
+      (Rel(up1), _, []) => (Rel(up1 + up2), ft, s2),
+      (Abs(_) as d, _, []) => (d, ft, s2),
+      (d, pft, [_, ...rest] as s1) => {
+        if (up2 > 0)
+          appendHelper((d, pft, rest), (Rel(up2 - 1), ft, s2))
+        else
+          (d, ft, List.append(s2, s1))
       },
+    },
     (Abs(_), _, _) => fail "Impossible: relative path encoded as absolute path",
   }: PathInfo
 
 /**
  * Creates a new path by appending a relative path segment to a directory path.
- * 
+ *
  * @param path: The base path
  * @param toAppend: The relative path to append
  * @returns `Ok(path)` combining the base and appended paths or `Err(err)` if the paths are incompatible
- * 
+ *
  * @example append(fromString("./dir/"), fromString("file.txt")) == Ok(fromString("./dir/file.txt"))
  * @example append(fromString("a.txt"), fromString("b.sh")) == Err(AppendToFile) // cannot append to file path
  * @example append(fromString("./dir/"), fromString("/dir2")) == Err(AppendAbsolute) // cannot append an absolute path
- * 
+ *
  * @since v0.5.5
  */
-export let append = (path: Path, toAppend: Path) => {
+provide let append = (path: Path, toAppend: Path) => {
   match ((pathInfo(path), pathInfo(toAppend))) {
     ((_, File, _), _) => Err(AppendToFile),
     (_, (Abs(_), _, _)) => Err(AppendAbsolute),
@@ -561,8 +526,10 @@ let relativeToHelper = (source: PathInfo, dest: PathInfo) => {
   let result = match ((source, dest)) {
     ((_, File, [name, ..._]), _) when source == dest => Ok((1, [name])),
     ((Abs(r1), _, s1), (Abs(r2), _, s2)) =>
-      if (r1 != r2) Err(Incompatible(DifferentRoots))
-      else relativizeDepth((0, List.reverse(s1)), (0, List.reverse(s2))),
+      if (r1 != r2)
+        Err(Incompatible(DifferentRoots))
+      else
+        relativizeDepth((0, List.reverse(s1)), (0, List.reverse(s2))),
     ((Rel(up1), _, s1), (Rel(up2), _, s2)) =>
       relativizeDepth((up1, List.reverse(s1)), (up2, List.reverse(s2))),
     _ => fail "Impossible: paths should have both been absolute or relative",
@@ -578,45 +545,44 @@ let relativeToHelper = (source: PathInfo, dest: PathInfo) => {
 /**
  * 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)`.
  *
  * If the route to the destination cannot be concretely determined from the
  * source, the result will be `Err(ImpossibleRelativization)`.
- * 
+ *
  * @param source: The source path
  * @param dest: The destination path to resolve
  * @returns `Ok(path)` containing the relative path if successfully resolved or `Err(err)` otherwise
- * 
+ *
  * @example relativeTo(fromString("/usr"), fromString("/usr/bin")) == Ok(fromString("./bin"))
  * @example relativeTo(fromString("/home/me"), fromString("/home/me")) == Ok(fromString("."))
  * @example relativeTo(fromString("/file.txt"), fromString("/etc/")) == Ok(fromString("../etc/"))
  * @example relativeTo(fromString(".."), fromString("../../thing")) Ok(fromString("../thing"))
  * @example relativeTo(fromString("/usr/bin"), fromString("C:/Users")) == Err(Incompatible(DifferentRoots))
  * @example relativeTo(fromString("../here"), fromString("./there")) == Err(ImpossibleRelativization)
- * 
+ *
  * @since v0.5.5
  */
-export let relativeTo = (source, dest) => {
+provide let relativeTo = (source, dest) => {
   let pathInfo1 = pathInfo(source)
   let (base1, _, _) = pathInfo1
   let pathInfo2 = pathInfo(dest)
   let (base2, _, _) = pathInfo2
   match ((base1, base2)) {
-    (Abs(_), Rel(_)) | (Abs(_), Rel(_)) => Err(Incompatible(DifferentBases)),
+    (Abs(_), Rel(_)) | (Rel(_), Abs(_)) => Err(Incompatible(DifferentBases)),
     _ => Result.map(toPath, relativeToHelper(pathInfo1, pathInfo2)),
   }
 }
 
-let rec segsAncestry = (baseSegs, pathSegs) =>
-  match ((baseSegs, pathSegs)) {
-    ([], []) => Self,
-    ([], _) => Descendant,
-    (_, []) => Ancestor,
-    ([first1, ..._], [first2, ..._]) when first1 != first2 => NoLineage,
-    ([_, ...rest1], [_, ...rest2]) => segsAncestry(rest1, rest2),
-  }
+let rec segsAncestry = (baseSegs, pathSegs) => match ((baseSegs, pathSegs)) {
+  ([], []) => Self,
+  ([], _) => Descendant,
+  (_, []) => Ancestor,
+  ([first1, ..._], [first2, ..._]) when first1 != first2 => NoLineage,
+  ([_, ...rest1], [_, ...rest2]) => segsAncestry(rest1, rest2),
+}
 
 // should be used on paths with same absolute/relativeness
 let ancestryHelper = (base: PathInfo, path: PathInfo) => {
@@ -630,22 +596,22 @@ let ancestryHelper = (base: PathInfo, path: PathInfo) => {
 
 /**
  * Determines the relative ancestry betwen two paths.
- * 
+ *
  * @param base: The first path to consider
  * @param path: The second path to consider
  * @returns `Ok(ancestryStatus)` with the relative ancestry between the paths if they are compatible or `Err(err)` if they are incompatible
- * 
+ *
  * @example ancestry(fromString("/usr"), fromString("/usr/bin/bash")) == Ok(Ancestor)
  * @example ancestry(fromString("/Users/me"), fromString("/Users")) == Ok(Descendant)
  * @example ancestry(fromString("/usr"), fromString("/etc")) == Ok(Neither)
  * @example ancestry(fromString("C:/dir1"), fromString("/dir2")) == Err(DifferentRoots)
- * 
+ *
  * @since v0.5.5
  */
-export let ancestry = (path1: Path, path2: Path) => {
-  let pathInfo1 = pathInfo(path1)
+provide let ancestry = (base: Path, path: Path) => {
+  let pathInfo1 = pathInfo(base)
   let (base1, _, _) = pathInfo1
-  let pathInfo2 = pathInfo(path2)
+  let pathInfo2 = pathInfo(path)
   let (base2, _, _) = pathInfo2
   match ((base1, base2)) {
     (Rel(_), Abs(_)) | (Abs(_), Rel(_)) => Err(DifferentBases),
@@ -653,81 +619,77 @@ export let ancestry = (path1: Path, path2: Path) => {
   }
 }
 
-let parentHelper = (path: PathInfo) =>
-  match (path) {
-    (base, _, [_, ...rest]) => (base, Dir, rest),
-    (Rel(upDirs), _, []) => (Rel(upDirs + 1), Dir, []),
-    (Abs(_) as base, _, []) => (base, Dir, []),
-  }: PathInfo
+let parentHelper = (path: PathInfo) => match (path) {
+  (base, _, [_, ...rest]) => (base, Dir, rest),
+  (Rel(upDirs), _, []) => (Rel(upDirs + 1), Dir, []),
+  (Abs(_) as base, _, []) => (base, Dir, []),
+}: PathInfo
 
 /**
  * Retrieves the path corresponding to the parent directory of the given path.
- * 
+ *
  * @param path: The path to inspect
  * @returns A path corresponding to the parent directory of the given path
- * 
+ *
  * @example parent(fromString("./dir/inner")) == fromString("./dir/")
  * @example parent(fromString("/")) == fromString("/")
- * 
+ *
  * @since v0.5.5
  */
-export let parent = (path: Path) => {
+provide let parent = (path: Path) => {
   toPath(parentHelper(pathInfo(path)))
 }
 
-let basenameHelper = (path: PathInfo) =>
-  match (path) {
-    (_, _, [name, ..._]) => Some(name),
-    _ => None,
-  }
+let basenameHelper = (path: PathInfo) => match (path) {
+  (_, _, [name, ..._]) => Some(name),
+  _ => None,
+}
 
 /**
  * Retrieves the basename (named final segment) of a path.
- * 
+ *
  * @param path: The path to inspect
  * @returns `Some(path)` containing the basename of the path or `None` if the path does not have one
- * 
+ *
  * @example basename(fromString("./dir/file.txt")) == Some("file.txt")
  * @example basename(fromString(".."))) == None
- * 
+ *
  * @since v0.5.5
  */
-export let basename = (path: Path) => {
+provide let basename = (path: Path) => {
   basenameHelper(pathInfo(path))
 }
 
 // should only be used on file paths
-let stemExtHelper = (path: PathInfo) =>
-  match (path) {
-    (_, _, [name, ..._]) => {
-      let len = String.length(name)
-      // trim first character (which is possibly a .) off as trick for
-      // splitting .a.b.c into .a, .b.c
-      match (String.indexOf(".", String.slice(1, len, name))) {
-        Some(dotI) => {
-          let dotI = dotI + 1
-          (String.slice(0, dotI, name), String.slice(dotI, len, name))
-        },
-        None => (name, ""),
-      }
-    },
-    _ => ("", ""),
-  }
+let stemExtHelper = (path: PathInfo) => match (path) {
+  (_, _, [name, ..._]) => {
+    // trim first character (which is possibly a .) off as trick for
+    // splitting .a.b.c into .a, .b.c
+    match (String.indexOf(".", String.slice(1, name))) {
+      Some(dotI) => {
+        let dotI = dotI + 1
+        (String.slice(0, end=dotI, name), String.slice(dotI, name))
+      },
+      None => (name, ""),
+    }
+  },
+  _ => ("", ""),
+}
 
 /**
  * Retrieves the basename of a file path without the extension.
- * 
+ *
  * @param path: The path to inspect
  * @returns `Ok(path)` containing the stem of the file path or `Err(err)` if the path is a directory path
- * 
+ *
  * @example stem(fromString("file.txt")) == Ok("file")
  * @example stem(fromString(".gitignore")) == Ok(".gitignore")
  * @example stem(fromString(".a.tar.gz")) == Ok(".a")
  * @example stem(fromString("/dir/")) == Err(IncompatiblePathType) // can only take stem of a file path
- * 
+ *
  * @since v0.5.5
  */
-export let stem = (path: Path) => {
+provide let stem = (path: Path) => {
   match (pathInfo(path)) {
     (_, Dir, _) => Err(IncompatiblePathType),
     pathInfo => {
@@ -739,18 +701,18 @@ export let stem = (path: Path) => {
 
 /**
  * Retrieves the extension on the basename of a file path.
- * 
+ *
  * @param path: The path to inspect
  * @returns `Ok(path)` containing the extension of the file path or `Err(err)` if the path is a directory path
- * 
+ *
  * @example extension(fromString("file.txt")) == Ok(".txt")
  * @example extension(fromString(".gitignore")) == Ok("")
  * @example extension(fromString(".a.tar.gz")) == Ok(".tar.gz")
  * @example extension(fromString("/dir/")) == Err(IncompatiblePathType) // can only take extension of a file path
- * 
+ *
  * @since v0.5.5
  */
-export let extension = (path: Path) => {
+provide let extension = (path: Path) => {
   match (pathInfo(path)) {
     (_, Dir, _) => Err(IncompatiblePathType),
     pathInfo => {
@@ -761,25 +723,24 @@ export let extension = (path: Path) => {
 }
 
 // should only be used on absolute paths
-let rootHelper = (path: PathInfo) =>
-  match (path) {
-    (Abs(root), _, _) => root,
-    _ => fail "Impossible: malformed absolute path data",
-  }
+let rootHelper = (path: PathInfo) => match (path) {
+  (Abs(root), _, _) => root,
+  _ => fail "Impossible: malformed absolute path data",
+}
 
 /**
  * Retrieves the root of the absolute path.
- * 
+ *
  * @param path: The path to inspect
  * @returns `Ok(root)` containing the root of the path or `Err(err)` if the path is a relative path
- * 
+ *
  * @example root(fromString("C:/Users/me/")) == Ok(Drive('C'))
  * @example root(fromString("/home/me/")) == Ok(Root)
  * @example root(fromString("./file.txt")) == Err(IncompatiblePathType)
- * 
+ *
  * @since v0.5.5
  */
-export let root = (path: Path) => {
+provide let root = (path: Path) => {
   match (pathInfo(path)) {
     (Rel(_), _, _) => Err(IncompatiblePathType),
     pathInfo => Ok(rootHelper(pathInfo)),