Safe Haskell	None
Language	Haskell2010

Web.Stripe.Test.Prelude

Synopsis

Documentation

($) :: (a -> b) -> a -> b infixr 0 #

Application operator. This operator is redundant, since ordinary application (f x) means the same as (f $ x). However, $ has low, right-associative binding precedence, so it sometimes allows parentheses to be omitted; for example:

    f $ g $ h x  =  f (g (h x))

It is also useful in higher-order situations, such as map ($ 0) xs, or zipWith ($) fs xs.

(-&-) :: StripeHasParam request param => StripeRequest request -> param -> StripeRequest request #

add an optional parameter to a StripeRequest

data Char :: * #

The character type Char is an enumeration whose values represent Unicode (or equivalently ISO/IEC 10646) characters (see http://www.unicode.org/ for details). This set extends the ISO 8859-1 (Latin-1) character set (the first 256 characters), which is itself an extension of the ASCII character set (the first 128 characters). A character literal in Haskell has type Char.

To convert a Char to or from the corresponding Int value defined by Unicode, use toEnum and fromEnum from the Enum class respectively (or equivalently ord and chr).

Instances

Eq Char
Methods (==) :: Char -> Char -> Bool # (/=) :: Char -> Char -> Bool #
Ord Char
Methods compare :: Char -> Char -> Ordering # (<) :: Char -> Char -> Bool # (<=) :: Char -> Char -> Bool # (>) :: Char -> Char -> Bool # (>=) :: Char -> Char -> Bool # max :: Char -> Char -> Char # min :: Char -> Char -> Char #
Show Char
Methods showsPrec :: Int -> Char -> ShowS # show :: Char -> String # showList :: [Char] -> ShowS #
Lift Char
Methods lift :: Char -> Q Exp #
FromJSON Char
Methods parseJSON :: Value -> Parser Char # parseJSONList :: Value -> Parser [Char] #
FromJSONKey Char
Methods fromJSONKey :: FromJSONKeyFunction Char # fromJSONKeyList :: FromJSONKeyFunction [Char] #
Random Char
Methods randomR :: RandomGen g => (Char, Char) -> g -> (Char, g) # random :: RandomGen g => g -> (Char, g) # randomRs :: RandomGen g => (Char, Char) -> g -> [Char] # randoms :: RandomGen g => g -> [Char] # randomRIO :: (Char, Char) -> IO Char # randomIO :: IO Char #
ErrorList Char
Methods listMsg :: String -> [Char] #
Unbox Char

Vector Vector Char
Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Char -> m (Vector Char) # basicUnsafeThaw :: PrimMonad m => Vector Char -> m (Mutable Vector (PrimState m) Char) # basicLength :: Vector Char -> Int # basicUnsafeSlice :: Int -> Int -> Vector Char -> Vector Char # basicUnsafeIndexM :: Monad m => Vector Char -> Int -> m Char # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Char -> Vector Char -> m () # elemseq :: Vector Char -> Char -> b -> b #
MVector MVector Char
Methods basicLength :: MVector s Char -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Char -> MVector s Char # basicOverlaps :: MVector s Char -> MVector s Char -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Char) # basicInitialize :: PrimMonad m => MVector (PrimState m) Char -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Char -> m (MVector (PrimState m) Char) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Char -> Int -> m Char # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Char -> Int -> Char -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Char -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Char -> Char -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Char -> MVector (PrimState m) Char -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Char -> MVector (PrimState m) Char -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Char -> Int -> m (MVector (PrimState m) Char) #
Functor (URec Char)
Methods fmap :: (a -> b) -> URec Char a -> URec Char b # (<$) :: a -> URec Char b -> URec Char a #
IsString (Seq Char)
Methods fromString :: String -> Seq Char #
Foldable (URec Char)
Methods fold :: Monoid m => URec Char m -> m # foldMap :: Monoid m => (a -> m) -> URec Char a -> m # foldr :: (a -> b -> b) -> b -> URec Char a -> b # foldr' :: (a -> b -> b) -> b -> URec Char a -> b # foldl :: (b -> a -> b) -> b -> URec Char a -> b # foldl' :: (b -> a -> b) -> b -> URec Char a -> b # foldr1 :: (a -> a -> a) -> URec Char a -> a # foldl1 :: (a -> a -> a) -> URec Char a -> a # toList :: URec Char a -> [a] # null :: URec Char a -> Bool # length :: URec Char a -> Int # elem :: Eq a => a -> URec Char a -> Bool # maximum :: Ord a => URec Char a -> a # minimum :: Ord a => URec Char a -> a # sum :: Num a => URec Char a -> a # product :: Num a => URec Char a -> a #
Generic1 (URec Char)
Associated Types type Rep1 (URec Char :: * -> ) :: -> * # Methods from1 :: URec Char a -> Rep1 (URec Char) a # to1 :: Rep1 (URec Char) a -> URec Char a #
Eq (URec Char p)
Methods (==) :: URec Char p -> URec Char p -> Bool # (/=) :: URec Char p -> URec Char p -> Bool #
Ord (URec Char p)
Methods compare :: URec Char p -> URec Char p -> Ordering # (<) :: URec Char p -> URec Char p -> Bool # (<=) :: URec Char p -> URec Char p -> Bool # (>) :: URec Char p -> URec Char p -> Bool # (>=) :: URec Char p -> URec Char p -> Bool # max :: URec Char p -> URec Char p -> URec Char p # min :: URec Char p -> URec Char p -> URec Char p #
Show (URec Char p)
Methods showsPrec :: Int -> URec Char p -> ShowS # show :: URec Char p -> String # showList :: [URec Char p] -> ShowS #
Generic (URec Char p)
Associated Types type Rep (URec Char p) :: * -> * # Methods from :: URec Char p -> Rep (URec Char p) x # to :: Rep (URec Char p) x -> URec Char p #
data URec Char	Used for marking occurrences of `Char#`
data URec Char = UChar { uChar# :: Char# }
data Vector Char
data Vector Char = V_Char (Vector Char)
data MVector s Char
data MVector s Char = MV_Char (MVector s Char)
type Rep1 (URec Char)
type Rep1 (URec Char) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UChar" PrefixI True) (S1 (MetaSel (Just Symbol "uChar#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UChar))
type Rep (URec Char p)
type Rep (URec Char p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UChar" PrefixI True) (S1 (MetaSel (Just Symbol "uChar#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UChar))

class Functor f #

The Functor class is used for types that can be mapped over. Instances of Functor should satisfy the following laws:

fmap id  ==  id
fmap (f . g)  ==  fmap f . fmap g

The instances of Functor for lists, Maybe and IO satisfy these laws.

Minimal complete definition

fmap

Instances

Functor []
Methods fmap :: (a -> b) -> [a] -> [b] # (<$) :: a -> [b] -> [a] #
Functor Maybe
Methods fmap :: (a -> b) -> Maybe a -> Maybe b # (<$) :: a -> Maybe b -> Maybe a #
Functor IO
Methods fmap :: (a -> b) -> IO a -> IO b # (<$) :: a -> IO b -> IO a #
Functor V1
Methods fmap :: (a -> b) -> V1 a -> V1 b # (<$) :: a -> V1 b -> V1 a #
Functor U1
Methods fmap :: (a -> b) -> U1 a -> U1 b # (<$) :: a -> U1 b -> U1 a #
Functor Par1
Methods fmap :: (a -> b) -> Par1 a -> Par1 b # (<$) :: a -> Par1 b -> Par1 a #
Functor Q
Methods fmap :: (a -> b) -> Q a -> Q b # (<$) :: a -> Q b -> Q a #
Functor Rose
Methods fmap :: (a -> b) -> Rose a -> Rose b # (<$) :: a -> Rose b -> Rose a #
Functor FromJSONKeyFunction	Only law abiding up to interpretation
Methods fmap :: (a -> b) -> FromJSONKeyFunction a -> FromJSONKeyFunction b # (<$) :: a -> FromJSONKeyFunction b -> FromJSONKeyFunction a #
Functor IResult
Methods fmap :: (a -> b) -> IResult a -> IResult b # (<$) :: a -> IResult b -> IResult a #
Functor Result
Methods fmap :: (a -> b) -> Result a -> Result b # (<$) :: a -> Result b -> Result a #
Functor Parser
Methods fmap :: (a -> b) -> Parser a -> Parser b # (<$) :: a -> Parser b -> Parser a #
Functor Identity
Methods fmap :: (a -> b) -> Identity a -> Identity b # (<$) :: a -> Identity b -> Identity a #
Functor Min
Methods fmap :: (a -> b) -> Min a -> Min b # (<$) :: a -> Min b -> Min a #
Functor Max
Methods fmap :: (a -> b) -> Max a -> Max b # (<$) :: a -> Max b -> Max a #
Functor First
Methods fmap :: (a -> b) -> First a -> First b # (<$) :: a -> First b -> First a #
Functor Last
Methods fmap :: (a -> b) -> Last a -> Last b # (<$) :: a -> Last b -> Last a #
Functor Option
Methods fmap :: (a -> b) -> Option a -> Option b # (<$) :: a -> Option b -> Option a #
Functor NonEmpty
Methods fmap :: (a -> b) -> NonEmpty a -> NonEmpty b # (<$) :: a -> NonEmpty b -> NonEmpty a #
Functor Complex
Methods fmap :: (a -> b) -> Complex a -> Complex b # (<$) :: a -> Complex b -> Complex a #
Functor ZipList
Methods fmap :: (a -> b) -> ZipList a -> ZipList b # (<$) :: a -> ZipList b -> ZipList a #
Functor Dual
Methods fmap :: (a -> b) -> Dual a -> Dual b # (<$) :: a -> Dual b -> Dual a #
Functor Sum
Methods fmap :: (a -> b) -> Sum a -> Sum b # (<$) :: a -> Sum b -> Sum a #
Functor Product
Methods fmap :: (a -> b) -> Product a -> Product b # (<$) :: a -> Product b -> Product a #
Functor First
Methods fmap :: (a -> b) -> First a -> First b # (<$) :: a -> First b -> First a #
Functor Last
Methods fmap :: (a -> b) -> Last a -> Last b # (<$) :: a -> Last b -> Last a #
Functor Digit
Methods fmap :: (a -> b) -> Digit a -> Digit b # (<$) :: a -> Digit b -> Digit a #
Functor Node
Methods fmap :: (a -> b) -> Node a -> Node b # (<$) :: a -> Node b -> Node a #
Functor Elem
Methods fmap :: (a -> b) -> Elem a -> Elem b # (<$) :: a -> Elem b -> Elem a #
Functor FingerTree
Methods fmap :: (a -> b) -> FingerTree a -> FingerTree b # (<$) :: a -> FingerTree b -> FingerTree a #
Functor IntMap
Methods fmap :: (a -> b) -> IntMap a -> IntMap b # (<$) :: a -> IntMap b -> IntMap a #
Functor Seq
Methods fmap :: (a -> b) -> Seq a -> Seq b # (<$) :: a -> Seq b -> Seq a #
Functor ViewL
Methods fmap :: (a -> b) -> ViewL a -> ViewL b # (<$) :: a -> ViewL b -> ViewL a #
Functor ViewR
Methods fmap :: (a -> b) -> ViewR a -> ViewR b # (<$) :: a -> ViewR b -> ViewR a #
Functor DList
Methods fmap :: (a -> b) -> DList a -> DList b # (<$) :: a -> DList b -> DList a #
Functor Doc
Methods fmap :: (a -> b) -> Doc a -> Doc b # (<$) :: a -> Doc b -> Doc a #
Functor AnnotDetails
Methods fmap :: (a -> b) -> AnnotDetails a -> AnnotDetails b # (<$) :: a -> AnnotDetails b -> AnnotDetails a #
Functor Span
Methods fmap :: (a -> b) -> Span a -> Span b # (<$) :: a -> Span b -> Span a #
Functor Array
Methods fmap :: (a -> b) -> Array a -> Array b # (<$) :: a -> Array b -> Array a #
Functor Vector
Methods fmap :: (a -> b) -> Vector a -> Vector b # (<$) :: a -> Vector b -> Vector a #
Functor StripeRequestF #
Methods fmap :: (a -> b) -> StripeRequestF a -> StripeRequestF b # (<$) :: a -> StripeRequestF b -> StripeRequestF a #
Functor ((->) r)
Methods fmap :: (a -> b) -> (r -> a) -> r -> b # (<$) :: a -> (r -> b) -> r -> a #
Functor (Either a)
Methods fmap :: (a -> b) -> Either a a -> Either a b # (<$) :: a -> Either a b -> Either a a #
Functor f => Functor (Rec1 f)
Methods fmap :: (a -> b) -> Rec1 f a -> Rec1 f b # (<$) :: a -> Rec1 f b -> Rec1 f a #
Functor (URec Char)
Methods fmap :: (a -> b) -> URec Char a -> URec Char b # (<$) :: a -> URec Char b -> URec Char a #
Functor (URec Double)
Methods fmap :: (a -> b) -> URec Double a -> URec Double b # (<$) :: a -> URec Double b -> URec Double a #
Functor (URec Float)
Methods fmap :: (a -> b) -> URec Float a -> URec Float b # (<$) :: a -> URec Float b -> URec Float a #
Functor (URec Int)
Methods fmap :: (a -> b) -> URec Int a -> URec Int b # (<$) :: a -> URec Int b -> URec Int a #
Functor (URec Word)
Methods fmap :: (a -> b) -> URec Word a -> URec Word b # (<$) :: a -> URec Word b -> URec Word a #
Functor (URec (Ptr ()))
Methods fmap :: (a -> b) -> URec (Ptr ()) a -> URec (Ptr ()) b # (<$) :: a -> URec (Ptr ()) b -> URec (Ptr ()) a #
Functor ((,) a)
Methods fmap :: (a -> b) -> (a, a) -> (a, b) # (<$) :: a -> (a, b) -> (a, a) #
Functor (ST s)
Methods fmap :: (a -> b) -> ST s a -> ST s b # (<$) :: a -> ST s b -> ST s a #
Functor (HashMap k)
Methods fmap :: (a -> b) -> HashMap k a -> HashMap k b # (<$) :: a -> HashMap k b -> HashMap k a #
Functor (Map k)
Methods fmap :: (a -> b) -> Map k a -> Map k b # (<$) :: a -> Map k b -> Map k a #
Functor (IResult i)
Methods fmap :: (a -> b) -> IResult i a -> IResult i b # (<$) :: a -> IResult i b -> IResult i a #
Functor (Parser i)
Methods fmap :: (a -> b) -> Parser i a -> Parser i b # (<$) :: a -> Parser i b -> Parser i a #
Functor (Arg a)
Methods fmap :: (a -> b) -> Arg a a -> Arg a b # (<$) :: a -> Arg a b -> Arg a a #
Monad m => Functor (WrappedMonad m)
Methods fmap :: (a -> b) -> WrappedMonad m a -> WrappedMonad m b # (<$) :: a -> WrappedMonad m b -> WrappedMonad m a #
Arrow a => Functor (ArrowMonad a)
Methods fmap :: (a -> b) -> ArrowMonad a a -> ArrowMonad a b # (<$) :: a -> ArrowMonad a b -> ArrowMonad a a #
Functor (Proxy *)
Methods fmap :: (a -> b) -> Proxy * a -> Proxy * b # (<$) :: a -> Proxy * b -> Proxy * a #
Functor (State s)
Methods fmap :: (a -> b) -> State s a -> State s b # (<$) :: a -> State s b -> State s a #
Functor (SpecM a)
Methods fmap :: (a -> b) -> SpecM a a -> SpecM a b # (<$) :: a -> SpecM a b -> SpecM a a #
Functor m => Functor (ListT m)
Methods fmap :: (a -> b) -> ListT m a -> ListT m b # (<$) :: a -> ListT m b -> ListT m a #
Functor m => Functor (MaybeT m)
Methods fmap :: (a -> b) -> MaybeT m a -> MaybeT m b # (<$) :: a -> MaybeT m b -> MaybeT m a #
Functor (K1 i c)
Methods fmap :: (a -> b) -> K1 i c a -> K1 i c b # (<$) :: a -> K1 i c b -> K1 i c a #
(Functor g, Functor f) => Functor ((:+:) f g)
Methods fmap :: (a -> b) -> (f :+: g) a -> (f :+: g) b # (<$) :: a -> (f :+: g) b -> (f :+: g) a #
(Functor g, Functor f) => Functor ((:*:) f g)
Methods fmap :: (a -> b) -> (f :: g) a -> (f :: g) b # (<$) :: a -> (f :: g) b -> (f :: g) a #
(Functor g, Functor f) => Functor ((:.:) f g)
Methods fmap :: (a -> b) -> (f :.: g) a -> (f :.: g) b # (<$) :: a -> (f :.: g) b -> (f :.: g) a #
Arrow a => Functor (WrappedArrow a b)
Methods fmap :: (a -> b) -> WrappedArrow a b a -> WrappedArrow a b b # (<$) :: a -> WrappedArrow a b b -> WrappedArrow a b a #
Functor (Const * m)
Methods fmap :: (a -> b) -> Const * m a -> Const * m b # (<$) :: a -> Const * m b -> Const * m a #
Functor f => Functor (Alt * f)
Methods fmap :: (a -> b) -> Alt * f a -> Alt * f b # (<$) :: a -> Alt * f b -> Alt * f a #
Bifunctor p => Functor (Join * p)
Methods fmap :: (a -> b) -> Join * p a -> Join * p b # (<$) :: a -> Join * p b -> Join * p a #
Functor m => Functor (IdentityT * m)
Methods fmap :: (a -> b) -> IdentityT * m a -> IdentityT * m b # (<$) :: a -> IdentityT * m b -> IdentityT * m a #
Functor f => Functor (FreeF f a)
Methods fmap :: (a -> b) -> FreeF f a a -> FreeF f a b # (<$) :: a -> FreeF f a b -> FreeF f a a #
(Functor f, Monad m) => Functor (FreeT f m)
Methods fmap :: (a -> b) -> FreeT f m a -> FreeT f m b # (<$) :: a -> FreeT f m b -> FreeT f m a #
Functor m => Functor (ErrorT e m)
Methods fmap :: (a -> b) -> ErrorT e m a -> ErrorT e m b # (<$) :: a -> ErrorT e m b -> ErrorT e m a #
Functor m => Functor (ExceptT e m)
Methods fmap :: (a -> b) -> ExceptT e m a -> ExceptT e m b # (<$) :: a -> ExceptT e m b -> ExceptT e m a #
Functor m => Functor (StateT s m)
Methods fmap :: (a -> b) -> StateT s m a -> StateT s m b # (<$) :: a -> StateT s m b -> StateT s m a #
Functor m => Functor (StateT s m)
Methods fmap :: (a -> b) -> StateT s m a -> StateT s m b # (<$) :: a -> StateT s m b -> StateT s m a #
Functor m => Functor (WriterT w m)
Methods fmap :: (a -> b) -> WriterT w m a -> WriterT w m b # (<$) :: a -> WriterT w m b -> WriterT w m a #
Functor m => Functor (WriterT w m)
Methods fmap :: (a -> b) -> WriterT w m a -> WriterT w m b # (<$) :: a -> WriterT w m b -> WriterT w m a #
Functor (Tagged k s)
Methods fmap :: (a -> b) -> Tagged k s a -> Tagged k s b # (<$) :: a -> Tagged k s b -> Tagged k s a #
Functor f => Functor (M1 i c f)
Methods fmap :: (a -> b) -> M1 i c f a -> M1 i c f b # (<$) :: a -> M1 i c f b -> M1 i c f a #
(Functor f, Functor g) => Functor (Sum * f g)
Methods fmap :: (a -> b) -> Sum * f g a -> Sum * f g b # (<$) :: a -> Sum * f g b -> Sum * f g a #
(Functor f, Functor g) => Functor (Product * f g)
Methods fmap :: (a -> b) -> Product * f g a -> Product * f g b # (<$) :: a -> Product * f g b -> Product * f g a #
Functor m => Functor (ReaderT * r m)
Methods fmap :: (a -> b) -> ReaderT * r m a -> ReaderT * r m b # (<$) :: a -> ReaderT * r m b -> ReaderT * r m a #
(Functor f, Functor g) => Functor (Compose * * f g)
Methods fmap :: (a -> b) -> Compose * * f g a -> Compose * * f g b # (<$) :: a -> Compose * * f g b -> Compose * * f g a #
Bifunctor p => Functor (WrappedBifunctor * * p a)
Methods fmap :: (a -> b) -> WrappedBifunctor * * p a a -> WrappedBifunctor * * p a b # (<$) :: a -> WrappedBifunctor * * p a b -> WrappedBifunctor * * p a a #
Functor g => Functor (Joker k * g a)
Methods fmap :: (a -> b) -> Joker k * g a a -> Joker k * g a b # (<$) :: a -> Joker k * g a b -> Joker k * g a a #
Bifunctor p => Functor (Flip * * p a)
Methods fmap :: (a -> b) -> Flip * * p a a -> Flip * * p a b # (<$) :: a -> Flip * * p a b -> Flip * * p a a #
Functor (Clown * k f a)
Methods fmap :: (a -> b) -> Clown * k f a a -> Clown * k f a b # (<$) :: a -> Clown * k f a b -> Clown * k f a a #
Functor m => Functor (RWST r w s m)
Methods fmap :: (a -> b) -> RWST r w s m a -> RWST r w s m b # (<$) :: a -> RWST r w s m b -> RWST r w s m a #
Functor m => Functor (RWST r w s m)
Methods fmap :: (a -> b) -> RWST r w s m a -> RWST r w s m b # (<$) :: a -> RWST r w s m b -> RWST r w s m a #
(Functor f, Bifunctor p) => Functor (Tannen * * * f p a)
Methods fmap :: (a -> b) -> Tannen * * * f p a a -> Tannen * * * f p a b # (<$) :: a -> Tannen * * * f p a b -> Tannen * * * f p a a #
(Bifunctor p, Functor g) => Functor (Biff * k * * p f g a)
Methods fmap :: (a -> b) -> Biff * k * * p f g a a -> Biff * k * * p f g a b # (<$) :: a -> Biff * k * * p f g a b -> Biff * k * * p f g a a #

data IO a :: * -> * #

A value of type IO a is a computation which, when performed, does some I/O before returning a value of type a.

There is really only one way to "perform" an I/O action: bind it to Main.main in your program. When your program is run, the I/O will be performed. It isn't possible to perform I/O from an arbitrary function, unless that function is itself in the IO monad and called at some point, directly or indirectly, from Main.main.

IO is a monad, so IO actions can be combined using either the do-notation or the >> and >>= operations from the Monad class.

Instances

Monad IO
Methods (>>=) :: IO a -> (a -> IO b) -> IO b # (>>) :: IO a -> IO b -> IO b # return :: a -> IO a # fail :: String -> IO a #
Functor IO
Methods fmap :: (a -> b) -> IO a -> IO b # (<$) :: a -> IO b -> IO a #
Applicative IO
Methods pure :: a -> IO a # (<>) :: IO (a -> b) -> IO a -> IO b # (>) :: IO a -> IO b -> IO b # (<*) :: IO a -> IO b -> IO a #
Alternative IO
Methods empty :: IO a # (<\|>) :: IO a -> IO a -> IO a # some :: IO a -> IO [a] # many :: IO a -> IO [a] #
MonadPlus IO
Methods mzero :: IO a # mplus :: IO a -> IO a -> IO a #
MonadIO IO
Methods liftIO :: IO a -> IO a #
Example Expectation
Associated Types type Arg Expectation :: * # Methods evaluateExample :: Expectation -> Params -> (ActionWith (Arg Expectation) -> IO ()) -> ProgressCallback -> IO Result #
PrimMonad IO
Associated Types type PrimState (IO :: * -> ) :: # Methods primitive :: (State# (PrimState IO) -> (#VoidRep, PtrRepLifted, State# (PrimState IO), a#)) -> IO a #
PrimBase IO
Methods internal :: IO a -> State# (PrimState IO) -> (#VoidRep, PtrRepLifted, State# (PrimState IO), a#) #
Quasi IO
Methods qNewName :: String -> IO Name # qReport :: Bool -> String -> IO () # qRecover :: IO a -> IO a -> IO a # qLookupName :: Bool -> String -> IO (Maybe Name) # qReify :: Name -> IO Info # qReifyFixity :: Name -> IO (Maybe Fixity) # qReifyInstances :: Name -> [Type] -> IO [Dec] # qReifyRoles :: Name -> IO [Role] # qReifyAnnotations :: Data a => AnnLookup -> IO [a] # qReifyModule :: Module -> IO ModuleInfo # qReifyConStrictness :: Name -> IO [DecidedStrictness] # qLocation :: IO Loc # qRunIO :: IO a -> IO a # qAddDependentFile :: FilePath -> IO () # qAddTopDecls :: [Dec] -> IO () # qAddModFinalizer :: Q () -> IO () # qGetQ :: Typeable * a => IO (Maybe a) # qPutQ :: Typeable * a => a -> IO () # qIsExtEnabled :: Extension -> IO Bool # qExtsEnabled :: IO [Extension] #
Monoid a => Monoid (IO a)
Methods mempty :: IO a # mappend :: IO a -> IO a -> IO a # mconcat :: [IO a] -> IO a #
Example (a -> Expectation)
Associated Types type Arg (a -> Expectation) :: * # Methods evaluateExample :: (a -> Expectation) -> Params -> (ActionWith (Arg (a -> Expectation)) -> IO ()) -> ProgressCallback -> IO Result #
type Arg Expectation
type Arg Expectation = ()
type PrimState IO
type PrimState IO = RealWorld
type Arg (a -> Expectation)
type Arg (a -> Expectation) = a

type String = [Char] #

A String is a list of characters. String constants in Haskell are values of type String.

error :: HasCallStack => [Char] -> a #

error stops execution and displays an error message.

module GHC.Num

id :: a -> a #

Identity function.

(.) :: (b -> c) -> (a -> b) -> a -> c infixr 9 #

Function composition.

length :: Foldable t => forall a. t a -> Int #

Returns the size/length of a finite structure as an Int. The default implementation is optimized for structures that are similar to cons-lists, because there is no general way to do better.

undefined :: HasCallStack => a #

A special case of error. It is expected that compilers will recognize this and insert error messages which are more appropriate to the context in which undefined appears.

return :: Monad m => a -> m a Source #

(>>=) :: (StripeLift t, Monad m, LiftedType t ~ m a) => t -> (a -> m b) -> m b Source #

(>>) :: (StripeLift t, Monad m, LiftedType t ~ m a) => t -> m b -> m b Source #

fail :: Monad m => String -> m a Source #

void :: FromJSON (StripeReturn a) => StripeRequest a -> Stripe () Source #

liftIO :: IO a -> Stripe a Source #

fromString :: IsString a => String -> a #

stripeLift :: StripeLift a => a -> LiftedType a Source #

module Test.Hspec

class Eq a where #

The Eq class defines equality (==) and inequality (/=). All the basic datatypes exported by the Prelude are instances of Eq, and Eq may be derived for any datatype whose constituents are also instances of Eq.

Minimal complete definition: either == or /=.

Minimal complete definition

(==) | (/=)

Methods

(==) :: a -> a -> Bool infix 4 #

(/=) :: a -> a -> Bool infix 4 #

Instances

Eq Bool
Methods (==) :: Bool -> Bool -> Bool # (/=) :: Bool -> Bool -> Bool #
Eq Char
Methods (==) :: Char -> Char -> Bool # (/=) :: Char -> Char -> Bool #
Eq Double
Methods (==) :: Double -> Double -> Bool # (/=) :: Double -> Double -> Bool #
Eq Float
Methods (==) :: Float -> Float -> Bool # (/=) :: Float -> Float -> Bool #
Eq Int
Methods (==) :: Int -> Int -> Bool # (/=) :: Int -> Int -> Bool #
Eq Int8
Methods (==) :: Int8 -> Int8 -> Bool # (/=) :: Int8 -> Int8 -> Bool #
Eq Int16
Methods (==) :: Int16 -> Int16 -> Bool # (/=) :: Int16 -> Int16 -> Bool #
Eq Int32
Methods (==) :: Int32 -> Int32 -> Bool # (/=) :: Int32 -> Int32 -> Bool #
Eq Int64
Methods (==) :: Int64 -> Int64 -> Bool # (/=) :: Int64 -> Int64 -> Bool #
Eq Integer
Methods (==) :: Integer -> Integer -> Bool # (/=) :: Integer -> Integer -> Bool #
Eq Ordering
Methods (==) :: Ordering -> Ordering -> Bool # (/=) :: Ordering -> Ordering -> Bool #
Eq Word
Methods (==) :: Word -> Word -> Bool # (/=) :: Word -> Word -> Bool #
Eq Word8
Methods (==) :: Word8 -> Word8 -> Bool # (/=) :: Word8 -> Word8 -> Bool #
Eq Word16
Methods (==) :: Word16 -> Word16 -> Bool # (/=) :: Word16 -> Word16 -> Bool #
Eq Word32
Methods (==) :: Word32 -> Word32 -> Bool # (/=) :: Word32 -> Word32 -> Bool #
Eq Word64
Methods (==) :: Word64 -> Word64 -> Bool # (/=) :: Word64 -> Word64 -> Bool #
Eq Exp
Methods (==) :: Exp -> Exp -> Bool # (/=) :: Exp -> Exp -> Bool #
Eq Match
Methods (==) :: Match -> Match -> Bool # (/=) :: Match -> Match -> Bool #
Eq Clause
Methods (==) :: Clause -> Clause -> Bool # (/=) :: Clause -> Clause -> Bool #
Eq Pat
Methods (==) :: Pat -> Pat -> Bool # (/=) :: Pat -> Pat -> Bool #
Eq Type
Methods (==) :: Type -> Type -> Bool # (/=) :: Type -> Type -> Bool #
Eq Dec
Methods (==) :: Dec -> Dec -> Bool # (/=) :: Dec -> Dec -> Bool #
Eq Name
Methods (==) :: Name -> Name -> Bool # (/=) :: Name -> Name -> Bool #
Eq FunDep
Methods (==) :: FunDep -> FunDep -> Bool # (/=) :: FunDep -> FunDep -> Bool #
Eq TyVarBndr
Methods (==) :: TyVarBndr -> TyVarBndr -> Bool # (/=) :: TyVarBndr -> TyVarBndr -> Bool #
Eq InjectivityAnn
Methods (==) :: InjectivityAnn -> InjectivityAnn -> Bool # (/=) :: InjectivityAnn -> InjectivityAnn -> Bool #
Eq Overlap
Methods (==) :: Overlap -> Overlap -> Bool # (/=) :: Overlap -> Overlap -> Bool #
Eq ()
Methods (==) :: () -> () -> Bool # (/=) :: () -> () -> Bool #
Eq TyCon
Methods (==) :: TyCon -> TyCon -> Bool # (/=) :: TyCon -> TyCon -> Bool #
Eq HUnitFailure
Methods (==) :: HUnitFailure -> HUnitFailure -> Bool # (/=) :: HUnitFailure -> HUnitFailure -> Bool #
Eq FailureReason
Methods (==) :: FailureReason -> FailureReason -> Bool # (/=) :: FailureReason -> FailureReason -> Bool #
Eq Result
Methods (==) :: Result -> Result -> Bool # (/=) :: Result -> Result -> Bool #
Eq Version
Methods (==) :: Version -> Version -> Bool # (/=) :: Version -> Version -> Bool #
Eq Con
Methods (==) :: Con -> Con -> Bool # (/=) :: Con -> Con -> Bool #
Eq ByteString
Methods (==) :: ByteString -> ByteString -> Bool # (/=) :: ByteString -> ByteString -> Bool #
Eq Scientific
Methods (==) :: Scientific -> Scientific -> Bool # (/=) :: Scientific -> Scientific -> Bool #
Eq UTCTime
Methods (==) :: UTCTime -> UTCTime -> Bool # (/=) :: UTCTime -> UTCTime -> Bool #
Eq JSONPathElement
Methods (==) :: JSONPathElement -> JSONPathElement -> Bool # (/=) :: JSONPathElement -> JSONPathElement -> Bool #
Eq Value
Methods (==) :: Value -> Value -> Bool # (/=) :: Value -> Value -> Bool #
Eq DotNetTime
Methods (==) :: DotNetTime -> DotNetTime -> Bool # (/=) :: DotNetTime -> DotNetTime -> Bool #
Eq SumEncoding
Methods (==) :: SumEncoding -> SumEncoding -> Bool # (/=) :: SumEncoding -> SumEncoding -> Bool #
Eq Pos
Methods (==) :: Pos -> Pos -> Bool # (/=) :: Pos -> Pos -> Bool #
Eq More
Methods (==) :: More -> More -> Bool # (/=) :: More -> More -> Bool #
Eq BigNat
Methods (==) :: BigNat -> BigNat -> Bool # (/=) :: BigNat -> BigNat -> Bool #
Eq SpecConstrAnnotation
Methods (==) :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool # (/=) :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool #
Eq Void
Methods (==) :: Void -> Void -> Bool # (/=) :: Void -> Void -> Bool #
Eq AsyncException
Methods (==) :: AsyncException -> AsyncException -> Bool # (/=) :: AsyncException -> AsyncException -> Bool #
Eq ArrayException
Methods (==) :: ArrayException -> ArrayException -> Bool # (/=) :: ArrayException -> ArrayException -> Bool #
Eq ExitCode
Methods (==) :: ExitCode -> ExitCode -> Bool # (/=) :: ExitCode -> ExitCode -> Bool #
Eq IOErrorType
Methods (==) :: IOErrorType -> IOErrorType -> Bool # (/=) :: IOErrorType -> IOErrorType -> Bool #
Eq All
Methods (==) :: All -> All -> Bool # (/=) :: All -> All -> Bool #
Eq Any
Methods (==) :: Any -> Any -> Bool # (/=) :: Any -> Any -> Bool #
Eq Fixity
Methods (==) :: Fixity -> Fixity -> Bool # (/=) :: Fixity -> Fixity -> Bool #
Eq Associativity
Methods (==) :: Associativity -> Associativity -> Bool # (/=) :: Associativity -> Associativity -> Bool #
Eq SourceUnpackedness
Methods (==) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (/=) :: SourceUnpackedness -> SourceUnpackedness -> Bool #
Eq SourceStrictness
Methods (==) :: SourceStrictness -> SourceStrictness -> Bool # (/=) :: SourceStrictness -> SourceStrictness -> Bool #
Eq DecidedStrictness
Methods (==) :: DecidedStrictness -> DecidedStrictness -> Bool # (/=) :: DecidedStrictness -> DecidedStrictness -> Bool #
Eq IOException
Methods (==) :: IOException -> IOException -> Bool # (/=) :: IOException -> IOException -> Bool #
Eq SomeNat
Methods (==) :: SomeNat -> SomeNat -> Bool # (/=) :: SomeNat -> SomeNat -> Bool #
Eq SomeSymbol
Methods (==) :: SomeSymbol -> SomeSymbol -> Bool # (/=) :: SomeSymbol -> SomeSymbol -> Bool #
Eq SrcLoc
Methods (==) :: SrcLoc -> SrcLoc -> Bool # (/=) :: SrcLoc -> SrcLoc -> Bool #
Eq IntSet
Methods (==) :: IntSet -> IntSet -> Bool # (/=) :: IntSet -> IntSet -> Bool #
Eq Extension
Methods (==) :: Extension -> Extension -> Bool # (/=) :: Extension -> Extension -> Bool #
Eq LocationAccuracy
Methods (==) :: LocationAccuracy -> LocationAccuracy -> Bool # (/=) :: LocationAccuracy -> LocationAccuracy -> Bool #
Eq Location
Methods (==) :: Location -> Location -> Bool # (/=) :: Location -> Location -> Bool #
Eq Result
Methods (==) :: Result -> Result -> Bool # (/=) :: Result -> Result -> Bool #
Eq FailureReason
Methods (==) :: FailureReason -> FailureReason -> Bool # (/=) :: FailureReason -> FailureReason -> Bool #
Eq Summary
Methods (==) :: Summary -> Summary -> Bool # (/=) :: Summary -> Summary -> Bool #
Eq Doc
Methods (==) :: Doc -> Doc -> Bool # (/=) :: Doc -> Doc -> Bool #
Eq TextDetails
Methods (==) :: TextDetails -> TextDetails -> Bool # (/=) :: TextDetails -> TextDetails -> Bool #
Eq Style
Methods (==) :: Style -> Style -> Bool # (/=) :: Style -> Style -> Bool #
Eq Mode
Methods (==) :: Mode -> Mode -> Bool # (/=) :: Mode -> Mode -> Bool #
Eq StripeKey
Methods (==) :: StripeKey -> StripeKey -> Bool # (/=) :: StripeKey -> StripeKey -> Bool #
Eq StripeConfig
Methods (==) :: StripeConfig -> StripeConfig -> Bool # (/=) :: StripeConfig -> StripeConfig -> Bool #
Eq APIVersion
Methods (==) :: APIVersion -> APIVersion -> Bool # (/=) :: APIVersion -> APIVersion -> Bool #
Eq Method
Methods (==) :: Method -> Method -> Bool # (/=) :: Method -> Method -> Bool #
Eq AvailableOn
Methods (==) :: AvailableOn -> AvailableOn -> Bool # (/=) :: AvailableOn -> AvailableOn -> Bool #
Eq Created
Methods (==) :: Created -> Created -> Bool # (/=) :: Created -> Created -> Bool #
Eq Date
Methods (==) :: Date -> Date -> Bool # (/=) :: Date -> Date -> Bool #
Eq ChargeId
Methods (==) :: ChargeId -> ChargeId -> Bool # (/=) :: ChargeId -> ChargeId -> Bool #
Eq StatementDescription
Methods (==) :: StatementDescription -> StatementDescription -> Bool # (/=) :: StatementDescription -> StatementDescription -> Bool #
Eq Charge
Methods (==) :: Charge -> Charge -> Bool # (/=) :: Charge -> Charge -> Bool #
Eq Capture
Methods (==) :: Capture -> Capture -> Bool # (/=) :: Capture -> Capture -> Bool #
Eq RefundId
Methods (==) :: RefundId -> RefundId -> Bool # (/=) :: RefundId -> RefundId -> Bool #
Eq Refund
Methods (==) :: Refund -> Refund -> Bool # (/=) :: Refund -> Refund -> Bool #
Eq RefundApplicationFee
Methods (==) :: RefundApplicationFee -> RefundApplicationFee -> Bool # (/=) :: RefundApplicationFee -> RefundApplicationFee -> Bool #
Eq RefundReason
Methods (==) :: RefundReason -> RefundReason -> Bool # (/=) :: RefundReason -> RefundReason -> Bool #
Eq CustomerId
Methods (==) :: CustomerId -> CustomerId -> Bool # (/=) :: CustomerId -> CustomerId -> Bool #
Eq Customer
Methods (==) :: Customer -> Customer -> Bool # (/=) :: Customer -> Customer -> Bool #
Eq AccountBalance
Methods (==) :: AccountBalance -> AccountBalance -> Bool # (/=) :: AccountBalance -> AccountBalance -> Bool #
Eq CardId
Methods (==) :: CardId -> CardId -> Bool # (/=) :: CardId -> CardId -> Bool #
Eq RecipientCardId
Methods (==) :: RecipientCardId -> RecipientCardId -> Bool # (/=) :: RecipientCardId -> RecipientCardId -> Bool #
Eq CardNumber
Methods (==) :: CardNumber -> CardNumber -> Bool # (/=) :: CardNumber -> CardNumber -> Bool #
Eq ExpMonth
Methods (==) :: ExpMonth -> ExpMonth -> Bool # (/=) :: ExpMonth -> ExpMonth -> Bool #
Eq ExpYear
Methods (==) :: ExpYear -> ExpYear -> Bool # (/=) :: ExpYear -> ExpYear -> Bool #
Eq CVC
Methods (==) :: CVC -> CVC -> Bool # (/=) :: CVC -> CVC -> Bool #
Eq AddressCity
Methods (==) :: AddressCity -> AddressCity -> Bool # (/=) :: AddressCity -> AddressCity -> Bool #
Eq AddressCountry
Methods (==) :: AddressCountry -> AddressCountry -> Bool # (/=) :: AddressCountry -> AddressCountry -> Bool #
Eq AddressLine1
Methods (==) :: AddressLine1 -> AddressLine1 -> Bool # (/=) :: AddressLine1 -> AddressLine1 -> Bool #
Eq AddressLine2
Methods (==) :: AddressLine2 -> AddressLine2 -> Bool # (/=) :: AddressLine2 -> AddressLine2 -> Bool #
Eq AddressState
Methods (==) :: AddressState -> AddressState -> Bool # (/=) :: AddressState -> AddressState -> Bool #
Eq AddressZip
Methods (==) :: AddressZip -> AddressZip -> Bool # (/=) :: AddressZip -> AddressZip -> Bool #
Eq IsVerified
Methods (==) :: IsVerified -> IsVerified -> Bool # (/=) :: IsVerified -> IsVerified -> Bool #
Eq Brand
Methods (==) :: Brand -> Brand -> Bool # (/=) :: Brand -> Brand -> Bool #
Eq Card
Methods (==) :: Card -> Card -> Bool # (/=) :: Card -> Card -> Bool #
Eq RecipientCard
Methods (==) :: RecipientCard -> RecipientCard -> Bool # (/=) :: RecipientCard -> RecipientCard -> Bool #
Eq NewCard
Methods (==) :: NewCard -> NewCard -> Bool # (/=) :: NewCard -> NewCard -> Bool #
Eq DefaultCard
Methods (==) :: DefaultCard -> DefaultCard -> Bool # (/=) :: DefaultCard -> DefaultCard -> Bool #
Eq SubscriptionId
Methods (==) :: SubscriptionId -> SubscriptionId -> Bool # (/=) :: SubscriptionId -> SubscriptionId -> Bool #
Eq Subscription
Methods (==) :: Subscription -> Subscription -> Bool # (/=) :: Subscription -> Subscription -> Bool #
Eq SubscriptionStatus
Methods (==) :: SubscriptionStatus -> SubscriptionStatus -> Bool # (/=) :: SubscriptionStatus -> SubscriptionStatus -> Bool #
Eq TaxPercent
Methods (==) :: TaxPercent -> TaxPercent -> Bool # (/=) :: TaxPercent -> TaxPercent -> Bool #
Eq PlanId
Methods (==) :: PlanId -> PlanId -> Bool # (/=) :: PlanId -> PlanId -> Bool #
Eq Plan
Methods (==) :: Plan -> Plan -> Bool # (/=) :: Plan -> Plan -> Bool #
Eq TrialPeriod
Methods (==) :: TrialPeriod -> TrialPeriod -> Bool # (/=) :: TrialPeriod -> TrialPeriod -> Bool #
Eq TrialEnd
Methods (==) :: TrialEnd -> TrialEnd -> Bool # (/=) :: TrialEnd -> TrialEnd -> Bool #
Eq Interval
Methods (==) :: Interval -> Interval -> Bool # (/=) :: Interval -> Interval -> Bool #
Eq Duration
Methods (==) :: Duration -> Duration -> Bool # (/=) :: Duration -> Duration -> Bool #
Eq Coupon
Methods (==) :: Coupon -> Coupon -> Bool # (/=) :: Coupon -> Coupon -> Bool #
Eq CouponId
Methods (==) :: CouponId -> CouponId -> Bool # (/=) :: CouponId -> CouponId -> Bool #
Eq AmountOff
Methods (==) :: AmountOff -> AmountOff -> Bool # (/=) :: AmountOff -> AmountOff -> Bool #
Eq MaxRedemptions
Methods (==) :: MaxRedemptions -> MaxRedemptions -> Bool # (/=) :: MaxRedemptions -> MaxRedemptions -> Bool #
Eq PercentOff
Methods (==) :: PercentOff -> PercentOff -> Bool # (/=) :: PercentOff -> PercentOff -> Bool #
Eq RedeemBy
Methods (==) :: RedeemBy -> RedeemBy -> Bool # (/=) :: RedeemBy -> RedeemBy -> Bool #
Eq DurationInMonths
Methods (==) :: DurationInMonths -> DurationInMonths -> Bool # (/=) :: DurationInMonths -> DurationInMonths -> Bool #
Eq IntervalCount
Methods (==) :: IntervalCount -> IntervalCount -> Bool # (/=) :: IntervalCount -> IntervalCount -> Bool #
Eq TrialPeriodDays
Methods (==) :: TrialPeriodDays -> TrialPeriodDays -> Bool # (/=) :: TrialPeriodDays -> TrialPeriodDays -> Bool #
Eq Amount
Methods (==) :: Amount -> Amount -> Bool # (/=) :: Amount -> Amount -> Bool #
Eq Discount
Methods (==) :: Discount -> Discount -> Bool # (/=) :: Discount -> Discount -> Bool #
Eq InvoiceId
Methods (==) :: InvoiceId -> InvoiceId -> Bool # (/=) :: InvoiceId -> InvoiceId -> Bool #
Eq Invoice
Methods (==) :: Invoice -> Invoice -> Bool # (/=) :: Invoice -> Invoice -> Bool #
Eq InvoiceItemId
Methods (==) :: InvoiceItemId -> InvoiceItemId -> Bool # (/=) :: InvoiceItemId -> InvoiceItemId -> Bool #
Eq InvoiceItem
Methods (==) :: InvoiceItem -> InvoiceItem -> Bool # (/=) :: InvoiceItem -> InvoiceItem -> Bool #
Eq InvoiceLineItemId
Methods (==) :: InvoiceLineItemId -> InvoiceLineItemId -> Bool # (/=) :: InvoiceLineItemId -> InvoiceLineItemId -> Bool #
Eq InvoiceLineItemType
Methods (==) :: InvoiceLineItemType -> InvoiceLineItemType -> Bool # (/=) :: InvoiceLineItemType -> InvoiceLineItemType -> Bool #
Eq InvoiceLineItem
Methods (==) :: InvoiceLineItem -> InvoiceLineItem -> Bool # (/=) :: InvoiceLineItem -> InvoiceLineItem -> Bool #
Eq Period
Methods (==) :: Period -> Period -> Bool # (/=) :: Period -> Period -> Bool #
Eq Closed
Methods (==) :: Closed -> Closed -> Bool # (/=) :: Closed -> Closed -> Bool #
Eq Forgiven
Methods (==) :: Forgiven -> Forgiven -> Bool # (/=) :: Forgiven -> Forgiven -> Bool #
Eq DisputeStatus
Methods (==) :: DisputeStatus -> DisputeStatus -> Bool # (/=) :: DisputeStatus -> DisputeStatus -> Bool #
Eq DisputeReason
Methods (==) :: DisputeReason -> DisputeReason -> Bool # (/=) :: DisputeReason -> DisputeReason -> Bool #
Eq Dispute
Methods (==) :: Dispute -> Dispute -> Bool # (/=) :: Dispute -> Dispute -> Bool #
Eq Evidence
Methods (==) :: Evidence -> Evidence -> Bool # (/=) :: Evidence -> Evidence -> Bool #
Eq TransferId
Methods (==) :: TransferId -> TransferId -> Bool # (/=) :: TransferId -> TransferId -> Bool #
Eq TransferStatus
Methods (==) :: TransferStatus -> TransferStatus -> Bool # (/=) :: TransferStatus -> TransferStatus -> Bool #
Eq TransferType
Methods (==) :: TransferType -> TransferType -> Bool # (/=) :: TransferType -> TransferType -> Bool #
Eq Transfer
Methods (==) :: Transfer -> Transfer -> Bool # (/=) :: Transfer -> Transfer -> Bool #
Eq BankAccount
Methods (==) :: BankAccount -> BankAccount -> Bool # (/=) :: BankAccount -> BankAccount -> Bool #
Eq BankAccountId
Methods (==) :: BankAccountId -> BankAccountId -> Bool # (/=) :: BankAccountId -> BankAccountId -> Bool #
Eq BankAccountStatus
Methods (==) :: BankAccountStatus -> BankAccountStatus -> Bool # (/=) :: BankAccountStatus -> BankAccountStatus -> Bool #
Eq RoutingNumber
Methods (==) :: RoutingNumber -> RoutingNumber -> Bool # (/=) :: RoutingNumber -> RoutingNumber -> Bool #
Eq Country
Methods (==) :: Country -> Country -> Bool # (/=) :: Country -> Country -> Bool #
Eq AccountNumber
Methods (==) :: AccountNumber -> AccountNumber -> Bool # (/=) :: AccountNumber -> AccountNumber -> Bool #
Eq NewBankAccount
Methods (==) :: NewBankAccount -> NewBankAccount -> Bool # (/=) :: NewBankAccount -> NewBankAccount -> Bool #
Eq FirstName
Methods (==) :: FirstName -> FirstName -> Bool # (/=) :: FirstName -> FirstName -> Bool #
Eq LastName
Methods (==) :: LastName -> LastName -> Bool # (/=) :: LastName -> LastName -> Bool #
Eq RecipientId
Methods (==) :: RecipientId -> RecipientId -> Bool # (/=) :: RecipientId -> RecipientId -> Bool #
Eq TaxID
Methods (==) :: TaxID -> TaxID -> Bool # (/=) :: TaxID -> TaxID -> Bool #
Eq RecipientType
Methods (==) :: RecipientType -> RecipientType -> Bool # (/=) :: RecipientType -> RecipientType -> Bool #
Eq Recipient
Methods (==) :: Recipient -> Recipient -> Bool # (/=) :: Recipient -> Recipient -> Bool #
Eq ApplicationFeeId
Methods (==) :: ApplicationFeeId -> ApplicationFeeId -> Bool # (/=) :: ApplicationFeeId -> ApplicationFeeId -> Bool #
Eq ApplicationFee
Methods (==) :: ApplicationFee -> ApplicationFee -> Bool # (/=) :: ApplicationFee -> ApplicationFee -> Bool #
Eq ApplicationFeePercent
Methods (==) :: ApplicationFeePercent -> ApplicationFeePercent -> Bool # (/=) :: ApplicationFeePercent -> ApplicationFeePercent -> Bool #
Eq ApplicationFeeAmount
Methods (==) :: ApplicationFeeAmount -> ApplicationFeeAmount -> Bool # (/=) :: ApplicationFeeAmount -> ApplicationFeeAmount -> Bool #
Eq ApplicationId
Methods (==) :: ApplicationId -> ApplicationId -> Bool # (/=) :: ApplicationId -> ApplicationId -> Bool #
Eq FeeId
Methods (==) :: FeeId -> FeeId -> Bool # (/=) :: FeeId -> FeeId -> Bool #
Eq ApplicationFeeRefund
Methods (==) :: ApplicationFeeRefund -> ApplicationFeeRefund -> Bool # (/=) :: ApplicationFeeRefund -> ApplicationFeeRefund -> Bool #
Eq AccountId
Methods (==) :: AccountId -> AccountId -> Bool # (/=) :: AccountId -> AccountId -> Bool #
Eq Account
Methods (==) :: Account -> Account -> Bool # (/=) :: Account -> Account -> Bool #
Eq Balance
Methods (==) :: Balance -> Balance -> Bool # (/=) :: Balance -> Balance -> Bool #
Eq BalanceAmount
Methods (==) :: BalanceAmount -> BalanceAmount -> Bool # (/=) :: BalanceAmount -> BalanceAmount -> Bool #
Eq BalanceTransaction
Methods (==) :: BalanceTransaction -> BalanceTransaction -> Bool # (/=) :: BalanceTransaction -> BalanceTransaction -> Bool #
Eq TransactionId
Methods (==) :: TransactionId -> TransactionId -> Bool # (/=) :: TransactionId -> TransactionId -> Bool #
Eq FeeDetails
Methods (==) :: FeeDetails -> FeeDetails -> Bool # (/=) :: FeeDetails -> FeeDetails -> Bool #
Eq TransactionType
Methods (==) :: TransactionType -> TransactionType -> Bool # (/=) :: TransactionType -> TransactionType -> Bool #
Eq EventType
Methods (==) :: EventType -> EventType -> Bool # (/=) :: EventType -> EventType -> Bool #
Eq EventId
Methods (==) :: EventId -> EventId -> Bool # (/=) :: EventId -> EventId -> Bool #
Eq EventData
Methods (==) :: EventData -> EventData -> Bool # (/=) :: EventData -> EventData -> Bool #
Eq Event
Methods (==) :: Event -> Event -> Bool # (/=) :: Event -> Event -> Bool #
Eq ConnectApp
Methods (==) :: ConnectApp -> ConnectApp -> Bool # (/=) :: ConnectApp -> ConnectApp -> Bool #
Eq TokenId
Methods (==) :: TokenId -> TokenId -> Bool # (/=) :: TokenId -> TokenId -> Bool #
Eq TokenType
Methods (==) :: TokenType -> TokenType -> Bool # (/=) :: TokenType -> TokenType -> Bool #
Eq Limit
Methods (==) :: Limit -> Limit -> Bool # (/=) :: Limit -> Limit -> Bool #
Eq StripeDeleteResult
Methods (==) :: StripeDeleteResult -> StripeDeleteResult -> Bool # (/=) :: StripeDeleteResult -> StripeDeleteResult -> Bool #
Eq MetaData
Methods (==) :: MetaData -> MetaData -> Bool # (/=) :: MetaData -> MetaData -> Bool #
Eq ExpandParams
Methods (==) :: ExpandParams -> ExpandParams -> Bool # (/=) :: ExpandParams -> ExpandParams -> Bool #
Eq Name
Methods (==) :: Name -> Name -> Bool # (/=) :: Name -> Name -> Bool #
Eq PlanName
Methods (==) :: PlanName -> PlanName -> Bool # (/=) :: PlanName -> PlanName -> Bool #
Eq Description
Methods (==) :: Description -> Description -> Bool # (/=) :: Description -> Description -> Bool #
Eq Quantity
Methods (==) :: Quantity -> Quantity -> Bool # (/=) :: Quantity -> Quantity -> Bool #
Eq Prorate
Methods (==) :: Prorate -> Prorate -> Bool # (/=) :: Prorate -> Prorate -> Bool #
Eq AtPeriodEnd
Methods (==) :: AtPeriodEnd -> AtPeriodEnd -> Bool # (/=) :: AtPeriodEnd -> AtPeriodEnd -> Bool #
Eq Email
Methods (==) :: Email -> Email -> Bool # (/=) :: Email -> Email -> Bool #
Eq ReceiptEmail
Methods (==) :: ReceiptEmail -> ReceiptEmail -> Bool # (/=) :: ReceiptEmail -> ReceiptEmail -> Bool #
Eq Currency
Methods (==) :: Currency -> Currency -> Bool # (/=) :: Currency -> Currency -> Bool #
Eq BitcoinReceiver
Methods (==) :: BitcoinReceiver -> BitcoinReceiver -> Bool # (/=) :: BitcoinReceiver -> BitcoinReceiver -> Bool #
Eq Transactions
Methods (==) :: Transactions -> Transactions -> Bool # (/=) :: Transactions -> Transactions -> Bool #
Eq BitcoinTransaction
Methods (==) :: BitcoinTransaction -> BitcoinTransaction -> Bool # (/=) :: BitcoinTransaction -> BitcoinTransaction -> Bool #
Eq BitcoinTransactionId
Methods (==) :: BitcoinTransactionId -> BitcoinTransactionId -> Bool # (/=) :: BitcoinTransactionId -> BitcoinTransactionId -> Bool #
Eq BitcoinReceiverId
Methods (==) :: BitcoinReceiverId -> BitcoinReceiverId -> Bool # (/=) :: BitcoinReceiverId -> BitcoinReceiverId -> Bool #
Eq PaymentId
Methods (==) :: PaymentId -> PaymentId -> Bool # (/=) :: PaymentId -> PaymentId -> Bool #
Eq ModName
Methods (==) :: ModName -> ModName -> Bool # (/=) :: ModName -> ModName -> Bool #
Eq PkgName
Methods (==) :: PkgName -> PkgName -> Bool # (/=) :: PkgName -> PkgName -> Bool #
Eq Module
Methods (==) :: Module -> Module -> Bool # (/=) :: Module -> Module -> Bool #
Eq OccName
Methods (==) :: OccName -> OccName -> Bool # (/=) :: OccName -> OccName -> Bool #
Eq NameFlavour
Methods (==) :: NameFlavour -> NameFlavour -> Bool # (/=) :: NameFlavour -> NameFlavour -> Bool #
Eq NameSpace
Methods (==) :: NameSpace -> NameSpace -> Bool # (/=) :: NameSpace -> NameSpace -> Bool #
Eq Loc
Methods (==) :: Loc -> Loc -> Bool # (/=) :: Loc -> Loc -> Bool #
Eq Info
Methods (==) :: Info -> Info -> Bool # (/=) :: Info -> Info -> Bool #
Eq ModuleInfo
Methods (==) :: ModuleInfo -> ModuleInfo -> Bool # (/=) :: ModuleInfo -> ModuleInfo -> Bool #
Eq Fixity
Methods (==) :: Fixity -> Fixity -> Bool # (/=) :: Fixity -> Fixity -> Bool #
Eq FixityDirection
Methods (==) :: FixityDirection -> FixityDirection -> Bool # (/=) :: FixityDirection -> FixityDirection -> Bool #
Eq Lit
Methods (==) :: Lit -> Lit -> Bool # (/=) :: Lit -> Lit -> Bool #
Eq Body
Methods (==) :: Body -> Body -> Bool # (/=) :: Body -> Body -> Bool #
Eq Guard
Methods (==) :: Guard -> Guard -> Bool # (/=) :: Guard -> Guard -> Bool #
Eq Stmt
Methods (==) :: Stmt -> Stmt -> Bool # (/=) :: Stmt -> Stmt -> Bool #
Eq Range
Methods (==) :: Range -> Range -> Bool # (/=) :: Range -> Range -> Bool #
Eq TypeFamilyHead
Methods (==) :: TypeFamilyHead -> TypeFamilyHead -> Bool # (/=) :: TypeFamilyHead -> TypeFamilyHead -> Bool #
Eq TySynEqn
Methods (==) :: TySynEqn -> TySynEqn -> Bool # (/=) :: TySynEqn -> TySynEqn -> Bool #
Eq FamFlavour
Methods (==) :: FamFlavour -> FamFlavour -> Bool # (/=) :: FamFlavour -> FamFlavour -> Bool #
Eq Foreign
Methods (==) :: Foreign -> Foreign -> Bool # (/=) :: Foreign -> Foreign -> Bool #
Eq Callconv
Methods (==) :: Callconv -> Callconv -> Bool # (/=) :: Callconv -> Callconv -> Bool #
Eq Safety
Methods (==) :: Safety -> Safety -> Bool # (/=) :: Safety -> Safety -> Bool #
Eq Pragma
Methods (==) :: Pragma -> Pragma -> Bool # (/=) :: Pragma -> Pragma -> Bool #
Eq Inline
Methods (==) :: Inline -> Inline -> Bool # (/=) :: Inline -> Inline -> Bool #
Eq RuleMatch
Methods (==) :: RuleMatch -> RuleMatch -> Bool # (/=) :: RuleMatch -> RuleMatch -> Bool #
Eq Phases
Methods (==) :: Phases -> Phases -> Bool # (/=) :: Phases -> Phases -> Bool #
Eq RuleBndr
Methods (==) :: RuleBndr -> RuleBndr -> Bool # (/=) :: RuleBndr -> RuleBndr -> Bool #
Eq AnnTarget
Methods (==) :: AnnTarget -> AnnTarget -> Bool # (/=) :: AnnTarget -> AnnTarget -> Bool #
Eq SourceUnpackedness
Methods (==) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (/=) :: SourceUnpackedness -> SourceUnpackedness -> Bool #
Eq SourceStrictness
Methods (==) :: SourceStrictness -> SourceStrictness -> Bool # (/=) :: SourceStrictness -> SourceStrictness -> Bool #
Eq DecidedStrictness
Methods (==) :: DecidedStrictness -> DecidedStrictness -> Bool # (/=) :: DecidedStrictness -> DecidedStrictness -> Bool #
Eq Bang
Methods (==) :: Bang -> Bang -> Bool # (/=) :: Bang -> Bang -> Bool #
Eq FamilyResultSig
Methods (==) :: FamilyResultSig -> FamilyResultSig -> Bool # (/=) :: FamilyResultSig -> FamilyResultSig -> Bool #
Eq TyLit
Methods (==) :: TyLit -> TyLit -> Bool # (/=) :: TyLit -> TyLit -> Bool #
Eq Role
Methods (==) :: Role -> Role -> Bool # (/=) :: Role -> Role -> Bool #
Eq AnnLookup
Methods (==) :: AnnLookup -> AnnLookup -> Bool # (/=) :: AnnLookup -> AnnLookup -> Bool #
Eq LocalTime
Methods (==) :: LocalTime -> LocalTime -> Bool # (/=) :: LocalTime -> LocalTime -> Bool #
Eq NominalDiffTime
Methods (==) :: NominalDiffTime -> NominalDiffTime -> Bool # (/=) :: NominalDiffTime -> NominalDiffTime -> Bool #
Eq UnpackedUUID
Methods (==) :: UnpackedUUID -> UnpackedUUID -> Bool # (/=) :: UnpackedUUID -> UnpackedUUID -> Bool #
Eq UUID
Methods (==) :: UUID -> UUID -> Bool # (/=) :: UUID -> UUID -> Bool #
Eq a => Eq [a]
Methods (==) :: [a] -> [a] -> Bool # (/=) :: [a] -> [a] -> Bool #
Eq a => Eq (Maybe a)
Methods (==) :: Maybe a -> Maybe a -> Bool # (/=) :: Maybe a -> Maybe a -> Bool #
Eq a => Eq (Ratio a)
Methods (==) :: Ratio a -> Ratio a -> Bool # (/=) :: Ratio a -> Ratio a -> Bool #
Eq (Ptr a)
Methods (==) :: Ptr a -> Ptr a -> Bool # (/=) :: Ptr a -> Ptr a -> Bool #
Eq (FunPtr a)
Methods (==) :: FunPtr a -> FunPtr a -> Bool # (/=) :: FunPtr a -> FunPtr a -> Bool #
Eq (V1 p)
Methods (==) :: V1 p -> V1 p -> Bool # (/=) :: V1 p -> V1 p -> Bool #
Eq (U1 p)
Methods (==) :: U1 p -> U1 p -> Bool # (/=) :: U1 p -> U1 p -> Bool #
Eq p => Eq (Par1 p)
Methods (==) :: Par1 p -> Par1 p -> Bool # (/=) :: Par1 p -> Par1 p -> Bool #
Eq a => Eq (IResult a)
Methods (==) :: IResult a -> IResult a -> Bool # (/=) :: IResult a -> IResult a -> Bool #
Eq a => Eq (Result a)
Methods (==) :: Result a -> Result a -> Bool # (/=) :: Result a -> Result a -> Bool #
Eq a => Eq (Identity a)
Methods (==) :: Identity a -> Identity a -> Bool # (/=) :: Identity a -> Identity a -> Bool #
Eq a => Eq (Min a)
Methods (==) :: Min a -> Min a -> Bool # (/=) :: Min a -> Min a -> Bool #
Eq a => Eq (Max a)
Methods (==) :: Max a -> Max a -> Bool # (/=) :: Max a -> Max a -> Bool #
Eq a => Eq (First a)
Methods (==) :: First a -> First a -> Bool # (/=) :: First a -> First a -> Bool #
Eq a => Eq (Last a)
Methods (==) :: Last a -> Last a -> Bool # (/=) :: Last a -> Last a -> Bool #
Eq m => Eq (WrappedMonoid m)
Methods (==) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (/=) :: WrappedMonoid m -> WrappedMonoid m -> Bool #
Eq a => Eq (Option a)
Methods (==) :: Option a -> Option a -> Bool # (/=) :: Option a -> Option a -> Bool #
Eq a => Eq (NonEmpty a)
Methods (==) :: NonEmpty a -> NonEmpty a -> Bool # (/=) :: NonEmpty a -> NonEmpty a -> Bool #
Eq a => Eq (Complex a)
Methods (==) :: Complex a -> Complex a -> Bool # (/=) :: Complex a -> Complex a -> Bool #
Eq a => Eq (ZipList a)
Methods (==) :: ZipList a -> ZipList a -> Bool # (/=) :: ZipList a -> ZipList a -> Bool #
Eq a => Eq (Dual a)
Methods (==) :: Dual a -> Dual a -> Bool # (/=) :: Dual a -> Dual a -> Bool #
Eq a => Eq (Sum a)
Methods (==) :: Sum a -> Sum a -> Bool # (/=) :: Sum a -> Sum a -> Bool #
Eq a => Eq (Product a)
Methods (==) :: Product a -> Product a -> Bool # (/=) :: Product a -> Product a -> Bool #
Eq a => Eq (First a)
Methods (==) :: First a -> First a -> Bool # (/=) :: First a -> First a -> Bool #
Eq a => Eq (Last a)
Methods (==) :: Last a -> Last a -> Bool # (/=) :: Last a -> Last a -> Bool #
Eq a => Eq (IntMap a)
Methods (==) :: IntMap a -> IntMap a -> Bool # (/=) :: IntMap a -> IntMap a -> Bool #
Eq a => Eq (Seq a)
Methods (==) :: Seq a -> Seq a -> Bool # (/=) :: Seq a -> Seq a -> Bool #
Eq a => Eq (ViewL a)
Methods (==) :: ViewL a -> ViewL a -> Bool # (/=) :: ViewL a -> ViewL a -> Bool #
Eq a => Eq (ViewR a)
Methods (==) :: ViewR a -> ViewR a -> Bool # (/=) :: ViewR a -> ViewR a -> Bool #
Eq a => Eq (Set a)
Methods (==) :: Set a -> Set a -> Bool # (/=) :: Set a -> Set a -> Bool #
Eq a => Eq (DList a)
Methods (==) :: DList a -> DList a -> Bool # (/=) :: DList a -> DList a -> Bool #
Eq (Doc a)
Methods (==) :: Doc a -> Doc a -> Bool # (/=) :: Doc a -> Doc a -> Bool #
Eq a => Eq (AnnotDetails a)
Methods (==) :: AnnotDetails a -> AnnotDetails a -> Bool # (/=) :: AnnotDetails a -> AnnotDetails a -> Bool #
Eq a => Eq (Span a)
Methods (==) :: Span a -> Span a -> Bool # (/=) :: Span a -> Span a -> Bool #
Eq a => Eq (Array a)
Methods (==) :: Array a -> Array a -> Bool # (/=) :: Array a -> Array a -> Bool #
(Eq id, Eq (ExpandsTo id)) => Eq (Expandable id)
Methods (==) :: Expandable id -> Expandable id -> Bool # (/=) :: Expandable id -> Expandable id -> Bool #
Eq a => Eq (TimeRange a)
Methods (==) :: TimeRange a -> TimeRange a -> Bool # (/=) :: TimeRange a -> TimeRange a -> Bool #
Eq a => Eq (Source a)
Methods (==) :: Source a -> Source a -> Bool # (/=) :: Source a -> Source a -> Bool #
Eq a => Eq (Token a)
Methods (==) :: Token a -> Token a -> Bool # (/=) :: Token a -> Token a -> Bool #
Eq a => Eq (StripeList a)
Methods (==) :: StripeList a -> StripeList a -> Bool # (/=) :: StripeList a -> StripeList a -> Bool #
Eq a => Eq (StartingAfter a)
Methods (==) :: StartingAfter a -> StartingAfter a -> Bool # (/=) :: StartingAfter a -> StartingAfter a -> Bool #
Eq a => Eq (EndingBefore a)
Methods (==) :: EndingBefore a -> EndingBefore a -> Bool # (/=) :: EndingBefore a -> EndingBefore a -> Bool #
Eq a => Eq (HashSet a)
Methods (==) :: HashSet a -> HashSet a -> Bool # (/=) :: HashSet a -> HashSet a -> Bool #
Eq a => Eq (Vector a)
Methods (==) :: Vector a -> Vector a -> Bool # (/=) :: Vector a -> Vector a -> Bool #
(Storable a, Eq a) => Eq (Vector a)
Methods (==) :: Vector a -> Vector a -> Bool # (/=) :: Vector a -> Vector a -> Bool #
(Prim a, Eq a) => Eq (Vector a)
Methods (==) :: Vector a -> Vector a -> Bool # (/=) :: Vector a -> Vector a -> Bool #
(Eq b, Eq a) => Eq (Either a b)
Methods (==) :: Either a b -> Either a b -> Bool # (/=) :: Either a b -> Either a b -> Bool #
Eq (f p) => Eq (Rec1 f p)
Methods (==) :: Rec1 f p -> Rec1 f p -> Bool # (/=) :: Rec1 f p -> Rec1 f p -> Bool #
Eq (URec Char p)
Methods (==) :: URec Char p -> URec Char p -> Bool # (/=) :: URec Char p -> URec Char p -> Bool #
Eq (URec Double p)
Methods (==) :: URec Double p -> URec Double p -> Bool # (/=) :: URec Double p -> URec Double p -> Bool #
Eq (URec Float p)
Methods (==) :: URec Float p -> URec Float p -> Bool # (/=) :: URec Float p -> URec Float p -> Bool #
Eq (URec Int p)
Methods (==) :: URec Int p -> URec Int p -> Bool # (/=) :: URec Int p -> URec Int p -> Bool #
Eq (URec Word p)
Methods (==) :: URec Word p -> URec Word p -> Bool # (/=) :: URec Word p -> URec Word p -> Bool #
Eq (URec (Ptr ()) p)
Methods (==) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (/=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool #
(Eq a, Eq b) => Eq (a, b)
Methods (==) :: (a, b) -> (a, b) -> Bool # (/=) :: (a, b) -> (a, b) -> Bool #
(Eq k, Eq v) => Eq (HashMap k v)
Methods (==) :: HashMap k v -> HashMap k v -> Bool # (/=) :: HashMap k v -> HashMap k v -> Bool #
(Eq k, Eq a) => Eq (Map k a)
Methods (==) :: Map k a -> Map k a -> Bool # (/=) :: Map k a -> Map k a -> Bool #
Eq a => Eq (Arg a b)
Methods (==) :: Arg a b -> Arg a b -> Bool # (/=) :: Arg a b -> Arg a b -> Bool #
Eq (Proxy k s)
Methods (==) :: Proxy k s -> Proxy k s -> Bool # (/=) :: Proxy k s -> Proxy k s -> Bool #
(Eq1 m, Eq a) => Eq (ListT m a)
Methods (==) :: ListT m a -> ListT m a -> Bool # (/=) :: ListT m a -> ListT m a -> Bool #
Eq (MutableArray s a)
Methods (==) :: MutableArray s a -> MutableArray s a -> Bool # (/=) :: MutableArray s a -> MutableArray s a -> Bool #
(Eq1 m, Eq a) => Eq (MaybeT m a)
Methods (==) :: MaybeT m a -> MaybeT m a -> Bool # (/=) :: MaybeT m a -> MaybeT m a -> Bool #
(Eq v, Eq k) => Eq (Leaf k v)
Methods (==) :: Leaf k v -> Leaf k v -> Bool # (/=) :: Leaf k v -> Leaf k v -> Bool #
Eq c => Eq (K1 i c p)
Methods (==) :: K1 i c p -> K1 i c p -> Bool # (/=) :: K1 i c p -> K1 i c p -> Bool #
(Eq (g p), Eq (f p)) => Eq ((:+:) f g p)
Methods (==) :: (f :+: g) p -> (f :+: g) p -> Bool # (/=) :: (f :+: g) p -> (f :+: g) p -> Bool #
(Eq (g p), Eq (f p)) => Eq ((:*:) f g p)
Methods (==) :: (f :: g) p -> (f :: g) p -> Bool # (/=) :: (f :: g) p -> (f :: g) p -> Bool #
Eq (f (g p)) => Eq ((:.:) f g p)
Methods (==) :: (f :.: g) p -> (f :.: g) p -> Bool # (/=) :: (f :.: g) p -> (f :.: g) p -> Bool #
(Eq a, Eq b, Eq c) => Eq (a, b, c)
Methods (==) :: (a, b, c) -> (a, b, c) -> Bool # (/=) :: (a, b, c) -> (a, b, c) -> Bool #
Eq a => Eq (Const k a b)
Methods (==) :: Const k a b -> Const k a b -> Bool # (/=) :: Const k a b -> Const k a b -> Bool #
Eq (f a) => Eq (Alt k f a)
Methods (==) :: Alt k f a -> Alt k f a -> Bool # (/=) :: Alt k f a -> Alt k f a -> Bool #
Eq ((:~:) k a b)
Methods (==) :: (k :~: a) b -> (k :~: a) b -> Bool # (/=) :: (k :~: a) b -> (k :~: a) b -> Bool #
Eq (p a a) => Eq (Join k p a)
Methods (==) :: Join k p a -> Join k p a -> Bool # (/=) :: Join k p a -> Join k p a -> Bool #
(Eq1 f, Eq a) => Eq (IdentityT * f a)
Methods (==) :: IdentityT * f a -> IdentityT * f a -> Bool # (/=) :: IdentityT * f a -> IdentityT * f a -> Bool #
(Eq (f b), Eq a) => Eq (FreeF f a b)
Methods (==) :: FreeF f a b -> FreeF f a b -> Bool # (/=) :: FreeF f a b -> FreeF f a b -> Bool #
Eq (m (FreeF f a (FreeT f m a))) => Eq (FreeT f m a)
Methods (==) :: FreeT f m a -> FreeT f m a -> Bool # (/=) :: FreeT f m a -> FreeT f m a -> Bool #
(Eq e, Eq1 m, Eq a) => Eq (ErrorT e m a)
Methods (==) :: ErrorT e m a -> ErrorT e m a -> Bool # (/=) :: ErrorT e m a -> ErrorT e m a -> Bool #
(Eq e, Eq1 m, Eq a) => Eq (ExceptT e m a)
Methods (==) :: ExceptT e m a -> ExceptT e m a -> Bool # (/=) :: ExceptT e m a -> ExceptT e m a -> Bool #
(Eq w, Eq1 m, Eq a) => Eq (WriterT w m a)
Methods (==) :: WriterT w m a -> WriterT w m a -> Bool # (/=) :: WriterT w m a -> WriterT w m a -> Bool #
(Eq w, Eq1 m, Eq a) => Eq (WriterT w m a)
Methods (==) :: WriterT w m a -> WriterT w m a -> Bool # (/=) :: WriterT w m a -> WriterT w m a -> Bool #
Eq b => Eq (Tagged k s b)
Methods (==) :: Tagged k s b -> Tagged k s b -> Bool # (/=) :: Tagged k s b -> Tagged k s b -> Bool #
Eq (f p) => Eq (M1 i c f p)
Methods (==) :: M1 i c f p -> M1 i c f p -> Bool # (/=) :: M1 i c f p -> M1 i c f p -> Bool #
(Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d)
Methods (==) :: (a, b, c, d) -> (a, b, c, d) -> Bool # (/=) :: (a, b, c, d) -> (a, b, c, d) -> Bool #
(Eq1 f, Eq1 g, Eq a) => Eq (Sum * f g a)
Methods (==) :: Sum * f g a -> Sum * f g a -> Bool # (/=) :: Sum * f g a -> Sum * f g a -> Bool #
(Eq1 f, Eq1 g, Eq a) => Eq (Product * f g a)
Methods (==) :: Product * f g a -> Product * f g a -> Bool # (/=) :: Product * f g a -> Product * f g a -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e)
Methods (==) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # (/=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool #
(Eq1 f, Eq1 g, Eq a) => Eq (Compose * * f g a)
Methods (==) :: Compose * * f g a -> Compose * * f g a -> Bool # (/=) :: Compose * * f g a -> Compose * * f g a -> Bool #
Eq (p a b) => Eq (WrappedBifunctor k1 k p a b)
Methods (==) :: WrappedBifunctor k1 k p a b -> WrappedBifunctor k1 k p a b -> Bool # (/=) :: WrappedBifunctor k1 k p a b -> WrappedBifunctor k1 k p a b -> Bool #
Eq (g b) => Eq (Joker k1 k g a b)
Methods (==) :: Joker k1 k g a b -> Joker k1 k g a b -> Bool # (/=) :: Joker k1 k g a b -> Joker k1 k g a b -> Bool #
Eq (p b a) => Eq (Flip k k1 p a b)
Methods (==) :: Flip k k1 p a b -> Flip k k1 p a b -> Bool # (/=) :: Flip k k1 p a b -> Flip k k1 p a b -> Bool #
Eq (f a) => Eq (Clown k1 k f a b)
Methods (==) :: Clown k1 k f a b -> Clown k1 k f a b -> Bool # (/=) :: Clown k1 k f a b -> Clown k1 k f a b -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) => Eq (a, b, c, d, e, f)
Methods (==) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool # (/=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool #
(Eq (g a b), Eq (f a b)) => Eq (Product k1 k f g a b)
Methods (==) :: Product k1 k f g a b -> Product k1 k f g a b -> Bool # (/=) :: Product k1 k f g a b -> Product k1 k f g a b -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) => Eq (a, b, c, d, e, f, g)
Methods (==) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool # (/=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool #
Eq (f (p a b)) => Eq (Tannen k2 k1 k f p a b)
Methods (==) :: Tannen k2 k1 k f p a b -> Tannen k2 k1 k f p a b -> Bool # (/=) :: Tannen k2 k1 k f p a b -> Tannen k2 k1 k f p a b -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h) => Eq (a, b, c, d, e, f, g, h)
Methods (==) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool # (/=) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i) => Eq (a, b, c, d, e, f, g, h, i)
Methods (==) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool # (/=) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool #
Eq (p (f a) (g b)) => Eq (Biff k3 k2 k1 k p f g a b)
Methods (==) :: Biff k3 k2 k1 k p f g a b -> Biff k3 k2 k1 k p f g a b -> Bool # (/=) :: Biff k3 k2 k1 k p f g a b -> Biff k3 k2 k1 k p f g a b -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j) => Eq (a, b, c, d, e, f, g, h, i, j)
Methods (==) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool # (/=) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k) => Eq (a, b, c, d, e, f, g, h, i, j, k)
Methods (==) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool # (/=) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l) => Eq (a, b, c, d, e, f, g, h, i, j, k, l)
Methods (==) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool # (/=) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m)
Methods (==) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool # (/=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
Methods (==) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool # (/=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n, Eq o) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
Methods (==) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool # (/=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool #

data Bool :: * #

Constructors

False
True

Instances

Eq Bool
Methods (==) :: Bool -> Bool -> Bool # (/=) :: Bool -> Bool -> Bool #
Ord Bool
Methods compare :: Bool -> Bool -> Ordering # (<) :: Bool -> Bool -> Bool # (<=) :: Bool -> Bool -> Bool # (>) :: Bool -> Bool -> Bool # (>=) :: Bool -> Bool -> Bool # max :: Bool -> Bool -> Bool # min :: Bool -> Bool -> Bool #
Show Bool
Methods showsPrec :: Int -> Bool -> ShowS # show :: Bool -> String # showList :: [Bool] -> ShowS #
Generic Bool
Associated Types type Rep Bool :: * -> * # Methods from :: Bool -> Rep Bool x # to :: Rep Bool x -> Bool #
Lift Bool
Methods lift :: Bool -> Q Exp #
Testable Bool
Methods property :: Bool -> Property #
FromJSON Bool
Methods parseJSON :: Value -> Parser Bool # parseJSONList :: Value -> Parser [Bool] #
FromJSONKey Bool
Methods fromJSONKey :: FromJSONKeyFunction Bool # fromJSONKeyList :: FromJSONKeyFunction [Bool] #
Example Bool
Associated Types type Arg Bool :: * # Methods evaluateExample :: Bool -> Params -> (ActionWith (Arg Bool) -> IO ()) -> ProgressCallback -> IO Result #
Random Bool
Methods randomR :: RandomGen g => (Bool, Bool) -> g -> (Bool, g) # random :: RandomGen g => g -> (Bool, g) # randomRs :: RandomGen g => (Bool, Bool) -> g -> [Bool] # randoms :: RandomGen g => g -> [Bool] # randomRIO :: (Bool, Bool) -> IO Bool # randomIO :: IO Bool #
Unbox Bool

SingI Bool False
Methods sing :: Sing False a
SingI Bool True
Methods sing :: Sing True a
Vector Vector Bool
Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Bool -> m (Vector Bool) # basicUnsafeThaw :: PrimMonad m => Vector Bool -> m (Mutable Vector (PrimState m) Bool) # basicLength :: Vector Bool -> Int # basicUnsafeSlice :: Int -> Int -> Vector Bool -> Vector Bool # basicUnsafeIndexM :: Monad m => Vector Bool -> Int -> m Bool # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Bool -> Vector Bool -> m () # elemseq :: Vector Bool -> Bool -> b -> b #
MVector MVector Bool
Methods basicLength :: MVector s Bool -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Bool -> MVector s Bool # basicOverlaps :: MVector s Bool -> MVector s Bool -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Bool) # basicInitialize :: PrimMonad m => MVector (PrimState m) Bool -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Bool -> m (MVector (PrimState m) Bool) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Bool -> Int -> m Bool # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Bool -> Int -> Bool -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Bool -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Bool -> Bool -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Bool -> MVector (PrimState m) Bool -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Bool -> MVector (PrimState m) Bool -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Bool -> Int -> m (MVector (PrimState m) Bool) #
SingKind Bool (KProxy Bool)
Associated Types type DemoteRep (KProxy Bool) (kparam :: KProxy (KProxy Bool)) :: * Methods fromSing :: Sing (KProxy Bool) a -> DemoteRep (KProxy Bool) kparam
Example (a -> Bool)
Associated Types type Arg (a -> Bool) :: * # Methods evaluateExample :: (a -> Bool) -> Params -> (ActionWith (Arg (a -> Bool)) -> IO ()) -> ProgressCallback -> IO Result #
type Rep Bool
type Rep Bool = D1 (MetaData "Bool" "GHC.Types" "ghc-prim" False) ((:+:) (C1 (MetaCons "False" PrefixI False) U1) (C1 (MetaCons "True" PrefixI False) U1))
data Sing Bool
data Sing Bool where STrue :: Sing Bool True SFalse :: Sing Bool False
type Arg Bool
type Arg Bool = ()
data Vector Bool
data Vector Bool = V_Bool (Vector Word8)
data MVector s Bool
data MVector s Bool = MV_Bool (MVector s Word8)
type (==) Bool a b
type (==) Bool a b = EqBool a b
type DemoteRep Bool (KProxy Bool)
type DemoteRep Bool (KProxy Bool) = Bool
type Arg (a -> Bool)
type Arg (a -> Bool) = a

data Maybe a :: * -> * #

The Maybe type encapsulates an optional value. A value of type Maybe a either contains a value of type a (represented as Just a), or it is empty (represented as Nothing). Using Maybe is a good way to deal with errors or exceptional cases without resorting to drastic measures such as error.

The Maybe type is also a monad. It is a simple kind of error monad, where all errors are represented by Nothing. A richer error monad can be built using the Either type.

Constructors

Nothing
Just a

Instances

Monad Maybe
Methods (>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b # (>>) :: Maybe a -> Maybe b -> Maybe b # return :: a -> Maybe a # fail :: String -> Maybe a #
Functor Maybe
Methods fmap :: (a -> b) -> Maybe a -> Maybe b # (<$) :: a -> Maybe b -> Maybe a #
Applicative Maybe
Methods pure :: a -> Maybe a # (<>) :: Maybe (a -> b) -> Maybe a -> Maybe b # (>) :: Maybe a -> Maybe b -> Maybe b # (<*) :: Maybe a -> Maybe b -> Maybe a #
Foldable Maybe
Methods fold :: Monoid m => Maybe m -> m # foldMap :: Monoid m => (a -> m) -> Maybe a -> m # foldr :: (a -> b -> b) -> b -> Maybe a -> b # foldr' :: (a -> b -> b) -> b -> Maybe a -> b # foldl :: (b -> a -> b) -> b -> Maybe a -> b # foldl' :: (b -> a -> b) -> b -> Maybe a -> b # foldr1 :: (a -> a -> a) -> Maybe a -> a # foldl1 :: (a -> a -> a) -> Maybe a -> a # toList :: Maybe a -> [a] # null :: Maybe a -> Bool # length :: Maybe a -> Int # elem :: Eq a => a -> Maybe a -> Bool # maximum :: Ord a => Maybe a -> a # minimum :: Ord a => Maybe a -> a # sum :: Num a => Maybe a -> a # product :: Num a => Maybe a -> a #
Generic1 Maybe
Associated Types type Rep1 (Maybe :: * -> ) :: -> * # Methods from1 :: Maybe a -> Rep1 Maybe a # to1 :: Rep1 Maybe a -> Maybe a #
FromJSON1 Maybe
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Maybe a) # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Maybe a] #
Alternative Maybe
Methods empty :: Maybe a # (<\|>) :: Maybe a -> Maybe a -> Maybe a # some :: Maybe a -> Maybe [a] # many :: Maybe a -> Maybe [a] #
MonadPlus Maybe
Methods mzero :: Maybe a # mplus :: Maybe a -> Maybe a -> Maybe a #
(Selector Meta s, FromJSON a) => FromRecord arity (S1 s (K1 i (Maybe a)))
Methods parseRecord :: Options -> FromArgs arity a -> Maybe Text -> Object -> Parser (S1 s (K1 i (Maybe a)) a)
Eq a => Eq (Maybe a)
Methods (==) :: Maybe a -> Maybe a -> Bool # (/=) :: Maybe a -> Maybe a -> Bool #
Ord a => Ord (Maybe a)
Methods compare :: Maybe a -> Maybe a -> Ordering # (<) :: Maybe a -> Maybe a -> Bool # (<=) :: Maybe a -> Maybe a -> Bool # (>) :: Maybe a -> Maybe a -> Bool # (>=) :: Maybe a -> Maybe a -> Bool # max :: Maybe a -> Maybe a -> Maybe a # min :: Maybe a -> Maybe a -> Maybe a #
Show a => Show (Maybe a)
Methods showsPrec :: Int -> Maybe a -> ShowS # show :: Maybe a -> String # showList :: [Maybe a] -> ShowS #
Generic (Maybe a)
Associated Types type Rep (Maybe a) :: * -> * # Methods from :: Maybe a -> Rep (Maybe a) x # to :: Rep (Maybe a) x -> Maybe a #
Semigroup a => Semigroup (Maybe a)
Methods (<>) :: Maybe a -> Maybe a -> Maybe a # sconcat :: NonEmpty (Maybe a) -> Maybe a # stimes :: Integral b => b -> Maybe a -> Maybe a #
Monoid a => Monoid (Maybe a)	Lift a semigroup into `Maybe` forming a `Monoid` according to http://en.wikipedia.org/wiki/Monoid: "Any semigroup `S` may be turned into a monoid simply by adjoining an element `e` not in `S` and defining `ee = e` and `es = s = s*e` for all `s ∈ S`." Since there is no "Semigroup" typeclass providing just `mappend`, we use `Monoid` instead.
Methods mempty :: Maybe a # mappend :: Maybe a -> Maybe a -> Maybe a # mconcat :: [Maybe a] -> Maybe a #
Lift a => Lift (Maybe a)
Methods lift :: Maybe a -> Q Exp #
FromJSON a => FromJSON (Maybe a)
Methods parseJSON :: Value -> Parser (Maybe a) # parseJSONList :: Value -> Parser [Maybe a] #
SingI (Maybe a) (Nothing a)
Methods sing :: Sing (Nothing a) a
SingKind a (KProxy a) => SingKind (Maybe a) (KProxy (Maybe a))
Associated Types type DemoteRep (KProxy (Maybe a)) (kparam :: KProxy (KProxy (Maybe a))) :: * Methods fromSing :: Sing (KProxy (Maybe a)) a -> DemoteRep (KProxy (Maybe a)) kparam
SingI a a1 => SingI (Maybe a) (Just a a1)
Methods sing :: Sing (Just a a1) a
type Rep1 Maybe
type Rep1 Maybe = D1 (MetaData "Maybe" "GHC.Base" "base" False) ((:+:) (C1 (MetaCons "Nothing" PrefixI False) U1) (C1 (MetaCons "Just" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1)))
type Rep (Maybe a)
type Rep (Maybe a) = D1 (MetaData "Maybe" "GHC.Base" "base" False) ((:+:) (C1 (MetaCons "Nothing" PrefixI False) U1) (C1 (MetaCons "Just" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a))))
data Sing (Maybe a)
data Sing (Maybe a) where SNothing :: Sing (Maybe a) (Nothing a) SJust :: Sing (Maybe a) (Just a a1)
type (==) (Maybe k) a b
type (==) (Maybe k) a b = EqMaybe k a b
type DemoteRep (Maybe a) (KProxy (Maybe a))
type DemoteRep (Maybe a) (KProxy (Maybe a)) = Maybe (DemoteRep a (KProxy a))

type Stripe = FreeT StripeRequestF IO Source #

data StripeRequestF ret Source #

Constructors

StripeRequestF
Fields getStripeRequest :: StripeRequest req decode :: Value -> Result ret

Instances

Functor StripeRequestF Source #
Methods fmap :: (a -> b) -> StripeRequestF a -> StripeRequestF b # (<$) :: a -> StripeRequestF b -> StripeRequestF a #

type StripeSpec = (forall a. Stripe a -> IO (Either StripeError a)) -> Spec Source #