filepather 0.4.1 → 0.5

raw patch · 11 files changed

+580/−495 lines, 11 filesdep +containersdep −semigroupsdep ~basedep ~bytestringdep ~contravariantPVP ok

version bump matches the API change (PVP)

Dependencies added: containers

Dependencies removed: semigroups

Dependency ranges changed: base, bytestring, contravariant, directory, filepath, lens, mmorph, mtl, semigroupoids, time, transformers

API changes (from Hackage documentation)

Files

• changelog.md +7/−0
• filepather.cabal +18/−18
• src/System/FilePath/FilePather.hs +2/−2
• src/System/FilePath/FilePather/ByteString.hs +42/−0
• src/System/FilePath/FilePather/Compose.hs +0/−55
• src/System/FilePath/FilePather/Directory.hs +123/−89
• src/System/FilePath/FilePather/Find.hs +53/−83
• src/System/FilePath/FilePather/IO.hs +121/−0
• src/System/FilePath/FilePather/Posix.hs +61/−60
• src/System/FilePath/FilePather/ReadFilePath.hs +153/−111
• src/System/FilePath/FilePather/ToFilePath.hs +0/−77

@@ -1,3 +1,10 @@+0.5++* Introduce `Either` into filepath reader+* Remove `ToFilePath`+* Remove some functions that do not fit+* Update GHC version requirement >= 9+ 0.4.1  * Add `System.Directory`

@@ -1,5 +1,5 @@ name:                 filepather-version:              0.4.1+version:              0.5 synopsis:             Functions on System.FilePath description:   Functions over @System.FilePath@ including a find function for recursing down directories.@@ -7,14 +7,14 @@ license-file:         LICENCE author:               Tony Morris <ʇǝu˙sıɹɹoɯʇ@ןןǝʞsɐɥ> maintainer:           Tony Morris <ʇǝu˙sıɹɹoɯʇ@ןןǝʞsɐɥ>-copyright:            Copyright (C) 2021 Tony Morris+copyright:            Copyright (C) 2021-2023 Tony Morris category:             Test build-type:           Simple extra-source-files:   changelog.md cabal-version:        >=1.10 homepage:             https://gitlab.com/tonymorris/filepather bug-reports:          https://gitlab.com/tonymorris/filepather/issues-tested-with:          GHC == 8.0.2, GHC == 8.2.2, GHC == 8.4.3, GHC == 8.6.5+tested-with:          GHC == 9.0.2  source-repository     head   type:               git@@ -23,25 +23,25 @@ library   exposed-modules:                       System.FilePath.FilePather-                      System.FilePath.FilePather.Compose+                      System.FilePath.FilePather.ByteString                       System.FilePath.FilePather.Directory                       System.FilePath.FilePather.Find-                      System.FilePath.FilePather.ReadFilePath-                      System.FilePath.FilePather.ToFilePath+                      System.FilePath.FilePather.IO                       System.FilePath.FilePather.Posix+                      System.FilePath.FilePather.ReadFilePath -  build-depends:        base >= 4.8 && < 6-                      , bytestring >= 0.10 && < 0.12-                      , contravariant >= 1 && < 2-                      , directory >= 1.3 && < 2-                      , filepath >= 1.4 && < 2-                      , lens >= 4 && < 6-                      , mmorph >= 1.1 && < 2-                      , mtl >= 2.2 && < 2.3-                      , semigroups >= 0.9 && < 1-                      , semigroupoids >= 5.2 && < 6-                      , time >= 1.2 && < 2-                      , transformers >= 0.5 && < 0.7+  build-depends:         base                 >= 4.15 && < 6+                       , bytestring           >= 0.11.2.0 && < 0.12+                       , containers           >= 0.6.4.1 && < 0.7+                       , contravariant        >= 1.5.5 && < 2+                       , directory            >= 1.3.7.1 && < 2+                       , filepath             >= 1.4.2.1 && < 2+                       , lens                 >= 5.2.3 && < 6+                       , mmorph               >= 1.2.0 && < 2+                       , mtl                  >= 2.2.2 && < 3+                       , semigroupoids        >= 6.0.0.1 && < 7+                       , time                 >= 1.9.3 && < 2+                       , transformers         >= 0.5.6.2 && < 0.6    hs-source-dirs:     src   default-language:   Haskell2010

@@ -2,9 +2,9 @@   module P ) where -import System.FilePath.FilePather.Compose as P+import System.FilePath.FilePather.ByteString as P import System.FilePath.FilePather.Directory as P import System.FilePath.FilePather.Find as P+import System.FilePath.FilePather.IO as P import System.FilePath.FilePather.Posix as P import System.FilePath.FilePather.ReadFilePath as P-import System.FilePath.FilePather.ToFilePath as P

