System.Directory.Layout.Internal

directory-layout internals

Documentation

>>> import qualified Data.ByteString as ByteString

newtype Layout a

Directory layout description

Constructors

L

Fields

unL :: Free F a

Instances

Monad Layout

Functor Layout

Applicative Layout

Foldable Layout

Traversable Layout

Eq (Layout a)

Equality check does not care about the order the files are listed insofar they are consistent, i.e. different things aren't named the same

Generic (Layout a)

Semigroup (Layout a)

Typeable (* -> *) Layout

type Rep (Layout a)

data F a

The underlying Functor

Constructors

F String (Maybe Contents) Aux a

SL String FilePath Bool Aux a

D String a Aux a

E

Instances

Functor F

Foldable F

Traversable F

Eq a => Eq (F a)

Generic (F a)

Typeable (* -> *) F

type Rep (F a)

data Contents

Regular file contents

Constructors

Binary ByteString

Text Text

CopyOf FilePath

Instances

IsList Contents

Eq Contents

Data Contents

IsString Contents

Generic Contents

Typeable * Contents

type Rep Contents

type Item Contents = Word8

data Aux

Auxiliary data

Constructors

Aux (Maybe User) (Maybe Group) (Maybe FileMode)

Instances

Eq Aux

Show Aux

Generic Aux

Typeable * Aux

type Rep Aux

data User

File owner

Constructors

UserID UserID

Username String

Instances

Eq User

Show User

IsString User

Generic User

Typeable * User

type Rep User

data Group

File group

Constructors

GroupID GroupID

Groupname String

Instances

Eq Group

Show Group

IsString Group

Generic Group

Typeable * Group

type Rep Group

file :: String -> Layout ()

Regular file with some contents or empty

>>> let layout = file "foo"

symlink :: String -> FilePath -> Layout ()

Symbolic link

>>> let layout = symlink "foo" "bar"

dir :: String -> Layout a -> Layout ()

Directory

>>> :{
let layout = dir "foo" $ do
      file "bar"
      file "baz"
:}

emptydir :: String -> Layout ()

Empty directory

>>> let layout = emptydir "foo"

dirs :: [String] -> Layout () -> Layout ()

A nested list of directories

>>> :{
let layout = dirs ["foo", "bar"] $ do
               file "qux"
               file "quux"
:}

defaux :: Aux

The default (empty) auxiliary data

contents :: Traversal' (Layout a) (Maybe Contents)

An optic into file contents

binary :: ByteString -> Contents

Binary contents

>>> let layout = file "foo" & contents ?~ binary (ByteString.pack [1..10])

text :: Text -> Contents

Plain text contents

>>> let layout = file "foo" & contents ?~ text (Data.Text.pack "hello")

copyOf :: FilePath -> Contents

Contents are the copy of whose of the real file

>>> let layout = file "foo" & contents ?~ copyOf "/home/user/.vimrc"

anything :: Maybe a

Anything

>>> let layout = file "foo" & contents .~ anything
>>> let layout = file "foo" & user .~ anything

source :: Traversal' (Layout a) String

An optic into symbolic link source

>>> symlink "foo" "bar" ^? source
Just "bar"

exists :: Traversal' (Layout a) Bool

An optic into symbolic link source expected existence

>>> let layout = symlink "foo" "bar" & exists .~ True

aux :: Traversal' (Layout a) Aux

An optic into file auxiliary data

user :: Traversal' (Layout a) (Maybe User)

An optic into file owner

>>> let layout = file "foo" & user ?~ uid 0

uid :: UserID -> User

Set the file owner by uid

username :: String -> User

Set the file owner by username

>>> let layout = file "foo" & user ?~ username "root"

group :: Traversal' (Layout a) (Maybe Group)

An optic into file group

>>> let layout = file "foo" & group ?~ gid 0

gid :: GroupID -> Group

Set the file group by groupname

groupname :: String -> Group

Set the file group by groupname

>>> let layout = file "foo" & group ?~ groupname "wheel"

mode :: Traversal' (Layout a) (Maybe FileMode)

An optic into file mode

>>> let layout = file "foo" & mode ?~ 0o100777

innards :: Traversal' (Layout a) (Layout a)

An optic into directory contents

into :: String -> Traversal' (Layout ()) (Layout ())

An optic into the directory contents of the particular directory

>>> :{
dirs ["foo", "bar", "baz"] (symlink "qux" "quux")
  ^? into "foo".into "bar".into "baz".focus "qux".source
:}
Just "quux"

focus :: String -> Traversal' (Layout ()) (Layout ())

An optic into the particular node