2020-01-04 16:52:21 +00:00
# HPath libraries
2015-05-08 12:35:05 +00:00
2020-01-04 17:39:42 +00:00
[](https://gitter.im/hasufell/hpath?utm_source=badge& utm_medium=badge& utm_campaign=pr-badge& utm_content=badge) [](http://travis-ci.org/hasufell/hpath)
2016-05-09 16:06:40 +00:00
2020-01-04 16:52:21 +00:00
Set of libraries to deal with filepaths and files.
2016-01-28 11:47:46 +00:00
## Motivation
2020-01-04 16:52:21 +00:00
* filepaths should be type-safe (absolute, relative, ...)
* filepaths should be ByteString under the hood, see [Abstract FilePath Proposal (AFPP) ](https://gitlab.haskell.org/ghc/ghc/wikis/proposal/abstract-file-path )
* file high-level operations should be platform-specific, exception-stable, safe and as atomic as possible
Fork chrisdone's path library
I wasn't happy with the way it dealt with Dir vs File things. In his
version of the library, a `Path b Dir` always ends with a trailing
path separator and `Path b File` never ends with a trailing path separator.
IMO, it is nonsensical to make a Dir vs File distinction on path level,
although it first seems nice.
Some of the reasons are:
* a path is just that: a path. It is completely disconnected from IO level
and even if a `Dir`/`File` type theoretically allows us to say "this path
ought to point to a file", there is literally zero guarantee that it will
hold true at runtime. So this basically gives a false feeling of a
type-safe file distinction.
* it's imprecise about Dir vs File distinction, which makes it even worse,
because a directory is also a file (just not a regular file). Add symlinks
to that and the confusion is complete.
* it makes the API oddly complicated for use cases where we basically don't
care (yet) whether something turns out to be a directory or not
Still, it comes also with a few perks:
* it simplifies some functions, because they now have guarantees whether a
path ends in a trailing path separator or not
* it may be safer for interaction with other library functions, which behave
differently depending on a trailing path separator (like probably shelly)
Not limited to, but also in order to fix my remarks without breaking any
benefits, I did:
* rename the `Dir`/`File` types to `TPS`/`NoTPS`, so it's clear we are only
giving information about trailing path separators and not actual file
types we don't know about yet
* add a `MaybeTPS` type, which does not mess with trailing path separators
and also gives no guarantees about them... then added `toNoTPS` and
`toTPS` to allow type-safe conversion
* make some functions accept more general types, so we don't unnecessarily
force paths with trailing separators for `(</>)` for example... instead
these functions now examine the paths to still have correct behavior.
This is really minor overhead. You might say now "but then I can append
filepath to filepath". Well, as I said... we don't know whether it's a
"filepath" at all.
* merge `filename` and `dirname` into `basename` and make `parent` be
`dirname`, so the function names match the name of the POSIX ones,
which do (almost) the same...
* fix a bug in `basename` (formerly `dirname`) which broke the type
guarantees
* add a pattern synonym for easier pattern matching without exporting
the internal Path constructor
2016-03-08 21:53:42 +00:00
2020-01-04 16:52:21 +00:00
## Projects
2016-05-30 14:02:08 +00:00
2020-01-04 18:58:20 +00:00
* [](https://hackage.haskell.org/package/hpath) [hpath ](./hpath ): Support for well-typed paths
* [](https://hackage.haskell.org/package/hpath-filepath) [hpath-filepath ](./hpath-filepath ): ByteString based filepath manipulation (can be used without hpath)
2020-01-26 20:49:52 +00:00
* [](https://hackage.haskell.org/package/hpath-directory) [hpath-directory ](./hpath-directory ): Hhigh-level IO operations for files/directories on raw ByteString filepaths (use hpath-io for the type-safe path version)
* [](https://hackage.haskell.org/package/hpath-io) [hpath-io ](./hpath-io ): High-level IO operations for files/directories utilizing type-safe Path
