stripe-tests-2.3.0: Tests for Stripe API bindings for Haskell

Safe HaskellNone
LanguageHaskell2010

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

Since: 2.1

Methods

showsPrec :: Int -> Char -> ShowS #

show :: Char -> String #

showList :: [Char] -> ShowS #

FromJSON Char 
FromJSONKey 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 
MVector MVector Char 
Generic1 k (URec k Char) 

Associated Types

type Rep1 (URec k Char) (f :: URec k Char -> *) :: k -> * #

Methods

from1 :: f a -> Rep1 (URec k Char) f a #

to1 :: Rep1 (URec k Char) f a -> f a #

Functor (URec * Char) 

Methods

fmap :: (a -> b) -> URec * Char a -> URec * Char b #

(<$) :: a -> URec * Char b -> URec * Char a #

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 #

Eq (URec k Char p) 

Methods

(==) :: URec k Char p -> URec k Char p -> Bool #

(/=) :: URec k Char p -> URec k Char p -> Bool #

Ord (URec k Char p) 

Methods

compare :: URec k Char p -> URec k Char p -> Ordering #

(<) :: URec k Char p -> URec k Char p -> Bool #

(<=) :: URec k Char p -> URec k Char p -> Bool #

(>) :: URec k Char p -> URec k Char p -> Bool #

(>=) :: URec k Char p -> URec k Char p -> Bool #

max :: URec k Char p -> URec k Char p -> URec k Char p #

min :: URec k Char p -> URec k Char p -> URec k Char p #

Show (URec k Char p) 

Methods

showsPrec :: Int -> URec k Char p -> ShowS #

show :: URec k Char p -> String #

showList :: [URec k Char p] -> ShowS #

Generic (URec k Char p) 

Associated Types

type Rep (URec k Char p) :: * -> * #

Methods

from :: URec k Char p -> Rep (URec k Char p) x #

to :: Rep (URec k Char p) x -> URec k Char p #

data Vector Char 
data URec k Char

Used for marking occurrences of Char#

Since: 4.9.0.0

