Photoname.Common

Documentation

newtype Artist

Constructors

Artist String

newtype ConfigPath

Constructors

ConfigPath FilePath

newtype CopySwitch

Constructors

CopySwitch

Fields

• v :: Bool

newtype DestPath

Constructors

DestPath FilePath

data Extension

Constructors

Extension FilePath

UseExistingExtension

data Links

Constructors

Exactly CNlink

NoLimit

newtype MoveSwitch

Constructors

MoveSwitch

Fields

• v :: Bool

newtype NoActionSwitch

Constructors

NoActionSwitch

Fields

• v :: Bool

newtype NoDirsSwitch

Constructors

NoDirsSwitch

Fields

• v :: Bool

newtype ParentDir

Constructors

ParentDir

Fields

• v :: FilePath

data Options

Constructors

Options

Fields

• artist :: Maybe Artist
• config :: Maybe ConfigPath
• copy :: CopySwitch
• noDirs :: NoDirsSwitch
• extension :: Extension
• formatter :: DateFormatter
• links :: Links
• move :: MoveSwitch
• noAction :: NoActionSwitch
• parentDir :: ParentDir
• prefix :: Prefix
• suffix :: Suffix
• verbosity :: Verbosity
• paths :: [FilePath]

type Ph a = ReaderT Options (ExceptT String IO) a

newtype Prefix

Constructors

Prefix

Fields

• v :: String

newtype SrcPath

Constructors

SrcPath

Fields

• v :: FilePath

newtype Suffix

Constructors

Suffix

Fields

• v :: String

data Verbosity

Constructors

Quiet

Verbose Priority

Instances

Show Verbosity

Defined in Photoname.Common

Methods

showsPrec :: Int -> Verbosity -> ShowS

show :: Verbosity -> String

showList :: [Verbosity] -> ShowS

defaultDateTimeFormat :: String

readVerbosity :: String -> Either String Verbosity

runRename :: Options -> Ph a -> IO (Either String a)

class Monad m => MonadError e (m :: Type -> Type) | m -> e

The strategy of combining computations that can throw exceptions by bypassing bound functions from the point an exception is thrown to the point that it is handled.

Is parameterized over the type of error information and the monad type constructor. It is common to use Either String as the monad type constructor for an error monad in which error descriptions take the form of strings. In that case and many other common cases the resulting monad is already defined as an instance of the MonadError class. You can also define your own error type and/or use a monad type constructor other than Either String or Either IOError. In these cases you will have to explicitly define instances of the MonadError class. (If you are using the deprecated Control.Monad.Error or Control.Monad.Trans.Error, you may also have to define an Error instance.)

Minimal complete definition

throwError, catchError

Instances

MonadError IOException IO

Defined in Control.Monad.Error.Class

Methods

throwError :: IOException -> IO a

catchError :: IO a -> (IOException -> IO a) -> IO a

MonadError () Maybe

Since: mtl-2.2.2

Defined in Control.Monad.Error.Class

Methods

throwError :: () -> Maybe a

catchError :: Maybe a -> (() -> Maybe a) -> Maybe a

MonadError e (Either e)

Defined in Control.Monad.Error.Class

Methods

throwError :: e -> Either e a

catchError :: Either e a -> (e -> Either e a) -> Either e a

MonadError e m => MonadError e (ListT m)

Defined in Control.Monad.Error.Class

Methods

throwError :: e -> ListT m a

catchError :: ListT m a -> (e -> ListT m a) -> ListT m a

MonadError e m => MonadError e (MaybeT m)

Defined in Control.Monad.Error.Class

Methods

throwError :: e -> MaybeT m a

catchError :: MaybeT m a -> (e -> MaybeT m a) -> MaybeT m a

(Monad m, Error e) => MonadError e (ErrorT e m)

Defined in Control.Monad.Error.Class

Methods

throwError :: e -> ErrorT e m a

catchError :: ErrorT e m a -> (e -> ErrorT e m a) -> ErrorT e m a

Monad m => MonadError e (ExceptT e m)

Since: mtl-2.2

Defined in Control.Monad.Error.Class

Methods

throwError :: e -> ExceptT e m a

catchError :: ExceptT e m a -> (e -> ExceptT e m a) -> ExceptT e m a

MonadError e m => MonadError e (IdentityT m)

Defined in Control.Monad.Error.Class

Methods

throwError :: e -> IdentityT m a

catchError :: IdentityT m a -> (e -> IdentityT m a) -> IdentityT m a

MonadError e m => MonadError e (ReaderT r m)

Defined in Control.Monad.Error.Class

Methods

throwError :: e -> ReaderT r m a

catchError :: ReaderT r m a -> (e -> ReaderT r m a) -> ReaderT r m a

MonadError e m => MonadError e (StateT s m)

Defined in Control.Monad.Error.Class

Methods

throwError :: e -> StateT s m a

catchError :: StateT s m a -> (e -> StateT s m a) -> StateT s m a

MonadError e m => MonadError e (StateT s m)

Defined in Control.Monad.Error.Class

Methods

throwError :: e -> StateT s m a

catchError :: StateT s m a -> (e -> StateT s m a) -> StateT s m a

(Monoid w, MonadError e m) => MonadError e (WriterT w m)

Defined in Control.Monad.Error.Class

Methods

throwError :: e -> WriterT w m a

catchError :: WriterT w m a -> (e -> WriterT w m a) -> WriterT w m a

(Monoid w, MonadError e m) => MonadError e (WriterT w m)

Defined in Control.Monad.Error.Class

Methods

throwError :: e -> WriterT w m a

catchError :: WriterT w m a -> (e -> WriterT w m a) -> WriterT w m a

MonadError e m => MonadError e (ParsecT s u m)

Defined in Text.Parsec.Prim

Methods

throwError :: e -> ParsecT s u m a

catchError :: ParsecT s u m a -> (e -> ParsecT s u m a) -> ParsecT s u m a

(Monoid w, MonadError e m) => MonadError e (RWST r w s m)

Defined in Control.Monad.Error.Class

Methods

throwError :: e -> RWST r w s m a

catchError :: RWST r w s m a -> (e -> RWST r w s m a) -> RWST r w s m a

(Monoid w, MonadError e m) => MonadError e (RWST r w s m)

Defined in Control.Monad.Error.Class

Methods

throwError :: e -> RWST r w s m a

catchError :: RWST r w s m a -> (e -> RWST r w s m a) -> RWST r w s m a

ask :: MonadReader r m => m r

Retrieves the monad environment.

asks

Arguments

:: MonadReader r m

=> (r -> a)

The selector function to apply to the environment.

-> m a

Retrieves a function of the current environment.

liftIO :: MonadIO m => IO a -> m a

Lift a computation from the IO monad. This allows us to run IO computations in any monadic stack, so long as it supports these kinds of operations (i.e. IO is the base monad for the stack).

Example

import Control.Monad.Trans.State -- from the "transformers" library

printState :: Show s => StateT s IO ()
printState = do
  state <- get
  liftIO $ print state

Had we omitted liftIO, we would have ended up with this error:

• Couldn't match type ‘IO’ with ‘StateT s IO’
 Expected type: StateT s IO ()
   Actual type: IO ()

The important part here is the mismatch between StateT s IO () and IO ().

Luckily, we know of a function that takes an IO a and returns an (m a): liftIO, enabling us to run the program and see the expected results:

> evalStateT printState "hello"
"hello"

> evalStateT printState 3
3

throwError :: MonadError e m => e -> m a

Is used within a monadic computation to begin exception processing.