Safe Haskell | Safe-Infered |
---|

- class FilePathPredicate f where
- always :: Monad g => f g
- never :: Monad g => f g
- (.&&.) :: Monad g => f g -> f g -> f g
- (.||.) :: Monad g => f g -> f g -> f g
- (.!.) :: Monad g => f g -> f g
- anyof :: (Foldable t, Monad g) => t (f g) -> f g
- allof :: (Foldable t, Monad g) => t (f g) -> f g
- extension :: Monad g => (FilePath -> Bool) -> f g
- extensionEq :: Monad g => FilePath -> f g
- extensionOneof :: (Foldable t, Monad g) => t FilePath -> f g
- extensionNoneof :: (Foldable t, Monad g) => t FilePath -> f g
- directory :: Monad g => (FilePath -> Bool) -> f g
- hasExtension :: Monad g => f g
- notHasExtension :: Monad g => f g
- splitExtension :: Monad g => (String -> String -> Bool) -> f g
- splitDirectories :: Monad g => ([FilePath] -> Bool) -> f g
- hasTrailingPathSeparator :: Monad g => f g
- notHasTrailingPathSeparator :: Monad g => f g
- fileName :: Monad g => (FilePath -> Bool) -> f g
- baseName :: Monad g => (FilePath -> Bool) -> f g
- normalise :: Monad g => (FilePath -> Bool) -> f g
- makeValid :: Monad g => (FilePath -> Bool) -> f g
- isRelative :: Monad g => f g
- isNotRelative :: Monad g => f g
- isAbsolute :: Monad g => f g
- isNotAbsolute :: Monad g => f g
- isValid :: Monad g => f g
- isNotValid :: Monad g => f g

# Documentation

class FilePathPredicate f whereSource

Functions that are common to predicates that work on `FilePath`

values.

always :: Monad g => f gSource

A predicate that always succeeds.

A predicate that always fails.

(.&&.) :: Monad g => f g -> f g -> f gSource

Return a predicate that succeeds only if the two given predicates succeed.

(.||.) :: Monad g => f g -> f g -> f gSource

Return a predicate that succeeds if any of the two given predicates succeed.

(.!.) :: Monad g => f g -> f gSource

Negates the given predicate.

anyof :: (Foldable t, Monad g) => t (f g) -> f gSource

Folds the predicates on disjunction.

allof :: (Foldable t, Monad g) => t (f g) -> f gSource

extension :: Monad g => (FilePath -> Bool) -> f gSource

A predicate that computes its result based on a file name extension.

extensionEq :: Monad g => FilePath -> f gSource

A predicate that computes its result based equivalence to a file name extension. This function matches with and without the preceding extension separator (.).

extensionOneof :: (Foldable t, Monad g) => t FilePath -> f gSource

A predicate that computes its result based equivalence to one of a list of file name extensions.

extensionNoneof :: (Foldable t, Monad g) => t FilePath -> f gSource

A predicate that computes its result based inequivalence to any of a list of file name extensions.

directory :: Monad g => (FilePath -> Bool) -> f gSource

A predicate that computes its result based on a directory.

hasExtension :: Monad g => f gSource

A predicate that succeeds if its `FilePath`

has an extension.

notHasExtension :: Monad g => f gSource

A predicate that succeeds if its `FilePath`

does not have an extension.

splitExtension :: Monad g => (String -> String -> Bool) -> f gSource

A predicate that computes its result based on the splitting of a name and extension.

splitDirectories :: Monad g => ([FilePath] -> Bool) -> f gSource

A predicate that computes its result based on the splitting of a name into directories.

hasTrailingPathSeparator :: Monad g => f gSource

A predicate that succeeds if its `FilePath`

has a trailing path separator.

notHasTrailingPathSeparator :: Monad g => f gSource

A predicate that succeeds if its `FilePath`

does not have a trailing path separator.

fileName :: Monad g => (FilePath -> Bool) -> f gSource

A predicate that computes its result based on the file name.

baseName :: Monad g => (FilePath -> Bool) -> f gSource

A predicate that computes its result based on the base name.

normalise :: Monad g => (FilePath -> Bool) -> f gSource

A predicate that computes its result based on the normalised file name.

makeValid :: Monad g => (FilePath -> Bool) -> f gSource

A predicate that computes its result based on the file name having been made valid.

isRelative :: Monad g => f gSource

A predicate that succeeds if its `FilePath`

is relative.

isNotRelative :: Monad g => f gSource

A predicate that succeeds if its `FilePath`

is not relative.

isAbsolute :: Monad g => f gSource

A predicate that succeeds if its `FilePath`

is absolute.

isNotAbsolute :: Monad g => f gSource

A predicate that succeeds if its `FilePath`

is not absolute.

isValid :: Monad g => f gSource

A predicate that succeeds if its `FilePath`

is valid.

isNotValid :: Monad g => f gSource

A predicate that succeeds if its `FilePath`

is not valid.