data URec k Char = UChar {}
data MVector s Char 
type Rep1 k (URec k Char) 
type Rep1 k (URec k Char) = D1 k (MetaData "URec" "GHC.Generics" "base" False) (C1 k (MetaCons "UChar" PrefixI True) (S1 k (MetaSel (Just Symbol "uChar#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UChar k)))
type Rep (URec k Char p) 
type Rep (URec k 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 []

Since: 2.1

Methods

fmap :: (a -> b) -> [a] -> [b] #

(<$) :: a -> [b] -> [a] #

Functor Maybe

Since: 2.1

Methods

fmap :: (a -> b) -> Maybe a -> Maybe b #

(<$) :: a -> Maybe b -> Maybe a #

Functor IO

Since: 2.1

Methods

fmap :: (a -> b) -> IO a -> IO b #

(<$) :: a -> IO b -> IO a #

Functor Par1 

Methods

fmap :: (a -> b) -> Par1 a -> Par1 b #

(<$) :: a -> Par1 b -> Par1 a #

Functor FromJSONKeyFunction

Only law abiding up to interpretation

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 ZipList 

Methods

fmap :: (a -> b) -> ZipList a -> ZipList b #

(<$) :: a -> ZipList b -> ZipList a #

Functor Tree 

Methods

fmap :: (a -> b) -> Tree a -> Tree b #

(<$) :: a -> Tree b -> Tree 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 (Either a)

Since: 3.0

Methods

fmap :: (a -> b) -> Either a a -> Either a b #

(<$) :: a -> Either a b -> Either a a #

Functor (V1 *) 

Methods

fmap :: (a -> b) -> V1 * a -> V1 * b #

(<$) :: a -> V1 * b -> V1 * a #

Functor (U1 *)

Since: 4.9.0.0

Methods

fmap :: (a -> b) -> U1 * a -> U1 * b #

(<$) :: a -> U1 * b -> U1 * a #

Functor ((,) a)

Since: 2.1

Methods

fmap :: (a -> b) -> (a, a) -> (a, b) #

(<$) :: a -> (a, b) -> (a, a) #

Functor (HashMap k) 

Methods

fmap :: (a -> b) -> HashMap k a -> HashMap k b #

(<$) :: a -> HashMap k b -> HashMap 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 #

Monad m => Functor (WrappedMonad m)

Since: 2.1

Methods

fmap :: (a -> b) -> WrappedMonad m a -> WrappedMonad m b #

(<$) :: a -> WrappedMonad m b -> WrappedMonad m a #

Arrow a => Functor (ArrowMonad a)

Since: 4.6.0.0

Methods

fmap :: (a -> b) -> ArrowMonad a a -> ArrowMonad a b #

(<$) :: a -> ArrowMonad a b -> ArrowMonad a a #

Functor (SpecM a) 

Methods

fmap :: (a -> b) -> SpecM a a -> SpecM a b #

(<$) :: a -> SpecM a b -> SpecM 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 #

Arrow a => Functor (WrappedArrow a b)

Since: 2.1

Methods

fmap :: (a -> b) -> WrappedArrow a b a -> WrappedArrow a b b #

(<$) :: a -> WrappedArrow a b b -> WrappedArrow a b a #

Bifunctor p => Functor (Join * p) 

Methods

fmap :: (a -> b) -> Join * p a -> Join * p b #

(<$) :: a -> Join * p b -> Join * p 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 (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 ((->) LiftedRep LiftedRep r)

Since: 2.1

Methods

fmap :: (a -> b) -> (LiftedRep -> LiftedRep) r a -> (LiftedRep -> LiftedRep) r b #

(<$) :: a -> (LiftedRep -> LiftedRep) r b -> (LiftedRep -> LiftedRep) r 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 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 g, Functor f) => Functor ((:.:) * * f g) 

Methods

fmap :: (a -> b) -> (* :.: *) f g a -> (* :.: *) f g b #

(<$) :: a -> (* :.: *) f g b -> (* :.: *) 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 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

Since: 2.1

Methods

(>>=) :: IO a -> (a -> IO b) -> IO b #

(>>) :: IO a -> IO b -> IO b #

return :: a -> IO a #

fail :: String -> IO a #

Functor IO

Since: 2.1

Methods

fmap :: (a -> b) -> IO a -> IO b #

(<$) :: a -> IO b -> IO a #

Applicative IO

Since: 2.1

Methods

pure :: a -> IO a #

(<*>) :: IO (a -> b) -> IO a -> IO b #

liftA2 :: (a -> b -> c) -> IO a -> IO b -> IO c #

(*>) :: IO a -> IO b -> IO b #

(<*) :: IO a -> IO b -> IO a #

Alternative IO

Since: 4.9.0.0

Methods

empty :: IO a #

(<|>) :: IO a -> IO a -> IO a #

some :: IO a -> IO [a] #

many :: IO a -> IO [a] #

MonadPlus IO

Since: 4.9.0.0

Methods

mzero :: IO a #

mplus :: IO a -> IO a -> IO a #

MonadIO IO

Since: 4.9.0.0

Methods

liftIO :: IO a -> IO a #

Example Expectation 

Associated Types

type Arg Expectation :: * #

PrimMonad IO 

Associated Types

type PrimState (IO :: * -> *) :: * #

PrimBase IO 
Monoid a => Monoid (IO a)

Since: 4.9.0.0

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 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 #

liftIO :: IO a -> Stripe a Source #

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 Integer 

Methods

(==) :: Integer -> Integer -> Bool #

(/=) :: Integer -> Integer -> Bool #

Eq Ordering 
Eq Word 

Methods

(==) :: Word -> Word -> Bool #

(/=) :: Word -> Word -> Bool #

Eq () 

Methods

(==) :: () -> () -> Bool #

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

Eq TyCon 

Methods

(==) :: TyCon -> TyCon -> Bool #

(/=) :: TyCon -> TyCon -> Bool #

Eq Module 

Methods

(==) :: Module -> Module -> Bool #

(/=) :: Module -> Module -> Bool #

Eq TrName 

Methods

(==) :: TrName -> TrName -> Bool #

(/=) :: TrName -> TrName -> Bool #

Eq HUnitFailure 
Eq FailureReason 
Eq Result 

Methods

(==) :: Result -> Result -> Bool #

(/=) :: Result -> Result -> Bool #

Eq ByteString 
Eq Scientific 
Eq UTCTime 

Methods

(==) :: UTCTime -> UTCTime -> Bool #

(/=) :: UTCTime -> UTCTime -> Bool #

Eq JSONPathElement 
Eq Value 

Methods

(==) :: Value -> Value -> Bool #

(/=) :: Value -> Value -> Bool #

Eq DotNetTime 
Eq SumEncoding 
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 
Eq Fixity 

Methods

(==) :: Fixity -> Fixity -> Bool #

(/=) :: Fixity -> Fixity -> Bool #

Eq Associativity 
Eq SourceUnpackedness 
Eq SourceStrictness 
Eq DecidedStrictness 
Eq SrcLoc 

Methods

(==) :: SrcLoc -> SrcLoc -> Bool #

(/=) :: SrcLoc -> SrcLoc -> Bool #

Eq Summary 

Methods

(==) :: Summary -> Summary -> Bool #

(/=) :: Summary -> Summary -> Bool #

Eq LocationAccuracy 
Eq Location 
Eq FailureReason 
Eq Result 

Methods

(==) :: Result -> Result -> Bool #

(/=) :: Result -> Result -> Bool #

Eq Doc 

Methods

(==) :: Doc -> Doc -> Bool #

(/=) :: Doc -> Doc -> Bool #

Eq TextDetails 
Eq Style 

Methods

(==) :: Style -> Style -> Bool #

(/=) :: Style -> Style -> Bool #

Eq Mode 

Methods

(==) :: Mode -> Mode -> Bool #

(/=) :: Mode -> Mode -> Bool #

Eq StripeKey 
Eq StripeConfig 
Eq APIVersion 
Eq Method 

Methods

(==) :: Method -> Method -> Bool #

(/=) :: Method -> Method -> Bool #

Eq AvailableOn 
Eq Created 

Methods

(==) :: Created -> Created -> Bool #

(/=) :: Created -> Created -> Bool #

Eq Date 

Methods

(==) :: Date -> Date -> Bool #

(/=) :: Date -> Date -> Bool #

Eq ChargeId 
Eq StatementDescription 
Eq Charge 

Methods

(==) :: Charge -> Charge -> Bool #

(/=) :: Charge -> Charge -> Bool #

Eq Capture 

Methods

(==) :: Capture -> Capture -> Bool #

(/=) :: Capture -> Capture -> Bool #

Eq RefundId 
Eq Refund 

Methods

(==) :: Refund -> Refund -> Bool #

(/=) :: Refund -> Refund -> Bool #

Eq RefundApplicationFee 
Eq RefundReason 
Eq CustomerId 
Eq Customer 
Eq AccountBalance 
Eq CardId 

Methods

(==) :: CardId -> CardId -> Bool #

(/=) :: CardId -> CardId -> Bool #

Eq RecipientCardId 
Eq CardNumber 
Eq ExpMonth 
Eq ExpYear 

Methods

(==) :: ExpYear -> ExpYear -> Bool #

(/=) :: ExpYear -> ExpYear -> Bool #

Eq CVC 

Methods

(==) :: CVC -> CVC -> Bool #

(/=) :: CVC -> CVC -> Bool #

Eq AddressCity 
Eq AddressCountry 
Eq AddressLine1 
Eq AddressLine2 
Eq AddressState 
Eq AddressZip 
Eq IsVerified 
Eq Brand 

Methods

(==) :: Brand -> Brand -> Bool #

(/=) :: Brand -> Brand -> Bool #

Eq Card 

Methods

(==) :: Card -> Card -> Bool #

(/=) :: Card -> Card -> Bool #

Eq RecipientCard 
Eq NewCard 

Methods

(==) :: NewCard -> NewCard -> Bool #

(/=) :: NewCard -> NewCard -> Bool #

Eq DefaultCard 
Eq SubscriptionId 
Eq Subscription 
Eq SubscriptionStatus 
Eq TaxPercent 
Eq PlanId 

Methods

(==) :: PlanId -> PlanId -> Bool #

(/=) :: PlanId -> PlanId -> Bool #

Eq Plan 

Methods

(==) :: Plan -> Plan -> Bool #

(/=) :: Plan -> Plan -> Bool #

Eq TrialPeriod 
Eq TrialEnd 
Eq Interval 
Eq Duration 
Eq Coupon 

Methods

(==) :: Coupon -> Coupon -> Bool #

(/=) :: Coupon -> Coupon -> Bool #

Eq CouponId 
Eq AmountOff 
Eq MaxRedemptions 
Eq PercentOff 
Eq RedeemBy 
Eq DurationInMonths 
Eq IntervalCount 
Eq TrialPeriodDays 
Eq Amount 

Methods

(==) :: Amount -> Amount -> Bool #

(/=) :: Amount -> Amount -> Bool #

Eq Discount 
Eq InvoiceId 
Eq Invoice 

Methods

(==) :: Invoice -> Invoice -> Bool #

(/=) :: Invoice -> Invoice -> Bool #

Eq InvoiceItemId 
Eq InvoiceItem 
Eq InvoiceLineItemId 
Eq InvoiceLineItemType 
Eq InvoiceLineItem 
Eq Period 

Methods

(==) :: Period -> Period -> Bool #

(/=) :: Period -> Period -> Bool #

Eq Closed 

Methods

(==) :: Closed -> Closed -> Bool #

(/=) :: Closed -> Closed -> Bool #

Eq Forgiven 
Eq DisputeStatus 
Eq DisputeReason 
Eq Dispute 

Methods

(==) :: Dispute -> Dispute -> Bool #

(/=) :: Dispute -> Dispute -> Bool #

Eq Evidence 
Eq TransferId 
Eq TransferStatus 
Eq TransferType 
Eq Transfer 
Eq BankAccount 
Eq BankAccountId 
Eq BankAccountStatus 
Eq RoutingNumber 
Eq Country 

Methods

(==) :: Country -> Country -> Bool #

(/=) :: Country -> Country -> Bool #

Eq AccountNumber 
Eq NewBankAccount 
Eq FirstName 
Eq LastName 
Eq RecipientId 
Eq TaxID 

Methods

(==) :: TaxID -> TaxID -> Bool #

(/=) :: TaxID -> TaxID -> Bool #

Eq RecipientType 
Eq Recipient 
Eq ApplicationFeeId 
Eq ApplicationFee 
Eq ApplicationFeePercent 
Eq ApplicationFeeAmount 
Eq ApplicationId 
Eq FeeId 

Methods

(==) :: FeeId -> FeeId -> Bool #

(/=) :: FeeId -> FeeId -> Bool #

Eq ApplicationFeeRefund 
Eq AccountId 
Eq Account 

Methods

(==) :: Account -> Account -> Bool #

(/=) :: Account -> Account -> Bool #

Eq Balance 

Methods

(==) :: Balance -> Balance -> Bool #

(/=) :: Balance -> Balance -> Bool #

Eq BalanceAmount 
Eq BalanceTransaction 
Eq TransactionId 
Eq FeeDetails 
Eq TransactionType 
Eq EventType 
Eq EventId 

Methods

(==) :: EventId -> EventId -> Bool #

(/=) :: EventId -> EventId -> Bool #

Eq EventData 
Eq Event 

Methods

(==) :: Event -> Event -> Bool #

(/=) :: Event -> Event -> Bool #

Eq ConnectApp 
Eq TokenId 

Methods

(==) :: TokenId -> TokenId -> Bool #

(/=) :: TokenId -> TokenId -> Bool #

Eq TokenType 
Eq Limit 

Methods

(==) :: Limit -> Limit -> Bool #

(/=) :: Limit -> Limit -> Bool #

Eq StripeDeleteResult 
Eq MetaData 
Eq ExpandParams 
Eq Name 

Methods

(==) :: Name -> Name -> Bool #

(/=) :: Name -> Name -> Bool #

Eq PlanName 
Eq Description 
Eq Quantity 
Eq Prorate 

Methods

(==) :: Prorate -> Prorate -> Bool #

(/=) :: Prorate -> Prorate -> Bool #

Eq AtPeriodEnd 
Eq Email 

Methods

(==) :: Email -> Email -> Bool #

(/=) :: Email -> Email -> Bool #

Eq ReceiptEmail 
Eq Currency 
Eq BitcoinReceiver 
Eq Transactions 
Eq BitcoinTransaction 
Eq BitcoinTransactionId 
Eq BitcoinReceiverId 
Eq PaymentId 
Eq LocalTime 
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 (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 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 (ZipList a) 

Methods

(==) :: ZipList a -> ZipList a -> Bool #

(/=) :: ZipList a -> ZipList a -> Bool #

Eq a => Eq (Tree a) 

Methods

(==) :: Tree a -> Tree a -> Bool #

(/=) :: Tree a -> Tree 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) 
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) 
Eq a => Eq (EndingBefore a) 
Eq a => Eq (HashSet a) 

Methods

(==) :: HashSet a -> HashSet a -> Bool #

(/=) :: HashSet a -> HashSet 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 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 (V1 k p) 

Methods

(==) :: V1 k p -> V1 k p -> Bool #

(/=) :: V1 k p -> V1 k p -> Bool #

Eq (U1 k p)

Since: 4.9.0.0

Methods

(==) :: U1 k p -> U1 k p -> Bool #

(/=) :: U1 k p -> U1 k 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 (MutableArray s a) 

Methods

(==) :: MutableArray s a -> MutableArray s a -> Bool #

(/=) :: MutableArray s a -> MutableArray s 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 (f p) => Eq (Rec1 k f p) 

Methods

(==) :: Rec1 k f p -> Rec1 k f p -> Bool #

(/=) :: Rec1 k f p -> Rec1 k f p -> Bool #

Eq (URec k (Ptr ()) p) 

Methods

(==) :: URec k (Ptr ()) p -> URec k (Ptr ()) p -> Bool #

(/=) :: URec k (Ptr ()) p -> URec k (Ptr ()) p -> Bool #

Eq (URec k Char p) 

Methods

(==) :: URec k Char p -> URec k Char p -> Bool #

(/=) :: URec k Char p -> URec k Char p -> Bool #

Eq (URec k Double p) 

Methods

(==) :: URec k Double p -> URec k Double p -> Bool #

(/=) :: URec k Double p -> URec k Double p -> Bool #

Eq (URec k Float p) 

Methods

(==) :: URec k Float p -> URec k Float p -> Bool #

(/=) :: URec k Float p -> URec k Float p -> Bool #

Eq (URec k Int p) 

Methods

(==) :: URec k Int p -> URec k Int p -> Bool #

(/=) :: URec k Int p -> URec k Int p -> Bool #

Eq (URec k Word p) 

Methods

(==) :: URec k Word p -> URec k Word p -> Bool #

(/=) :: URec k Word p -> URec k Word 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 ((:~:) 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 #

(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 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 c => Eq (K1 k i c p) 

Methods

(==) :: K1 k i c p -> K1 k i c p -> Bool #

(/=) :: K1 k i c p -> K1 k i c p -> Bool #

(Eq (g p), Eq (f p)) => Eq ((:+:) k f g p) 

Methods

(==) :: (k :+: f) g p -> (k :+: f) g p -> Bool #

(/=) :: (k :+: f) g p -> (k :+: f) g p -> Bool #

(Eq (g p), Eq (f p)) => Eq ((:*:) k f g p) 

Methods

(==) :: (k :*: f) g p -> (k :*: f) g p -> Bool #

(/=) :: (k :*: f) g p -> (k :*: f) g 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 #

Eq ((:~~:) k1 k2 a b)

Since: 4.10.0.0

Methods

(==) :: (k1 :~~: k2) a b -> (k1 :~~: k2) a b -> Bool #

(/=) :: (k1 :~~: k2) a b -> (k1 :~~: k2) a b -> Bool #

Eq (f p) => Eq (M1 k i c f p) 

Methods

(==) :: M1 k i c f p -> M1 k i c f p -> Bool #

(/=) :: M1 k i c f p -> M1 k i c f p -> Bool #

Eq (f (g p)) => Eq ((:.:) k2 k1 f g p) 

Methods

(==) :: (k2 :.: k1) f g p -> (k2 :.: k1) f g p -> Bool #

(/=) :: (k2 :.: k1) f g p -> (k2 :.: k1) f g p -> 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 #

Eq (p a b) => Eq (WrappedBifunctor k1 k2 p a b) 

Methods

(==) :: WrappedBifunctor k1 k2 p a b -> WrappedBifunctor k1 k2 p a b -> Bool #

(/=) :: WrappedBifunctor k1 k2 p a b -> WrappedBifunctor k1 k2 p a b -> Bool #

Eq (g b) => Eq (Joker k2 k1 g a b) 

Methods

(==) :: Joker k2 k1 g a b -> Joker k2 k1 g a b -> Bool #

(/=) :: Joker k2 k1 g a b -> Joker k2 k1 g a b -> Bool #

Eq (p b a) => Eq (Flip k1 k2 p a b) 

Methods

(==) :: Flip k1 k2 p a b -> Flip k1 k2 p a b -> Bool #

(/=) :: Flip k1 k2 p a b -> Flip k1 k2 p a b -> Bool #

Eq (f a) => Eq (Clown k1 k2 f a b) 

Methods

(==) :: Clown k1 k2 f a b -> Clown k1 k2 f a b -> Bool #

(/=) :: Clown k1 k2 f a b -> Clown k1 k2 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 k2 f g a b) 

Methods

(==) :: Product k1 k2 f g a b -> Product k1 k2 f g a b -> Bool #

(/=) :: Product k1 k2 f g a b -> Product k1 k2 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 k1 k2 k3 f p a b) 

Methods

(==) :: Tannen k1 k2 k3 f p a b -> Tannen k1 k2 k3 f p a b -> Bool #

(/=) :: Tannen k1 k2 k3 f p a b -> Tannen k1 k2 k3 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 k1 k2 k3 k4 p f g a b) 

Methods

(==) :: Biff k1 k2 k3 k4 p f g a b -> Biff k1 k2 k3 k4 p f g a b -> Bool #

(/=) :: Biff k1 k2 k3 k4 p f g a b -> Biff k1 k2 k3 k4 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 #

FromJSON Bool 
FromJSONKey Bool 
SingKind Bool

Since: 4.9.0.0

Associated Types

type DemoteRep Bool :: *

Methods

fromSing :: Sing Bool a -> DemoteRep Bool

Example Bool 

Associated Types

type Arg Bool :: * #

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

Since: 4.9.0.0

Methods

sing :: Sing False a

SingI Bool True

Since: 4.9.0.0

Methods

sing :: Sing True a

Vector Vector Bool 
MVector MVector Bool 
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
type DemoteRep Bool 
type DemoteRep Bool = Bool
type Arg Bool 
type Arg Bool = ()
data Vector Bool 
data MVector s Bool 
type (==) Bool a b 
type (==) Bool a b = EqBool a b
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

Since: 2.1

Methods

(>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b #

(>>) :: Maybe a -> Maybe b -> Maybe b #

return :: a -> Maybe a #

fail :: String -> Maybe a #

Functor Maybe

Since: 2.1

Methods

fmap :: (a -> b) -> Maybe a -> Maybe b #

(<$) :: a -> Maybe b -> Maybe a #

Applicative Maybe

Since: 2.1

Methods

pure :: a -> Maybe a #

(<*>) :: Maybe (a -> b) -> Maybe a -> Maybe b #

liftA2 :: (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c #

(*>) :: Maybe a -> Maybe b -> Maybe b #

(<*) :: Maybe a -> Maybe b -> Maybe a #

Foldable Maybe

Since: 2.1

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 #

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

Since: 2.1

Methods

empty :: Maybe a #

(<|>) :: Maybe a -> Maybe a -> Maybe a #

some :: Maybe a -> Maybe [a] #

many :: Maybe a -> Maybe [a] #

MonadPlus Maybe

Since: 2.1

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 #

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 e*e = e and e*s = s = s*e for all s ∈ S." Since there used to be no "Semigroup" typeclass providing just mappend, we use Monoid instead.

Since: 2.1

Methods

mempty :: Maybe a #

mappend :: Maybe a -> Maybe a -> Maybe a #

mconcat :: [Maybe a] -> Maybe a #

FromJSON a => FromJSON (Maybe a) 
SingKind a => SingKind (Maybe a)

Since: 4.9.0.0

Associated Types

type DemoteRep (Maybe a) :: *

Methods

fromSing :: Sing (Maybe a) a -> DemoteRep (Maybe a)

Generic1 * Maybe 

Associated Types

type Rep1 Maybe (f :: Maybe -> *) :: k -> * #

Methods

from1 :: f a -> Rep1 Maybe f a #

to1 :: Rep1 Maybe f a -> f a #

SingI (Maybe a) (Nothing a)

Since: 4.9.0.0

Methods

sing :: Sing (Nothing a) a

SingI a1 a2 => SingI (Maybe a1) (Just a1 a2)

Since: 4.9.0.0

Methods

sing :: Sing (Just a1 a2) a

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
type DemoteRep (Maybe a) 
type DemoteRep (Maybe a) = Maybe (DemoteRep a)
type Rep1 * Maybe 
type (==) (Maybe k) a b 
type (==) (Maybe k) a b = EqMaybe k a b

data StripeRequestF ret Source #

Constructors

StripeRequestF 

Instances

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