diff --git a/changelog.md b/changelog.md
--- a/changelog.md
+++ b/changelog.md
@@ -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`
diff --git a/filepather.cabal b/filepather.cabal
--- a/filepather.cabal
+++ b/filepather.cabal
@@ -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
diff --git a/src/System/FilePath/FilePather.hs b/src/System/FilePath/FilePather.hs
--- a/src/System/FilePath/FilePather.hs
+++ b/src/System/FilePath/FilePather.hs
@@ -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
diff --git a/src/System/FilePath/FilePather/ByteString.hs b/src/System/FilePath/FilePather/ByteString.hs
new file mode 100644
--- /dev/null
+++ b/src/System/FilePath/FilePather/ByteString.hs
@@ -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)
diff --git a/src/System/FilePath/FilePather/Compose.hs b/src/System/FilePath/FilePather/Compose.hs
deleted file mode 100644
--- a/src/System/FilePath/FilePather/Compose.hs
+++ /dev/null
@@ -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 -<<-
diff --git a/src/System/FilePath/FilePather/Directory.hs b/src/System/FilePath/FilePather/Directory.hs
--- a/src/System/FilePath/FilePather/Directory.hs
+++ b/src/System/FilePath/FilePather/Directory.hs
@@ -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)
diff --git a/src/System/FilePath/FilePather/Find.hs b/src/System/FilePath/FilePather/Find.hs
--- a/src/System/FilePath/FilePather/Find.hs
+++ b/src/System/FilePath/FilePather/Find.hs
@@ -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)
diff --git a/src/System/FilePath/FilePather/IO.hs b/src/System/FilePath/FilePather/IO.hs
new file mode 100644
--- /dev/null
+++ b/src/System/FilePath/FilePather/IO.hs
@@ -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)
diff --git a/src/System/FilePath/FilePather/Posix.hs b/src/System/FilePath/FilePather/Posix.hs
--- a/src/System/FilePath/FilePather/Posix.hs
+++ b/src/System/FilePath/FilePather/Posix.hs
@@ -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
diff --git a/src/System/FilePath/FilePather/ReadFilePath.hs b/src/System/FilePath/FilePather/ReadFilePath.hs
--- a/src/System/FilePath/FilePather/ReadFilePath.hs
+++ b/src/System/FilePath/FilePather/ReadFilePath.hs
@@ -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 #)
diff --git a/src/System/FilePath/FilePather/ToFilePath.hs b/src/System/FilePath/FilePather/ToFilePath.hs
deleted file mode 100644
--- a/src/System/FilePath/FilePather/ToFilePath.hs
+++ /dev/null
@@ -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 #-}