Beging work to port f.el to Haskell

This is a work-in-progress. I'd like to add a README to this project to explain
my intention. The goal, roughly, is to port Elisp's fantastic f.el module to
Haskell. I consider Haskell APIs to be useful but somewhat sloppily designed. In
the same spirit as Elixir wrapping Erlang APIs, many of the functions I intend
to define will simply wrap existing Haskell APIs, but with a hopefully cleaner
API that I find more intuitive.

haskell-file/f-todo.org

@@ -0,0 +1,67 @@
+* Paths
+** TODO f-join (&rest args)
+** TODO f-split (path)
+** TODO f-expand (path &optional dir)
+** TODO f-filename (path)
+** TODO f-dirname (path)
+** TODO f-common-parent (paths)
+** TODO f-ext (path)
+** TODO f-no-ext (path)
+** TODO f-swap-ext (path ext)
+** TODO f-base (path)
+** TODO f-relative (path &optional dir)
+** TODO f-short (path)
+** TODO f-long (path)
+** TODO f-canonical (path)
+** TODO f-slash (path)
+** TODO f-full (path)
+** TODO f-uniquify (paths)
+** TODO f-uniquify-alist (paths)
+* I/O
+** TODO f-read-bytes (path)
+** TODO f-write-bytes (data path)
+** TODO f-read-text (path &optional coding)
+** TODO f-write-text(text coding path)
+** TODO f-append-text(text coding path)
+** TODO f-append-bytes(text coding path)
+** TODO Destructive
+** TODO f-mkdir (&rest dirs)
+** TODO f-delete (path &optional force)
+** TODO f-symlink (source path)
+** TODO f-move (from to)
+** TODO f-copy (from to)
+** TODO f-copy-contenst (from to)
+** TODO f-touch (path)
+** TODO Predicates
+** TODO f-exists? (path)
+** TODO f-directory? (path)
+** TODO f-file? (path)
+** TODO f-symlink? (path)
+** TODO f-readable? (path)
+** TODO f-writable? (path)
+** TODO f-executable? (path)
+** TODO f-absolute? (path)
+** TODO f-relative? (path)
+** TODO f-root? (path)
+** TODO f-ext? (path ext)
+** TODO f-same? (path-a path-b)
+** TODO f-parent-of? (path-a path-b)
+** TODO f-child-of? (path-a path-b)
+** TODO f-ancestor-of? (path-a path-b)
+** TODO f-descendant-of? (path-a path-b)
+** TODO f-hidden? (path)
+** TODO f-empty? (path)
+** TODO Stats
+** TODO f-size (path)
+** f-depth (path)
+
+* Misc
+** TODO f-this-file ()
+** TODO f-path-separator ()
+** TODO f-glob (pattern &optional path)
+** TODO f-entries (path &optional fn recursive)
+** TODO f-directories (path &optional fn recursive)
+** TODO f-files (path &optional fn recursive)
+** TODO f-root ()
+** TODO f-traverse-upwards (fn &optional path)
+** TODO f-with-sandbox (path-or-paths &rest body)

haskell-file/f.hs

@@ -0,0 +1,47 @@
+module F
+  ( join
+  ) where
+
+import System.FilePath.Posix (FilePath)
+import qualified System.FilePath.Posix as F
+
+-- TODO: Move this to a misc.hs, prelude.hs, operators.hs; somewhere.
+(|>) :: a -> (a -> b) -> b
+(|>) a f = f a
+infixl 1 |>
+
+-- TODO: Move this to a test_utils.hs or elsewhere.
+simpleAssert :: (Eq a) => a -> a -> ()
+simpleAssert x y =
+  if x == y then
+    ()
+  else
+    error "Assertion error"
+
+--------------------------------------------------------------------------------
+-- Library
+--------------------------------------------------------------------------------
+
+join :: [FilePath] -> FilePath
+join = F.joinPath
+
+--------------------------------------------------------------------------------
+-- Tests
+--------------------------------------------------------------------------------
+
+expected :: [([FilePath], FilePath)]
+expected = [ (["path"], "path")
+           , (["/path"], "/path")
+           , (["path", "to", "file"], "path/to/file")
+           , (["/path", "to", "file"], "/path/to/file")
+           , (["/"], "/")
+           ]
+
+runTests :: [()]
+runTests =
+  fmap (\(input, expected) -> simpleAssert (join input) expected) expected
+
+main :: IO ()
+main = do
+  print runTests
+  pure ()

haskell-file/shell.nix

@@ -0,0 +1,9 @@
+with import <nixpkgs> {};
+
+stdenv.mkDerivation {
+  name = "f-hs";
+  buildInputs = [
+    (pkgs.haskellPackages.ghcWithPackages (pkgs: [
+    ]))
+  ];
+}