System.FileSystem

Contents

Several type synonyms
Types
Across the FileSystem
- Mapping
- Folding
Computations over a FileSystem
- Types
  - FST monad transformer
  - List-based paths
- Computations
  - Put/Get File operations
  - Writing and reading
    - Pure operations
    - IO monad operations
  - System.Directory operations
Re-exports

Synopsis

Several type synonyms

type InApp a = a -> aSource

Internal Application: An application from somewhere over itself.

type DirName = String Source

A name for a directory.

type FileName = String Source

A name for a file.

Types

`ByteString`

A re-export of the ByteString type. The content of a File is stored in a ByteString.

data ByteString

A space-efficient representation of a Word8 vector, supporting many efficient operations. A ByteString contains 8-bit characters only.

Instances of Eq, Ord, Read, Show, Data, Typeable

Instances

Eq ByteString
Data ByteString
Ord ByteString
Read ByteString
Show ByteString
Typeable ByteString
Monoid ByteString
Binary ByteString

`ClockTime`

A re-export of the ClockTime type. ClockTime is used to represents modification times.

data ClockTime

A representation of the internal clock time. Clock times may be compared, converted to strings, or converted to an external calendar time CalendarTime for I/O or other manipulations.

Instances

Eq ClockTime
Ord ClockTime
Show ClockTime
Binary ClockTime

`File`

The File type and basic functions to operate with it.

data File Source

A complete file.

Instances

Eq File
Show File
Binary File

emptyFile :: FileName -> File Source

Create an empty file with the given FileName.

newFile :: FileName -> ByteString -> File Source

Build a new file with an initial FileName and content.

getFileName :: File -> FileName Source

Get the name of a File.

setFileName :: FileName -> File -> File Source

Rename a File with the given FileName.

getFileContent :: File -> ByteString Source

Extract the content of a File.

setFileContent :: ByteString -> File -> File Source

Set the content of a File to the given ByteString.

getModifTime :: File -> ClockTime Source

Get the last modification time of a File.

setModifTime :: ClockTime -> File -> File Source

Set the last modification time of a File.

fileSize :: File -> Int Source

Calculate the size of a File.

`FileSystem`

data FileSystem Source

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

Instances

Show FileSystem
Monoid FileSystem
Binary FileSystem

emptyFileSystem :: FileSystem Source

An empty file system.

Across the `FileSystem`

Mapping

mapFileSystem :: InApp DirName -> InApp File -> InApp FileSystem Source

Map a pair of applications (one over DirName, and the other over File) through a FileSystem.

mapFiles :: InApp File -> InApp FileSystem Source

Map a function over all the Files of a FileSystem.

Folding

foldFileSystem Source

Arguments

:: FilePath	Root path
-> Either (FilePath -> t -> Either DirName File -> t) (FilePath -> Either DirName File -> t -> t)	Folding operator, with current `FilePath` reference
-> t	The initial value
-> FileSystem	The `FileSystem` to fold
-> t	Result

Folding function for FileSystems.

foldFiles :: Either (t -> File -> t) (File -> t -> t) -> t -> FileSystem -> tSource

An usage of foldFileSystem, folding only Files, ignoring the FilePath where they are.

Computations over a `FileSystem`

Types

`FST` monad transformer

type FSState = FileSystem Source

The state of file system computations.

Currently, a FileSystem structure.

data FST m a Source

Monadic transformer which adds a FSState environment.

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)Source

Run an FST computation, given an initial state.

type FS = FST Identity Source

Application of the FST monad transformer to the Identity monad.

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

Just a composition of runIdentity and runFST.

List-based paths

List-based paths is an alternative to FilePath that represents a path as a list of names.

While directory paths are a simple list of DirNames, file paths are a pair: (DirPath,FileName). First component is the directory where the file is, and the second is the name of the file.

Below you can see a list of examples of how to represent several FilePaths:

 |  FilePath  |   List-based path   |
 ------------------------------------
 | "aa\bb\cc" |   ["aa","bb",cc"]   |
 | "dir\file" |   (["dir"],"file")  |
 | "a\b\f.hs" |  (["a","b"],"f.hs") |

type DirPath = [DirName]Source

A list-based directory path.

toDirPath :: FilePath -> DirPath Source

Translation between FilePath and DirPath.

fromDirPath :: DirPath -> FilePath Source

Translation between DirPath and FilePath.

type FPath = (DirPath, FileName)Source

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

toFPath :: FilePath -> FPath Source

Translation between FilePath and FPath.

fromFPath :: FPath -> FilePath Source

Translation between FPath and FilePath.

Computations

Computations within a FSMonad environment. All functions have a list-based path version (with L at the end), and a normal FilePath version. Use toDirPath (toFPath) and fromDirPath (fromFPath) to change between both formats.

Also, to avoid name collisions, function with existing names have fs_ as preffix.

Put/Get `File` operations

putFileL Source

Arguments

:: FSMonad m
=> DirPath	Directory where put the `File`.
-> File
-> m ()

Puts a file in the given directory. It creates the parent directory if missing.

putFile :: FSMonad m => FilePath -> File -> m ()Source

getFileL Source

Arguments

:: FSMonad m
=> FPath	Path where search the `File`.
-> m (Maybe File)

Gets a file from the file system. It returns Nothing if the File is not found.

getFile :: FSMonad m => FilePath -> m (Maybe File)Source

modFileL :: FSMonad m => FPath -> InApp File -> m Bool Source

Modifies a file with the given application. It returns True if the file was found and modified.

modFile :: FSMonad m => FilePath -> InApp File -> m Bool Source

moveFileL Source

Arguments

:: FSMonad m
=> FPath	Original path of the `File`.
-> FPath	New path for the `File`.
-> m Bool

Moves a file. It returns True if the file exists and has been moved.

moveFile :: FSMonad m => FilePath -> FilePath -> m Bool Source

Writing and reading

Writing and reading files in a FSMonad environment.

Pure operations

fs_writeFileL :: FSMonad m => FPath -> ByteString -> m ()Source

Writes a file. If the files already exists, it is overwritten.

fs_writeFile :: FSMonad m => FilePath -> ByteString -> m ()Source

fs_readFileL :: FSMonad m => FPath -> m (Maybe ByteString)Source

Reads a file. It returns Nothing if the file can't be found.

fs_readFile :: FSMonad m => FilePath -> m (Maybe ByteString)Source

`IO` monad operations

writeFileTimeL :: (FSMonad m, MonadIO m) => FPath -> ByteString -> m ()Source

Writes a file, changing its last modification time to the current time. If the file already exists, it is overwritten. Note that MonadIO instance is needed.

writeFileTime :: (FSMonad m, MonadIO m) => FilePath -> ByteString -> m ()Source