System.FileSystem.Types

Synonyms

type InApp a = a -> a

Internal Application: An application from somewhere over itself.

type DirName = String

A name for a directory.

type FileName = String

A name for a file.

type FileCnt = ByteString

The content of a file. Stored in a ByteString.

type DirPath = [DirName]

A list-based directory path.

toDirPath :: FilePath -> DirPath

Translation between FilePath and DirPath.

fromDirPath :: DirPath -> FilePath

Translation between DirPath and FilePath.

type FPath = (DirPath, FileName)

A file path, composed by the path of the directory which contains it, and its file name.

toFPath :: FilePath -> FPath

Translation between FilePath and FPath.

fromFPath :: FPath -> FilePath

Translation between FPath and FilePath.

File

data FileData

Information about the content of a file.

Constructors

FD

Fields

getCnt :: FileCnt

getLmt :: ClockTime

Instances

Eq FileData

Binary FileData

emptyFD :: FileData

An empty file data.

data File

A complete file.

Constructors

File

Fields

getFD :: FileData

getFN :: FileName

Instances

Eq File

Show File

Binary File

File System

type FSE = Either (DirName, FileSystem) File

File System Element: Each one of the elements in a FileSystem.

newtype FileSystem

The file system structure. It stores a directory with files and subdirectories.

Constructors

Directory

Fields

dirCnt :: [FSE]

Instances

Show FileSystem

Monoid FileSystem

Binary FileSystem

emptyFileSystem :: FileSystem

An empty file system.

modDirCnt :: InApp [FSE] -> InApp FileSystem

Lift a function over a list of FSE (File System Elements) to a function over FileSystem.

Path

data Path

A path to a possible File.

Constructors

Path

Fields

pathList :: DirPath

pathFile :: Maybe File

isFilePath :: Path -> Bool

Check if a Path contents a File.

FileSystem monad

type FSState = FileSystem

The state of file system computations.

Currently, a FileSystem structure.

newtype FST m a

Monadic transformer which adds a FSState environment.

Constructors

WrapFST

Fields

unwrapFST :: StateT FSState m a

Instances

MonadTrans FST

Monad m => Monad (FST m)

Functor m => Functor (FST m)

MonadIO m => MonadIO (FST m)

(Functor m, Monad m) => FSMonad (FST m)

runFST :: Monad m => FST m a -> FSState -> m (a, FSState)

Run an FST computation, given an initial state.

type FS = FST Identity

Application of the FST monad transformer to the Identity monad.

runFS :: FS a -> FSState -> (a, FSState)

Just a composition of runIdentity and runFST.