@@ -0,0 +1,42 @@+{-# OPTIONS_GHC -Wall #-}+{-# LANGUAGE NoImplicitPrelude #-}++module System.FilePath.FilePather.ByteString(+  fromFilePath+, readFileB+, writeFileB+, appendFileB+) where++import Control.Exception ( Exception )+import Data.ByteString( ByteString )+import qualified Data.ByteString as B+import System.FilePath.FilePather.ReadFilePath+    ( ReadFilePathT, tryReadFilePath )+import System.IO ( IO )++fromFilePath ::+  Exception e =>+  ReadFilePathT e IO ByteString+fromFilePath =+  tryReadFilePath B.fromFilePath++readFileB ::+  Exception e =>+  ReadFilePathT e IO ByteString+readFileB =+  tryReadFilePath B.readFile++writeFileB ::+  Exception e =>+  ByteString+  -> ReadFilePathT e IO ()+writeFileB s =+  tryReadFilePath (`B.writeFile` s)++appendFileB ::+  Exception e =>+  ByteString+  -> ReadFilePathT e IO ()+appendFileB s =+  tryReadFilePath (`B.appendFile` s)

@@ -1,55 +0,0 @@-{-# OPTIONS_GHC -Wall #-}-{-# LANGUAGE NoImplicitPrelude #-}--module System.FilePath.FilePather.Compose(-  composeToRead-, (->>-)-, composeReadTo-, (-<<-)-) where--import Control.Lens ( view, Wrapped(_Wrapped') )-import Data.Functor.Bind ( (-<-), (->-), Bind )-import System.FilePath.FilePather.ReadFilePath-    ( ReadFilePathT(..) )-import System.FilePath.FilePather.ToFilePath ( ToFilePathT(..) )--composeToRead ::-  Bind f =>-  ToFilePathT f a-  -> ReadFilePathT f b-  -> a-  -> f b-composeToRead f g =-  view _Wrapped' f ->- view _Wrapped' g--(->>-) ::-  Bind f =>-  ToFilePathT f a-  -> ReadFilePathT f b-  -> a-  -> f b-(->>-) =-  composeToRead--infixr 1 ->>---composeReadTo ::-  Bind f =>-  ReadFilePathT f b-  -> ToFilePathT f a-  -> a-  -> f b-composeReadTo f g =-  view _Wrapped' f -<- view _Wrapped' g--(-<<-) ::-  Bind f =>-  ReadFilePathT f b-  -> ToFilePathT f a-  -> a-  -> f b-(-<<-) =-  composeReadTo--infixr 1 -<<-

@@ -48,245 +48,279 @@ ) where  import Control.Category ( Category((.)) )+import Control.Exception ( Exception ) import Control.Lens ( over, _Wrapped )-import Data.Maybe ( Maybe )-import Data.Bool ( Bool )+import Data.Maybe ( Maybe, maybe )+import Data.Bool ( Bool(..) )+import Data.Either ( Either(Right, Left), either )+import Data.Functor ( Functor(fmap) ) import Data.Time ( UTCTime ) import GHC.Num( Integer ) import qualified System.Directory as D import System.Directory as SD(getCurrentDirectory, getHomeDirectory, XdgDirectory(..), XdgDirectoryList(..), getXdgDirectoryList, getUserDocumentsDirectory, getTemporaryDirectory, exeExtension, Permissions(..), emptyPermissions, readable, writable, executable, searchable, setOwnerReadable, setOwnerWritable, setOwnerExecutable, setOwnerSearchable) import System.FilePath.FilePather.ReadFilePath-    ( ReadFilePathT(..) ) import System.FilePath ( FilePath ) import System.IO ( IO )  createDirectory ::-  ReadFilePathT IO ()+  Exception e =>+  ReadFilePathT1 e IO createDirectory =-  ReadFilePathT D.createDirectory+  tryReadFilePath D.createDirectory  createDirectoryIfMissing ::+  Exception e =>   Bool-  -> ReadFilePathT IO ()+  -> ReadFilePathT1 e IO createDirectoryIfMissing =-  ReadFilePathT . D.createDirectoryIfMissing+  tryReadFilePath . D.createDirectoryIfMissing  removeDirectory ::-  ReadFilePathT IO ()+  Exception e =>+  ReadFilePathT1 e IO removeDirectory =-  ReadFilePathT D.removeDirectory+  tryReadFilePath D.removeDirectory  removeDirectoryRecursive ::-  ReadFilePathT IO ()+  Exception e =>+  ReadFilePathT1 e IO removeDirectoryRecursive =-  ReadFilePathT D.removeDirectoryRecursive+  tryReadFilePath D.removeDirectoryRecursive  removePathForcibly ::-  ReadFilePathT IO ()+  Exception e =>+  ReadFilePathT1 e IO removePathForcibly =-  ReadFilePathT D.removePathForcibly+  tryReadFilePath D.removePathForcibly  renameDirectory ::+  Exception e =>   FilePath-  -> ReadFilePathT IO ()+  -> ReadFilePathT1 e IO renameDirectory =-  ReadFilePathT . D.renameDirectory+  tryReadFilePath . D.renameDirectory  listDirectory ::-  ReadFilePathT IO [FilePath]+  Exception e =>+  ReadFilePathT e IO [FilePath] listDirectory =-  ReadFilePathT D.listDirectory+  tryReadFilePath D.listDirectory  getDirectoryContents ::-  ReadFilePathT IO [FilePath]+  Exception e =>+  ReadFilePathT e IO [FilePath] getDirectoryContents =-  ReadFilePathT D.listDirectory+  tryReadFilePath D.listDirectory  withCurrentDirectory ::+  Exception e =>   IO a-  -> ReadFilePathT IO a+  -> ReadFilePathT e IO a withCurrentDirectory io =-  ReadFilePathT (`D.withCurrentDirectory` io)+  tryReadFilePath (`D.withCurrentDirectory` io)  getXdgDirectory ::+  Exception e =>   XdgDirectory-  -> ReadFilePathT IO FilePath+  -> ReadFilePathT e IO FilePath getXdgDirectory xdg =-  ReadFilePathT (D.getXdgDirectory xdg)+  tryReadFilePath (D.getXdgDirectory xdg)  getAppUserDataDirectory ::-  ReadFilePathT IO FilePath+  Exception e =>+  ReadFilePathT e IO FilePath getAppUserDataDirectory =-  ReadFilePathT D.getAppUserDataDirectory+  tryReadFilePath D.getAppUserDataDirectory  removeFile ::-  ReadFilePathT IO ()+  Exception e =>+  ReadFilePathT1 e IO removeFile =-  ReadFilePathT D.removeFile+  tryReadFilePath D.removeFile  renameFile ::+  Exception e =>   FilePath-  -> ReadFilePathT IO ()+  -> ReadFilePathT1 e IO renameFile =-  ReadFilePathT . D.renameFile+  tryReadFilePath . D.renameFile  renamePath ::+  Exception e =>   FilePath-  -> ReadFilePathT IO ()+  -> ReadFilePathT1 e IO renamePath =-  ReadFilePathT . D.renamePath+  tryReadFilePath . D.renamePath  copyFile ::+  Exception e =>   FilePath-  -> ReadFilePathT IO ()+  -> ReadFilePathT1 e IO copyFile =-  ReadFilePathT . D.copyFile+  tryReadFilePath . D.copyFile  copyFileWithMetadata ::+  Exception e =>   FilePath-  -> ReadFilePathT IO ()+  -> ReadFilePathT1 e IO copyFileWithMetadata =-  ReadFilePathT . D.copyFileWithMetadata+  tryReadFilePath . D.copyFileWithMetadata  getFileSize ::-  ReadFilePathT IO Integer+  Exception e =>+  ReadFilePathT e IO Integer getFileSize =-  ReadFilePathT D.getFileSize+  tryReadFilePath D.getFileSize  canonicalizePath ::-  ReadFilePathT IO FilePath+  Exception e =>+  ReadFilePathT e IO FilePath canonicalizePath =-  ReadFilePathT D.canonicalizePath+  tryReadFilePath D.canonicalizePath  makeAbsolute ::-  ReadFilePathT IO FilePath+  Exception e =>+  ReadFilePathT e IO FilePath makeAbsolute =-  ReadFilePathT D.makeAbsolute+  tryReadFilePath D.makeAbsolute  makeRelativeToCurrentDirectory ::-  ReadFilePathT IO FilePath+  Exception e =>+  ReadFilePathT e IO FilePath makeRelativeToCurrentDirectory =-  ReadFilePathT D.makeRelativeToCurrentDirectory+  tryReadFilePath D.makeRelativeToCurrentDirectory  doesPathExist ::-  ReadFilePathT IO Bool+  ReadFilePathT e IO Bool doesPathExist =-  ReadFilePathT D.doesPathExist+  successReadFilePath D.doesPathExist  doesFileExist ::-  ReadFilePathT IO Bool+  ReadFilePathT e IO Bool doesFileExist =-  ReadFilePathT D.doesFileExist+  successReadFilePath D.doesFileExist  doesDirectoryExist ::-  ReadFilePathT IO Bool+  ReadFilePathT e IO Bool doesDirectoryExist =-  ReadFilePathT D.doesDirectoryExist+  successReadFilePath D.doesDirectoryExist  findExecutable ::-  ReadFilePathT IO (Maybe FilePath)+  ReadFilePathT e IO (Maybe FilePath) findExecutable =-  ReadFilePathT D.findExecutable+  successReadFilePath D.findExecutable  findExecutables ::-  ReadFilePathT IO [FilePath]+  ReadFilePathT e IO [FilePath] findExecutables =-  ReadFilePathT D.findExecutables+  successReadFilePath D.findExecutables  findExecutablesInDirectories ::   [FilePath]-  -> ReadFilePathT IO [FilePath]+  -> ReadFilePathT e IO [FilePath] findExecutablesInDirectories =-  ReadFilePathT . D.findExecutablesInDirectories+  successReadFilePath . D.findExecutablesInDirectories  findFile ::   [FilePath]-  -> ReadFilePathT IO (Maybe FilePath)+  -> ReadFilePathT e IO (Maybe FilePath) findFile =-  ReadFilePathT . D.findFile+  successReadFilePath . D.findFile  findFiles ::   [FilePath]-  -> ReadFilePathT IO [FilePath]+  -> ReadFilePathT e IO [FilePath] findFiles =-  ReadFilePathT . D.findFiles+  successReadFilePath . D.findFiles  findFileWith ::-  ReadFilePathT IO Bool+  ReadFilePathT () IO ()   -> [FilePath]-  -> ReadFilePathT IO (Maybe FilePath)+  -> ReadFilePathT () IO FilePath findFileWith x ps =-  over _Wrapped (`D.findFileWith` ps) x+  over _Wrapped (\k -> fmap (maybe (Left ()) Right) . D.findFileWith (fmap (either (\() -> False) (\() -> True)) . k) ps) x  findFilesWith ::-  ReadFilePathT IO Bool+  ReadFilePathT () IO ()   -> [FilePath]-  -> ReadFilePathT IO [FilePath]+  -> ReadFilePathT e' IO [FilePath] findFilesWith x ps =-  over _Wrapped (`D.findFilesWith` ps) x+  over _Wrapped (\w -> fmap Right . D.findFilesWith (fmap (either (\() -> False) (\() -> True)) . w) ps) x  createFileLink ::+  Exception e =>   FilePath-  -> ReadFilePathT IO ()+  -> ReadFilePathT1 e IO createFileLink =-  ReadFilePathT . D.createFileLink+  tryReadFilePath . D.createFileLink  createDirectoryLink ::+  Exception e =>   FilePath-  -> ReadFilePathT IO ()+  -> ReadFilePathT1 e IO createDirectoryLink =-  ReadFilePathT . D.createDirectoryLink+  tryReadFilePath . D.createDirectoryLink  removeDirectoryLink ::-  ReadFilePathT IO ()+  Exception e =>+  ReadFilePathT1 e IO removeDirectoryLink =-  ReadFilePathT D.removeDirectoryLink+  tryReadFilePath D.removeDirectoryLink  pathIsSymbolicLink ::-  ReadFilePathT IO Bool+  Exception e =>+  ReadFilePathT e IO Bool pathIsSymbolicLink =-  ReadFilePathT D.pathIsSymbolicLink+  tryReadFilePath D.pathIsSymbolicLink  getSymbolicLinkTarget ::-  ReadFilePathT IO FilePath+  Exception e =>+  ReadFilePathT e IO FilePath getSymbolicLinkTarget =-  ReadFilePathT D.getSymbolicLinkTarget+  tryReadFilePath D.getSymbolicLinkTarget  getPermissions ::-  ReadFilePathT IO Permissions+  Exception e =>+  ReadFilePathT e IO Permissions getPermissions =-  ReadFilePathT D.getPermissions+  tryReadFilePath D.getPermissions  setPermissions ::+  Exception e =>   Permissions-  -> ReadFilePathT IO ()+  -> ReadFilePathT1 e IO setPermissions p =-  ReadFilePathT (`D.setPermissions` p)+  tryReadFilePath (`D.setPermissions` p)  copyPermissions ::+  Exception e =>   FilePath-  -> ReadFilePathT IO ()+  -> ReadFilePathT1 e IO copyPermissions =-  ReadFilePathT . D.copyPermissions+  tryReadFilePath . D.copyPermissions  getAccessTime ::-  ReadFilePathT IO UTCTime+  Exception e =>+  ReadFilePathT e IO UTCTime getAccessTime =-  ReadFilePathT D.getAccessTime+  tryReadFilePath D.getAccessTime  getModificationTime ::-  ReadFilePathT IO UTCTime+  Exception e =>+  ReadFilePathT e IO UTCTime getModificationTime =-  ReadFilePathT D.getModificationTime+  tryReadFilePath D.getModificationTime  setAccessTime ::+  Exception e =>   UTCTime-  -> ReadFilePathT IO ()+  -> ReadFilePathT1 e IO setAccessTime u =-  ReadFilePathT (`D.setAccessTime` u)+  tryReadFilePath (`D.setAccessTime` u)  setModificationTime ::+  Exception e =>   UTCTime-  -> ReadFilePathT IO ()+  -> ReadFilePathT1 e IO setModificationTime u =-  ReadFilePathT (`D.setModificationTime` u)+  tryReadFilePath (`D.setModificationTime` u)

@@ -2,93 +2,63 @@ {-# LANGUAGE NoImplicitPrelude #-}  module System.FilePath.FilePather.Find(-  findAllFiles-, always-, findFilesAlways-, findFilesBase-, findFilesBaseAlways+  findWith+, findDirectories+, findAll+, findAllFiles ) where -import Control.Applicative ( Applicative(liftA2, pure) )-import Control.Category ( Category(id) )-import Control.Lens ( view )-import Control.Monad ( join, Monad((>>=)) )-import Control.Monad.Reader.Class ( MonadReader(ask) )-import System.FilePath.FilePather.Posix-    ( (</>), FilePath, dropTrailingPathSeparator )-import System.IO ( IO )-import Data.Bool ( Bool(True), bool )-import Data.Function(($))-import Data.Functor ( Functor(fmap) )-import Data.Traversable ( Traversable(traverse) )+import Control.Applicative ( Applicative(pure) )+import Control.Category ( Category((.)) )+import Control.Exception ( Exception )+import Control.Lens ( view, _Wrapped )+import Control.Monad ( Monad((>>=)), filterM )+import Control.Monad.IO.Class ( MonadIO(liftIO) )+import Control.Monad.Reader ( MonadReader(local, ask) )+import Data.Bool ( Bool(True) )+import Data.Foldable ( fold )+import Data.Functor ( Functor(fmap), (<$>) ) import Data.Semigroup ( Semigroup((<>)) )-import System.Directory(doesDirectoryExist, listDirectory)-import System.FilePath.FilePather.ReadFilePath-    ( ReadFilePathT(..), readFilePath )--findAllFiles ::-  ReadFilePathT IO Bool-  -> ReadFilePathT IO [FilePath]-findAllFiles (ReadFilePathT test) =-  let bool' ::-        Monad f =>-        f a-        -> f a-        -> f Bool-        -> f a-      bool' f t p =-        p >>= bool f t-      partitionM ::-        Applicative m =>-        (a -> m Bool)-        -> [a]-        -> m ([a], [a])-      partitionM _ [] =-        pure ([], [])-      partitionM f (x:xs) =-        liftA2-          (\res (as, bs) ->-            let onres p q =-                  bool p q res-            in  (onres id (x:) as, onres (x:) id bs)-          )-          (f x)-          (partitionM f xs)-      findFiles' base dx =-        bool'-          (pure [])-          (-            let findFiles'' dir =-                  let dir' =-                        base </> dir-                  in  do  (dirs,files) <- listDirectory dir' >>= partitionM (\d -> doesDirectoryExist (dir' </> d))-                          rest <- fmap join (traverse (\d -> findFiles'' (dir </> d)) dirs)-                          pure (fmap (dir </>) files <> rest)-            in  findFiles'' dx-          )-          (test $ view readFilePath dropTrailingPathSeparator dx)-  in  ReadFilePathT (`findFiles'` "")+import Data.Traversable ( Traversable(traverse) )+import System.FilePath ( FilePath, (</>) )+import System.FilePath.FilePather.Directory+    ( listDirectory, doesFileExist, doesDirectoryExist )+import System.FilePath.FilePather.ReadFilePath ( ReadFilePathT )+import System.IO ( IO )+import System.IO.Unsafe( unsafeInterleaveIO ) -always ::-  Applicative f =>-  ReadFilePathT f Bool-always =-  pure True+findWith ::+  Exception e =>+  ReadFilePathT e IO Bool+  -> ReadFilePathT e IO [FilePath]+findWith p =+  let setl =+        local . pure+  in  do  z <- ask+          a <- listDirectory+          b <- filterM (`setl` p) ((z </>) <$> a)+          d <- filterM (`setl` doesDirectoryExist) b+          case d of+            [] ->+              pure b+            _ ->+              do  n <- liftIO (unsafeInterleaveIO (fmap (>>= fold) (traverse (view _Wrapped (findWith p)) d)))+                  pure (b <> n) -findFilesAlways ::-  ReadFilePathT IO [FilePath]-findFilesAlways =-  findAllFiles always+findDirectories ::+  Exception e =>+  ReadFilePathT e IO [FilePath]+findDirectories =+  findWith doesDirectoryExist -findFilesBase ::-  ReadFilePathT IO Bool-  -> ReadFilePathT IO [FilePath]-findFilesBase r =-  do  p <- ask-      z <- findAllFiles r-      pure (fmap (p </>) z)+findAll ::+  Exception e =>+  ReadFilePathT e IO [FilePath]+findAll =+  findWith (pure True) -findFilesBaseAlways ::-  ReadFilePathT IO [FilePath]-findFilesBaseAlways =-  findFilesBase always+findAllFiles ::+  Exception e =>+  ReadFilePathT e IO [FilePath]+findAllFiles =+  findAll >>= filterM (\p -> local (pure p) doesFileExist)

@@ -0,0 +1,121 @@+{-# OPTIONS_GHC -Wall #-}+{-# LANGUAGE NoImplicitPrelude #-}++module System.FilePath.FilePather.IO(+  readFile+, readFile'+, appendFile+, writeFile+, withFile+, openFile+, withBinaryFile+, openBinaryFile+, openTempFile+, openBinaryTempFile+, openTempFileWithDefaultPermissions+, openBinaryTempFileWithDefaultPermissions+) where++import Control.Exception ( Exception )+import Data.String ( String )+import System.FilePath(FilePath)+import System.FilePath.FilePather.ReadFilePath+    ( ReadFilePathT, tryReadFilePath )+import qualified System.IO as I+    ( appendFile,+      readFile,+      writeFile,+      openBinaryFile,+      openFile,+      openBinaryTempFile,+      openBinaryTempFileWithDefaultPermissions,+      openTempFile,+      openTempFileWithDefaultPermissions,+      readFile',+      withBinaryFile,+      withFile )+import System.IO(IO, IOMode, Handle)++readFile ::+  Exception e =>+  ReadFilePathT e IO String+readFile =+  tryReadFilePath I.readFile++readFile' ::+  Exception e =>+  ReadFilePathT e IO String+readFile' =+  tryReadFilePath I.readFile'++appendFile ::+  Exception e =>+  String+  -> ReadFilePathT e IO ()+appendFile s =+  tryReadFilePath (`I.appendFile` s)++writeFile ::+  Exception e =>+  String+  -> ReadFilePathT e IO ()+writeFile s =+  tryReadFilePath (`I.writeFile` s)++withFile ::+  Exception e =>+  IOMode+  -> (Handle -> IO r)+  -> ReadFilePathT e IO r+withFile mode k =+  tryReadFilePath (\p -> I.withFile p mode k)++openFile ::+  Exception e =>+  IOMode+  -> ReadFilePathT e IO Handle+openFile mode =+  tryReadFilePath (`I.openFile` mode)++withBinaryFile ::+  Exception e =>+  IOMode+  -> (Handle -> IO r)+  -> ReadFilePathT e IO r+withBinaryFile mode k =+  tryReadFilePath (\p -> I.withBinaryFile p mode k)++openBinaryFile ::+  Exception e =>+  IOMode+  -> ReadFilePathT e IO Handle+openBinaryFile mode =+  tryReadFilePath (`I.openBinaryFile` mode)++openTempFile ::+  Exception e =>+  String+  -> ReadFilePathT e IO (FilePath, Handle)+openTempFile s =+  tryReadFilePath (`I.openTempFile` s)++openBinaryTempFile ::+  Exception e =>+  String+  -> ReadFilePathT e IO (FilePath, Handle)+openBinaryTempFile s =+  tryReadFilePath (`I.openBinaryTempFile` s)++openTempFileWithDefaultPermissions ::+  Exception e =>+  String+  -> ReadFilePathT e IO (FilePath, Handle)+openTempFileWithDefaultPermissions s =+  tryReadFilePath (`I.openTempFileWithDefaultPermissions` s)++openBinaryTempFileWithDefaultPermissions ::+  Exception e =>+  String+  -> ReadFilePathT e IO (FilePath, Handle)+openBinaryTempFileWithDefaultPermissions s =+  tryReadFilePath (`I.openBinaryTempFileWithDefaultPermissions` s)

@@ -1,7 +1,7 @@ {-# OPTIONS_GHC -Wall #-} {-# LANGUAGE NoImplicitPrelude #-} -module System.FilePath.FilePather.Posix(+module System.FilePath.FilePather.Posix (   splitExtension , takeExtension , replaceExtension@@ -24,7 +24,6 @@ , replaceDirectory , combine , splitPath-, joinPath , splitDirectories , splitDrive , joinDrive@@ -47,254 +46,256 @@  import Control.Applicative ( Applicative ) import Control.Category((.))-import Control.Lens ( (#) ) import Data.String( String ) import Data.Bool( Bool ) import Data.Maybe ( Maybe ) import qualified System.FilePath.Posix as FP-import System.FilePath.Posix as SFP(FilePath, pathSeparator, pathSeparators, isPathSeparator, extSeparator, isExtSeparator, splitSearchPath, (-<.>), (</>))-import System.FilePath.FilePather.ToFilePath-    ( ToFilePath, toFilePath )+import System.FilePath.Posix as SFP(FilePath) import System.FilePath.FilePather.ReadFilePath     ( ReadFilePathT, liftReadFilePath )  splitExtension ::   Applicative f =>-  ReadFilePathT f (String, String)+  ReadFilePathT e f (String, String) splitExtension =   liftReadFilePath FP.splitExtension  takeExtension ::   Applicative f =>-  ReadFilePathT f String+  ReadFilePathT e f String takeExtension =   liftReadFilePath FP.takeExtension  replaceExtension ::   Applicative f =>-  ReadFilePathT f (String -> FilePath)+  String+  -> ReadFilePathT e f FilePath replaceExtension =-  liftReadFilePath FP.replaceExtension+  liftReadFilePath . FP.replaceExtension  dropExtension ::   Applicative f =>-  ReadFilePathT f FilePath+  ReadFilePathT e f FilePath dropExtension =   liftReadFilePath FP.dropExtensions  addExtension ::   Applicative f =>-  ReadFilePathT f (String -> FilePath)+  String+  -> ReadFilePathT e f FilePath addExtension =-  liftReadFilePath FP.addExtension+  liftReadFilePath . FP.addExtension  hasExtension ::   Applicative f =>-  ReadFilePathT f Bool+  ReadFilePathT e f Bool hasExtension =   liftReadFilePath FP.hasExtension  splitExtensions ::   Applicative f =>-  ReadFilePathT f (FilePath, String)+  ReadFilePathT e f (FilePath, String) splitExtensions =   liftReadFilePath FP.splitExtensions  dropExtensions ::   Applicative f =>-  ReadFilePathT f FilePath+  ReadFilePathT e f FilePath dropExtensions =   liftReadFilePath FP.dropExtensions  takeExtensions ::   Applicative f =>-  ReadFilePathT f String+  ReadFilePathT e f String takeExtensions =   liftReadFilePath FP.takeExtensions  replaceExtensions ::   Applicative f =>-  ReadFilePathT f (String -> FilePath)+  String+  -> ReadFilePathT e f FilePath replaceExtensions =-  liftReadFilePath FP.replaceExtensions+  liftReadFilePath . FP.replaceExtensions  isExtensionOf ::   Applicative f =>   String-  -> ReadFilePathT f Bool+  -> ReadFilePathT e f Bool isExtensionOf =   liftReadFilePath . FP.isExtensionOf  stripExtension ::   Applicative f =>   String-  -> ReadFilePathT f (Maybe FilePath)+  -> ReadFilePathT e f (Maybe FilePath) stripExtension =   liftReadFilePath . FP.stripExtension  splitFileName ::   Applicative f =>-  ReadFilePathT f (String, String)+  ReadFilePathT e f (String, String) splitFileName =   liftReadFilePath FP.splitFileName  takeFileName ::   Applicative f =>-  ReadFilePathT f String+  ReadFilePathT e f String takeFileName =   liftReadFilePath FP.takeFileName  replaceFileName ::   Applicative f =>-  ReadFilePathT f (String -> FilePath)+  String+  -> ReadFilePathT e f FilePath replaceFileName =-  liftReadFilePath FP.replaceFileName+  liftReadFilePath . FP.replaceFileName  dropFileName ::   Applicative f =>-  ReadFilePathT f FilePath+  ReadFilePathT e f FilePath dropFileName =   liftReadFilePath FP.dropFileName  takeBaseName ::   Applicative f =>-  ReadFilePathT f String+  ReadFilePathT e f String takeBaseName =   liftReadFilePath FP.takeBaseName  replaceBaseName ::   Applicative f =>-  ReadFilePathT f (String -> FilePath)+  String ->+  ReadFilePathT e f FilePath replaceBaseName =-  liftReadFilePath FP.replaceBaseName+  liftReadFilePath . FP.replaceBaseName  takeDirectory ::   Applicative f =>-  ReadFilePathT f FilePath+  ReadFilePathT e f FilePath takeDirectory =   liftReadFilePath FP.takeDirectory  replaceDirectory ::   Applicative f =>-  ReadFilePathT f (String -> FilePath)+  String ->+  ReadFilePathT e f FilePath replaceDirectory =-  liftReadFilePath FP.replaceDirectory+  liftReadFilePath . FP.replaceDirectory  combine ::   Applicative f =>-  ReadFilePathT f (FilePath -> FilePath)+  FilePath+  ->  ReadFilePathT e f FilePath combine =-  liftReadFilePath FP.combine+  liftReadFilePath . FP.combine  splitPath ::   Applicative f =>-  ReadFilePathT f [FilePath]+  ReadFilePathT e f [FilePath] splitPath =   liftReadFilePath FP.splitPath -joinPath ::-  ToFilePath [FilePath]-joinPath =-  toFilePath # FP.joinPath- splitDirectories ::   Applicative f =>-  ReadFilePathT f [FilePath]+  ReadFilePathT e f [FilePath] splitDirectories =   liftReadFilePath FP.splitDirectories  splitDrive ::   Applicative f =>-  ReadFilePathT f (FilePath, FilePath)+  ReadFilePathT e f (FilePath, FilePath) splitDrive =   liftReadFilePath FP.splitDrive  joinDrive ::   Applicative f =>-  ReadFilePathT f (FilePath -> FilePath)+  FilePath+  -> ReadFilePathT e f FilePath joinDrive =-  liftReadFilePath FP.joinDrive+  liftReadFilePath . FP.joinDrive  takeDrive ::   Applicative f =>-  ReadFilePathT f FilePath+  ReadFilePathT e f FilePath takeDrive =   liftReadFilePath FP.takeDrive  hasDrive ::   Applicative f =>-  ReadFilePathT f Bool+  ReadFilePathT e f Bool hasDrive =   liftReadFilePath FP.hasDrive  dropDrive ::   Applicative f =>-  ReadFilePathT f FilePath+  ReadFilePathT e f FilePath dropDrive =   liftReadFilePath FP.dropDrive  isDrive ::   Applicative f =>-  ReadFilePathT f Bool+  ReadFilePathT e f Bool isDrive =   liftReadFilePath FP.isDrive  hasTrailingPathSeparator ::   Applicative f =>-  ReadFilePathT f Bool+  ReadFilePathT e f Bool hasTrailingPathSeparator =   liftReadFilePath FP.hasTrailingPathSeparator  addTrailingPathSeparator ::   Applicative f =>-  ReadFilePathT f FilePath+  ReadFilePathT e f FilePath addTrailingPathSeparator =   liftReadFilePath FP.addTrailingPathSeparator  dropTrailingPathSeparator ::   Applicative f =>-  ReadFilePathT f FilePath+  ReadFilePathT e f FilePath dropTrailingPathSeparator =   liftReadFilePath FP.dropTrailingPathSeparator  normalise ::   Applicative f =>-  ReadFilePathT f FilePath+  ReadFilePathT e f FilePath normalise =   liftReadFilePath FP.normalise  equalFilePath ::   Applicative f =>-  ReadFilePathT f (FilePath -> Bool)+  FilePath+  -> ReadFilePathT e f Bool equalFilePath =-  liftReadFilePath FP.equalFilePath+  liftReadFilePath . FP.equalFilePath  makeRelative ::   Applicative f =>-  ReadFilePathT f (FilePath -> FilePath)+  FilePath+  -> ReadFilePathT e f FilePath makeRelative =-  liftReadFilePath FP.makeRelative+  liftReadFilePath . FP.makeRelative  isRelative ::   Applicative f =>-  ReadFilePathT f Bool+  ReadFilePathT e f Bool isRelative =   liftReadFilePath FP.isRelative  isAbsolute ::   Applicative f =>-  ReadFilePathT f Bool+  ReadFilePathT e f Bool isAbsolute =   liftReadFilePath FP.isAbsolute  isValid ::   Applicative f =>-  ReadFilePathT f Bool+  ReadFilePathT e f Bool isValid =   liftReadFilePath FP.isValid  makeValid ::   Applicative f =>-  ReadFilePathT f FilePath+  ReadFilePathT e f FilePath makeValid =   liftReadFilePath FP.makeValid

@@ -1,28 +1,38 @@ {-# OPTIONS_GHC -Wall #-}-{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE UndecidableInstances #-}+{-# LANGUAGE NoImplicitPrelude #-}  module System.FilePath.FilePather.ReadFilePath(-  ReadFilePathT(..)-, ReadFilePath+  ReadFilePathT , ReadFilePathT1 , ReadFilePath1 , readFilePath-, hoistReadFilePath+, swapReadFilePath+, pureReadFilePath , liftReadFilePath+, successReadFilePath+, errorReadFilePath+, maybeReadFilePath+, tryReadFilePath ) where -import Control.Applicative-    ( Applicative(liftA2, (<*>), pure), Alternative((<|>), empty) )-import Control.Category((.))+import Control.Applicative ( Applicative((<*>), pure) )+import Control.Category ( Category((.)) )+import Control.Exception ( try, Exception ) import Control.Lens-    ( iso, Iso, Rewrapped, Wrapped(Unwrapped, _Wrapped'), view, _Wrapped, ( # ) )+    ( view,+      iso,+      swapped,+      _Wrapped,+      Field1(_1),+      Iso,+      Rewrapped,+      Wrapped(..) ) import Control.Monad-    ( Monad((>>=), return), Functor(fmap), MonadPlus(mplus, mzero) )+    ( join, Monad(return, (>>=)) ) import Control.Monad.Cont.Class ( MonadCont(callCC) ) import Control.Monad.Error.Class ( MonadError(throwError, catchError) ) import Control.Monad.Fail ( MonadFail(fail) )@@ -34,138 +44,192 @@ import Control.Monad.Trans.Class(MonadTrans(lift)) import Control.Monad.Writer.Class ( MonadWriter(pass, tell, writer, listen) ) import Control.Monad.Zip ( MonadZip(mzipWith) )-import Data.Functor.Apply ( Apply(liftF2, (<.>)) )-import Data.Functor.Alt ( Alt((<!>)) )+import Data.Either ( Either(..), either )+import Data.Functor ( Functor(fmap) )+import Data.Functor.Alt ( Apply((<.>)), Alt((<!>)) ) import Data.Functor.Bind ( Bind((>>-)) )-import Data.Functor.Identity(Identity(Identity, runIdentity))-import Data.Monoid(Monoid(mappend, mempty))-import Data.Semigroup(Semigroup((<>)))-import System.FilePath(FilePath)+import Data.Functor.Identity( Identity(..) )+import Data.Maybe ( Maybe, maybe )+import Data.Monoid ( Monoid(mempty, mappend) )+import Data.Semigroup ( Semigroup((<>)) )+import System.FilePath ( FilePath )+import System.IO ( IO ) -newtype ReadFilePathT f a =-  ReadFilePathT (FilePath -> f a)+newtype ReadFilePathT e f a =+  ReadFilePathT (FilePath -> f (Either e a)) -instance ReadFilePathT f a ~ t =>-  Rewrapped (ReadFilePathT f' a') t+instance ReadFilePathT e f a ~ t =>+  Rewrapped (ReadFilePathT e' f' a') t -instance Wrapped (ReadFilePathT f a) where-  type Unwrapped (ReadFilePathT f a) =+instance Wrapped (ReadFilePathT e f a) where+  type Unwrapped (ReadFilePathT e f a) =     FilePath-    -> f a+    -> f (Either e a)   _Wrapped' =     iso (\(ReadFilePathT x) -> x) ReadFilePathT   {-# INLINE _Wrapped' #-} -type ReadFilePath a =-  ReadFilePathT Identity a+type ReadFilePath e a =+  ReadFilePathT e Identity a -type ReadFilePathT1 f =-  ReadFilePathT f ()+type ReadFilePathT1 e f =+  ReadFilePathT e f () -type ReadFilePath1 f =-  ReadFilePath ()+type ReadFilePath1 e f =+  ReadFilePath e ()  readFilePath ::   Iso-    (ReadFilePath a)-    (ReadFilePath a')-    (FilePath -> a)-    (FilePath -> a')+    (ReadFilePath e a)+    (ReadFilePath e' a')+    (FilePath -> Either e a)+    (FilePath -> Either e' a') readFilePath =   iso     (\(ReadFilePathT x) -> runIdentity . x)     (\p -> ReadFilePathT (Identity . p)) {-# INLINE readFilePath #-} -instance (Apply f, Semigroup a) => Semigroup (ReadFilePathT f a) where-  ReadFilePathT a <> ReadFilePathT b =-    ReadFilePathT (\p -> liftF2 (<>) (a p) (b p))+swapReadFilePath ::+  Functor f =>+  Iso+    (ReadFilePathT e f a)+    (ReadFilePathT e' f a')+    (ReadFilePathT a f e)+    (ReadFilePathT a' f e')+swapReadFilePath =+  iso+    (\r -> ReadFilePathT (fmap (view swapped) . view _Wrapped r))+    (\r -> ReadFilePathT (fmap (view swapped) . view _Wrapped r))+{-# INLINE swapReadFilePath #-}++pureReadFilePath ::+  Applicative f =>+  ReadFilePath e a+  -> ReadFilePathT e f a+pureReadFilePath =+  hoist (pure . runIdentity)+{-# INLINE pureReadFilePath #-}++liftReadFilePath ::+  Applicative f =>+  (FilePath -> a)+  -> ReadFilePathT e f a+liftReadFilePath =+  pureReadFilePath . reader+{-# INLINE liftReadFilePath #-}++successReadFilePath ::+  Functor f =>+  (FilePath -> f a)+  -> ReadFilePathT e f a+successReadFilePath k =+  ReadFilePathT (fmap Right . k)+{-# INLINE successReadFilePath #-}++errorReadFilePath ::+  Functor f =>+  (FilePath -> f e)+  -> ReadFilePathT e f a+errorReadFilePath k =+  ReadFilePathT (fmap Left . k)+{-# INLINE errorReadFilePath #-}++maybeReadFilePath ::+  Functor f =>+  (FilePath -> f (Maybe a))+  -> ReadFilePathT () f a+maybeReadFilePath k =+  ReadFilePathT (fmap (maybe (Left ()) Right) . k)+{-# INLINE maybeReadFilePath #-}++tryReadFilePath ::+  Exception e =>+  (FilePath -> IO a)+  -> ReadFilePathT e IO a+tryReadFilePath k =+  ReadFilePathT (try . k)+{-# INLINE tryReadFilePath #-}++instance (Monad f, Semigroup a) => Semigroup (ReadFilePathT e f a) where+  ReadFilePathT x <> ReadFilePathT y =+    ReadFilePathT (\p -> x p >>= either (pure . Left) (\a -> fmap (fmap (a <>)) (y p)))   {-# INLINE (<>) #-} -instance (Apply f, Applicative f, Monoid a) => Monoid (ReadFilePathT f a) where-  ReadFilePathT a `mappend` ReadFilePathT b =-    ReadFilePathT (\p -> liftA2 mappend (a p) (b p))+instance (Monad f, Monoid a) => Monoid (ReadFilePathT e f a) where+  mappend =+    (<>)   {-# INLINE mappend #-}   mempty =-    ReadFilePathT (pure (pure mempty))+    ReadFilePathT (pure (pure (pure mempty)))   {-# INLINE mempty #-} -instance Functor f => Functor (ReadFilePathT f) where+instance Functor f => Functor (ReadFilePathT e f) where   fmap f (ReadFilePathT x) =-    ReadFilePathT (fmap (fmap f) x)+    ReadFilePathT (fmap (fmap (fmap f)) x)   {-# INLINE fmap #-} -instance Apply f => Apply (ReadFilePathT f) where-  ReadFilePathT f <.> ReadFilePathT a =-    ReadFilePathT (\p -> f p <.> a p)+instance Monad f => Apply (ReadFilePathT e f) where+  ReadFilePathT f <.> ReadFilePathT k =+    ReadFilePathT (\p -> f p >>= either (pure . Left) (\a -> fmap (fmap a) (k p)))   {-# INLINE (<.>) #-} -instance Bind f => Bind (ReadFilePathT f) where+instance Monad f => Bind (ReadFilePathT e f) where   ReadFilePathT f >>- g =-    ReadFilePathT (\p -> f p >>- \a -> view _Wrapped (g a) p)+    ReadFilePathT (\p -> f p >>= either (pure . Left) (\a -> view _Wrapped (g a) p))   {-# INLINE (>>-) #-} -instance Applicative f => Applicative (ReadFilePathT f) where-  ReadFilePathT f <*> ReadFilePathT a =-    ReadFilePathT (\p -> f p <*> a p)-  {-# INLINE (<*>) #-}+instance Monad f => Applicative (ReadFilePathT e f) where+  (<*>) =+    (<.>)   pure =-    ReadFilePathT . pure . pure-  {-# INLINE pure #-}+    ReadFilePathT . pure . pure . pure -instance Alt f => Alt (ReadFilePathT f) where+instance Monad f => Alt (ReadFilePathT e f) where   ReadFilePathT a <!> ReadFilePathT b =-    ReadFilePathT (\p -> a p <!> b p)+    ReadFilePathT (\p -> a p >>= either (pure (b p)) (pure . pure))   {-# INLINE (<!>) #-} -instance Alternative f => Alternative (ReadFilePathT f) where-  ReadFilePathT a <|> ReadFilePathT b =-    ReadFilePathT (\p -> a p <|> b p)-  {-# INLINE (<|>) #-}-  empty =-    ReadFilePathT (pure empty)-  {-# INLINE empty #-}--instance Monad f => Monad (ReadFilePathT f) where-  ReadFilePathT f >>= g =-    ReadFilePathT (\p -> f p >>= \a -> view _Wrapped (g a) p)+instance Monad f => Monad (ReadFilePathT e f) where+  (>>=) =+    (>>-)   {-# INLINE (>>=) #-}   return =-    ReadFilePathT . return . return+    pure   {-# INLINE return #-} -instance MonadTrans ReadFilePathT where+instance MonadTrans (ReadFilePathT e) where   lift =-    ReadFilePathT . pure+    ReadFilePathT . pure . fmap pure   {-# INLINE lift #-} -instance MonadIO f => MonadIO (ReadFilePathT f) where+instance MonadIO f => MonadIO (ReadFilePathT e f) where   liftIO =-    ReadFilePathT . pure . liftIO+    ReadFilePathT . pure . liftIO . fmap pure   {-# INLINE liftIO #-} -instance MFunctor ReadFilePathT where+instance MFunctor (ReadFilePathT e) where   hoist k (ReadFilePathT f) =     ReadFilePathT (k .f)   {-# INLINE hoist #-} -instance MMonad ReadFilePathT where+instance MMonad (ReadFilePathT e) where   embed k (ReadFilePathT f) =-    ReadFilePathT (\p -> view _Wrapped (k (f p)) p)+    ReadFilePathT (\p -> fmap join (view _Wrapped (k (f p)) p))   {-# INLINE embed #-} -instance Monad f => MonadReader FilePath (ReadFilePathT f) where+instance Monad f => MonadReader FilePath (ReadFilePathT e f) where   ask =-    ReadFilePathT pure+    ReadFilePathT (pure . pure)   {-# INLINE ask #-}   local k (ReadFilePathT f) =     ReadFilePathT (f . k)   {-# INLINE local #-}   reader k =-    ReadFilePathT (pure . k)+    ReadFilePathT (pure . pure . k)   {-# INLINE reader #-} -instance MonadState FilePath f => MonadState FilePath (ReadFilePathT f) where+instance MonadState FilePath f => MonadState FilePath (ReadFilePathT e f) where   state =     lift . state   {-# INLINE state #-}@@ -176,7 +240,7 @@     lift . put   {-# INLINE put #-} -instance MonadWriter FilePath f => MonadWriter FilePath (ReadFilePathT f) where+instance MonadWriter FilePath f => MonadWriter FilePath (ReadFilePathT e f) where   writer =     lift . writer   {-# INLINE writer #-}@@ -184,58 +248,36 @@     lift . tell   {-# INLINE tell #-}   listen (ReadFilePathT f) =-    ReadFilePathT (listen . f)+    ReadFilePathT (\p -> fmap (fmap (\a -> (a, p))) (f p))   {-# INLINE listen #-}   pass (ReadFilePathT f) =-    ReadFilePathT (pass . f)+    ReadFilePathT (fmap (fmap (view _1)) . f)   {-# INLINE pass #-} -instance MonadFail f => MonadFail (ReadFilePathT f) where+instance MonadFail f => MonadFail (ReadFilePathT e f) where   fail =     lift . fail   {-# INLINE fail #-} -instance MonadFix f => MonadFix (ReadFilePathT f) where+instance MonadFix f => MonadFix (ReadFilePathT e f) where   mfix f =-    ReadFilePathT (\p -> mfix (\a -> view _Wrapped (f a) p))+    ReadFilePathT (\p -> mfix (either (pure . Left) (\a -> view _Wrapped (f a) p)))   {-# INLINE mfix #-} -instance MonadZip f => MonadZip (ReadFilePathT f) where+instance MonadZip f => MonadZip (ReadFilePathT e f) where   mzipWith f (ReadFilePathT m) (ReadFilePathT n) =-    ReadFilePathT (\a -> mzipWith f (m a) (n a))+    ReadFilePathT (\p -> m p >>= either (pure . Left) (\a -> fmap (fmap (f a)) (n p)))   {-# INLINE mzipWith #-} -instance MonadCont f => MonadCont (ReadFilePathT f) where+instance MonadCont f => MonadCont (ReadFilePathT e f) where   callCC p =-    ReadFilePathT (\r -> callCC (\c -> view _Wrapped (p (ReadFilePathT . pure . c)) r))+    ReadFilePathT (\r -> callCC (\c -> view _Wrapped (p (ReadFilePathT . pure . c . pure)) r))   {-# INLINE callCC #-} -instance MonadError e f => MonadError e (ReadFilePathT f) where+instance MonadError e f => MonadError e (ReadFilePathT e f) where   throwError =     lift . throwError   {-# INLINE throwError #-}   catchError (ReadFilePathT f) g =     ReadFilePathT (\ r -> catchError (f r) (\ e -> view _Wrapped (g e) r))   {-# INLINE catchError #-}--instance MonadPlus f => MonadPlus (ReadFilePathT f) where-  mzero =-    lift mzero-  {-# INLINE mzero #-}-  ReadFilePathT a `mplus` ReadFilePathT b =-    ReadFilePathT (\ r -> a r `mplus` b r)-  {-# INLINE mplus #-}--hoistReadFilePath ::-  Applicative f =>-  ReadFilePath a-  -> ReadFilePathT f a-hoistReadFilePath =-  hoist (pure . runIdentity)--liftReadFilePath ::-  Applicative f =>-  (FilePath -> a)-  -> ReadFilePathT f a-liftReadFilePath =-  hoistReadFilePath . (readFilePath #)

@@ -1,77 +0,0 @@-{-# OPTIONS_GHC -Wall #-}-{-# LANGUAGE NoImplicitPrelude #-}-{-# LANGUAGE TypeFamilies #-}--module System.FilePath.FilePather.ToFilePath(-  ToFilePathT(..)-, ToFilePath-, toFilePath-, toRead-) where--import Control.Applicative ( Applicative(pure, liftA2) )-import Control.Category ( Category((.)) )-import Control.Lens ( iso, Iso, Wrapped(..) )-import Data.Functor.Contravariant ( Contravariant(contramap) )-import Data.Either ( either )-import Data.Functor.Contravariant.Divisible-    ( Decidable(..), Divisible(..) )-import Data.Functor.Identity ( Identity(..) )-import Data.Void ( absurd )-import System.FilePath ( (</>), FilePath )-import System.FilePath.FilePather.ReadFilePath-    ( ReadFilePathT(..) )--newtype ToFilePathT f a =-  ToFilePathT (a -> f FilePath)--type ToFilePath a =-  ToFilePathT Identity a--instance Wrapped (ToFilePathT f a) where-  type Unwrapped (ToFilePathT f a) =-    a-    -> f FilePath-  _Wrapped' =-    iso (\(ToFilePathT x) -> x) ToFilePathT-  {-# INLINE _Wrapped' #-}--instance Contravariant (ToFilePathT f) where-  contramap f (ToFilePathT g) =-    ToFilePathT (g . f)--instance Applicative f => Divisible (ToFilePathT f) where-  divide f (ToFilePathT g) (ToFilePathT h) =-    ToFilePathT (\x -> let (b, c) = f x in liftA2 (</>) (g b) (h c))-  conquer =-    ToFilePathT (pure (pure ""))--instance Applicative f => Decidable (ToFilePathT f) where-  choose f (ToFilePathT g) (ToFilePathT h) =-    ToFilePathT (either g h . f)-  lose f =-    ToFilePathT (absurd . f)--toFilePath ::-  Iso-    (ToFilePath a)-    (ToFilePath a')-    (a -> FilePath)-    (a' -> FilePath)-toFilePath =-  iso-    (\(ToFilePathT x) -> runIdentity . x)-    (\p -> ToFilePathT (Identity . p))-{-# INLINE toFilePath #-}--toRead ::-  Iso-    (ToFilePathT f FilePath)-    (ToFilePathT f' FilePath)-    (ReadFilePathT f FilePath)-    (ReadFilePathT f' FilePath)-toRead =-  iso-    (\(ToFilePathT x) -> ReadFilePathT x)-    (\(ReadFilePathT x) -> ToFilePathT x)-{-# INLINE toRead #-}