A Path is an internal structure representing some namespace in the codebase.

Foo.Bar.baz becomes [Foo, Bar, "baz"].

NB: This shouldn’t be exposed outside of this module (preferPath', Absolute, or Relative), but it’s currently used pretty widely. Such usage should be replaced when encountered.

A namespace that may be either absolute or relative, This is the most general type that should be used.

An absolute from the current project root

A namespace path that doesn’t necessarily start from the root. Typically refers to a path from the current namespace.

This always prefixes, since the secend argument can never be Absolute.

Returns Nothing if the second argument is absolute. A common pattern is fromMaybe path $ maybePrefix prefix path to use the unmodified path in that case.

examples: unprefix .foo.bar .blah == .blah (absolute paths left alone) unprefix .foo.bar id == id (relative paths starting w/ nonmatching prefix left alone) unprefix .foo.bar foo.bar.baz == baz (relative paths w/ common prefix get stripped)

Returns Nothing if the second argument is absolute. A common pattern is fromMaybe name $ maybePrefixName prefix name to use the unmodified path in that case.

Remove a path prefix from a name. Returns Nothing if there are no remaining segments to construct the name from.

>>> unprefixName (Absolute $ fromList ["base", "List"]) (Name.unsafeFromText "base.List.map")
Just (Name Relative (NameSegment {toText = "map"} :| []))

Finds the longest shared path prefix of two paths. Returns (shared prefix, path to first location from shared prefix, path to second location from shared prefix)

>>> longestPathPrefix ("a" :< "b" :< "x" :< Empty) ("a" :< "b" :< "c" :< Empty)
(a.b,x,c)

>>> longestPathPrefix Empty ("a" :< "b" :< "c" :< Empty)
(,,a.b.c)

Construct a Path' from a text

>>> fromText' "a.b.c"
a.b.c

>>> fromText' ".a.b.c"
.a.b.c

>>> show $ fromText' ""
""

Convert a Path' to a Name

Note: This treats the path as relative.

>>> splitFromName "a.b.c"
(a.b,c)

>>> splitFromName "foo"
(,foo)