Test.Fixie

Documentation

newtype Note

Constructors

Note Text

Instances

Eq Note

Methods

(==) :: Note -> Note -> Bool

(/=) :: Note -> Note -> Bool

Show Note

Methods

showsPrec :: Int -> Note -> ShowS

show :: Note -> String

showList :: [Note] -> ShowS

IsString Note

Methods

fromString :: String -> Note

newtype Function

Constructors

Function Text

Instances

Eq Function

Methods

(==) :: Function -> Function -> Bool

(/=) :: Function -> Function -> Bool

Ord Function

Methods

compare :: Function -> Function -> Ordering

(<) :: Function -> Function -> Bool

(<=) :: Function -> Function -> Bool

(>) :: Function -> Function -> Bool

(>=) :: Function -> Function -> Bool

max :: Function -> Function -> Function

min :: Function -> Function -> Function

Show Function

Methods

showsPrec :: Int -> Function -> ShowS

show :: Function -> String

showList :: [Function] -> ShowS

IsString Function

Methods

fromString :: String -> Function

newtype Call

Constructors

Call

Fields

• _function :: Function

data FixieT f e m a

Instances

Monad m => MonadError e (FixieT f e m)

Methods

throwError :: e -> FixieT f e m a

catchError :: FixieT f e m a -> (e -> FixieT f e m a) -> FixieT f e m a

MonadTrans (FixieT f e)

Methods

lift :: Monad m => m a -> FixieT f e m a

Monad m => Monad (FixieT f e m)

Methods

(>>=) :: FixieT f e m a -> (a -> FixieT f e m b) -> FixieT f e m b

(>>) :: FixieT f e m a -> FixieT f e m b -> FixieT f e m b

return :: a -> FixieT f e m a

fail :: String -> FixieT f e m a

Functor m => Functor (FixieT f e m)

Methods

fmap :: (a -> b) -> FixieT f e m a -> FixieT f e m b

(<$) :: a -> FixieT f e m b -> FixieT f e m a

Monad m => Applicative (FixieT f e m)

Methods

pure :: a -> FixieT f e m a

(<*>) :: FixieT f e m (a -> b) -> FixieT f e m a -> FixieT f e m b

(*>) :: FixieT f e m a -> FixieT f e m b -> FixieT f e m b

(<*) :: FixieT f e m a -> FixieT f e m b -> FixieT f e m a

type FixieM f e = FixieT f e Identity

toSet :: Ord a => [a] -> Set a

note :: Monad m => Note -> FixieT f e m ()

getFixture :: Monad m => FixieT f e m (f (FixieT f e m))

getFunction :: Monad m => (f (FixieT f e m) -> a) -> FixieT f e m a

captureCall :: Monad m => Call -> FixieT f e m ()

unimplemented :: String -> a

outputNotesFunctionsT :: Monad m => f (FixieT f e m) -> FixieT f e m a -> m (Either e a, [Note], [Function])

outputNotesFunctionsetT :: Monad m => f (FixieT f e m) -> FixieT f e m a -> m (Either e a, [Note], Set Function)

outputFunctionsNotesT :: Monad m => f (FixieT f e m) -> FixieT f e m a -> m (Either e a, [Function], [Note])

outputFunctionsetNotesT :: Monad m => f (FixieT f e m) -> FixieT f e m a -> m (Either e a, Set Function, [Note])

valueNotesFunctionsT :: Monad m => f (FixieT f Void m) -> FixieT f Void m a -> m (a, [Note], [Function])

valueNotesFunctionsetT :: Monad m => f (FixieT f Void m) -> FixieT f Void m a -> m (a, [Note], Set Function)

valueFunctionsNotesT :: Monad m => f (FixieT f Void m) -> FixieT f Void m a -> m (a, [Function], [Note])

valueFunctionsetNotesT :: Monad m => f (FixieT f Void m) -> FixieT f Void m a -> m (a, Set Function, [Note])

notesOutputFunctionsT :: Monad m => f (FixieT f e m) -> FixieT f e m a -> m ([Note], Either e a, [Function])

notesOutputFunctionsetT :: Monad m => f (FixieT f e m) -> FixieT f e m a -> m ([Note], Either e a, Set Function)

notesValueFunctionsT :: Monad m => f (FixieT f Void m) -> FixieT f Void m a -> m ([Note], a, [Function])

notesValueFunctionsetT :: Monad m => f (FixieT f Void m) -> FixieT f Void m a -> m ([Note], a, Set Function)

notesFunctionsOutputT :: Monad m => f (FixieT f e m) -> FixieT f e m a -> m ([Note], [Function], Either e a)

notesFunctionsetOutputT :: Monad m => f (FixieT f e m) -> FixieT f e m a -> m ([Note], Set Function, Either e a)

notesFunctionsValueT :: Monad m => f (FixieT f Void m) -> FixieT f Void m a -> m ([Note], [Function], a)

