-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Opininated testing framework for mtl style (spies, stubs, and mocks)
--   
--   Please see README.md
@package fixie
@version 1.0.0

module Test.Fixie
newtype Note
Note :: Text -> Note
newtype Function
Function :: Text -> Function
newtype Call
Call :: Function -> Call
[_function] :: Call -> Function
data 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)

-- | 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
--   <a>Control.Monad.Fixie.TH</a>. For example, the following splice would
--   create a new record type called <tt>Fixture</tt> with fields and
--   instances for typeclasses called <tt>Foo</tt> and <tt>Bar</tt>:
--   
--   <pre>
--   mkFixture "Fixture" [ts| Foo, Bar |]
--   </pre>
--   
--   <a>mkFixture</a> supports types in the same format that
--   <tt>deriving</tt> clauses do when used with the
--   <tt>GeneralizedNewtypeDeriving</tt> GHC extension, so deriving
--   multi-parameter typeclasses is possible if they are partially applied.
--   For example, the following is valid:
--   
--   <pre>
--   class MultiParam a m where
--     doSomething :: a -&gt; m ()
--   
--   mkFixture "Fixture" [ts| MultiParam String |]
--   </pre>
mkFixture :: String -> [Type] -> Q [Dec]

-- | The default value for this type.
def :: Default a => a

-- | A quasi-quoter like the built-in <tt>[t| ... |]</tt> quasi-quoter, but
--   produces a <i>list</i> of types instead of a single type. Each type
--   should be separated by a comma.
--   
--   <pre>
--   &gt;&gt;&gt; [ts| Bool, (), String |]
--   [ConT GHC.Types.Bool,ConT GHC.Tuple.(),ConT GHC.Base.String]
--   
--   &gt;&gt;&gt; [ts| Maybe Int, Monad m |]
--   [AppT (ConT GHC.Base.Maybe) (ConT GHC.Types.Int),AppT (ConT GHC.Base.Monad) (VarT m)]
--   </pre>
ts :: QuasiQuoter