notesFunctionsetValueT :: Monad m => f (FixieT f Void m) -> FixieT f Void m a -> m ([Note], Set Function, a)

functionsOutputNotesT :: Monad m => f (FixieT f e m) -> FixieT f e m a -> m ([Function], Either e a, [Note])

functionsValueNotesT :: Monad m => f (FixieT f Void m) -> FixieT f Void m a -> m ([Function], a, [Note])

functionsNotesOutputT :: Monad m => f (FixieT f e m) -> FixieT f e m a -> m ([Function], [Note], Either e a)

functionsNotesValueT :: Monad m => f (FixieT f Void m) -> FixieT f Void m a -> m ([Function], [Note], a)

functionsetOutputNotesT :: Monad m => f (FixieT f e m) -> FixieT f e m a -> m (Set Function, Either e a, [Note])

functionsetValueNotesT :: Monad m => f (FixieT f Void m) -> FixieT f Void m a -> m (Set Function, a, [Note])

functionsetNotesOutputT :: Monad m => f (FixieT f e m) -> FixieT f e m a -> m (Set Function, [Note], Either e a)

functionsetNotesValueT :: Monad m => f (FixieT f Void m) -> FixieT f Void m a -> m (Set Function, [Note], a)

outputNotesT :: Monad m => f (FixieT f e m) -> FixieT f e m a -> m (Either e a, [Note])

outputFunctionsT :: Monad m => f (FixieT f e m) -> FixieT f e m a -> m (Either e a, [Function])

outputFunctionsetT :: Monad m => f (FixieT f e m) -> FixieT f e m a -> m (Either e a, Set Function)

valueNotesT :: Monad m => f (FixieT f Void m) -> FixieT f Void m a -> m (a, [Note])

valueFunctionsT :: Monad m => f (FixieT f Void m) -> FixieT f Void m a -> m (a, [Function])

valueFunctionsetT :: Monad m => f (FixieT f Void m) -> FixieT f Void m a -> m (a, Set Function)

notesOutputT :: Monad m => f (FixieT f e m) -> FixieT f e m a -> m ([Note], Either e a)

notesValueT :: Monad m => f (FixieT f Void m) -> FixieT f Void m a -> m ([Note], a)

notesFunctionsT :: Monad m => f (FixieT f e m) -> FixieT f e m a -> m ([Note], [Function])

notesFunctionsetT :: Monad m => f (FixieT f e m) -> FixieT f e m a -> m ([Note], Set Function)

functionsOutputT :: Monad m => f (FixieT f e m) -> FixieT f e m a -> m ([Function], Either e a)

functionsValueT :: Monad m => f (FixieT f Void m) -> FixieT f Void m a -> m ([Function], a)

functionsNotesT :: Monad m => f (FixieT f e m) -> FixieT f e m a -> m ([Function], [Note])

functionsetOutputT :: Monad m => f (FixieT f e m) -> FixieT f e m a -> m (Set Function, Either e a)

functionsetValueT :: Monad m => f (FixieT f Void m) -> FixieT f Void m a -> m (Set Function, a)

functionsetNotesT :: Monad m => f (FixieT f e m) -> FixieT f e m a -> m (Set Function, [Note])

outputT :: Monad m => f (FixieT f e m) -> FixieT f e m a -> m (Either e a)

valueT :: Monad m => f (FixieT f Void m) -> FixieT f Void m a -> m a

notesT :: Monad m => f (FixieT f e m) -> FixieT f e m a -> m [Note]

functionsT :: Monad m => f (FixieT f e m) -> FixieT f e m a -> m [Function]

functionsetT :: Monad m => f (FixieT f e m) -> FixieT f e m a -> m (Set Function)

outputNotesFunctionsM :: f (FixieM f e) -> FixieM f e a -> (Either e a, [Note], [Function])

outputNotesFunctionsetM :: f (FixieM f e) -> FixieM f e a -> (Either e a, [Note], Set Function)

outputFunctionsNotesM :: f (FixieM f e) -> FixieM f e a -> (Either e a, [Function], [Note])

outputFunctionsetNotesM :: f (FixieM f e) -> FixieM f e a -> (Either e a, Set Function, [Note])

valueNotesFunctionsM :: f (FixieM f Void) -> FixieM f Void a -> (a, [Note], [Function])

valueNotesFunctionsetM :: f (FixieM f Void) -> FixieM f Void a -> (a, [Note], Set Function)

valueFunctionsNotesM :: f (FixieM f Void) -> FixieM f Void a -> (a, [Function], [Note])

valueFunctionsetNotesM :: f (FixieM f Void) -> FixieM f Void a -> (a, Set Function, [Note])

notesOutputFunctionsM :: f (FixieM f e) -> FixieM f e a -> ([Note], Either e a, [Function])

notesOutputFunctionsetM :: f (FixieM f e) -> FixieM f e a -> ([Note], Either e a, Set Function)

notesValueFunctionsM :: f (FixieM f Void) -> FixieM f Void a -> ([Note], a, [Function])

notesValueFunctionsetM :: f (FixieM f Void) -> FixieM f Void a -> ([Note], a, Set Function)

notesFunctionsOutputM :: f (FixieM f e) -> FixieM f e a -> ([Note], [Function], Either e a)

notesFunctionsetOutputM :: f (FixieM f e) -> FixieM f e a -> ([Note], Set Function, Either e a)

notesFunctionsValueM :: f (FixieM f Void) -> FixieM f Void a -> ([Note], [Function], a)

notesFunctionsetValueM :: f (FixieM f Void) -> FixieM f Void a -> ([Note], Set Function, a)

functionsOutputNotesM :: f (FixieM f e) -> FixieM f e a -> ([Function], Either e a, [Note])

functionsValueNotesM :: f (FixieM f Void) -> FixieM f Void a -> ([Function], a, [Note])

functionsNotesOutputM :: f (FixieM f e) -> FixieM f e a -> ([Function], [Note], Either e a)

functionsNotesValueM :: f (FixieM f Void) -> FixieM f Void a -> ([Function], [Note], a)

functionsetOutputNotesM :: f (FixieM f e) -> FixieM f e a -> (Set Function, Either e a, [Note])

functionsetValueNotesM :: f (FixieM f Void) -> FixieM f Void a -> (Set Function, a, [Note])

functionsetNotesOutputM :: f (FixieM f e) -> FixieM f e a -> (Set Function, [Note], Either e a)

functionsetNotesValueM :: f (FixieM f Void) -> FixieM f Void a -> (Set Function, [Note], a)

outputNotesM :: f (FixieM f e) -> FixieM f e a -> (Either e a, [Note])

outputFunctionsM :: f (FixieM f e) -> FixieM f e a -> (Either e a, [Function])

outputFunctionsetM :: f (FixieM f e) -> FixieM f e a -> (Either e a, Set Function)

valueNotesM :: f (FixieM f Void) -> FixieM f Void a -> (a, [Note])

valueFunctionsM :: f (FixieM f Void) -> FixieM f Void a -> (a, [Function])

valueFunctionsetM :: f (FixieM f Void) -> FixieM f Void a -> (a, Set Function)

notesOutputM :: f (FixieM f e) -> FixieM f e a -> ([Note], Either e a)

notesValueM :: f (FixieM f Void) -> FixieM f Void a -> ([Note], a)

notesFunctionsM :: f (FixieM f e) -> FixieM f e a -> ([Note], [Function])

notesFunctionsetM :: f (FixieM f e) -> FixieM f e a -> ([Note], Set Function)

functionsOutputM :: f (FixieM f e) -> FixieM f e a -> ([Function], Either e a)

functionsValueM :: f (FixieM f Void) -> FixieM f Void a -> ([Function], a)

functionsNotesM :: f (FixieM f e) -> FixieM f e a -> ([Function], [Note])

functionsetOutputM :: f (FixieM f e) -> FixieM f e a -> (Set Function, Either e a)

functionsetValueM :: f (FixieM f Void) -> FixieM f Void a -> (Set Function, a)

functionsetNotesM :: f (FixieM f e) -> FixieM f e a -> (Set Function, [Note])

outputM :: f (FixieM f e) -> FixieM f e a -> Either e a

valueM :: f (FixieM f Void) -> FixieM f Void a -> a

notesM :: f (FixieM f e) -> FixieM f e a -> [Note]

functionsM :: f (FixieM f e) -> FixieM f e a -> [Function]

functionsetM :: f (FixieM f e) -> FixieM f e a -> Set Function

mkFixture :: String -> [Type] -> Q [Dec]

A Template Haskell function that generates a fixture record type with a given name that reifies the set of typeclass dictionaries provided, as described in the module documentation for Control.Monad.Fixie.TH. For example, the following splice would create a new record type called Fixture with fields and instances for typeclasses called Foo and Bar:

mkFixture "Fixture" [ts| Foo, Bar |]

mkFixture supports types in the same format that deriving clauses do when used with the GeneralizedNewtypeDeriving GHC extension, so deriving multi-parameter typeclasses is possible if they are partially applied. For example, the following is valid:

class MultiParam a m where
  doSomething :: a -> m ()

mkFixture "Fixture" [ts| MultiParam String |]

def :: Default a => a

The default value for this type.

ts :: QuasiQuoter

A quasi-quoter like the built-in [t| ... |] quasi-quoter, but produces a list of types instead of a single type. Each type should be separated by a comma.

>>> [ts| Bool, (), String |]
[ConT GHC.Types.Bool,ConT GHC.Tuple.(),ConT GHC.Base.String]
>>> [ts| Maybe Int, Monad m |]
[AppT (ConT GHC.Base.Maybe) (ConT GHC.Types.Int),AppT (ConT GHC.Base.Monad) (VarT m)]