Safe Haskell | Safe-Inferred |
---|---|
Language | Haskell2010 |
Documentation
fromIntegral :: (Integral a, Num b) => a -> b #
realToFrac :: (Real a, Fractional b) => a -> b #
guard :: Alternative f => Bool -> f () #
Instances
Instances
Enum Bool | |
Enum Char | |
Enum Int | |
Enum Integer | |
Enum Natural | |
Defined in GHC.Enum enumFrom :: Natural -> [Natural] # enumFromThen :: Natural -> Natural -> [Natural] # enumFromTo :: Natural -> Natural -> [Natural] # enumFromThenTo :: Natural -> Natural -> Natural -> [Natural] # | |
Enum Ordering | |
Enum Word | |
Enum Word8 | |
Enum Word16 | |
Defined in GHC.Word | |
Enum Word32 | |
Defined in GHC.Word | |
Enum Word64 | |
Defined in GHC.Word | |
Enum VecCount | |
Defined in GHC.Enum succ :: VecCount -> VecCount # pred :: VecCount -> VecCount # enumFrom :: VecCount -> [VecCount] # enumFromThen :: VecCount -> VecCount -> [VecCount] # enumFromTo :: VecCount -> VecCount -> [VecCount] # enumFromThenTo :: VecCount -> VecCount -> VecCount -> [VecCount] # | |
Enum VecElem | |
Defined in GHC.Enum enumFrom :: VecElem -> [VecElem] # enumFromThen :: VecElem -> VecElem -> [VecElem] # enumFromTo :: VecElem -> VecElem -> [VecElem] # enumFromThenTo :: VecElem -> VecElem -> VecElem -> [VecElem] # | |
Enum () | |
Enum Day | |
Defined in Data.Time.Calendar.Days | |
Enum SeekMode | |
Defined in GHC.IO.Device succ :: SeekMode -> SeekMode # pred :: SeekMode -> SeekMode # enumFrom :: SeekMode -> [SeekMode] # enumFromThen :: SeekMode -> SeekMode -> [SeekMode] # enumFromTo :: SeekMode -> SeekMode -> [SeekMode] # enumFromThenTo :: SeekMode -> SeekMode -> SeekMode -> [SeekMode] # | |
Enum IOMode | |
Defined in GHC.IO.IOMode | |
Enum Associativity | |
Defined in GHC.Generics succ :: Associativity -> Associativity # pred :: Associativity -> Associativity # toEnum :: Int -> Associativity # fromEnum :: Associativity -> Int # enumFrom :: Associativity -> [Associativity] # enumFromThen :: Associativity -> Associativity -> [Associativity] # enumFromTo :: Associativity -> Associativity -> [Associativity] # enumFromThenTo :: Associativity -> Associativity -> Associativity -> [Associativity] # | |
Enum DecidedStrictness | |
Defined in GHC.Generics succ :: DecidedStrictness -> DecidedStrictness # pred :: DecidedStrictness -> DecidedStrictness # toEnum :: Int -> DecidedStrictness # fromEnum :: DecidedStrictness -> Int # enumFrom :: DecidedStrictness -> [DecidedStrictness] # enumFromThen :: DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] # enumFromTo :: DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] # enumFromThenTo :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] # | |
Enum SourceStrictness | |
Defined in GHC.Generics succ :: SourceStrictness -> SourceStrictness # pred :: SourceStrictness -> SourceStrictness # toEnum :: Int -> SourceStrictness # fromEnum :: SourceStrictness -> Int # enumFrom :: SourceStrictness -> [SourceStrictness] # enumFromThen :: SourceStrictness -> SourceStrictness -> [SourceStrictness] # enumFromTo :: SourceStrictness -> SourceStrictness -> [SourceStrictness] # enumFromThenTo :: SourceStrictness -> SourceStrictness -> SourceStrictness -> [SourceStrictness] # | |
Enum SourceUnpackedness | |
Defined in GHC.Generics succ :: SourceUnpackedness -> SourceUnpackedness # pred :: SourceUnpackedness -> SourceUnpackedness # toEnum :: Int -> SourceUnpackedness # fromEnum :: SourceUnpackedness -> Int # enumFrom :: SourceUnpackedness -> [SourceUnpackedness] # enumFromThen :: SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] # enumFromTo :: SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] # enumFromThenTo :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] # | |
Integral a => Enum (Ratio a) | |
Defined in GHC.Real enumFrom :: Ratio a -> [Ratio a] # enumFromThen :: Ratio a -> Ratio a -> [Ratio a] # enumFromTo :: Ratio a -> Ratio a -> [Ratio a] # enumFromThenTo :: Ratio a -> Ratio a -> Ratio a -> [Ratio a] # | |
Enum a => Enum (Identity a) | |
Defined in Data.Functor.Identity succ :: Identity a -> Identity a # pred :: Identity a -> Identity a # fromEnum :: Identity a -> Int # enumFrom :: Identity a -> [Identity a] # enumFromThen :: Identity a -> Identity a -> [Identity a] # enumFromTo :: Identity a -> Identity a -> [Identity a] # enumFromThenTo :: Identity a -> Identity a -> Identity a -> [Identity a] # | |
Enum a => Enum (Down a) | |
Defined in Data.Ord | |
Enum a => Enum (First a) | |
Defined in Data.Semigroup enumFrom :: First a -> [First a] # enumFromThen :: First a -> First a -> [First a] # enumFromTo :: First a -> First a -> [First a] # enumFromThenTo :: First a -> First a -> First a -> [First a] # | |
Enum a => Enum (Last a) | |
Defined in Data.Semigroup | |
Enum a => Enum (Max a) | |
Defined in Data.Semigroup | |
Enum a => Enum (Min a) | |
Defined in Data.Semigroup | |
Enum a => Enum (WrappedMonoid a) | |
Defined in Data.Semigroup succ :: WrappedMonoid a -> WrappedMonoid a # pred :: WrappedMonoid a -> WrappedMonoid a # toEnum :: Int -> WrappedMonoid a # fromEnum :: WrappedMonoid a -> Int # enumFrom :: WrappedMonoid a -> [WrappedMonoid a] # enumFromThen :: WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] # enumFromTo :: WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] # enumFromThenTo :: WrappedMonoid a -> WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] # | |
Enum (Proxy s) | |
Defined in Data.Proxy enumFrom :: Proxy s -> [Proxy s] # enumFromThen :: Proxy s -> Proxy s -> [Proxy s] # enumFromTo :: Proxy s -> Proxy s -> [Proxy s] # enumFromThenTo :: Proxy s -> Proxy s -> Proxy s -> [Proxy s] # | |
Enum a => Enum (Const a b) | |
Defined in Data.Functor.Const succ :: Const a b -> Const a b # pred :: Const a b -> Const a b # fromEnum :: Const a b -> Int # enumFrom :: Const a b -> [Const a b] # enumFromThen :: Const a b -> Const a b -> [Const a b] # enumFromTo :: Const a b -> Const a b -> [Const a b] # enumFromThenTo :: Const a b -> Const a b -> Const a b -> [Const a b] # | |
Enum (f a) => Enum (Alt f a) | |
Defined in Data.Semigroup.Internal enumFrom :: Alt f a -> [Alt f a] # enumFromThen :: Alt f a -> Alt f a -> [Alt f a] # enumFromTo :: Alt f a -> Alt f a -> [Alt f a] # enumFromThenTo :: Alt f a -> Alt f a -> Alt f a -> [Alt f a] # | |
Enum (f a) => Enum (Ap f a) | |
Defined in Data.Monoid |
Instances
Eq Bool | |
Eq Char | |
Eq Double | |
Eq Float | |
Eq Int | |
Eq Integer | |
Eq Natural | |
Eq Ordering | |
Eq Word | |
Eq Word8 | |
Eq Word16 | |
Eq Word32 | |
Eq Word64 | |
Eq () | |
Eq TyCon | |
Eq Module | |
Eq TrName | |
Eq SrcLoc | |
Eq ByteString | |
Eq DataRep | |
Eq Constr | |
Eq ConstrRep | |
Eq SourcePos | |
Eq SourceSpan | |
Eq Comment | |
Eq Ident | |
Eq ModuleName | |
Eq Name | |
Eq ConstraintData | |
Eq SkolemScope | |
Eq Version | |
Eq PSString | |
Eq Value | |
Eq Handle | |
Eq DefName | |
Eq More | |
Eq Pos | |
Eq AbsoluteTime | |
Eq UTCTime | |
Eq Day | |
Eq LocalTime | |
Eq UniversalTime | |
Eq IOException | |
Eq Any | |
Eq Key Source # | |
Eq Var Source # | |
Eq JSONPathElement | |
Eq BigNat | |
Eq SeekMode | |
Eq HandlePosn | |
Eq BufferMode | |
Eq Newline | |
Eq NewlineMode | |
Eq IOMode | |
Eq All | |
Eq ArrayException | |
Eq AsyncException | |
Eq ExitCode | |
Eq IOErrorType | |
Eq MaskingState | |
Eq Op Source # | |
Eq ConstructorType | |
Eq Meta | |
Eq ModuleInfo Source # | |
Defined in PureNix.Convert (==) :: ModuleInfo -> ModuleInfo -> Bool # (/=) :: ModuleInfo -> ModuleInfo -> Bool # | |
Eq Fixity | |
Eq Associativity | |
Eq DecidedStrictness | |
Eq Fixity | |
Eq SourceStrictness | |
Eq SourceUnpackedness | |
Eq Builder | |
Eq DotNetTime | |
Eq SumEncoding | |
Eq IODeviceType | |
Eq CodingProgress | |
Eq a => Eq [a] | |
Eq a => Eq (Maybe a) | |
Eq a => Eq (Ratio a) | |
Eq (Ptr a) | |
Eq (FunPtr a) | |
Eq p => Eq (Par1 p) | |
Eq a => Eq (Set a) | |
Eq a => Eq (Identity a) | |
Eq a => Eq (NonEmpty a) | |
Eq a => Eq (Literal a) | |
Eq (OpName a) | |
Eq (ProperName a) | |
Eq a => Eq (Qualified a) | |
Eq (Constraint a) | |
Eq (Type a) | |
(PrimType ty, Eq ty) => Eq (UArray ty) | |
Eq a => Eq (AlphaColour a) | |
Eq a => Eq (Colour a) | |
Eq a => Eq (Dual a) | |
Eq a => Eq (Product a) | |
Eq a => Eq (Sum a) | |
Eq a => Eq (ZipList a) | |
Eq a => Eq (Down a) | |
Eq a => Eq (First a) | |
Eq a => Eq (Last a) | |
Eq a => Eq (First a) | |
Eq a => Eq (Last a) | |
Eq a => Eq (Max a) | |
Eq a => Eq (Min a) | |
Eq m => Eq (WrappedMonoid m) | |
Eq a => Eq (Option a) | |
Eq a => Eq (Result a) | |
Eq a => Eq (IResult a) | |
(Eq a, Eq b) => Eq (Either a b) | |
Eq (V1 p) | |
Eq (U1 p) | |
(Eq a, Eq b) => Eq (a, b) | |
Eq (Proxy s) | |
(Eq k, Eq a) => Eq (Map k a) | |
(Ix i, Eq e) => Eq (Array i e) | |
Eq a => Eq (Arg a b) | |
Eq (f p) => Eq (Rec1 f p) | |
Eq (URec (Ptr ()) p) | |
Eq (URec Char p) | |
Eq (URec Double p) | |
Eq (URec Float p) | |
Eq (URec Int p) | |
Eq (URec Word p) | |
(Eq a, Eq b, Eq c) => Eq (a, b, c) | |
Eq a => Eq (Const a b) | |
Eq (STArray s i e) | |
(Eq e, Eq1 m, Eq a) => Eq (ErrorT e m a) | |
(Eq e, Eq1 m, Eq a) => Eq (ExceptT e m a) | |
Eq (f a) => Eq (Alt f a) | |
Eq (f a) => Eq (Ap f a) | |
Eq c => Eq (K1 i c p) | |
(Eq (f p), Eq (g p)) => Eq ((f :+: g) p) | |
(Eq (f p), Eq (g p)) => Eq ((f :*: g) p) | |
(Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d) | |
Eq (f p) => Eq (M1 i c f p) | |
Eq (f (g p)) => Eq ((f :.: g) p) | |
(Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) => Eq (a, b, c, d, e, f) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) => Eq (a, b, c, d, e, f, g) | |
(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) | |
(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) | |
(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) | |
(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) | |
(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) | |
(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) | |
(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) | |
(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) | |
class Fractional a => Floating a where #
Instances
Floating Double | |
Floating Float | |
Floating a => Floating (Identity a) | |
Defined in Data.Functor.Identity exp :: Identity a -> Identity a # log :: Identity a -> Identity a # sqrt :: Identity a -> Identity a # (**) :: Identity a -> Identity a -> Identity a # logBase :: Identity a -> Identity a -> Identity a # sin :: Identity a -> Identity a # cos :: Identity a -> Identity a # tan :: Identity a -> Identity a # asin :: Identity a -> Identity a # acos :: Identity a -> Identity a # atan :: Identity a -> Identity a # sinh :: Identity a -> Identity a # cosh :: Identity a -> Identity a # tanh :: Identity a -> Identity a # asinh :: Identity a -> Identity a # acosh :: Identity a -> Identity a # atanh :: Identity a -> Identity a # log1p :: Identity a -> Identity a expm1 :: Identity a -> Identity a log1pexp :: Identity a -> Identity a log1mexp :: Identity a -> Identity a | |
Floating a => Floating (Down a) | |
Floating a => Floating (Const a b) | |
Defined in Data.Functor.Const exp :: Const a b -> Const a b # log :: Const a b -> Const a b # sqrt :: Const a b -> Const a b # (**) :: Const a b -> Const a b -> Const a b # logBase :: Const a b -> Const a b -> Const a b # sin :: Const a b -> Const a b # cos :: Const a b -> Const a b # tan :: Const a b -> Const a b # asin :: Const a b -> Const a b # acos :: Const a b -> Const a b # atan :: Const a b -> Const a b # sinh :: Const a b -> Const a b # cosh :: Const a b -> Const a b # tanh :: Const a b -> Const a b # asinh :: Const a b -> Const a b # acosh :: Const a b -> Const a b # atanh :: Const a b -> Const a b # log1p :: Const a b -> Const a b expm1 :: Const a b -> Const a b |
class Num a => Fractional a where #
fromRational, (recip | (/))
Instances
Integral a => Fractional (Ratio a) | |
Fractional a => Fractional (Identity a) | |
Defined in Data.Functor.Identity | |
Fractional a => Fractional (Down a) | |
Fractional a => Fractional (Const a b) | |
class (Real a, Enum a) => Integral a where #
Instances
Integral Int | |
Integral Integer | |
Defined in GHC.Real | |
Integral Natural | |
Defined in GHC.Real | |
Integral Word | |
Integral Word8 | |
Integral Word16 | |
Integral Word32 | |
Integral Word64 | |
Integral a => Integral (Identity a) | |
Defined in Data.Functor.Identity quot :: Identity a -> Identity a -> Identity a # rem :: Identity a -> Identity a -> Identity a # div :: Identity a -> Identity a -> Identity a # mod :: Identity a -> Identity a -> Identity a # quotRem :: Identity a -> Identity a -> (Identity a, Identity a) # divMod :: Identity a -> Identity a -> (Identity a, Identity a) # | |
Integral a => Integral (Down a) | |
Integral a => Integral (Const a b) | |
Defined in Data.Functor.Const |
class Applicative m => Monad (m :: Type -> Type) where #
Instances
Monad [] | |
Monad Maybe | |
Monad IO | |
Monad Par1 | |
Monad Identity | |
Monad P | |
Monad NonEmpty | |
Monad Parser | |
Monad ReadP | |
Monad Dual | |
Monad Product | |
Monad Sum | |
Monad Put | |
Monad Down | |
Monad First | |
Monad Last | |
Monad First | |
Monad Last | |
Monad Max | |
Monad Min | |
Monad Option | |
Monad Result | |
Monad IResult | |
Monad (Either e) | |
Monad (U1 :: Type -> Type) | |
Monoid a => Monad ((,) a) | |
Monad (Proxy :: Type -> Type) | |
Monad (Parser i) | |
Monad m => Monad (WrappedMonad m) | |
Defined in Control.Applicative (>>=) :: WrappedMonad m a -> (a -> WrappedMonad m b) -> WrappedMonad m b # (>>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b # return :: a -> WrappedMonad m a # | |
Monad f => Monad (Rec1 f) | |
(Monoid a, Monoid b) => Monad ((,,) a b) | |
Monad m => Monad (StateT s m) | |
(Monad m, Error e) => Monad (ErrorT e m) | |
Monad m => Monad (ExceptT e m) | |
Monad m => Monad (ReaderT r m) | |
Monad f => Monad (Alt f) | |
Monad f => Monad (Ap f) | |
Monad m => Monad (StateT s m) | |
Monad ((->) r :: Type -> Type) | |
(Monad f, Monad g) => Monad (f :*: g) | |
(Monoid a, Monoid b, Monoid c) => Monad ((,,,) a b c) | |
(Applicative f, Monad f) => Monad (WhenMissing f k x) | |
Monad f => Monad (M1 i c f) | |
(Monad f, Applicative f) => Monad (WhenMatched f k x y) | |
class Functor (f :: Type -> Type) where #
Instances
fromInteger :: Integer -> a #
Instances
Num Int | |
Num Integer | |
Num Natural | |
Num Word | |
Num Word8 | |
Num Word16 | |
Num Word32 | |
Num Word64 | |
Num Pos | |
Integral a => Num (Ratio a) | |
Num a => Num (Identity a) | |
Defined in Data.Functor.Identity | |
Num a => Num (Product a) | |
Defined in Data.Semigroup.Internal | |
Num a => Num (Sum a) | |
Num a => Num (Down a) | |
Num a => Num (Max a) | |
Num a => Num (Min a) | |
Num a => Num (Const a b) | |
Num (f a) => Num (Alt f a) | |
(Applicative f, Num a) => Num (Ap f a) | |
Instances
Ord Bool | |
Ord Char | |
Ord Double | |
Ord Float | |
Ord Int | |
Ord Integer | |
Ord Natural | |
Ord Ordering | |
Defined in GHC.Classes | |
Ord Word | |
Ord Word8 | |
Ord Word16 | |
Ord Word32 | |
Ord Word64 | |
Ord () | |
Ord TyCon | |
Ord ByteString | |
Ord SourcePos | |
Defined in Language.PureScript.AST.SourcePos | |
Ord SourceSpan | |
Defined in Language.PureScript.AST.SourcePos | |
Ord Comment | |
Defined in Language.PureScript.Comments | |
Ord Ident | |
Ord ModuleName | |
Ord Name | |
Ord ConstraintData | |
Defined in Language.PureScript.Types compare :: ConstraintData -> ConstraintData -> Ordering # (<) :: ConstraintData -> ConstraintData -> Bool # (<=) :: ConstraintData -> ConstraintData -> Bool # (>) :: ConstraintData -> ConstraintData -> Bool # (>=) :: ConstraintData -> ConstraintData -> Bool # | |
Ord SkolemScope | |
Defined in Language.PureScript.Types | |
Ord Version | |
Ord PSString | |
Defined in Language.PureScript.PSString | |
Ord Value | |
Ord DefName | |
Ord Pos | |
Ord AbsoluteTime | |
Defined in Data.Time.Clock.Internal.AbsoluteTime | |
Ord UTCTime | |
Defined in Data.Time.Clock.Internal.UTCTime | |
Ord Day | |
Ord LocalTime | |
Defined in Data.Time.LocalTime.Internal.LocalTime | |
Ord UniversalTime | |
Defined in Data.Time.Clock.Internal.UniversalTime compare :: UniversalTime -> UniversalTime -> Ordering # (<) :: UniversalTime -> UniversalTime -> Bool # (<=) :: UniversalTime -> UniversalTime -> Bool # (>) :: UniversalTime -> UniversalTime -> Bool # (>=) :: UniversalTime -> UniversalTime -> Bool # | |
Ord Any | |
Ord JSONPathElement | |
Defined in Data.Aeson.Types.Internal compare :: JSONPathElement -> JSONPathElement -> Ordering # (<) :: JSONPathElement -> JSONPathElement -> Bool # (<=) :: JSONPathElement -> JSONPathElement -> Bool # (>) :: JSONPathElement -> JSONPathElement -> Bool # (>=) :: JSONPathElement -> JSONPathElement -> Bool # max :: JSONPathElement -> JSONPathElement -> JSONPathElement # min :: JSONPathElement -> JSONPathElement -> JSONPathElement # | |
Ord BigNat | |
Ord SeekMode | |
Defined in GHC.IO.Device | |
Ord BufferMode | |
Ord Newline | |
Ord NewlineMode | |
Defined in GHC.IO.Handle.Types | |
Ord IOMode | |
Ord All | |
Ord ArrayException | |
Defined in GHC.IO.Exception compare :: ArrayException -> ArrayException -> Ordering # (<) :: ArrayException -> ArrayException -> Bool # (<=) :: ArrayException -> ArrayException -> Bool # (>) :: ArrayException -> ArrayException -> Bool # (>=) :: ArrayException -> ArrayException -> Bool # | |
Ord AsyncException | |
Defined in GHC.IO.Exception compare :: AsyncException -> AsyncException -> Ordering # (<) :: AsyncException -> AsyncException -> Bool # (<=) :: AsyncException -> AsyncException -> Bool # (>) :: AsyncException -> AsyncException -> Bool # (>=) :: AsyncException -> AsyncException -> Bool # | |
Ord ExitCode | |
Defined in GHC.IO.Exception | |
Ord ConstructorType | |
Defined in Language.PureScript.CoreFn.Meta compare :: ConstructorType -> ConstructorType -> Ordering # (<) :: ConstructorType -> ConstructorType -> Bool # (<=) :: ConstructorType -> ConstructorType -> Bool # (>) :: ConstructorType -> ConstructorType -> Bool # (>=) :: ConstructorType -> ConstructorType -> Bool # max :: ConstructorType -> ConstructorType -> ConstructorType # min :: ConstructorType -> ConstructorType -> ConstructorType # | |
Ord Meta | |
Ord Associativity | |
Defined in GHC.Generics compare :: Associativity -> Associativity -> Ordering # (<) :: Associativity -> Associativity -> Bool # (<=) :: Associativity -> Associativity -> Bool # (>) :: Associativity -> Associativity -> Bool # (>=) :: Associativity -> Associativity -> Bool # | |
Ord DecidedStrictness | |
Defined in GHC.Generics compare :: DecidedStrictness -> DecidedStrictness -> Ordering # (<) :: DecidedStrictness -> DecidedStrictness -> Bool # (<=) :: DecidedStrictness -> DecidedStrictness -> Bool # (>) :: DecidedStrictness -> DecidedStrictness -> Bool # (>=) :: DecidedStrictness -> DecidedStrictness -> Bool # max :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness # min :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness # | |
Ord Fixity | |
Ord SourceStrictness | |
Defined in GHC.Generics compare :: SourceStrictness -> SourceStrictness -> Ordering # (<) :: SourceStrictness -> SourceStrictness -> Bool # (<=) :: SourceStrictness -> SourceStrictness -> Bool # (>) :: SourceStrictness -> SourceStrictness -> Bool # (>=) :: SourceStrictness -> SourceStrictness -> Bool # max :: SourceStrictness -> SourceStrictness -> SourceStrictness # min :: SourceStrictness -> SourceStrictness -> SourceStrictness # | |
Ord SourceUnpackedness | |
Defined in GHC.Generics compare :: SourceUnpackedness -> SourceUnpackedness -> Ordering # (<) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (<=) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (>) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (>=) :: SourceUnpackedness -> SourceUnpackedness -> Bool # max :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness # min :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness # | |
Ord Builder | |
Ord DotNetTime | |
Ord a => Ord [a] | |
Ord a => Ord (Maybe a) | |
Integral a => Ord (Ratio a) | |
Ord (Ptr a) | |
Ord (FunPtr a) | |
Ord p => Ord (Par1 p) | |
Ord a => Ord (Set a) | |
Ord a => Ord (Identity a) | |
Ord a => Ord (NonEmpty a) | |
Ord a => Ord (Literal a) | |
Defined in Language.PureScript.AST.Literals | |
Ord (OpName a) | |
Defined in Language.PureScript.Names | |
Ord (ProperName a) | |
Defined in Language.PureScript.Names | |
Ord a => Ord (Qualified a) | |
Defined in Language.PureScript.Names | |
Ord (Constraint a) | |
Defined in Language.PureScript.Types | |
Ord (Type a) | |
(PrimType ty, Ord ty) => Ord (UArray ty) | |
Defined in Basement.UArray.Base | |
Ord a => Ord (Dual a) | |
Ord a => Ord (Product a) | |
Defined in Data.Semigroup.Internal | |
Ord a => Ord (Sum a) | |
Ord a => Ord (ZipList a) | |
Defined in Control.Applicative | |
Ord a => Ord (Down a) | |
Ord a => Ord (First a) | |
Ord a => Ord (Last a) | |
Ord a => Ord (First a) | |
Ord a => Ord (Last a) | |
Ord a => Ord (Max a) | |
Ord a => Ord (Min a) | |
Ord m => Ord (WrappedMonoid m) | |
Defined in Data.Semigroup compare :: WrappedMonoid m -> WrappedMonoid m -> Ordering # (<) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (<=) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (>) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (>=) :: WrappedMonoid m -> WrappedMonoid m -> Bool # max :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # min :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # | |
Ord a => Ord (Option a) | |
Defined in Data.Semigroup | |
(Ord a, Ord b) => Ord (Either a b) | |
Ord (V1 p) | |
Ord (U1 p) | |
(Ord a, Ord b) => Ord (a, b) | |
Ord (Proxy s) | |
(Ord k, Ord v) => Ord (Map k v) | |
(Ix i, Ord e) => Ord (Array i e) | |
Defined in GHC.Arr | |
Ord a => Ord (Arg a b) | |
Ord (f p) => Ord (Rec1 f p) | |
Defined in GHC.Generics | |
Ord (URec (Ptr ()) p) | |
Defined in GHC.Generics compare :: URec (Ptr ()) p -> URec (Ptr ()) p -> Ordering # (<) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (<=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (>) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (>=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # max :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p # min :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p # | |
Ord (URec Char p) | |
Ord (URec Double p) | |
Defined in GHC.Generics compare :: URec Double p -> URec Double p -> Ordering # (<) :: URec Double p -> URec Double p -> Bool # (<=) :: URec Double p -> URec Double p -> Bool # (>) :: URec Double p -> URec Double p -> Bool # (>=) :: URec Double p -> URec Double p -> Bool # | |
Ord (URec Float p) | |
Defined in GHC.Generics | |
Ord (URec Int p) | |
Ord (URec Word p) | |
(Ord a, Ord b, Ord c) => Ord (a, b, c) | |
Defined in GHC.Classes | |
Ord a => Ord (Const a b) | |
Defined in Data.Functor.Const | |
(Ord e, Ord1 m, Ord a) => Ord (ErrorT e m a) | |
Defined in Control.Monad.Trans.Error | |
(Ord e, Ord1 m, Ord a) => Ord (ExceptT e m a) | |
Defined in Control.Monad.Trans.Except compare :: ExceptT e m a -> ExceptT e m a -> Ordering # (<) :: ExceptT e m a -> ExceptT e m a -> Bool # (<=) :: ExceptT e m a -> ExceptT e m a -> Bool # (>) :: ExceptT e m a -> ExceptT e m a -> Bool # (>=) :: ExceptT e m a -> ExceptT e m a -> Bool # | |
Ord (f a) => Ord (Alt f a) | |
Ord (f a) => Ord (Ap f a) | |
Ord c => Ord (K1 i c p) | |
Defined in GHC.Generics | |
(Ord (f p), Ord (g p)) => Ord ((f :+: g) p) | |
(Ord (f p), Ord (g p)) => Ord ((f :*: g) p) | |
(Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d) | |
Defined in GHC.Classes | |
Ord (f p) => Ord (M1 i c f p) | |
Ord (f (g p)) => Ord ((f :.: g) p) | |
(Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e) | |
Defined in GHC.Classes compare :: (a, b, c, d, e) -> (a, b, c, d, e) -> Ordering # (<) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # (<=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # (>) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # (>=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # max :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) # min :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f) => Ord (a, b, c, d, e, f) | |
Defined in GHC.Classes compare :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Ordering # (<) :: (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 # (>) :: (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 # max :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) # min :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g) => Ord (a, b, c, d, e, f, g) | |
Defined in GHC.Classes compare :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Ordering # (<) :: (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 # (>) :: (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 # max :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) # min :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h) => Ord (a, b, c, d, e, f, g, h) | |
Defined in GHC.Classes compare :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Ordering # (<) :: (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 # (>) :: (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 # max :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) # min :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i) => Ord (a, b, c, d, e, f, g, h, i) | |
Defined in GHC.Classes compare :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Ordering # (<) :: (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 # (>) :: (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 # max :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) # min :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j) => Ord (a, b, c, d, e, f, g, h, i, j) | |
Defined in GHC.Classes compare :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Ordering # (<) :: (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 # (>) :: (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 # max :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) # min :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k) => Ord (a, b, c, d, e, f, g, h, i, j, k) | |
Defined in GHC.Classes compare :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Ordering # (<) :: (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 # (>) :: (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 # max :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) # min :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l) => Ord (a, b, c, d, e, f, g, h, i, j, k, l) | |
Defined in GHC.Classes compare :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Ordering # (<) :: (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 # (>) :: (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 # max :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) # min :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m) | |
Defined in GHC.Classes compare :: (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) -> Ordering # (<) :: (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 # (>) :: (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 # max :: (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) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) # min :: (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) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n) | |
Defined in GHC.Classes compare :: (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) -> Ordering # (<) :: (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 # (>) :: (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 # max :: (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) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) # min :: (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) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n, Ord o) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) | |
Defined in GHC.Classes compare :: (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) -> Ordering # (<) :: (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 # (>) :: (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 # max :: (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) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) # min :: (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) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) # |
readsPrec | readPrec
Instances
Read Bool | |
Read Char | |
Read Double | |
Read Float | |
Read Int | |
Read Integer | |
Read Natural | |
Read Ordering | |
Read Word | |
Read Word8 | |
Read Word16 | |
Read Word32 | |
Read Word64 | |
Read () | |
Read ByteString | |
Defined in Data.ByteString.Internal | |
Read Version | |
Defined in Data.Version | |
Read Value | |
Defined in Data.Aeson.Types.Internal | |
Read Any | |
Defined in Data.Semigroup.Internal | |
Read Lexeme | |
Read SeekMode | |
Defined in GHC.IO.Device | |
Read BufferMode | |
Defined in GHC.IO.Handle.Types | |
Read Newline | |
Defined in GHC.IO.Handle.Types | |
Read NewlineMode | |
Defined in GHC.IO.Handle.Types | |
Read IOMode | |
Defined in GHC.IO.IOMode | |
Read GeneralCategory | |
Read All | |
Defined in Data.Semigroup.Internal | |
Read ExitCode | |
Defined in GHC.IO.Exception | |
Read Associativity | |
Defined in GHC.Generics | |
Read DecidedStrictness | |
Defined in GHC.Generics | |
Read Fixity | |
Defined in GHC.Generics | |
Read SourceStrictness | |
Defined in GHC.Generics | |
Read SourceUnpackedness | |
Defined in GHC.Generics | |
Read DotNetTime | |
Defined in Data.Aeson.Types.Internal | |
Read a => Read [a] | |
Read a => Read (Maybe a) | |
(Integral a, Read a) => Read (Ratio a) | |
Read p => Read (Par1 p) | |
Defined in GHC.Generics | |
(Read a, Ord a) => Read (Set a) | |
Defined in Data.Set.Internal | |
Read a => Read (Identity a) | |
Defined in Data.Functor.Identity | |
Read a => Read (NonEmpty a) | |
Read a => Read (Dual a) | |
Defined in Data.Semigroup.Internal | |
Read a => Read (Product a) | |
Defined in Data.Semigroup.Internal | |
Read a => Read (Sum a) | |
Defined in Data.Semigroup.Internal | |
Read a => Read (ZipList a) | |
Read a => Read (Down a) | |
Read a => Read (First a) | |
Defined in Data.Monoid | |
Read a => Read (Last a) | |
Defined in Data.Monoid | |
Read a => Read (First a) | |
Defined in Data.Semigroup | |
Read a => Read (Last a) | |
Defined in Data.Semigroup | |
Read a => Read (Max a) | |
Defined in Data.Semigroup | |
Read a => Read (Min a) | |
Defined in Data.Semigroup | |
Read m => Read (WrappedMonoid m) | |
Defined in Data.Semigroup | |
Read a => Read (Option a) | |
Defined in Data.Semigroup | |
(Read a, Read b) => Read (Either a b) | |
Read (V1 p) | |
Defined in GHC.Generics | |
Read (U1 p) | |
Defined in GHC.Generics | |
(Read a, Read b) => Read (a, b) | |
Read (Proxy t) | |
Defined in Data.Proxy | |
(Ord k, Read k, Read e) => Read (Map k e) | |
(Ix a, Read a, Read b) => Read (Array a b) | |
(Read a, Read b) => Read (Arg a b) | |
Defined in Data.Semigroup | |
Read (f p) => Read (Rec1 f p) | |
Defined in GHC.Generics | |
(Read a, Read b, Read c) => Read (a, b, c) | |
Read a => Read (Const a b) | |
(Read e, Read1 m, Read a) => Read (ErrorT e m a) | |
Defined in Control.Monad.Trans.Error | |
(Read e, Read1 m, Read a) => Read (ExceptT e m a) | |
Read (f a) => Read (Alt f a) | |
Defined in Data.Semigroup.Internal | |
Read (f a) => Read (Ap f a) | |
Defined in Data.Monoid | |
Read c => Read (K1 i c p) | |
Defined in GHC.Generics | |
(Read (f p), Read (g p)) => Read ((f :+: g) p) | |
Defined in GHC.Generics | |
(Read (f p), Read (g p)) => Read ((f :*: g) p) | |
Defined in GHC.Generics | |
(Read a, Read b, Read c, Read d) => Read (a, b, c, d) | |
Read (f p) => Read (M1 i c f p) | |
Defined in GHC.Generics | |
Read (f (g p)) => Read ((f :.: g) p) | |
Defined in GHC.Generics | |
(Read a, Read b, Read c, Read d, Read e) => Read (a, b, c, d, e) | |
(Read a, Read b, Read c, Read d, Read e, Read f) => Read (a, b, c, d, e, f) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g) => Read (a, b, c, d, e, f, g) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h) => Read (a, b, c, d, e, f, g, h) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i) => Read (a, b, c, d, e, f, g, h, i) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j) => Read (a, b, c, d, e, f, g, h, i, j) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k) => Read (a, b, c, d, e, f, g, h, i, j, k) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l) => Read (a, b, c, d, e, f, g, h, i, j, k, l) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m) => Read (a, b, c, d, e, f, g, h, i, j, k, l, m) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m, Read n) => Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m, Read n, Read o) => Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) | |
class (Num a, Ord a) => Real a where #
toRational :: a -> Rational #
Instances
Real Int | |
Defined in GHC.Real toRational :: Int -> Rational # | |
Real Integer | |
Defined in GHC.Real toRational :: Integer -> Rational # | |
Real Natural | |
Defined in GHC.Real toRational :: Natural -> Rational # | |
Real Word | |
Defined in GHC.Real toRational :: Word -> Rational # | |
Real Word8 | |
Defined in GHC.Word toRational :: Word8 -> Rational # | |
Real Word16 | |
Defined in GHC.Word toRational :: Word16 -> Rational # | |
Real Word32 | |
Defined in GHC.Word toRational :: Word32 -> Rational # | |
Real Word64 | |
Defined in GHC.Word toRational :: Word64 -> Rational # | |
Integral a => Real (Ratio a) | |
Defined in GHC.Real toRational :: Ratio a -> Rational # | |
Real a => Real (Identity a) | |
Defined in Data.Functor.Identity toRational :: Identity a -> Rational # | |
Real a => Real (Down a) | |
Defined in Data.Ord toRational :: Down a -> Rational # | |
Real a => Real (Const a b) | |
Defined in Data.Functor.Const toRational :: Const a b -> Rational # |
class (RealFrac a, Floating a) => RealFloat a where #
floatRadix, floatDigits, floatRange, decodeFloat, encodeFloat, isNaN, isInfinite, isDenormalized, isNegativeZero, isIEEE
floatRadix :: a -> Integer #
floatDigits :: a -> Int #
floatRange :: a -> (Int, Int) #
decodeFloat :: a -> (Integer, Int) #
encodeFloat :: Integer -> Int -> a #
significand :: a -> a #
scaleFloat :: Int -> a -> a #
isInfinite :: a -> Bool #
isDenormalized :: a -> Bool #
isNegativeZero :: a -> Bool #
Instances
class (Real a, Fractional a) => RealFrac a where #
properFraction :: Integral b => a -> (b, a) #
truncate :: Integral b => a -> b #
round :: Integral b => a -> b #
Instances
Show Bool | |
Show Char | |
Show Int | |
Show Integer | |
Show Natural | |
Show Ordering | |
Show Word | |
Show Word8 | |
Show Word16 | |
Show Word32 | |
Show Word64 | |
Show RuntimeRep | |
Show VecCount | |
Show VecElem | |
Show CallStack | |
Show () | |
Show TyCon | |
Show Module | |
Show TrName | |
Show KindRep | |
Show TypeLitSort | |
Show SrcLoc | |
Show ByteString | |
Show DataRep | |
Show Constr | |
Show DataType | |
Show ConstrRep | |
Show ErrorMessage | |
Show Level | |
Show MultipleErrors | |
Show SimpleErrorMessage | |
Show TypeMap | |
Show SourcePos | |
Show SourceSpan | |
Show Comment | |
Show Ident | |
Show ModuleName | |
Show Name | |
Show ConstraintData | |
Show SkolemScope | |
Show Version | |
Show PSString | |
Show Value | |
Show Handle | |
Show DefName | |
Show More | |
Show Pos | |
Show LocalTime | |
Show ZonedTime | |
Show IOException | |
Show Any | |
Show Key Source # | |
Show Var Source # | |
Show JSONPathElement | |
Show SeekMode | |
Show TextEncoding | |
Show HandlePosn | |
Show BufferMode | |
Show Newline | |
Show NewlineMode | |
Show IOMode | |
Show BlockedIndefinitelyOnMVar | |
Show All | |
Show AllocationLimitExceeded | |
Show ArrayException | |
Show AssertionFailed | |
Show AsyncException | |
Show BlockedIndefinitelyOnSTM | |
Show CompactionFailed | |
Show Deadlock | |
Show ExitCode | |
Show FixIOException | |
Show IOErrorType | |
Show SomeAsyncException | |
Show MaskingState | |
Show Op Source # | |
Show Expr Source # | |
Show ConstructorType | |
Show Meta | |
Show ModuleInfo Source # | |
Defined in PureNix.Convert showsPrec :: Int -> ModuleInfo -> ShowS # show :: ModuleInfo -> String # showList :: [ModuleInfo] -> ShowS # | |
Show Fixity | |
Show Associativity | |
Show DecidedStrictness | |
Show Fixity | |
Show SourceStrictness | |
Show SourceUnpackedness | |
Show Builder | |
Show DotNetTime | |
Show Options | |
Show SumEncoding | |
Show HandleType | |
Show CodingProgress | |
Show a => Show [a] | |
Show a => Show (Maybe a) | |
Show a => Show (Ratio a) | |
Show (Ptr a) | |
Show (FunPtr a) | |
Show p => Show (Par1 p) | |
Show a => Show (Set a) | |
Show a => Show (Identity a) | |
Show a => Show (NonEmpty a) | |
Show a => Show (Literal a) | |
Show (OpName a) | |
Show (ProperName a) | |
Show a => Show (Qualified a) | |
Show a => Show (Constraint a) | |
Show a => Show (RowListItem a) | |
Show a => Show (Type a) | |
(PrimType ty, Show ty) => Show (UArray ty) | |
Show a => Show (Dual a) | |
Show a => Show (Product a) | |
Show a => Show (Sum a) | |
Show a => Show (ZipList a) | |
Show a => Show (Down a) | |
Show a => Show (First a) | |
Show a => Show (Last a) | |
Show f => Show (ExprF f) Source # | |
Show a => Show (First a) | |
Show a => Show (Last a) | |
Show a => Show (Max a) | |
Show a => Show (Min a) | |
Show m => Show (WrappedMonoid m) | |
Show a => Show (Binder a) | |
Show a => Show (Bind a) | |
Show a => Show (CaseAlternative a) | |
Show a => Show (Expr a) | |
Show a => Show (Module a) | |
Show a => Show (Option a) | |
Show a => Show (Result a) | |
Show a => Show (IResult a) | |
(Show a, Show b) => Show (Either a b) | |
Show (V1 p) | |
Show (U1 p) | |
(Show a, Show b) => Show (a, b) | |
Show (Proxy s) | |
(Show k, Show a) => Show (Map k a) | |
(Ix a, Show a, Show b) => Show (Array a b) | |
(Show i, Show r) => Show (IResult i r) | |
(Show a, Show b) => Show (Arg a b) | |
Show (f p) => Show (Rec1 f p) | |
Show (URec Char p) | |
Show (URec Double p) | |
Show (URec Float p) | |
Show (URec Int p) | |
Show (URec Word p) | |
(Show a, Show b, Show c) => Show (a, b, c) | |
Show a => Show (Const a b) | |
(Show e, Show1 m, Show a) => Show (ErrorT e m a) | |
(Show e, Show1 m, Show a) => Show (ExceptT e m a) | |
Show (f a) => Show (Alt f a) | |
Show (f a) => Show (Ap f a) | |
Show c => Show (K1 i c p) | |
(Show (f p), Show (g p)) => Show ((f :+: g) p) | |
(Show (f p), Show (g p)) => Show ((f :*: g) p) | |
(Show a, Show b, Show c, Show d) => Show (a, b, c, d) | |
Show (f p) => Show (M1 i c f p) | |
Show (f (g p)) => Show ((f :.: g) p) | |
(Show a, Show b, Show c, Show d, Show e) => Show (a, b, c, d, e) | |
(Show a, Show b, Show c, Show d, Show e, Show f) => Show (a, b, c, d, e, f) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g) => Show (a, b, c, d, e, f, g) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h) => Show (a, b, c, d, e, f, g, h) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i) => Show (a, b, c, d, e, f, g, h, i) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j) => Show (a, b, c, d, e, f, g, h, i, j) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k) => Show (a, b, c, d, e, f, g, h, i, j, k) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l) => Show (a, b, c, d, e, f, g, h, i, j, k, l) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m, Show n) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m, Show n, Show o) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) | |
class Monad m => MonadFix (m :: Type -> Type) where #
Instances
class Monad m => MonadFail (m :: Type -> Type) where #
Instances
MonadFail [] | |
Defined in Control.Monad.Fail | |
MonadFail Maybe | |
Defined in Control.Monad.Fail | |
MonadFail IO | |
Defined in Control.Monad.Fail | |
MonadFail P | |
Defined in Text.ParserCombinators.ReadP | |
MonadFail Parser | |
Defined in Data.Aeson.Types.Internal | |
MonadFail ReadP | |
Defined in Text.ParserCombinators.ReadP | |
MonadFail Result | |
Defined in Data.Aeson.Types.Internal | |
MonadFail IResult | |
Defined in Data.Aeson.Types.Internal | |
MonadFail (Parser i) | |
Defined in Data.Attoparsec.Internal.Types | |
MonadFail m => MonadFail (StateT s m) | |
Defined in Control.Monad.Trans.State.Lazy | |
(Monad m, Error e) => MonadFail (ErrorT e m) | |
Defined in Control.Monad.Trans.Error | |
MonadFail m => MonadFail (ExceptT e m) | |
Defined in Control.Monad.Trans.Except | |
MonadFail m => MonadFail (ReaderT r m) | |
Defined in Control.Monad.Trans.Reader | |
MonadFail f => MonadFail (Ap f) | |
Defined in Data.Monoid | |
MonadFail m => MonadFail (StateT s m) | |
Defined in Lens.Micro |
fromString :: String -> a #
Instances
IsString ByteString | |
Defined in Data.ByteString.Internal fromString :: String -> ByteString # | |
IsString PSString | |
Defined in Language.PureScript.PSString fromString :: String -> PSString # | |
IsString Value | |
Defined in Data.Aeson.Types.Internal fromString :: String -> Value # | |
IsString Key Source # | |
Defined in PureNix.Identifiers fromString :: String -> Key # | |
IsString Var Source # | |
Defined in PureNix.Identifiers fromString :: String -> Var # | |
IsString Builder | |
Defined in Data.Text.Internal.Builder fromString :: String -> Builder # | |
a ~ Char => IsString [a] | |
Defined in Data.String fromString :: String -> [a] # | |
IsString a => IsString (Identity a) | |
Defined in Data.String fromString :: String -> Identity a # | |
IsString a => IsString (Const a b) | |
Defined in Data.String fromString :: String -> Const a b # |
class Functor f => Applicative (f :: Type -> Type) where #
Instances
Applicative [] | |
Applicative Maybe | |
Applicative IO | |
Applicative Par1 | |
Applicative Identity | |
Applicative P | |
Applicative NonEmpty | |
Applicative Parser | |
Applicative ReadP | |
Applicative Dual | |
Applicative Product | |
Applicative Sum | |
Applicative Put | |
Applicative ZipList | |
Applicative Down | |
Applicative First | |
Applicative Last | |
Applicative First | |
Applicative Last | |
Applicative Max | |
Applicative Min | |
Applicative Option | |
Applicative Result | |
Applicative IResult | |
Applicative (Either e) | |
Applicative (U1 :: Type -> Type) | |
Monoid a => Applicative ((,) a) | |
Applicative (Proxy :: Type -> Type) | |
Applicative (Parser i) | |
Monad m => Applicative (WrappedMonad m) | |
Defined in Control.Applicative pure :: a -> WrappedMonad m a # (<*>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b # liftA2 :: (a -> b -> c) -> WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m c # (*>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b # (<*) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a # | |
Applicative f => Applicative (Rec1 f) | |
(Monoid a, Monoid b) => Applicative ((,,) a b) | |
Monoid m => Applicative (Const m :: Type -> Type) | |
(Functor m, Monad m) => Applicative (StateT s m) | |
Defined in Control.Monad.Trans.State.Lazy | |
(Functor m, Monad m) => Applicative (ErrorT e m) | |
Defined in Control.Monad.Trans.Error | |
Arrow a => Applicative (WrappedArrow a b) | |
Defined in Control.Applicative pure :: a0 -> WrappedArrow a b a0 # (<*>) :: WrappedArrow a b (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 # liftA2 :: (a0 -> b0 -> c) -> WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b c # (*>) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b b0 # (<*) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 # | |
(Functor m, Monad m) => Applicative (ExceptT e m) | |
Defined in Control.Monad.Trans.Except | |
Applicative m => Applicative (ReaderT r m) | |
Defined in Control.Monad.Trans.Reader | |
Applicative f => Applicative (Alt f) | |
Applicative f => Applicative (Ap f) | |
Applicative (Bazaar a b) | |
Defined in Lens.Micro | |
(Functor m, Monad m) => Applicative (StateT s m) | |
Applicative ((->) r :: Type -> Type) | |
Monoid c => Applicative (K1 i c :: Type -> Type) | |
(Applicative f, Applicative g) => Applicative (f :*: g) | |
(Monoid a, Monoid b, Monoid c) => Applicative ((,,,) a b c) | |
Defined in GHC.Base | |
(Applicative f, Monad f) => Applicative (WhenMissing f k x) | |
Defined in Data.Map.Internal pure :: a -> WhenMissing f k x a # (<*>) :: WhenMissing f k x (a -> b) -> WhenMissing f k x a -> WhenMissing f k x b # liftA2 :: (a -> b -> c) -> WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x c # (*>) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x b # (<*) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x a # | |
Applicative f => Applicative (M1 i c f) | |
(Applicative f, Applicative g) => Applicative (f :.: g) | |
(Monad f, Applicative f) => Applicative (WhenMatched f k x y) | |
Defined in Data.Map.Internal pure :: a -> WhenMatched f k x y a # (<*>) :: WhenMatched f k x y (a -> b) -> WhenMatched f k x y a -> WhenMatched f k x y b # liftA2 :: (a -> b -> c) -> WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y c # (*>) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y b # (<*) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y a # |
class Foldable (t :: Type -> Type) where #
foldMap :: Monoid m => (a -> m) -> t a -> m #
foldr :: (a -> b -> b) -> b -> t a -> b #
foldl :: (b -> a -> b) -> b -> t a -> b #
foldr1 :: (a -> a -> a) -> t a -> a #
foldl1 :: (a -> a -> a) -> t a -> a #
elem :: Eq a => a -> t a -> Bool #
maximum :: Ord a => t a -> a #
Instances
Foldable [] | |
Defined in Data.Foldable foldMap :: Monoid m => (a -> m) -> [a] -> m # foldMap' :: Monoid m => (a -> m) -> [a] -> m foldr :: (a -> b -> b) -> b -> [a] -> b # foldr' :: (a -> b -> b) -> b -> [a] -> b foldl :: (b -> a -> b) -> b -> [a] -> b # foldl' :: (b -> a -> b) -> b -> [a] -> b foldr1 :: (a -> a -> a) -> [a] -> a # foldl1 :: (a -> a -> a) -> [a] -> a # toList :: [a] -> [a] elem :: Eq a => a -> [a] -> Bool # maximum :: Ord a => [a] -> a # | |
Foldable Maybe | |
Defined in Data.Foldable fold :: Monoid m => Maybe m -> m foldMap :: Monoid m => (a -> m) -> Maybe a -> 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 # elem :: Eq a => a -> Maybe a -> Bool # maximum :: Ord a => Maybe a -> a # minimum :: Ord a => Maybe a -> a # | |
Foldable Par1 | |
Defined in Data.Foldable fold :: Monoid m => Par1 m -> m foldMap :: Monoid m => (a -> m) -> Par1 a -> m # foldMap' :: Monoid m => (a -> m) -> Par1 a -> m foldr :: (a -> b -> b) -> b -> Par1 a -> b # foldr' :: (a -> b -> b) -> b -> Par1 a -> b foldl :: (b -> a -> b) -> b -> Par1 a -> b # foldl' :: (b -> a -> b) -> b -> Par1 a -> b foldr1 :: (a -> a -> a) -> Par1 a -> a # foldl1 :: (a -> a -> a) -> Par1 a -> a # toList :: Par1 a -> [a] elem :: Eq a => a -> Par1 a -> Bool # maximum :: Ord a => Par1 a -> a # | |
Foldable Set | |
Defined in Data.Set.Internal fold :: Monoid m => Set m -> m foldMap :: Monoid m => (a -> m) -> Set a -> m # foldMap' :: Monoid m => (a -> m) -> Set a -> m foldr :: (a -> b -> b) -> b -> Set a -> b # foldr' :: (a -> b -> b) -> b -> Set a -> b foldl :: (b -> a -> b) -> b -> Set a -> b # foldl' :: (b -> a -> b) -> b -> Set a -> b foldr1 :: (a -> a -> a) -> Set a -> a # foldl1 :: (a -> a -> a) -> Set a -> a # toList :: Set a -> [a] elem :: Eq a => a -> Set a -> Bool # maximum :: Ord a => Set a -> a # | |
Foldable Identity | |
Defined in Data.Functor.Identity fold :: Monoid m => Identity m -> m foldMap :: Monoid m => (a -> m) -> Identity a -> m # foldMap' :: Monoid m => (a -> m) -> Identity a -> m foldr :: (a -> b -> b) -> b -> Identity a -> b # foldr' :: (a -> b -> b) -> b -> Identity a -> b foldl :: (b -> a -> b) -> b -> Identity a -> b # foldl' :: (b -> a -> b) -> b -> Identity a -> b foldr1 :: (a -> a -> a) -> Identity a -> a # foldl1 :: (a -> a -> a) -> Identity a -> a # toList :: Identity a -> [a] elem :: Eq a => a -> Identity a -> Bool # maximum :: Ord a => Identity a -> a # minimum :: Ord a => Identity a -> a # | |
Foldable NonEmpty | |
Defined in Data.Foldable fold :: Monoid m => NonEmpty m -> m foldMap :: Monoid m => (a -> m) -> NonEmpty a -> m # foldMap' :: Monoid m => (a -> m) -> NonEmpty a -> m foldr :: (a -> b -> b) -> b -> NonEmpty a -> b # foldr' :: (a -> b -> b) -> b -> NonEmpty a -> b foldl :: (b -> a -> b) -> b -> NonEmpty a -> b # foldl' :: (b -> a -> b) -> b -> NonEmpty a -> b foldr1 :: (a -> a -> a) -> NonEmpty a -> a # foldl1 :: (a -> a -> a) -> NonEmpty a -> a # toList :: NonEmpty a -> [a] elem :: Eq a => a -> NonEmpty a -> Bool # maximum :: Ord a => NonEmpty a -> a # minimum :: Ord a => NonEmpty a -> a # | |
Foldable Qualified | |
Defined in Language.PureScript.Names fold :: Monoid m => Qualified m -> m foldMap :: Monoid m => (a -> m) -> Qualified a -> m # foldMap' :: Monoid m => (a -> m) -> Qualified a -> m foldr :: (a -> b -> b) -> b -> Qualified a -> b # foldr' :: (a -> b -> b) -> b -> Qualified a -> b foldl :: (b -> a -> b) -> b -> Qualified a -> b # foldl' :: (b -> a -> b) -> b -> Qualified a -> b foldr1 :: (a -> a -> a) -> Qualified a -> a # foldl1 :: (a -> a -> a) -> Qualified a -> a # toList :: Qualified a -> [a] length :: Qualified a -> Int # elem :: Eq a => a -> Qualified a -> Bool # maximum :: Ord a => Qualified a -> a # minimum :: Ord a => Qualified a -> a # | |
Foldable Constraint | |
Defined in Language.PureScript.Types fold :: Monoid m => Constraint m -> m foldMap :: Monoid m => (a -> m) -> Constraint a -> m # foldMap' :: Monoid m => (a -> m) -> Constraint a -> m foldr :: (a -> b -> b) -> b -> Constraint a -> b # foldr' :: (a -> b -> b) -> b -> Constraint a -> b foldl :: (b -> a -> b) -> b -> Constraint a -> b # foldl' :: (b -> a -> b) -> b -> Constraint a -> b foldr1 :: (a -> a -> a) -> Constraint a -> a # foldl1 :: (a -> a -> a) -> Constraint a -> a # toList :: Constraint a -> [a] null :: Constraint a -> Bool # length :: Constraint a -> Int # elem :: Eq a => a -> Constraint a -> Bool # maximum :: Ord a => Constraint a -> a # minimum :: Ord a => Constraint a -> a # | |
Foldable RowListItem | |
Defined in Language.PureScript.Types fold :: Monoid m => RowListItem m -> m foldMap :: Monoid m => (a -> m) -> RowListItem a -> m # foldMap' :: Monoid m => (a -> m) -> RowListItem a -> m foldr :: (a -> b -> b) -> b -> RowListItem a -> b # foldr' :: (a -> b -> b) -> b -> RowListItem a -> b foldl :: (b -> a -> b) -> b -> RowListItem a -> b # foldl' :: (b -> a -> b) -> b -> RowListItem a -> b foldr1 :: (a -> a -> a) -> RowListItem a -> a # foldl1 :: (a -> a -> a) -> RowListItem a -> a # toList :: RowListItem a -> [a] null :: RowListItem a -> Bool # length :: RowListItem a -> Int # elem :: Eq a => a -> RowListItem a -> Bool # maximum :: Ord a => RowListItem a -> a # minimum :: Ord a => RowListItem a -> a # | |
Foldable Type | |
Defined in Language.PureScript.Types fold :: Monoid m => Type m -> m foldMap :: Monoid m => (a -> m) -> Type a -> m # foldMap' :: Monoid m => (a -> m) -> Type a -> m foldr :: (a -> b -> b) -> b -> Type a -> b # foldr' :: (a -> b -> b) -> b -> Type a -> b foldl :: (b -> a -> b) -> b -> Type a -> b # foldl' :: (b -> a -> b) -> b -> Type a -> b foldr1 :: (a -> a -> a) -> Type a -> a # foldl1 :: (a -> a -> a) -> Type a -> a # toList :: Type a -> [a] elem :: Eq a => a -> Type a -> Bool # maximum :: Ord a => Type a -> a # | |
Foldable Dual | |
Defined in Data.Foldable fold :: Monoid m => Dual m -> m foldMap :: Monoid m => (a -> m) -> Dual a -> m # foldMap' :: Monoid m => (a -> m) -> Dual a -> m foldr :: (a -> b -> b) -> b -> Dual a -> b # foldr' :: (a -> b -> b) -> b -> Dual a -> b foldl :: (b -> a -> b) -> b -> Dual a -> b # foldl' :: (b -> a -> b) -> b -> Dual a -> b foldr1 :: (a -> a -> a) -> Dual a -> a # foldl1 :: (a -> a -> a) -> Dual a -> a # toList :: Dual a -> [a] elem :: Eq a => a -> Dual a -> Bool # maximum :: Ord a => Dual a -> a # | |
Foldable Product | |
Defined in Data.Foldable fold :: Monoid m => Product m -> m foldMap :: Monoid m => (a -> m) -> Product a -> m # foldMap' :: Monoid m => (a -> m) -> Product a -> m foldr :: (a -> b -> b) -> b -> Product a -> b # foldr' :: (a -> b -> b) -> b -> Product a -> b foldl :: (b -> a -> b) -> b -> Product a -> b # foldl' :: (b -> a -> b) -> b -> Product a -> b foldr1 :: (a -> a -> a) -> Product a -> a # foldl1 :: (a -> a -> a) -> Product a -> a # toList :: Product a -> [a] elem :: Eq a => a -> Product a -> Bool # maximum :: Ord a => Product a -> a # minimum :: Ord a => Product a -> a # | |
Foldable Sum | |
Defined in Data.Foldable fold :: Monoid m => Sum m -> m foldMap :: Monoid m => (a -> m) -> Sum a -> m # foldMap' :: Monoid m => (a -> m) -> Sum a -> m foldr :: (a -> b -> b) -> b -> Sum a -> b # foldr' :: (a -> b -> b) -> b -> Sum a -> b foldl :: (b -> a -> b) -> b -> Sum a -> b # foldl' :: (b -> a -> b) -> b -> Sum a -> b foldr1 :: (a -> a -> a) -> Sum a -> a # foldl1 :: (a -> a -> a) -> Sum a -> a # toList :: Sum a -> [a] elem :: Eq a => a -> Sum a -> Bool # maximum :: Ord a => Sum a -> a # | |
Foldable ZipList | |
Defined in Control.Applicative fold :: Monoid m => ZipList m -> m foldMap :: Monoid m => (a -> m) -> ZipList a -> m # foldMap' :: Monoid m => (a -> m) -> ZipList a -> m foldr :: (a -> b -> b) -> b -> ZipList a -> b # foldr' :: (a -> b -> b) -> b -> ZipList a -> b foldl :: (b -> a -> b) -> b -> ZipList a -> b # foldl' :: (b -> a -> b) -> b -> ZipList a -> b foldr1 :: (a -> a -> a) -> ZipList a -> a # foldl1 :: (a -> a -> a) -> ZipList a -> a # elem :: Eq a => a -> ZipList a -> Bool # maximum :: Ord a => ZipList a -> a # minimum :: Ord a => ZipList a -> a # | |
Foldable Down | |
Defined in Data.Foldable fold :: Monoid m => Down m -> m foldMap :: Monoid m => (a -> m) -> Down a -> m # foldMap' :: Monoid m => (a -> m) -> Down a -> m foldr :: (a -> b -> b) -> b -> Down a -> b # foldr' :: (a -> b -> b) -> b -> Down a -> b foldl :: (b -> a -> b) -> b -> Down a -> b # foldl' :: (b -> a -> b) -> b -> Down a -> b foldr1 :: (a -> a -> a) -> Down a -> a # foldl1 :: (a -> a -> a) -> Down a -> a # toList :: Down a -> [a] elem :: Eq a => a -> Down a -> Bool # maximum :: Ord a => Down a -> a # | |
Foldable First | |
Defined in Data.Foldable fold :: Monoid m => First m -> m foldMap :: Monoid m => (a -> m) -> First a -> m # foldMap' :: Monoid m => (a -> m) -> First a -> m foldr :: (a -> b -> b) -> b -> First a -> b # foldr' :: (a -> b -> b) -> b -> First a -> b foldl :: (b -> a -> b) -> b -> First a -> b # foldl' :: (b -> a -> b) -> b -> First a -> b foldr1 :: (a -> a -> a) -> First a -> a # foldl1 :: (a -> a -> a) -> First a -> a # toList :: First a -> [a] elem :: Eq a => a -> First a -> Bool # maximum :: Ord a => First a -> a # minimum :: Ord a => First a -> a # | |
Foldable Last | |
Defined in Data.Foldable fold :: Monoid m => Last m -> m foldMap :: Monoid m => (a -> m) -> Last a -> m # foldMap' :: Monoid m => (a -> m) -> Last a -> m foldr :: (a -> b -> b) -> b -> Last a -> b # foldr' :: (a -> b -> b) -> b -> Last a -> b foldl :: (b -> a -> b) -> b -> Last a -> b # foldl' :: (b -> a -> b) -> b -> Last a -> b foldr1 :: (a -> a -> a) -> Last a -> a # foldl1 :: (a -> a -> a) -> Last a -> a # toList :: Last a -> [a] elem :: Eq a => a -> Last a -> Bool # maximum :: Ord a => Last a -> a # | |
Foldable ExprF Source # | |
Defined in PureNix.Expr fold :: Monoid m => ExprF m -> m foldMap :: Monoid m => (a -> m) -> ExprF a -> m # foldMap' :: Monoid m => (a -> m) -> ExprF a -> m foldr :: (a -> b -> b) -> b -> ExprF a -> b # foldr' :: (a -> b -> b) -> b -> ExprF a -> b foldl :: (b -> a -> b) -> b -> ExprF a -> b # foldl' :: (b -> a -> b) -> b -> ExprF a -> b foldr1 :: (a -> a -> a) -> ExprF a -> a # foldl1 :: (a -> a -> a) -> ExprF a -> a # elem :: Eq a => a -> ExprF a -> Bool # maximum :: Ord a => ExprF a -> a # minimum :: Ord a => ExprF a -> a # | |
Foldable First | |
Defined in Data.Semigroup fold :: Monoid m => First m -> m foldMap :: Monoid m => (a -> m) -> First a -> m # foldMap' :: Monoid m => (a -> m) -> First a -> m foldr :: (a -> b -> b) -> b -> First a -> b # foldr' :: (a -> b -> b) -> b -> First a -> b foldl :: (b -> a -> b) -> b -> First a -> b # foldl' :: (b -> a -> b) -> b -> First a -> b foldr1 :: (a -> a -> a) -> First a -> a # foldl1 :: (a -> a -> a) -> First a -> a # toList :: First a -> [a] elem :: Eq a => a -> First a -> Bool # maximum :: Ord a => First a -> a # minimum :: Ord a => First a -> a # | |
Foldable Last | |
Defined in Data.Semigroup fold :: Monoid m => Last m -> m foldMap :: Monoid m => (a -> m) -> Last a -> m # foldMap' :: Monoid m => (a -> m) -> Last a -> m foldr :: (a -> b -> b) -> b -> Last a -> b # foldr' :: (a -> b -> b) -> b -> Last a -> b foldl :: (b -> a -> b) -> b -> Last a -> b # foldl' :: (b -> a -> b) -> b -> Last a -> b foldr1 :: (a -> a -> a) -> Last a -> a # foldl1 :: (a -> a -> a) -> Last a -> a # toList :: Last a -> [a] elem :: Eq a => a -> Last a -> Bool # maximum :: Ord a => Last a -> a # | |
Foldable Max | |
Defined in Data.Semigroup fold :: Monoid m => Max m -> m foldMap :: Monoid m => (a -> m) -> Max a -> m # foldMap' :: Monoid m => (a -> m) -> Max a -> m foldr :: (a -> b -> b) -> b -> Max a -> b # foldr' :: (a -> b -> b) -> b -> Max a -> b foldl :: (b -> a -> b) -> b -> Max a -> b # foldl' :: (b -> a -> b) -> b -> Max a -> b foldr1 :: (a -> a -> a) -> Max a -> a # foldl1 :: (a -> a -> a) -> Max a -> a # toList :: Max a -> [a] elem :: Eq a => a -> Max a -> Bool # maximum :: Ord a => Max a -> a # | |
Foldable Min | |
Defined in Data.Semigroup fold :: Monoid m => Min m -> m foldMap :: Monoid m => (a -> m) -> Min a -> m # foldMap' :: Monoid m => (a -> m) -> Min a -> m foldr :: (a -> b -> b) -> b -> Min a -> b # foldr' :: (a -> b -> b) -> b -> Min a -> b foldl :: (b -> a -> b) -> b -> Min a -> b # foldl' :: (b -> a -> b) -> b -> Min a -> b foldr1 :: (a -> a -> a) -> Min a -> a # foldl1 :: (a -> a -> a) -> Min a -> a # toList :: Min a -> [a] elem :: Eq a => a -> Min a -> Bool # maximum :: Ord a => Min a -> a # | |
Foldable Option | |
Defined in Data.Semigroup fold :: Monoid m => Option m -> m foldMap :: Monoid m => (a -> m) -> Option a -> m # foldMap' :: Monoid m => (a -> m) -> Option a -> m foldr :: (a -> b -> b) -> b -> Option a -> b # foldr' :: (a -> b -> b) -> b -> Option a -> b foldl :: (b -> a -> b) -> b -> Option a -> b # foldl' :: (b -> a -> b) -> b -> Option a -> b foldr1 :: (a -> a -> a) -> Option a -> a # foldl1 :: (a -> a -> a) -> Option a -> a # toList :: Option a -> [a] elem :: Eq a => a -> Option a -> Bool # maximum :: Ord a => Option a -> a # minimum :: Ord a => Option a -> a # | |
Foldable Result | |
Defined in Data.Aeson.Types.Internal fold :: Monoid m => Result m -> m foldMap :: Monoid m => (a -> m) -> Result a -> m # foldMap' :: Monoid m => (a -> m) -> Result a -> m foldr :: (a -> b -> b) -> b -> Result a -> b # foldr' :: (a -> b -> b) -> b -> Result a -> b foldl :: (b -> a -> b) -> b -> Result a -> b # foldl' :: (b -> a -> b) -> b -> Result a -> b foldr1 :: (a -> a -> a) -> Result a -> a # foldl1 :: (a -> a -> a) -> Result a -> a # toList :: Result a -> [a] elem :: Eq a => a -> Result a -> Bool # maximum :: Ord a => Result a -> a # minimum :: Ord a => Result a -> a # | |
Foldable IResult | |
Defined in Data.Aeson.Types.Internal fold :: Monoid m => IResult m -> m foldMap :: Monoid m => (a -> m) -> IResult a -> m # foldMap' :: Monoid m => (a -> m) -> IResult a -> m foldr :: (a -> b -> b) -> b -> IResult a -> b # foldr' :: (a -> b -> b) -> b -> IResult a -> b foldl :: (b -> a -> b) -> b -> IResult a -> b # foldl' :: (b -> a -> b) -> b -> IResult a -> b foldr1 :: (a -> a -> a) -> IResult a -> a # foldl1 :: (a -> a -> a) -> IResult a -> a # toList :: IResult a -> [a] elem :: Eq a => a -> IResult a -> Bool # maximum :: Ord a => IResult a -> a # minimum :: Ord a => IResult a -> a # | |
Foldable (Either a) | |
Defined in Data.Foldable fold :: Monoid m => Either a m -> m foldMap :: Monoid m => (a0 -> m) -> Either a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> Either a a0 -> m foldr :: (a0 -> b -> b) -> b -> Either a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Either a a0 -> b foldl :: (b -> a0 -> b) -> b -> Either a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Either a a0 -> b foldr1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 # length :: Either a a0 -> Int # elem :: Eq a0 => a0 -> Either a a0 -> Bool # maximum :: Ord a0 => Either a a0 -> a0 # minimum :: Ord a0 => Either a a0 -> a0 # | |
Foldable (V1 :: Type -> Type) | |
Defined in Data.Foldable foldMap :: Monoid m => (a -> m) -> V1 a -> m # foldMap' :: Monoid m => (a -> m) -> V1 a -> m foldr :: (a -> b -> b) -> b -> V1 a -> b # foldr' :: (a -> b -> b) -> b -> V1 a -> b foldl :: (b -> a -> b) -> b -> V1 a -> b # foldl' :: (b -> a -> b) -> b -> V1 a -> b foldr1 :: (a -> a -> a) -> V1 a -> a # foldl1 :: (a -> a -> a) -> V1 a -> a # toList :: V1 a -> [a] elem :: Eq a => a -> V1 a -> Bool # maximum :: Ord a => V1 a -> a # | |
Foldable (U1 :: Type -> Type) | |
Defined in Data.Foldable foldMap :: Monoid m => (a -> m) -> U1 a -> m # foldMap' :: Monoid m => (a -> m) -> U1 a -> m foldr :: (a -> b -> b) -> b -> U1 a -> b # foldr' :: (a -> b -> b) -> b -> U1 a -> b foldl :: (b -> a -> b) -> b -> U1 a -> b # foldl' :: (b -> a -> b) -> b -> U1 a -> b foldr1 :: (a -> a -> a) -> U1 a -> a # foldl1 :: (a -> a -> a) -> U1 a -> a # toList :: U1 a -> [a] elem :: Eq a => a -> U1 a -> Bool # maximum :: Ord a => U1 a -> a # | |
Foldable (UAddr :: Type -> Type) | |
Defined in Data.Foldable fold :: Monoid m => UAddr m -> m foldMap :: Monoid m => (a -> m) -> UAddr a -> m # foldMap' :: Monoid m => (a -> m) -> UAddr a -> m foldr :: (a -> b -> b) -> b -> UAddr a -> b # foldr' :: (a -> b -> b) -> b -> UAddr a -> b foldl :: (b -> a -> b) -> b -> UAddr a -> b # foldl' :: (b -> a -> b) -> b -> UAddr a -> b foldr1 :: (a -> a -> a) -> UAddr a -> a # foldl1 :: (a -> a -> a) -> UAddr a -> a # toList :: UAddr a -> [a] elem :: Eq a => a -> UAddr a -> Bool # maximum :: Ord a => UAddr a -> a # minimum :: Ord a => UAddr a -> a # | |
Foldable (UChar :: Type -> Type) | |
Defined in Data.Foldable fold :: Monoid m => UChar m -> m foldMap :: Monoid m => (a -> m) -> UChar a -> m # foldMap' :: Monoid m => (a -> m) -> UChar a -> m foldr :: (a -> b -> b) -> b -> UChar a -> b # foldr' :: (a -> b -> b) -> b -> UChar a -> b foldl :: (b -> a -> b) -> b -> UChar a -> b # foldl' :: (b -> a -> b) -> b -> UChar a -> b foldr1 :: (a -> a -> a) -> UChar a -> a # foldl1 :: (a -> a -> a) -> UChar a -> a # toList :: UChar a -> [a] elem :: Eq a => a -> UChar a -> Bool # maximum :: Ord a => UChar a -> a # minimum :: Ord a => UChar a -> a # | |
Foldable (UDouble :: Type -> Type) | |
Defined in Data.Foldable fold :: Monoid m => UDouble m -> m foldMap :: Monoid m => (a -> m) -> UDouble a -> m # foldMap' :: Monoid m => (a -> m) -> UDouble a -> m foldr :: (a -> b -> b) -> b -> UDouble a -> b # foldr' :: (a -> b -> b) -> b -> UDouble a -> b foldl :: (b -> a -> b) -> b -> UDouble a -> b # foldl' :: (b -> a -> b) -> b -> UDouble a -> b foldr1 :: (a -> a -> a) -> UDouble a -> a # foldl1 :: (a -> a -> a) -> UDouble a -> a # toList :: UDouble a -> [a] elem :: Eq a => a -> UDouble a -> Bool # maximum :: Ord a => UDouble a -> a # minimum :: Ord a => UDouble a -> a # | |
Foldable (UFloat :: Type -> Type) | |
Defined in Data.Foldable fold :: Monoid m => UFloat m -> m foldMap :: Monoid m => (a -> m) -> UFloat a -> m # foldMap' :: Monoid m => (a -> m) -> UFloat a -> m foldr :: (a -> b -> b) -> b -> UFloat a -> b # foldr' :: (a -> b -> b) -> b -> UFloat a -> b foldl :: (b -> a -> b) -> b -> UFloat a -> b # foldl' :: (b -> a -> b) -> b -> UFloat a -> b foldr1 :: (a -> a -> a) -> UFloat a -> a # foldl1 :: (a -> a -> a) -> UFloat a -> a # toList :: UFloat a -> [a] elem :: Eq a => a -> UFloat a -> Bool # maximum :: Ord a => UFloat a -> a # minimum :: Ord a => UFloat a -> a # | |
Foldable (UInt :: Type -> Type) | |
Defined in Data.Foldable fold :: Monoid m => UInt m -> m foldMap :: Monoid m => (a -> m) -> UInt a -> m # foldMap' :: Monoid m => (a -> m) -> UInt a -> m foldr :: (a -> b -> b) -> b -> UInt a -> b # foldr' :: (a -> b -> b) -> b -> UInt a -> b foldl :: (b -> a -> b) -> b -> UInt a -> b # foldl' :: (b -> a -> b) -> b -> UInt a -> b foldr1 :: (a -> a -> a) -> UInt a -> a # foldl1 :: (a -> a -> a) -> UInt a -> a # toList :: UInt a -> [a] elem :: Eq a => a -> UInt a -> Bool # maximum :: Ord a => UInt a -> a # | |
Foldable (UWord :: Type -> Type) | |
Defined in Data.Foldable fold :: Monoid m => UWord m -> m foldMap :: Monoid m => (a -> m) -> UWord a -> m # foldMap' :: Monoid m => (a -> m) -> UWord a -> m foldr :: (a -> b -> b) -> b -> UWord a -> b # foldr' :: (a -> b -> b) -> b -> UWord a -> b foldl :: (b -> a -> b) -> b -> UWord a -> b # foldl' :: (b -> a -> b) -> b -> UWord a -> b foldr1 :: (a -> a -> a) -> UWord a -> a # foldl1 :: (a -> a -> a) -> UWord a -> a # toList :: UWord a -> [a] elem :: Eq a => a -> UWord a -> Bool # maximum :: Ord a => UWord a -> a # minimum :: Ord a => UWord a -> a # | |
Foldable ((,) a) | |
Defined in Data.Foldable fold :: Monoid m => (a, m) -> m foldMap :: Monoid m => (a0 -> m) -> (a, a0) -> m # foldMap' :: Monoid m => (a0 -> m) -> (a, a0) -> m foldr :: (a0 -> b -> b) -> b -> (a, a0) -> b # foldr' :: (a0 -> b -> b) -> b -> (a, a0) -> b foldl :: (b -> a0 -> b) -> b -> (a, a0) -> b # foldl' :: (b -> a0 -> b) -> b -> (a, a0) -> b foldr1 :: (a0 -> a0 -> a0) -> (a, a0) -> a0 # foldl1 :: (a0 -> a0 -> a0) -> (a, a0) -> a0 # toList :: (a, a0) -> [a0] elem :: Eq a0 => a0 -> (a, a0) -> Bool # maximum :: Ord a0 => (a, a0) -> a0 # minimum :: Ord a0 => (a, a0) -> a0 # | |
Foldable (Proxy :: Type -> Type) | |
Defined in Data.Foldable fold :: Monoid m => Proxy m -> m foldMap :: Monoid m => (a -> m) -> Proxy a -> m # foldMap' :: Monoid m => (a -> m) -> Proxy a -> m foldr :: (a -> b -> b) -> b -> Proxy a -> b # foldr' :: (a -> b -> b) -> b -> Proxy a -> b foldl :: (b -> a -> b) -> b -> Proxy a -> b # foldl' :: (b -> a -> b) -> b -> Proxy a -> b foldr1 :: (a -> a -> a) -> Proxy a -> a # foldl1 :: (a -> a -> a) -> Proxy a -> a # toList :: Proxy a -> [a] elem :: Eq a => a -> Proxy a -> Bool # maximum :: Ord a => Proxy a -> a # minimum :: Ord a => Proxy a -> a # | |
Foldable (Map k) | |
Defined in Data.Map.Internal fold :: Monoid m => Map k m -> m foldMap :: Monoid m => (a -> m) -> Map k a -> m # foldMap' :: Monoid m => (a -> m) -> Map k a -> m foldr :: (a -> b -> b) -> b -> Map k a -> b # foldr' :: (a -> b -> b) -> b -> Map k a -> b foldl :: (b -> a -> b) -> b -> Map k a -> b # foldl' :: (b -> a -> b) -> b -> Map k a -> b foldr1 :: (a -> a -> a) -> Map k a -> a # foldl1 :: (a -> a -> a) -> Map k a -> a # elem :: Eq a => a -> Map k a -> Bool # maximum :: Ord a => Map k a -> a # minimum :: Ord a => Map k a -> a # | |
Foldable (Array i) | |
Defined in Data.Foldable fold :: Monoid m => Array i m -> m foldMap :: Monoid m => (a -> m) -> Array i a -> m # foldMap' :: Monoid m => (a -> m) -> Array i a -> m foldr :: (a -> b -> b) -> b -> Array i a -> b # foldr' :: (a -> b -> b) -> b -> Array i a -> b foldl :: (b -> a -> b) -> b -> Array i a -> b # foldl' :: (b -> a -> b) -> b -> Array i a -> b foldr1 :: (a -> a -> a) -> Array i a -> a # foldl1 :: (a -> a -> a) -> Array i a -> a # toList :: Array i a -> [a] elem :: Eq a => a -> Array i a -> Bool # maximum :: Ord a => Array i a -> a # minimum :: Ord a => Array i a -> a # | |
Foldable (Arg a) | |
Defined in Data.Semigroup fold :: Monoid m => Arg a m -> m foldMap :: Monoid m => (a0 -> m) -> Arg a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> Arg a a0 -> m foldr :: (a0 -> b -> b) -> b -> Arg a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Arg a a0 -> b foldl :: (b -> a0 -> b) -> b -> Arg a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Arg a a0 -> b foldr1 :: (a0 -> a0 -> a0) -> Arg a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Arg a a0 -> a0 # toList :: Arg a a0 -> [a0] elem :: Eq a0 => a0 -> Arg a a0 -> Bool # maximum :: Ord a0 => Arg a a0 -> a0 # minimum :: Ord a0 => Arg a a0 -> a0 # | |
Foldable f => Foldable (Rec1 f) | |
Defined in Data.Foldable fold :: Monoid m => Rec1 f m -> m foldMap :: Monoid m => (a -> m) -> Rec1 f a -> m # foldMap' :: Monoid m => (a -> m) -> Rec1 f a -> m foldr :: (a -> b -> b) -> b -> Rec1 f a -> b # foldr' :: (a -> b -> b) -> b -> Rec1 f a -> b foldl :: (b -> a -> b) -> b -> Rec1 f a -> b # foldl' :: (b -> a -> b) -> b -> Rec1 f a -> b foldr1 :: (a -> a -> a) -> Rec1 f a -> a # foldl1 :: (a -> a -> a) -> Rec1 f a -> a # toList :: Rec1 f a -> [a] elem :: Eq a => a -> Rec1 f a -> Bool # maximum :: Ord a => Rec1 f a -> a # minimum :: Ord a => Rec1 f a -> a # | |
Foldable (Const m :: Type -> Type) | |
Defined in Data.Functor.Const fold :: Monoid m0 => Const m m0 -> m0 foldMap :: Monoid m0 => (a -> m0) -> Const m a -> m0 # foldMap' :: Monoid m0 => (a -> m0) -> Const m a -> m0 foldr :: (a -> b -> b) -> b -> Const m a -> b # foldr' :: (a -> b -> b) -> b -> Const m a -> b foldl :: (b -> a -> b) -> b -> Const m a -> b # foldl' :: (b -> a -> b) -> b -> Const m a -> b foldr1 :: (a -> a -> a) -> Const m a -> a # foldl1 :: (a -> a -> a) -> Const m a -> a # elem :: Eq a => a -> Const m a -> Bool # maximum :: Ord a => Const m a -> a # minimum :: Ord a => Const m a -> a # | |
Foldable f => Foldable (ErrorT e f) | |
Defined in Control.Monad.Trans.Error fold :: Monoid m => ErrorT e f m -> m foldMap :: Monoid m => (a -> m) -> ErrorT e f a -> m # foldMap' :: Monoid m => (a -> m) -> ErrorT e f a -> m foldr :: (a -> b -> b) -> b -> ErrorT e f a -> b # foldr' :: (a -> b -> b) -> b -> ErrorT e f a -> b foldl :: (b -> a -> b) -> b -> ErrorT e f a -> b # foldl' :: (b -> a -> b) -> b -> ErrorT e f a -> b foldr1 :: (a -> a -> a) -> ErrorT e f a -> a # foldl1 :: (a -> a -> a) -> ErrorT e f a -> a # toList :: ErrorT e f a -> [a] null :: ErrorT e f a -> Bool # length :: ErrorT e f a -> Int # elem :: Eq a => a -> ErrorT e f a -> Bool # maximum :: Ord a => ErrorT e f a -> a # minimum :: Ord a => ErrorT e f a -> a # | |
Foldable f => Foldable (ExceptT e f) | |
Defined in Control.Monad.Trans.Except fold :: Monoid m => ExceptT e f m -> m foldMap :: Monoid m => (a -> m) -> ExceptT e f a -> m # foldMap' :: Monoid m => (a -> m) -> ExceptT e f a -> m foldr :: (a -> b -> b) -> b -> ExceptT e f a -> b # foldr' :: (a -> b -> b) -> b -> ExceptT e f a -> b foldl :: (b -> a -> b) -> b -> ExceptT e f a -> b # foldl' :: (b -> a -> b) -> b -> ExceptT e f a -> b foldr1 :: (a -> a -> a) -> ExceptT e f a -> a # foldl1 :: (a -> a -> a) -> ExceptT e f a -> a # toList :: ExceptT e f a -> [a] null :: ExceptT e f a -> Bool # length :: ExceptT e f a -> Int # elem :: Eq a => a -> ExceptT e f a -> Bool # maximum :: Ord a => ExceptT e f a -> a # minimum :: Ord a => ExceptT e f a -> a # | |
Foldable f => Foldable (Alt f) | |
Defined in Data.Foldable fold :: Monoid m => Alt f m -> m foldMap :: Monoid m => (a -> m) -> Alt f a -> m # foldMap' :: Monoid m => (a -> m) -> Alt f a -> m foldr :: (a -> b -> b) -> b -> Alt f a -> b # foldr' :: (a -> b -> b) -> b -> Alt f a -> b foldl :: (b -> a -> b) -> b -> Alt f a -> b # foldl' :: (b -> a -> b) -> b -> Alt f a -> b foldr1 :: (a -> a -> a) -> Alt f a -> a # foldl1 :: (a -> a -> a) -> Alt f a -> a # toList :: Alt f a -> [a] elem :: Eq a => a -> Alt f a -> Bool # maximum :: Ord a => Alt f a -> a # minimum :: Ord a => Alt f a -> a # | |
Foldable f => Foldable (Ap f) | |
Defined in Data.Foldable fold :: Monoid m => Ap f m -> m foldMap :: Monoid m => (a -> m) -> Ap f a -> m # foldMap' :: Monoid m => (a -> m) -> Ap f a -> m foldr :: (a -> b -> b) -> b -> Ap f a -> b # foldr' :: (a -> b -> b) -> b -> Ap f a -> b foldl :: (b -> a -> b) -> b -> Ap f a -> b # foldl' :: (b -> a -> b) -> b -> Ap f a -> b foldr1 :: (a -> a -> a) -> Ap f a -> a # foldl1 :: (a -> a -> a) -> Ap f a -> a # toList :: Ap f a -> [a] elem :: Eq a => a -> Ap f a -> Bool # maximum :: Ord a => Ap f a -> a # | |
Foldable (K1 i c :: Type -> Type) | |
Defined in Data.Foldable fold :: Monoid m => K1 i c m -> m foldMap :: Monoid m => (a -> m) -> K1 i c a -> m # foldMap' :: Monoid m => (a -> m) -> K1 i c a -> m foldr :: (a -> b -> b) -> b -> K1 i c a -> b # foldr' :: (a -> b -> b) -> b -> K1 i c a -> b foldl :: (b -> a -> b) -> b -> K1 i c a -> b # foldl' :: (b -> a -> b) -> b -> K1 i c a -> b foldr1 :: (a -> a -> a) -> K1 i c a -> a # foldl1 :: (a -> a -> a) -> K1 i c a -> a # toList :: K1 i c a -> [a] elem :: Eq a => a -> K1 i c a -> Bool # maximum :: Ord a => K1 i c a -> a # minimum :: Ord a => K1 i c a -> a # | |
(Foldable f, Foldable g) => Foldable (f :+: g) | |
Defined in Data.Foldable fold :: Monoid m => (f :+: g) m -> m foldMap :: Monoid m => (a -> m) -> (f :+: g) a -> m # foldMap' :: Monoid m => (a -> m) -> (f :+: g) a -> m foldr :: (a -> b -> b) -> b -> (f :+: g) a -> b # foldr' :: (a -> b -> b) -> b -> (f :+: g) a -> b foldl :: (b -> a -> b) -> b -> (f :+: g) a -> b # foldl' :: (b -> a -> b) -> b -> (f :+: g) a -> b foldr1 :: (a -> a -> a) -> (f :+: g) a -> a # foldl1 :: (a -> a -> a) -> (f :+: g) a -> a # toList :: (f :+: g) a -> [a] length :: (f :+: g) a -> Int # elem :: Eq a => a -> (f :+: g) a -> Bool # maximum :: Ord a => (f :+: g) a -> a # minimum :: Ord a => (f :+: g) a -> a # | |
(Foldable f, Foldable g) => Foldable (f :*: g) | |
Defined in Data.Foldable fold :: Monoid m => (f :*: g) m -> m foldMap :: Monoid m => (a -> m) -> (f :*: g) a -> m # foldMap' :: Monoid m => (a -> m) -> (f :*: g) a -> m foldr :: (a -> b -> b) -> b -> (f :*: g) a -> b # foldr' :: (a -> b -> b) -> b -> (f :*: g) a -> b foldl :: (b -> a -> b) -> b -> (f :*: g) a -> b # foldl' :: (b -> a -> b) -> b -> (f :*: g) a -> b foldr1 :: (a -> a -> a) -> (f :*: g) a -> a # foldl1 :: (a -> a -> a) -> (f :*: g) a -> a # toList :: (f :*: g) a -> [a] length :: (f :*: g) a -> Int # elem :: Eq a => a -> (f :*: g) a -> Bool # maximum :: Ord a => (f :*: g) a -> a # minimum :: Ord a => (f :*: g) a -> a # | |
Foldable f => Foldable (M1 i c f) | |
Defined in Data.Foldable fold :: Monoid m => M1 i c f m -> m foldMap :: Monoid m => (a -> m) -> M1 i c f a -> m # foldMap' :: Monoid m => (a -> m) -> M1 i c f a -> m foldr :: (a -> b -> b) -> b -> M1 i c f a -> b # foldr' :: (a -> b -> b) -> b -> M1 i c f a -> b foldl :: (b -> a -> b) -> b -> M1 i c f a -> b # foldl' :: (b -> a -> b) -> b -> M1 i c f a -> b foldr1 :: (a -> a -> a) -> M1 i c f a -> a # foldl1 :: (a -> a -> a) -> M1 i c f a -> a # toList :: M1 i c f a -> [a] elem :: Eq a => a -> M1 i c f a -> Bool # maximum :: Ord a => M1 i c f a -> a # minimum :: Ord a => M1 i c f a -> a # | |
(Foldable f, Foldable g) => Foldable (f :.: g) | |
Defined in Data.Foldable fold :: Monoid m => (f :.: g) m -> m foldMap :: Monoid m => (a -> m) -> (f :.: g) a -> m # foldMap' :: Monoid m => (a -> m) -> (f :.: g) a -> m foldr :: (a -> b -> b) -> b -> (f :.: g) a -> b # foldr' :: (a -> b -> b) -> b -> (f :.: g) a -> b foldl :: (b -> a -> b) -> b -> (f :.: g) a -> b # foldl' :: (b -> a -> b) -> b -> (f :.: g) a -> b foldr1 :: (a -> a -> a) -> (f :.: g) a -> a # foldl1 :: (a -> a -> a) -> (f :.: g) a -> a # toList :: (f :.: g) a -> [a] length :: (f :.: g) a -> Int # elem :: Eq a => a -> (f :.: g) a -> Bool # maximum :: Ord a => (f :.: g) a -> a # minimum :: Ord a => (f :.: g) a -> a # |
class (Functor t, Foldable t) => Traversable (t :: Type -> Type) where #
traverse :: Applicative f => (a -> f b) -> t a -> f (t b) #
sequenceA :: Applicative f => t (f a) -> f (t a) #
Instances
Instances
class Semigroup a => Monoid a where #
Instances
Monoid Ordering | |
Monoid () | |
Monoid ByteString | |
Monoid MultipleErrors | |
Monoid PSString | |
Monoid More | |
Monoid Builder | |
Monoid Any | |
Monoid All | |
Monoid ModuleInfo Source # | |
Defined in PureNix.Convert mempty :: ModuleInfo # mappend :: ModuleInfo -> ModuleInfo -> ModuleInfo # mconcat :: [ModuleInfo] -> ModuleInfo # | |
Monoid Builder | |
Monoid [a] | |
Semigroup a => Monoid (Maybe a) | |
Monoid a => Monoid (IO a) | |
Monoid p => Monoid (Par1 p) | |
Ord a => Monoid (Set a) | |
Monoid a => Monoid (Identity a) | |
Monoid (Parser a) | |
PrimType ty => Monoid (UArray ty) | |
Num a => Monoid (AlphaColour a) | |
Num a => Monoid (Colour a) | |
Monoid (Endo a) | |
Monoid a => Monoid (Dual a) | |
Num a => Monoid (Product a) | |
Num a => Monoid (Sum a) | |
Monoid (MergeSet a) | |
Monoid a => Monoid (Down a) | |
Monoid (First a) | |
Monoid (Last a) | |
(Ord a, Bounded a) => Monoid (Max a) | |
(Ord a, Bounded a) => Monoid (Min a) | |
Monoid m => Monoid (WrappedMonoid m) | |
Semigroup a => Monoid (Option a) | |
Monoid (Result a) | |
Monoid (IResult a) | |
Monoid b => Monoid (a -> b) | |
Monoid (U1 p) | |
(Monoid a, Monoid b) => Monoid (a, b) | |
Monoid (Proxy s) | |
Ord k => Monoid (Map k v) | |
Monoid (Parser i a) | |
Applicative f => Monoid (Traversed a f) | |
Monoid (f p) => Monoid (Rec1 f p) | |
(Monoid a, Monoid b, Monoid c) => Monoid (a, b, c) | |
Monoid a => Monoid (Const a b) | |
Alternative f => Monoid (Alt f a) | |
(Applicative f, Monoid a) => Monoid (Ap f a) | |
Monoid c => Monoid (K1 i c p) | |
(Monoid (f p), Monoid (g p)) => Monoid ((f :*: g) p) | |
(Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d) | |
Monoid (f p) => Monoid (M1 i c f p) | |
Monoid (f (g p)) => Monoid ((f :.: g) p) | |
(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e) | |
Instances
Bounded Bool | |
Enum Bool | |
Eq Bool | |
Data Bool | |
Defined in Data.Data gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bool -> c Bool gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Bool dataTypeOf :: Bool -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Bool) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bool) gmapT :: (forall b. Data b => b -> b) -> Bool -> Bool gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bool -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bool -> r gmapQ :: (forall d. Data d => d -> u) -> Bool -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Bool -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bool -> m Bool gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bool -> m Bool gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bool -> m Bool | |
Ord Bool | |
Read Bool | |
Show Bool | |
Generic Bool | |
FromJSON Bool | |
Defined in Data.Aeson.Types.FromJSON parseJSON :: Value -> Parser Bool parseJSONList :: Value -> Parser [Bool] | |
Unbox Bool | |
Defined in Data.Vector.Unboxed.Base | |
FromJSONKey Bool | |
Defined in Data.Aeson.Types.FromJSON fromJSONKey :: FromJSONKeyFunction Bool fromJSONKeyList :: FromJSONKeyFunction [Bool] | |
SingKind Bool | |
Defined in GHC.Generics type DemoteRep Bool | |
Vector Vector Bool | |
Defined in Data.Vector.Unboxed.Base 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 () | |
MVector MVector Bool | |
Defined in Data.Vector.Unboxed.Base 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) | |
SingI 'False | |
Defined in GHC.Generics | |
SingI 'True | |
Defined in GHC.Generics | |
type Rep Bool | |
Defined in GHC.Generics | |
newtype Vector Bool | |
Defined in Data.Vector.Unboxed.Base | |
type DemoteRep Bool | |
Defined in GHC.Generics | |
data Sing (a :: Bool) | |
newtype MVector s Bool | |
Defined in Data.Vector.Unboxed.Base |
Instances
Bounded Char | |
Enum Char | |
Eq Char | |
Data Char | |
Defined in Data.Data gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Char -> c Char gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Char dataTypeOf :: Char -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Char) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Char) gmapT :: (forall b. Data b => b -> b) -> Char -> Char gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r gmapQ :: (forall d. Data d => d -> u) -> Char -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Char -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Char -> m Char gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char | |
Ord Char | |
Read Char | |
Show Char | |
FromJSON Char | |
Defined in Data.Aeson.Types.FromJSON parseJSON :: Value -> Parser Char parseJSONList :: Value -> Parser [Char] | |
PrimType Char | |
Defined in Basement.PrimType type PrimSize Char :: Nat primSizeInBytes :: Proxy Char -> CountOf Word8 primShiftToBytes :: Proxy Char -> Int primBaUIndex :: ByteArray# -> Offset Char -> Char primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Char -> prim Char primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Char -> Char -> prim () primAddrIndex :: Addr# -> Offset Char -> Char primAddrRead :: PrimMonad prim => Addr# -> Offset Char -> prim Char primAddrWrite :: PrimMonad prim => Addr# -> Offset Char -> Char -> prim () | |
Unbox Char | |
Defined in Data.Vector.Unboxed.Base | |
ErrorList Char | |
Defined in Control.Monad.Trans.Error | |
FromJSONKey Char | |
Defined in Data.Aeson.Types.FromJSON fromJSONKey :: FromJSONKeyFunction Char fromJSONKeyList :: FromJSONKeyFunction [Char] | |
PrimMemoryComparable Char | |
Defined in Basement.PrimType | |
Vector Vector Char | |
Defined in Data.Vector.Unboxed.Base 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 () | |
MVector MVector Char | |
Defined in Data.Vector.Unboxed.Base 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) | |
Generic1 (URec Char :: k -> Type) | |
Foldable (UChar :: Type -> Type) | |
Defined in Data.Foldable fold :: Monoid m => UChar m -> m foldMap :: Monoid m => (a -> m) -> UChar a -> m # foldMap' :: Monoid m => (a -> m) -> UChar a -> m foldr :: (a -> b -> b) -> b -> UChar a -> b # foldr' :: (a -> b -> b) -> b -> UChar a -> b foldl :: (b -> a -> b) -> b -> UChar a -> b # foldl' :: (b -> a -> b) -> b -> UChar a -> b foldr1 :: (a -> a -> a) -> UChar a -> a # foldl1 :: (a -> a -> a) -> UChar a -> a # toList :: UChar a -> [a] elem :: Eq a => a -> UChar a -> Bool # maximum :: Ord a => UChar a -> a # minimum :: Ord a => UChar a -> a # | |
Traversable (UChar :: Type -> Type) | |
Defined in Data.Traversable | |
Functor (URec Char :: Type -> Type) | |
Eq (URec Char p) | |
Ord (URec Char p) | |
Show (URec Char p) | |
Generic (URec Char p) | |
newtype Vector Char | |
Defined in Data.Vector.Unboxed.Base | |
type PrimSize Char | |
Defined in Basement.PrimType type PrimSize Char = 4 | |
data URec Char (p :: k) | |
Defined in GHC.Generics | |
newtype MVector s Char | |
Defined in Data.Vector.Unboxed.Base | |
type Rep1 (URec Char :: k -> Type) | |
Defined in GHC.Generics | |
type Rep (URec Char p) | |
Defined in GHC.Generics |
Instances
Eq Double | |
Floating Double | |
Data Double | |
Defined in Data.Data gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Double -> c Double gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Double dataTypeOf :: Double -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Double) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Double) gmapT :: (forall b. Data b => b -> b) -> Double -> Double gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r gmapQ :: (forall d. Data d => d -> u) -> Double -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Double -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Double -> m Double gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double | |
Ord Double | |
Read Double | |
RealFloat Double | |
Defined in GHC.Float floatRadix :: Double -> Integer # floatDigits :: Double -> Int # floatRange :: Double -> (Int, Int) # decodeFloat :: Double -> (Integer, Int) # encodeFloat :: Integer -> Int -> Double # significand :: Double -> Double # scaleFloat :: Int -> Double -> Double # isInfinite :: Double -> Bool # isDenormalized :: Double -> Bool # isNegativeZero :: Double -> Bool # | |
FromJSON Double | |
Defined in Data.Aeson.Types.FromJSON parseJSON :: Value -> Parser Double parseJSONList :: Value -> Parser [Double] | |
PrimType Double | |
Defined in Basement.PrimType type PrimSize Double :: Nat primSizeInBytes :: Proxy Double -> CountOf Word8 primShiftToBytes :: Proxy Double -> Int primBaUIndex :: ByteArray# -> Offset Double -> Double primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Double -> prim Double primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Double -> Double -> prim () primAddrIndex :: Addr# -> Offset Double -> Double primAddrRead :: PrimMonad prim => Addr# -> Offset Double -> prim Double primAddrWrite :: PrimMonad prim => Addr# -> Offset Double -> Double -> prim () | |
Unbox Double | |
Defined in Data.Vector.Unboxed.Base | |
FromJSONKey Double | |
Defined in Data.Aeson.Types.FromJSON fromJSONKey :: FromJSONKeyFunction Double fromJSONKeyList :: FromJSONKeyFunction [Double] | |
Vector Vector Double | |
Defined in Data.Vector.Unboxed.Base basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Double -> m (Vector Double) basicUnsafeThaw :: PrimMonad m => Vector Double -> m (Mutable Vector (PrimState m) Double) basicLength :: Vector Double -> Int basicUnsafeSlice :: Int -> Int -> Vector Double -> Vector Double basicUnsafeIndexM :: Monad m => Vector Double -> Int -> m Double basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Double -> Vector Double -> m () | |
MVector MVector Double | |
Defined in Data.Vector.Unboxed.Base basicLength :: MVector s Double -> Int basicUnsafeSlice :: Int -> Int -> MVector s Double -> MVector s Double basicOverlaps :: MVector s Double -> MVector s Double -> Bool basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Double) basicInitialize :: PrimMonad m => MVector (PrimState m) Double -> m () basicUnsafeReplicate :: PrimMonad m => Int -> Double -> m (MVector (PrimState m) Double) basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Double -> Int -> m Double basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Double -> Int -> Double -> m () basicClear :: PrimMonad m => MVector (PrimState m) Double -> m () basicSet :: PrimMonad m => MVector (PrimState m) Double -> Double -> m () basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Double -> MVector (PrimState m) Double -> m () basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Double -> MVector (PrimState m) Double -> m () basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Double -> Int -> m (MVector (PrimState m) Double) | |
Generic1 (URec Double :: k -> Type) | |
Foldable (UDouble :: Type -> Type) | |
Defined in Data.Foldable fold :: Monoid m => UDouble m -> m foldMap :: Monoid m => (a -> m) -> UDouble a -> m # foldMap' :: Monoid m => (a -> m) -> UDouble a -> m foldr :: (a -> b -> b) -> b -> UDouble a -> b # foldr' :: (a -> b -> b) -> b -> UDouble a -> b foldl :: (b -> a -> b) -> b -> UDouble a -> b # foldl' :: (b -> a -> b) -> b -> UDouble a -> b foldr1 :: (a -> a -> a) -> UDouble a -> a # foldl1 :: (a -> a -> a) -> UDouble a -> a # toList :: UDouble a -> [a] elem :: Eq a => a -> UDouble a -> Bool # maximum :: Ord a => UDouble a -> a # minimum :: Ord a => UDouble a -> a # | |
Traversable (UDouble :: Type -> Type) | |
Defined in Data.Traversable | |
Functor (URec Double :: Type -> Type) | |
Eq (URec Double p) | |
Ord (URec Double p) | |
Defined in GHC.Generics compare :: URec Double p -> URec Double p -> Ordering # (<) :: URec Double p -> URec Double p -> Bool # (<=) :: URec Double p -> URec Double p -> Bool # (>) :: URec Double p -> URec Double p -> Bool # (>=) :: URec Double p -> URec Double p -> Bool # | |
Show (URec Double p) | |
Generic (URec Double p) | |
newtype Vector Double | |
Defined in Data.Vector.Unboxed.Base | |
type PrimSize Double | |
Defined in Basement.PrimType type PrimSize Double = 8 | |
data URec Double (p :: k) | |
Defined in GHC.Generics | |
newtype MVector s Double | |
Defined in Data.Vector.Unboxed.Base | |
type Rep1 (URec Double :: k -> Type) | |
Defined in GHC.Generics | |
type Rep (URec Double p) | |
Defined in GHC.Generics |
Instances
Eq Float | |
Floating Float | |
Data Float | |
Defined in Data.Data gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Float -> c Float gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Float dataTypeOf :: Float -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Float) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Float) gmapT :: (forall b. Data b => b -> b) -> Float -> Float gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r gmapQ :: (forall d. Data d => d -> u) -> Float -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Float -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Float -> m Float gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float | |
Ord Float | |
Read Float | |
RealFloat Float | |
Defined in GHC.Float floatRadix :: Float -> Integer # floatDigits :: Float -> Int # floatRange :: Float -> (Int, Int) # decodeFloat :: Float -> (Integer, Int) # encodeFloat :: Integer -> Int -> Float # significand :: Float -> Float # scaleFloat :: Int -> Float -> Float # isInfinite :: Float -> Bool # isDenormalized :: Float -> Bool # isNegativeZero :: Float -> Bool # | |
FromJSON Float | |
Defined in Data.Aeson.Types.FromJSON parseJSON :: Value -> Parser Float parseJSONList :: Value -> Parser [Float] | |
PrimType Float | |
Defined in Basement.PrimType type PrimSize Float :: Nat primSizeInBytes :: Proxy Float -> CountOf Word8 primShiftToBytes :: Proxy Float -> Int primBaUIndex :: ByteArray# -> Offset Float -> Float primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Float -> prim Float primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Float -> Float -> prim () primAddrIndex :: Addr# -> Offset Float -> Float primAddrRead :: PrimMonad prim => Addr# -> Offset Float -> prim Float primAddrWrite :: PrimMonad prim => Addr# -> Offset Float -> Float -> prim () | |
Unbox Float | |
Defined in Data.Vector.Unboxed.Base | |
FromJSONKey Float | |
Defined in Data.Aeson.Types.FromJSON fromJSONKey :: FromJSONKeyFunction Float fromJSONKeyList :: FromJSONKeyFunction [Float] | |
Vector Vector Float | |
Defined in Data.Vector.Unboxed.Base basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Float -> m (Vector Float) basicUnsafeThaw :: PrimMonad m => Vector Float -> m (Mutable Vector (PrimState m) Float) basicLength :: Vector Float -> Int basicUnsafeSlice :: Int -> Int -> Vector Float -> Vector Float basicUnsafeIndexM :: Monad m => Vector Float -> Int -> m Float basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Float -> Vector Float -> m () | |
MVector MVector Float | |
Defined in Data.Vector.Unboxed.Base basicLength :: MVector s Float -> Int basicUnsafeSlice :: Int -> Int -> MVector s Float -> MVector s Float basicOverlaps :: MVector s Float -> MVector s Float -> Bool basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Float) basicInitialize :: PrimMonad m => MVector (PrimState m) Float -> m () basicUnsafeReplicate :: PrimMonad m => Int -> Float -> m (MVector (PrimState m) Float) basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Float -> Int -> m Float basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Float -> Int -> Float -> m () basicClear :: PrimMonad m => MVector (PrimState m) Float -> m () basicSet :: PrimMonad m => MVector (PrimState m) Float -> Float -> m () basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Float -> MVector (PrimState m) Float -> m () basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Float -> MVector (PrimState m) Float -> m () basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Float -> Int -> m (MVector (PrimState m) Float) | |
Generic1 (URec Float :: k -> Type) | |
Foldable (UFloat :: Type -> Type) | |
Defined in Data.Foldable fold :: Monoid m => UFloat m -> m foldMap :: Monoid m => (a -> m) -> UFloat a -> m # foldMap' :: Monoid m => (a -> m) -> UFloat a -> m foldr :: (a -> b -> b) -> b -> UFloat a -> b # foldr' :: (a -> b -> b) -> b -> UFloat a -> b foldl :: (b -> a -> b) -> b -> UFloat a -> b # foldl' :: (b -> a -> b) -> b -> UFloat a -> b foldr1 :: (a -> a -> a) -> UFloat a -> a # foldl1 :: (a -> a -> a) -> UFloat a -> a # toList :: UFloat a -> [a] elem :: Eq a => a -> UFloat a -> Bool # maximum :: Ord a => UFloat a -> a # minimum :: Ord a => UFloat a -> a # | |
Traversable (UFloat :: Type -> Type) | |
Defined in Data.Traversable | |
Functor (URec Float :: Type -> Type) | |
Eq (URec Float p) | |
Ord (URec Float p) | |
Defined in GHC.Generics | |
Show (URec Float p) | |
Generic (URec Float p) | |
newtype Vector Float | |
Defined in Data.Vector.Unboxed.Base | |
type PrimSize Float | |
Defined in Basement.PrimType type PrimSize Float = 4 | |
data URec Float (p :: k) | |
Defined in GHC.Generics | |
newtype MVector s Float | |
Defined in Data.Vector.Unboxed.Base | |
type Rep1 (URec Float :: k -> Type) | |
Defined in GHC.Generics | |
type Rep (URec Float p) | |
Defined in GHC.Generics |
Instances
Bounded Int | |
Enum Int | |
Eq Int | |
Integral Int | |
Data Int | |
Defined in Data.Data gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int -> c Int gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int dataTypeOf :: Int -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int) gmapT :: (forall b. Data b => b -> b) -> Int -> Int gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r gmapQ :: (forall d. Data d => d -> u) -> Int -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Int -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int -> m Int gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int | |
Num Int | |
Ord Int | |
Read Int | |
Real Int | |
Defined in GHC.Real toRational :: Int -> Rational # | |
Show Int | |
FromJSON Int | |
Defined in Data.Aeson.Types.FromJSON parseJSON :: Value -> Parser Int parseJSONList :: Value -> Parser [Int] | |
PrimType Int | |
Defined in Basement.PrimType type PrimSize Int :: Nat primSizeInBytes :: Proxy Int -> CountOf Word8 primShiftToBytes :: Proxy Int -> Int primBaUIndex :: ByteArray# -> Offset Int -> Int primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int -> prim Int primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int -> Int -> prim () primAddrIndex :: Addr# -> Offset Int -> Int primAddrRead :: PrimMonad prim => Addr# -> Offset Int -> prim Int primAddrWrite :: PrimMonad prim => Addr# -> Offset Int -> Int -> prim () | |
Unbox Int | |
Defined in Data.Vector.Unboxed.Base | |
FromJSONKey Int | |
Defined in Data.Aeson.Types.FromJSON fromJSONKey :: FromJSONKeyFunction Int fromJSONKeyList :: FromJSONKeyFunction [Int] | |
PrimMemoryComparable Int | |
Defined in Basement.PrimType | |
Vector Vector Int | |
Defined in Data.Vector.Unboxed.Base basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int -> m (Vector Int) basicUnsafeThaw :: PrimMonad m => Vector Int -> m (Mutable Vector (PrimState m) Int) basicLength :: Vector Int -> Int basicUnsafeSlice :: Int -> Int -> Vector Int -> Vector Int basicUnsafeIndexM :: Monad m => Vector Int -> Int -> m Int basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int -> Vector Int -> m () | |
MVector MVector Int | |
Defined in Data.Vector.Unboxed.Base basicLength :: MVector s Int -> Int basicUnsafeSlice :: Int -> Int -> MVector s Int -> MVector s Int basicOverlaps :: MVector s Int -> MVector s Int -> Bool basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int) basicInitialize :: PrimMonad m => MVector (PrimState m) Int -> m () basicUnsafeReplicate :: PrimMonad m => Int -> Int -> m (MVector (PrimState m) Int) basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int -> Int -> m Int basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int -> Int -> Int -> m () basicClear :: PrimMonad m => MVector (PrimState m) Int -> m () basicSet :: PrimMonad m => MVector (PrimState m) Int -> Int -> m () basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int -> MVector (PrimState m) Int -> m () basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int -> MVector (PrimState m) Int -> m () basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int -> Int -> m (MVector (PrimState m) Int) | |
Generic1 (URec Int :: k -> Type) | |
Foldable (UInt :: Type -> Type) | |
Defined in Data.Foldable fold :: Monoid m => UInt m -> m foldMap :: Monoid m => (a -> m) -> UInt a -> m # foldMap' :: Monoid m => (a -> m) -> UInt a -> m foldr :: (a -> b -> b) -> b -> UInt a -> b # foldr' :: (a -> b -> b) -> b -> UInt a -> b foldl :: (b -> a -> b) -> b -> UInt a -> b # foldl' :: (b -> a -> b) -> b -> UInt a -> b foldr1 :: (a -> a -> a) -> UInt a -> a # foldl1 :: (a -> a -> a) -> UInt a -> a # toList :: UInt a -> [a] elem :: Eq a => a -> UInt a -> Bool # maximum :: Ord a => UInt a -> a # | |
Traversable (UInt :: Type -> Type) | |
Defined in Data.Traversable | |
Functor (URec Int :: Type -> Type) | |
Eq (URec Int p) | |
Ord (URec Int p) | |
Show (URec Int p) | |
Generic (URec Int p) | |
newtype Vector Int | |
Defined in Data.Vector.Unboxed.Base | |
type PrimSize Int | |
Defined in Basement.PrimType type PrimSize Int = 8 | |
data URec Int (p :: k) | |
Defined in GHC.Generics | |
newtype MVector s Int | |
Defined in Data.Vector.Unboxed.Base | |
type Rep1 (URec Int :: k -> Type) | |
Defined in GHC.Generics | |
type Rep (URec Int p) | |
Defined in GHC.Generics |
Instances
Enum Integer | |
Eq Integer | |
Integral Integer | |
Defined in GHC.Real | |
Data Integer | |
Defined in Data.Data gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Integer -> c Integer gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Integer dataTypeOf :: Integer -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Integer) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Integer) gmapT :: (forall b. Data b => b -> b) -> Integer -> Integer gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Integer -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Integer -> r gmapQ :: (forall d. Data d => d -> u) -> Integer -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Integer -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Integer -> m Integer gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Integer -> m Integer gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Integer -> m Integer | |
Num Integer | |
Ord Integer | |
Read Integer | |
Real Integer | |
Defined in GHC.Real toRational :: Integer -> Rational # | |
Show Integer | |
FromJSON Integer | |
Defined in Data.Aeson.Types.FromJSON parseJSON :: Value -> Parser Integer parseJSONList :: Value -> Parser [Integer] | |
FromJSONKey Integer | |
Defined in Data.Aeson.Types.FromJSON fromJSONKey :: FromJSONKeyFunction Integer fromJSONKeyList :: FromJSONKeyFunction [Integer] |
Instances
Monad Maybe | |
Functor Maybe | |
MonadFix Maybe | |
Defined in Control.Monad.Fix | |
MonadFail Maybe | |
Defined in Control.Monad.Fail | |
Applicative Maybe | |
Foldable Maybe | |
Defined in Data.Foldable fold :: Monoid m => Maybe m -> m foldMap :: Monoid m => (a -> m) -> Maybe a -> 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 # elem :: Eq a => a -> Maybe a -> Bool # maximum :: Ord a => Maybe a -> a # minimum :: Ord a => Maybe a -> a # | |
Traversable Maybe | |
MonadPlus Maybe | |
Eq1 Maybe | |
Ord1 Maybe | |
Defined in Data.Functor.Classes liftCompare :: (a -> b -> Ordering) -> Maybe a -> Maybe b -> Ordering | |
Alternative Maybe | |
Read1 Maybe | |
Defined in Data.Functor.Classes liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Maybe a) liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Maybe a] liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Maybe a) liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Maybe a] | |
Show1 Maybe | |
Defined in Data.Functor.Classes | |
FromJSON1 Maybe | |
Defined in Data.Aeson.Types.FromJSON liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Maybe a) liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Maybe a] | |
MonadError () Maybe | |
Defined in Control.Monad.Error.Class throwError :: () -> Maybe a # catchError :: Maybe a -> (() -> Maybe a) -> Maybe a # | |
(Selector s, FromJSON a) => RecordFromJSON' arity (S1 s (K1 i (Maybe a) :: Type -> Type)) | |
Defined in Data.Aeson.Types.FromJSON recordParseJSON' :: (ConName :* (TypeName :* (Options :* FromArgs arity a0))) -> Object -> Parser (S1 s (K1 i (Maybe a)) a0) | |
Eq a => Eq (Maybe a) | |
Data a => Data (Maybe a) | |
Defined in Data.Data gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Maybe a -> c (Maybe a) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Maybe a) dataTypeOf :: Maybe a -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Maybe a)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Maybe a)) gmapT :: (forall b. Data b => b -> b) -> Maybe a -> Maybe a gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r gmapQ :: (forall d. Data d => d -> u) -> Maybe a -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Maybe a -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) | |
Ord a => Ord (Maybe a) | |
Read a => Read (Maybe a) | |
Show a => Show (Maybe a) | |
Generic (Maybe a) | |
Semigroup a => Semigroup (Maybe a) | |
Semigroup a => Monoid (Maybe a) | |
FromJSON a => FromJSON (Maybe a) | |
Defined in Data.Aeson.Types.FromJSON parseJSON :: Value -> Parser (Maybe a) parseJSONList :: Value -> Parser [Maybe a] | |
SingKind a => SingKind (Maybe a) | |
Defined in GHC.Generics type DemoteRep (Maybe a) | |
Generic1 Maybe | |
SingI ('Nothing :: Maybe a) | |
Defined in GHC.Generics | |
Each (Maybe a) (Maybe b) a b | |
Defined in Lens.Micro.Internal | |
SingI a2 => SingI ('Just a2 :: Maybe a1) | |
Defined in GHC.Generics | |
type Rep (Maybe a) | |
Defined in GHC.Generics | |
type DemoteRep (Maybe a) | |
Defined in GHC.Generics | |
data Sing (b :: Maybe a) | |
type Rep1 Maybe | |
Instances
Bounded Ordering | |
Enum Ordering | |
Eq Ordering | |
Data Ordering | |
Defined in Data.Data gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ordering -> c Ordering gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Ordering toConstr :: Ordering -> Constr dataTypeOf :: Ordering -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Ordering) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ordering) gmapT :: (forall b. Data b => b -> b) -> Ordering -> Ordering gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ordering -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ordering -> r gmapQ :: (forall d. Data d => d -> u) -> Ordering -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Ordering -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering | |
Ord Ordering | |
Defined in GHC.Classes | |
Read Ordering | |
Show Ordering | |
Generic Ordering | |
Semigroup Ordering | |
Monoid Ordering | |
FromJSON Ordering | |
Defined in Data.Aeson.Types.FromJSON parseJSON :: Value -> Parser Ordering parseJSONList :: Value -> Parser [Ordering] | |
type Rep Ordering | |
Instances
Monad IO | |
Functor IO | |
MonadFix IO | |
Defined in Control.Monad.Fix | |
MonadFail IO | |
Defined in Control.Monad.Fail | |
Applicative IO | |
MonadPlus IO | |
Alternative IO | |
MonadIO IO | |
Defined in Control.Monad.IO.Class | |
MonadError IOException IO | |
Defined in Control.Monad.Error.Class throwError :: IOException -> IO a # catchError :: IO a -> (IOException -> IO a) -> IO a # | |
Semigroup a => Semigroup (IO a) | |
Monoid a => Monoid (IO a) | |
Instances
Bounded Word | |
Enum Word | |
Eq Word | |
Integral Word | |
Data Word | |
Defined in Data.Data gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word -> c Word gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word dataTypeOf :: Word -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word) gmapT :: (forall b. Data b => b -> b) -> Word -> Word gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r gmapQ :: (forall d. Data d => d -> u) -> Word -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Word -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word -> m Word gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word | |
Num Word | |
Ord Word | |
Read Word | |
Real Word | |
Defined in GHC.Real toRational :: Word -> Rational # | |
Show Word | |
FromJSON Word | |
Defined in Data.Aeson.Types.FromJSON parseJSON :: Value -> Parser Word parseJSONList :: Value -> Parser [Word] | |
PrimType Word | |
Defined in Basement.PrimType type PrimSize Word :: Nat primSizeInBytes :: Proxy Word -> CountOf Word8 primShiftToBytes :: Proxy Word -> Int primBaUIndex :: ByteArray# -> Offset Word -> Word primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word -> prim Word primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word -> Word -> prim () primAddrIndex :: Addr# -> Offset Word -> Word primAddrRead :: PrimMonad prim => Addr# -> Offset Word -> prim Word primAddrWrite :: PrimMonad prim => Addr# -> Offset Word -> Word -> prim () | |
Unbox Word | |
Defined in Data.Vector.Unboxed.Base | |
FromJSONKey Word | |
Defined in Data.Aeson.Types.FromJSON fromJSONKey :: FromJSONKeyFunction Word fromJSONKeyList :: FromJSONKeyFunction [Word] | |
PrimMemoryComparable Word | |
Defined in Basement.PrimType | |
Vector Vector Word | |
Defined in Data.Vector.Unboxed.Base basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word -> m (Vector Word) basicUnsafeThaw :: PrimMonad m => Vector Word -> m (Mutable Vector (PrimState m) Word) basicLength :: Vector Word -> Int basicUnsafeSlice :: Int -> Int -> Vector Word -> Vector Word basicUnsafeIndexM :: Monad m => Vector Word -> Int -> m Word basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word -> Vector Word -> m () | |
MVector MVector Word | |
Defined in Data.Vector.Unboxed.Base basicLength :: MVector s Word -> Int basicUnsafeSlice :: Int -> Int -> MVector s Word -> MVector s Word basicOverlaps :: MVector s Word -> MVector s Word -> Bool basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word) basicInitialize :: PrimMonad m => MVector (PrimState m) Word -> m () basicUnsafeReplicate :: PrimMonad m => Int -> Word -> m (MVector (PrimState m) Word) basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word -> Int -> m Word basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word -> Int -> Word -> m () basicClear :: PrimMonad m => MVector (PrimState m) Word -> m () basicSet :: PrimMonad m => MVector (PrimState m) Word -> Word -> m () basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word -> MVector (PrimState m) Word -> m () basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word -> MVector (PrimState m) Word -> m () basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word -> Int -> m (MVector (PrimState m) Word) | |
Generic1 (URec Word :: k -> Type) | |
Foldable (UWord :: Type -> Type) | |
Defined in Data.Foldable fold :: Monoid m => UWord m -> m foldMap :: Monoid m => (a -> m) -> UWord a -> m # foldMap' :: Monoid m => (a -> m) -> UWord a -> m foldr :: (a -> b -> b) -> b -> UWord a -> b # foldr' :: (a -> b -> b) -> b -> UWord a -> b foldl :: (b -> a -> b) -> b -> UWord a -> b # foldl' :: (b -> a -> b) -> b -> UWord a -> b foldr1 :: (a -> a -> a) -> UWord a -> a # foldl1 :: (a -> a -> a) -> UWord a -> a # toList :: UWord a -> [a] elem :: Eq a => a -> UWord a -> Bool # maximum :: Ord a => UWord a -> a # minimum :: Ord a => UWord a -> a # | |
Traversable (UWord :: Type -> Type) | |
Defined in Data.Traversable | |
Functor (URec Word :: Type -> Type) | |
Eq (URec Word p) | |
Ord (URec Word p) | |
Show (URec Word p) | |
Generic (URec Word p) | |
newtype Vector Word | |
Defined in Data.Vector.Unboxed.Base | |
type PrimSize Word | |
Defined in Basement.PrimType type PrimSize Word = 8 | |
data URec Word (p :: k) | |
Defined in GHC.Generics | |
newtype MVector s Word | |
Defined in Data.Vector.Unboxed.Base | |
type Rep1 (URec Word :: k -> Type) | |
Defined in GHC.Generics | |
type Rep (URec Word p) | |
Defined in GHC.Generics |
Instances
Eq2 Either | |
Ord2 Either | |
Defined in Data.Functor.Classes | |
Show2 Either | |
Read2 Either | |
Defined in Data.Functor.Classes liftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (Either a b) liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [Either a b] liftReadPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (Either a b) liftReadListPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [Either a b] | |
Bitraversable Either | |
Defined in Data.Bitraversable bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Either a b -> f (Either c d) | |
FromJSON2 Either | |
Defined in Data.Aeson.Types.FromJSON liftParseJSON2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser (Either a b) liftParseJSONList2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser [Either a b] | |
MonadError e (Either e) | |
Defined in Control.Monad.Error.Class throwError :: e -> Either e a # catchError :: Either e a -> (e -> Either e a) -> Either e a # | |
Monad (Either e) | |
Functor (Either a) | |
MonadFix (Either e) | |
Defined in Control.Monad.Fix | |
Applicative (Either e) | |
Foldable (Either a) | |
Defined in Data.Foldable fold :: Monoid m => Either a m -> m foldMap :: Monoid m => (a0 -> m) -> Either a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> Either a a0 -> m foldr :: (a0 -> b -> b) -> b -> Either a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Either a a0 -> b foldl :: (b -> a0 -> b) -> b -> Either a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Either a a0 -> b foldr1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 # length :: Either a a0 -> Int # elem :: Eq a0 => a0 -> Either a a0 -> Bool # maximum :: Ord a0 => Either a a0 -> a0 # minimum :: Ord a0 => Either a a0 -> a0 # | |
Traversable (Either a) | |
Eq a => Eq1 (Either a) | |
Ord a => Ord1 (Either a) | |
Defined in Data.Functor.Classes liftCompare :: (a0 -> b -> Ordering) -> Either a a0 -> Either a b -> Ordering | |
Read a => Read1 (Either a) | |
Defined in Data.Functor.Classes liftReadsPrec :: (Int -> ReadS a0) -> ReadS [a0] -> Int -> ReadS (Either a a0) liftReadList :: (Int -> ReadS a0) -> ReadS [a0] -> ReadS [Either a a0] liftReadPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec (Either a a0) liftReadListPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec [Either a a0] | |
Show a => Show1 (Either a) | |
Defined in Data.Functor.Classes | |
FromJSON a => FromJSON1 (Either a) | |
Defined in Data.Aeson.Types.FromJSON liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (Either a a0) liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [Either a a0] | |
Generic1 (Either a :: Type -> Type) | |
(Eq a, Eq b) => Eq (Either a b) | |
(Data a, Data b) => Data (Either a b) | |
Defined in Data.Data gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Either a b -> c (Either a b) gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Either a b) toConstr :: Either a b -> Constr dataTypeOf :: Either a b -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Either a b)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Either a b)) gmapT :: (forall b0. Data b0 => b0 -> b0) -> Either a b -> Either a b gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Either a b -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Either a b -> r gmapQ :: (forall d. Data d => d -> u) -> Either a b -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Either a b -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) | |
(Ord a, Ord b) => Ord (Either a b) | |
(Read a, Read b) => Read (Either a b) | |
(Show a, Show b) => Show (Either a b) | |
Generic (Either a b) | |
Semigroup (Either a b) | |
(FromJSON a, FromJSON b) => FromJSON (Either a b) | |
Defined in Data.Aeson.Types.FromJSON parseJSON :: Value -> Parser (Either a b) parseJSONList :: Value -> Parser [Either a b] | |
(a ~ a', b ~ b') => Each (Either a a') (Either b b') a b | |
Defined in Lens.Micro.Internal | |
type Rep1 (Either a :: Type -> Type) | |
Defined in GHC.Generics type Rep1 (Either a :: Type -> Type) = D1 ('MetaData "Either" "Data.Either" "base" 'False) (C1 ('MetaCons "Left" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)) :+: C1 ('MetaCons "Right" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1)) | |
type Rep (Either a b) | |
Defined in GHC.Generics type Rep (Either a b) = D1 ('MetaData "Either" "Data.Either" "base" 'False) (C1 ('MetaCons "Left" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)) :+: C1 ('MetaCons "Right" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 b))) |
errorWithoutStackTrace :: forall (r :: RuntimeRep) (a :: TYPE r). [Char] -> a #
(^^) :: (Fractional a, Integral b) => a -> b -> a #
showString :: String -> ShowS #
appendFile :: FilePath -> String -> IO () #
getContents :: IO String #
Instances
Generic1 (Const a :: k -> Type) | |
Unbox a => Vector Vector (Const a b) | |
Defined in Data.Vector.Unboxed.Base basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Const a b) -> m (Vector (Const a b)) basicUnsafeThaw :: PrimMonad m => Vector (Const a b) -> m (Mutable Vector (PrimState m) (Const a b)) basicLength :: Vector (Const a b) -> Int basicUnsafeSlice :: Int -> Int -> Vector (Const a b) -> Vector (Const a b) basicUnsafeIndexM :: Monad m => Vector (Const a b) -> Int -> m (Const a b) basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Const a b) -> Vector (Const a b) -> m () | |
Unbox a => MVector MVector (Const a b) | |
Defined in Data.Vector.Unboxed.Base basicLength :: MVector s (Const a b) -> Int basicUnsafeSlice :: Int -> Int -> MVector s (Const a b) -> MVector s (Const a b) basicOverlaps :: MVector s (Const a b) -> MVector s (Const a b) -> Bool basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Const a b)) basicInitialize :: PrimMonad m => MVector (PrimState m) (Const a b) -> m () basicUnsafeReplicate :: PrimMonad m => Int -> Const a b -> m (MVector (PrimState m) (Const a b)) basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Const a b) -> Int -> m (Const a b) basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Const a b) -> Int -> Const a b -> m () basicClear :: PrimMonad m => MVector (PrimState m) (Const a b) -> m () basicSet :: PrimMonad m => MVector (PrimState m) (Const a b) -> Const a b -> m () basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Const a b) -> MVector (PrimState m) (Const a b) -> m () basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Const a b) -> MVector (PrimState m) (Const a b) -> m () basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Const a b) -> Int -> m (MVector (PrimState m) (Const a b)) | |
Eq2 (Const :: Type -> Type -> Type) | |
Ord2 (Const :: Type -> Type -> Type) | |
Defined in Data.Functor.Classes | |
Show2 (Const :: Type -> Type -> Type) | |
Read2 (Const :: Type -> Type -> Type) | |
Defined in Data.Functor.Classes liftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (Const a b) liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [Const a b] liftReadPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (Const a b) liftReadListPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [Const a b] | |
Bitraversable (Const :: Type -> Type -> Type) | |
Defined in Data.Bitraversable bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Const a b -> f (Const c d) | |
FromJSON2 (Const :: Type -> Type -> Type) | |
Defined in Data.Aeson.Types.FromJSON liftParseJSON2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser (Const a b) liftParseJSONList2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser [Const a b] | |
Functor (Const m :: Type -> Type) | |
Monoid m => Applicative (Const m :: Type -> Type) | |
Foldable (Const m :: Type -> Type) | |
Defined in Data.Functor.Const fold :: Monoid m0 => Const m m0 -> m0 foldMap :: Monoid m0 => (a -> m0) -> Const m a -> m0 # foldMap' :: Monoid m0 => (a -> m0) -> Const m a -> m0 foldr :: (a -> b -> b) -> b -> Const m a -> b # foldr' :: (a -> b -> b) -> b -> Const m a -> b foldl :: (b -> a -> b) -> b -> Const m a -> b # foldl' :: (b -> a -> b) -> b -> Const m a -> b foldr1 :: (a -> a -> a) -> Const m a -> a # foldl1 :: (a -> a -> a) -> Const m a -> a # elem :: Eq a => a -> Const m a -> Bool # maximum :: Ord a => Const m a -> a # minimum :: Ord a => Const m a -> a # | |
Traversable (Const m :: Type -> Type) | |
Eq a => Eq1 (Const a :: Type -> Type) | |
Ord a => Ord1 (Const a :: Type -> Type) | |
Defined in Data.Functor.Classes liftCompare :: (a0 -> b -> Ordering) -> Const a a0 -> Const a b -> Ordering | |
Read a => Read1 (Const a :: Type -> Type) | |
Defined in Data.Functor.Classes liftReadsPrec :: (Int -> ReadS a0) -> ReadS [a0] -> Int -> ReadS (Const a a0) liftReadList :: (Int -> ReadS a0) -> ReadS [a0] -> ReadS [Const a a0] liftReadPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec (Const a a0) liftReadListPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec [Const a a0] | |
Show a => Show1 (Const a :: Type -> Type) | |
Defined in Data.Functor.Classes | |
FromJSON a => FromJSON1 (Const a :: Type -> Type) | |
Defined in Data.Aeson.Types.FromJSON liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (Const a a0) liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [Const a a0] | |
Bounded a => Bounded (Const a b) | |
Enum a => Enum (Const a b) | |
Defined in Data.Functor.Const succ :: Const a b -> Const a b # pred :: Const a b -> Const a b # fromEnum :: Const a b -> Int # enumFrom :: Const a b -> [Const a b] # enumFromThen :: Const a b -> Const a b -> [Const a b] # enumFromTo :: Const a b -> Const a b -> [Const a b] # enumFromThenTo :: Const a b -> Const a b -> Const a b -> [Const a b] # | |
Eq a => Eq (Const a b) | |
Floating a => Floating (Const a b) | |
Defined in Data.Functor.Const exp :: Const a b -> Const a b # log :: Const a b -> Const a b # sqrt :: Const a b -> Const a b # (**) :: Const a b -> Const a b -> Const a b # logBase :: Const a b -> Const a b -> Const a b # sin :: Const a b -> Const a b # cos :: Const a b -> Const a b # tan :: Const a b -> Const a b # asin :: Const a b -> Const a b # acos :: Const a b -> Const a b # atan :: Const a b -> Const a b # sinh :: Const a b -> Const a b # cosh :: Const a b -> Const a b # tanh :: Const a b -> Const a b # asinh :: Const a b -> Const a b # acosh :: Const a b -> Const a b # atanh :: Const a b -> Const a b # log1p :: Const a b -> Const a b expm1 :: Const a b -> Const a b | |
Fractional a => Fractional (Const a b) | |
Integral a => Integral (Const a b) | |
Defined in Data.Functor.Const | |
(Typeable k, Data a, Typeable b) => Data (Const a b) | |
Defined in Data.Data gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Const a b -> c (Const a b) gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Const a b) toConstr :: Const a b -> Constr dataTypeOf :: Const a b -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Const a b)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Const a b)) gmapT :: (forall b0. Data b0 => b0 -> b0) -> Const a b -> Const a b gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Const a b -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Const a b -> r gmapQ :: (forall d. Data d => d -> u) -> Const a b -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Const a b -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Const a b -> m (Const a b) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Const a b -> m (Const a b) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Const a b -> m (Const a b) | |
Num a => Num (Const a b) | |
Ord a => Ord (Const a b) | |
Defined in Data.Functor.Const | |
Read a => Read (Const a b) | |
Real a => Real (Const a b) | |
Defined in Data.Functor.Const toRational :: Const a b -> Rational # | |
RealFloat a => RealFloat (Const a b) | |
Defined in Data.Functor.Const floatRadix :: Const a b -> Integer # floatDigits :: Const a b -> Int # floatRange :: Const a b -> (Int, Int) # decodeFloat :: Const a b -> (Integer, Int) # encodeFloat :: Integer -> Int -> Const a b # exponent :: Const a b -> Int # significand :: Const a b -> Const a b # scaleFloat :: Int -> Const a b -> Const a b # isInfinite :: Const a b -> Bool # isDenormalized :: Const a b -> Bool # isNegativeZero :: Const a b -> Bool # | |
RealFrac a => RealFrac (Const a b) | |
Show a => Show (Const a b) | |
Ix a => Ix (Const a b) | |
Defined in Data.Functor.Const | |
IsString a => IsString (Const a b) | |
Defined in Data.String fromString :: String -> Const a b # | |
Generic (Const a b) | |
Semigroup a => Semigroup (Const a b) | |
Monoid a => Monoid (Const a b) | |
FromJSON a => FromJSON (Const a b) | |
Defined in Data.Aeson.Types.FromJSON parseJSON :: Value -> Parser (Const a b) parseJSONList :: Value -> Parser [Const a b] | |
Unbox a => Unbox (Const a b) | |
Defined in Data.Vector.Unboxed.Base | |
Storable a => Storable (Const a b) | |
Defined in Data.Functor.Const | |
Bits a => Bits (Const a b) | |
Defined in Data.Functor.Const (.&.) :: Const a b -> Const a b -> Const a b (.|.) :: Const a b -> Const a b -> Const a b xor :: Const a b -> Const a b -> Const a b complement :: Const a b -> Const a b shift :: Const a b -> Int -> Const a b rotate :: Const a b -> Int -> Const a b setBit :: Const a b -> Int -> Const a b clearBit :: Const a b -> Int -> Const a b complementBit :: Const a b -> Int -> Const a b testBit :: Const a b -> Int -> Bool bitSizeMaybe :: Const a b -> Maybe Int shiftL :: Const a b -> Int -> Const a b unsafeShiftL :: Const a b -> Int -> Const a b shiftR :: Const a b -> Int -> Const a b unsafeShiftR :: Const a b -> Int -> Const a b rotateL :: Const a b -> Int -> Const a b | |
(FromJSON a, FromJSONKey a) => FromJSONKey (Const a b) | |
Defined in Data.Aeson.Types.FromJSON fromJSONKey :: FromJSONKeyFunction (Const a b) fromJSONKeyList :: FromJSONKeyFunction [Const a b] | |
FiniteBits a => FiniteBits (Const a b) | |
Defined in Data.Functor.Const finiteBitSize :: Const a b -> Int countLeadingZeros :: Const a b -> Int countTrailingZeros :: Const a b -> Int | |
type Rep1 (Const a :: k -> Type) | |
Defined in Data.Functor.Const | |
newtype MVector s (Const a b) | |
Defined in Data.Vector.Unboxed.Base | |
type Rep (Const a b) | |
Defined in Data.Functor.Const | |
newtype Vector (Const a b) | |
Defined in Data.Vector.Unboxed.Base |
Instances
FromJSON Text | |
Defined in Data.Aeson.Types.FromJSON parseJSON :: Value -> Parser Text parseJSONList :: Value -> Parser [Text] | |
FromJSONKey Text | |
Defined in Data.Aeson.Types.FromJSON fromJSONKey :: FromJSONKeyFunction Text fromJSONKeyList :: FromJSONKeyFunction [Text] | |
Chunk Text | |
Defined in Data.Attoparsec.Internal.Types type ChunkElem Text pappendChunk :: State Text -> Text -> State Text atBufferEnd :: Text -> State Text -> Pos bufferElemAt :: Text -> Pos -> State Text -> Maybe (ChunkElem Text, Int) chunkElemToChar :: Text -> ChunkElem Text -> Char | |
type Item Text | |
type Index Text | |
Defined in Lens.Micro.Platform | |
type IxValue Text | |
Defined in Lens.Micro.Platform | |
type State Text | |
Defined in Data.Attoparsec.Internal.Types type State Text = Buffer | |
type ChunkElem Text | |
Defined in Data.Attoparsec.Internal.Types |
class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where #
Nothing
Instances
Instances
Eq2 Map | |
Ord2 Map | |
Defined in Data.Map.Internal | |
Show2 Map | |
Functor (Map k) | |
Foldable (Map k) | |
Defined in Data.Map.Internal fold :: Monoid m => Map k m -> m foldMap :: Monoid m => (a -> m) -> Map k a -> m # foldMap' :: Monoid m => (a -> m) -> Map k a -> m foldr :: (a -> b -> b) -> b -> Map k a -> b # foldr' :: (a -> b -> b) -> b -> Map k a -> b foldl :: (b -> a -> b) -> b -> Map k a -> b # foldl' :: (b -> a -> b) -> b -> Map k a -> b foldr1 :: (a -> a -> a) -> Map k a -> a # foldl1 :: (a -> a -> a) -> Map k a -> a # elem :: Eq a => a -> Map k a -> Bool # maximum :: Ord a => Map k a -> a # minimum :: Ord a => Map k a -> a # | |
Traversable (Map k) | |
Eq k => Eq1 (Map k) | |
Ord k => Ord1 (Map k) | |
Defined in Data.Map.Internal liftCompare :: (a -> b -> Ordering) -> Map k a -> Map k b -> Ordering | |
(Ord k, Read k) => Read1 (Map k) | |
Defined in Data.Map.Internal liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Map k a) liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Map k a] liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Map k a) liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Map k a] | |
Show k => Show1 (Map k) | |
Defined in Data.Map.Internal | |
(FromJSONKey k, Ord k) => FromJSON1 (Map k) | |
Defined in Data.Aeson.Types.FromJSON liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Map k a) liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Map k a] | |
Ord k => IsList (Map k v) | |
(Eq k, Eq a) => Eq (Map k a) | |
(Data k, Data a, Ord k) => Data (Map k a) | |
Defined in Data.Map.Internal gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Map k a -> c (Map k a) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Map k a) dataTypeOf :: Map k a -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Map k a)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Map k a)) gmapT :: (forall b. Data b => b -> b) -> Map k a -> Map k a gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Map k a -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Map k a -> r gmapQ :: (forall d. Data d => d -> u) -> Map k a -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Map k a -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Map k a -> m (Map k a) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Map k a -> m (Map k a) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Map k a -> m (Map k a) | |
(Ord k, Ord v) => Ord (Map k v) | |
(Ord k, Read k, Read e) => Read (Map k e) | |
(Show k, Show a) => Show (Map k a) | |
Ord k => Semigroup (Map k v) | |
Ord k => Monoid (Map k v) | |
(NFData k, NFData a) => NFData (Map k a) | |
Defined in Data.Map.Internal | |
(FromJSONKey k, Ord k, FromJSON v) => FromJSON (Map k v) | |
Defined in Data.Aeson.Types.FromJSON parseJSON :: Value -> Parser (Map k v) parseJSONList :: Value -> Parser [Map k v] | |
type Item (Map k v) | |
Defined in Data.Map.Internal type Item (Map k v) = (k, v) | |
type Index (Map k a) | |
Defined in Lens.Micro.GHC type Index (Map k a) = k | |
type IxValue (Map k a) | |
Defined in Lens.Micro.GHC type IxValue (Map k a) = a |
newtype StateT s (m :: Type -> Type) a #
Instances
MonadError e m => MonadError e (StateT s m) | |
Defined in Control.Monad.Error.Class throwError :: e -> StateT s m a # catchError :: StateT s m a -> (e -> StateT s m a) -> StateT s m a # | |
MonadReader r m => MonadReader r (StateT s m) | |
Monad m => MonadState s (StateT s m) | |
MonadTrans (StateT s) | |
Defined in Control.Monad.Trans.State.Lazy | |
Monad m => Monad (StateT s m) | |
Functor m => Functor (StateT s m) | |
MonadFix m => MonadFix (StateT s m) | |
Defined in Control.Monad.Trans.State.Lazy | |
MonadFail m => MonadFail (StateT s m) | |
Defined in Control.Monad.Trans.State.Lazy | |
(Functor m, Monad m) => Applicative (StateT s m) | |
Defined in Control.Monad.Trans.State.Lazy | |
MonadPlus m => MonadPlus (StateT s m) | |
(Functor m, MonadPlus m) => Alternative (StateT s m) | |
Contravariant m => Contravariant (StateT s m) | |
MonadIO m => MonadIO (StateT s m) | |
Defined in Control.Monad.Trans.State.Lazy |
class Applicative f => Alternative (f :: Type -> Type) where #
Instances
class Monad m => MonadIO (m :: Type -> Type) where #
Instances
MonadIO IO | |
Defined in Control.Monad.IO.Class | |
MonadIO m => MonadIO (StateT s m) | |
Defined in Control.Monad.Trans.State.Lazy | |
(Error e, MonadIO m) => MonadIO (ErrorT e m) | |
Defined in Control.Monad.Trans.Error | |
MonadIO m => MonadIO (ExceptT e m) | |
Defined in Control.Monad.Trans.Except | |
MonadIO m => MonadIO (ReaderT r m) | |
Defined in Control.Monad.Trans.Reader |
class MonadTrans (t :: (Type -> Type) -> Type -> Type) where #
Instances
MonadTrans (StateT s) | |
Defined in Control.Monad.Trans.State.Lazy | |
MonadTrans (ErrorT e) | |
Defined in Control.Monad.Trans.Error | |
MonadTrans (ExceptT e) | |
Defined in Control.Monad.Trans.Except | |
MonadTrans (ReaderT r) | |
Defined in Control.Monad.Trans.Reader |
(<**>) :: Applicative f => f a -> f (a -> b) -> f b #
liftA :: Applicative f => (a -> b) -> f a -> f b #
liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d #
liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r #
when :: Applicative f => Bool -> f () -> f () #
optional :: Alternative f => f a -> f (Maybe a) #
newtype WrappedArrow (a :: Type -> Type -> Type) b c #
WrapArrow | |
|
Instances
Generic1 (WrappedArrow a b :: Type -> Type) | |
Defined in Control.Applicative type Rep1 (WrappedArrow a b) :: k -> Type from1 :: forall (a0 :: k). WrappedArrow a b a0 -> Rep1 (WrappedArrow a b) a0 to1 :: forall (a0 :: k). Rep1 (WrappedArrow a b) a0 -> WrappedArrow a b a0 | |
Arrow a => Functor (WrappedArrow a b) | |
Defined in Control.Applicative fmap :: (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 # (<$) :: a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 # | |
Arrow a => Applicative (WrappedArrow a b) | |
Defined in Control.Applicative pure :: a0 -> WrappedArrow a b a0 # (<*>) :: WrappedArrow a b (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 # liftA2 :: (a0 -> b0 -> c) -> WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b c # (*>) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b b0 # (<*) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 # | |
(ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b) | |
Defined in Control.Applicative empty :: WrappedArrow a b a0 # (<|>) :: WrappedArrow a b a0 -> WrappedArrow a b a0 -> WrappedArrow a b a0 # some :: WrappedArrow a b a0 -> WrappedArrow a b [a0] # many :: WrappedArrow a b a0 -> WrappedArrow a b [a0] # | |
(Typeable a, Typeable b, Typeable c, Data (a b c)) => Data (WrappedArrow a b c) | |
Defined in Data.Data gfoldl :: (forall d b0. Data d => c0 (d -> b0) -> d -> c0 b0) -> (forall g. g -> c0 g) -> WrappedArrow a b c -> c0 (WrappedArrow a b c) gunfold :: (forall b0 r. Data b0 => c0 (b0 -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (WrappedArrow a b c) toConstr :: WrappedArrow a b c -> Constr dataTypeOf :: WrappedArrow a b c -> DataType dataCast1 :: Typeable t => (forall d. Data d => c0 (t d)) -> Maybe (c0 (WrappedArrow a b c)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c0 (t d e)) -> Maybe (c0 (WrappedArrow a b c)) gmapT :: (forall b0. Data b0 => b0 -> b0) -> WrappedArrow a b c -> WrappedArrow a b c gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WrappedArrow a b c -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WrappedArrow a b c -> r gmapQ :: (forall d. Data d => d -> u) -> WrappedArrow a b c -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> WrappedArrow a b c -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> WrappedArrow a b c -> m (WrappedArrow a b c) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WrappedArrow a b c -> m (WrappedArrow a b c) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WrappedArrow a b c -> m (WrappedArrow a b c) | |
Generic (WrappedArrow a b c) | |
Defined in Control.Applicative type Rep (WrappedArrow a b c) :: Type -> Type from :: WrappedArrow a b c -> Rep (WrappedArrow a b c) x to :: Rep (WrappedArrow a b c) x -> WrappedArrow a b c | |
type Rep1 (WrappedArrow a b :: Type -> Type) | |
Defined in Control.Applicative type Rep1 (WrappedArrow a b :: Type -> Type) = D1 ('MetaData "WrappedArrow" "Control.Applicative" "base" 'True) (C1 ('MetaCons "WrapArrow" 'PrefixI 'True) (S1 ('MetaSel ('Just "unwrapArrow") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 (a b)))) | |
type Rep (WrappedArrow a b c) | |
Defined in Control.Applicative type Rep (WrappedArrow a b c) = D1 ('MetaData "WrappedArrow" "Control.Applicative" "base" 'True) (C1 ('MetaCons "WrapArrow" 'PrefixI 'True) (S1 ('MetaSel ('Just "unwrapArrow") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (a b c)))) |
newtype WrappedMonad (m :: Type -> Type) a #
WrapMonad | |
|
Instances
Monad m => Monad (WrappedMonad m) | |
Defined in Control.Applicative (>>=) :: WrappedMonad m a -> (a -> WrappedMonad m b) -> WrappedMonad m b # (>>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b # return :: a -> WrappedMonad m a # | |
Monad m => Functor (WrappedMonad m) | |
Defined in Control.Applicative fmap :: (a -> b) -> WrappedMonad m a -> WrappedMonad m b # (<$) :: a -> WrappedMonad m b -> WrappedMonad m a # | |
Monad m => Applicative (WrappedMonad m) | |
Defined in Control.Applicative pure :: a -> WrappedMonad m a # (<*>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b # liftA2 :: (a -> b -> c) -> WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m c # (*>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b # (<*) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a # | |
MonadPlus m => Alternative (WrappedMonad m) | |
Defined in Control.Applicative empty :: WrappedMonad m a # (<|>) :: WrappedMonad m a -> WrappedMonad m a -> WrappedMonad m a # some :: WrappedMonad m a -> WrappedMonad m [a] # many :: WrappedMonad m a -> WrappedMonad m [a] # | |
Generic1 (WrappedMonad m :: Type -> Type) | |
Defined in Control.Applicative type Rep1 (WrappedMonad m) :: k -> Type from1 :: forall (a :: k). WrappedMonad m a -> Rep1 (WrappedMonad m) a to1 :: forall (a :: k). Rep1 (WrappedMonad m) a -> WrappedMonad m a | |
(Typeable m, Typeable a, Data (m a)) => Data (WrappedMonad m a) | |
Defined in Data.Data gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WrappedMonad m a -> c (WrappedMonad m a) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WrappedMonad m a) toConstr :: WrappedMonad m a -> Constr dataTypeOf :: WrappedMonad m a -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (WrappedMonad m a)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (WrappedMonad m a)) gmapT :: (forall b. Data b => b -> b) -> WrappedMonad m a -> WrappedMonad m a gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WrappedMonad m a -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WrappedMonad m a -> r gmapQ :: (forall d. Data d => d -> u) -> WrappedMonad m a -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> WrappedMonad m a -> u gmapM :: Monad m0 => (forall d. Data d => d -> m0 d) -> WrappedMonad m a -> m0 (WrappedMonad m a) gmapMp :: MonadPlus m0 => (forall d. Data d => d -> m0 d) -> WrappedMonad m a -> m0 (WrappedMonad m a) gmapMo :: MonadPlus m0 => (forall d. Data d => d -> m0 d) -> WrappedMonad m a -> m0 (WrappedMonad m a) | |
Generic (WrappedMonad m a) | |
Defined in Control.Applicative type Rep (WrappedMonad m a) :: Type -> Type from :: WrappedMonad m a -> Rep (WrappedMonad m a) x to :: Rep (WrappedMonad m a) x -> WrappedMonad m a | |
type Rep1 (WrappedMonad m :: Type -> Type) | |
Defined in Control.Applicative type Rep1 (WrappedMonad m :: Type -> Type) = D1 ('MetaData "WrappedMonad" "Control.Applicative" "base" 'True) (C1 ('MetaCons "WrapMonad" 'PrefixI 'True) (S1 ('MetaSel ('Just "unwrapMonad") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 m))) | |
type Rep (WrappedMonad m a) | |
Defined in Control.Applicative type Rep (WrappedMonad m a) = D1 ('MetaData "WrappedMonad" "Control.Applicative" "base" 'True) (C1 ('MetaCons "WrapMonad" 'PrefixI 'True) (S1 ('MetaSel ('Just "unwrapMonad") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (m a)))) |
ZipList | |
|
Instances
Functor ZipList | |
Applicative ZipList | |
Foldable ZipList | |
Defined in Control.Applicative fold :: Monoid m => ZipList m -> m foldMap :: Monoid m => (a -> m) -> ZipList a -> m # foldMap' :: Monoid m => (a -> m) -> ZipList a -> m foldr :: (a -> b -> b) -> b -> ZipList a -> b # foldr' :: (a -> b -> b) -> b -> ZipList a -> b foldl :: (b -> a -> b) -> b -> ZipList a -> b # foldl' :: (b -> a -> b) -> b -> ZipList a -> b foldr1 :: (a -> a -> a) -> ZipList a -> a # foldl1 :: (a -> a -> a) -> ZipList a -> a # elem :: Eq a => a -> ZipList a -> Bool # maximum :: Ord a => ZipList a -> a # minimum :: Ord a => ZipList a -> a # | |
Traversable ZipList | |
Alternative ZipList | |
Eq a => Eq (ZipList a) | |
Data a => Data (ZipList a) | |
Defined in Data.Data gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ZipList a -> c (ZipList a) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ZipList a) toConstr :: ZipList a -> Constr dataTypeOf :: ZipList a -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ZipList a)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ZipList a)) gmapT :: (forall b. Data b => b -> b) -> ZipList a -> ZipList a gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ZipList a -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ZipList a -> r gmapQ :: (forall d. Data d => d -> u) -> ZipList a -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> ZipList a -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> ZipList a -> m (ZipList a) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ZipList a -> m (ZipList a) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ZipList a -> m (ZipList a) | |
Ord a => Ord (ZipList a) | |
Defined in Control.Applicative | |
Read a => Read (ZipList a) | |
Show a => Show (ZipList a) | |
Generic (ZipList a) | |
Generic1 ZipList | |
type Rep (ZipList a) | |
Defined in Control.Applicative | |
type Rep1 ZipList | |
Defined in Control.Applicative |
filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a] #
forever :: Applicative f => f a -> f b #
mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c]) #
replicateM :: Applicative m => Int -> m a -> m [a] #
replicateM_ :: Applicative m => Int -> m a -> m () #
unless :: Applicative f => Bool -> f () -> f () #
zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c] #
zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m () #
forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b) #
liftEither :: MonadError e m => Either e a -> m a #
runExceptT :: ExceptT e m a -> m (Either e a) #
withExcept :: (e -> e') -> Except e a -> Except e' a #
withExceptT :: forall (m :: Type -> Type) e e' a. Functor m => (e -> e') -> ExceptT e m a -> ExceptT e' m a #
class Monad m => MonadError e (m :: Type -> Type) | m -> e where #
throwError :: e -> m a #
catchError :: m a -> (e -> m a) -> m a #
Instances
MonadError () Maybe | |
Defined in Control.Monad.Error.Class throwError :: () -> Maybe a # catchError :: Maybe a -> (() -> Maybe a) -> Maybe a # | |
MonadError IOException IO | |
Defined in Control.Monad.Error.Class throwError :: IOException -> IO a # catchError :: IO a -> (IOException -> IO a) -> IO a # | |
MonadError e m => MonadError e (MaybeT m) | |
Defined in Control.Monad.Error.Class throwError :: e -> MaybeT m a # catchError :: MaybeT m a -> (e -> MaybeT m a) -> MaybeT m a # | |
MonadError e m => MonadError e (ListT m) | |
Defined in Control.Monad.Error.Class throwError :: e -> ListT m a # catchError :: ListT m a -> (e -> ListT m a) -> ListT m a # | |
MonadError e (Either e) | |
Defined in Control.Monad.Error.Class throwError :: e -> Either e a # catchError :: Either e a -> (e -> Either e a) -> Either e a # | |
(Monoid w, MonadError e m) => MonadError e (WriterT w m) | |
Defined in Control.Monad.Error.Class throwError :: e -> WriterT w m a # catchError :: WriterT w m a -> (e -> WriterT w m a) -> WriterT w m a # | |
(Monoid w, MonadError e m) => MonadError e (WriterT w m) | |
Defined in Control.Monad.Error.Class throwError :: e -> WriterT w m a # catchError :: WriterT w m a -> (e -> WriterT w m a) -> WriterT w m a # | |
MonadError e m => MonadError e (StateT s m) | |
Defined in Control.Monad.Error.Class throwError :: e -> StateT s m a # catchError :: StateT s m a -> (e -> StateT s m a) -> StateT s m a # | |
MonadError e m => MonadError e (StateT s m) | |
Defined in Control.Monad.Error.Class throwError :: e -> StateT s m a # catchError :: StateT s m a -> (e -> StateT s m a) -> StateT s m a # | |
MonadError e m => MonadError e (ReaderT r m) | |
Defined in Control.Monad.Error.Class throwError :: e -> ReaderT r m a # catchError :: ReaderT r m a -> (e -> ReaderT r m a) -> ReaderT r m a # | |
MonadError e m => MonadError e (IdentityT m) | |
Defined in Control.Monad.Error.Class throwError :: e -> IdentityT m a # catchError :: IdentityT m a -> (e -> IdentityT m a) -> IdentityT m a # | |
Monad m => MonadError e (ExceptT e m) | |
Defined in Control.Monad.Error.Class throwError :: e -> ExceptT e m a # catchError :: ExceptT e m a -> (e -> ExceptT e m a) -> ExceptT e m a # | |
(Monad m, Error e) => MonadError e (ErrorT e m) | |
Defined in Control.Monad.Error.Class throwError :: e -> ErrorT e m a # catchError :: ErrorT e m a -> (e -> ErrorT e m a) -> ErrorT e m a # | |
(Monoid w, MonadError e m) => MonadError e (RWST r w s m) | |
Defined in Control.Monad.Error.Class throwError :: e -> RWST r w s m a # catchError :: RWST r w s m a -> (e -> RWST r w s m a) -> RWST r w s m a # | |
(Monoid w, MonadError e m) => MonadError e (RWST r w s m) | |
Defined in Control.Monad.Error.Class throwError :: e -> RWST r w s m a # catchError :: RWST r w s m a -> (e -> RWST r w s m a) -> RWST r w s m a # |
newtype ExceptT e (m :: Type -> Type) a #
Instances
Monad m => MonadError e (ExceptT e m) | |
Defined in Control.Monad.Error.Class throwError :: e -> ExceptT e m a # catchError :: ExceptT e m a -> (e -> ExceptT e m a) -> ExceptT e m a # | |
MonadReader r m => MonadReader r (ExceptT e m) | |
MonadState s m => MonadState s (ExceptT e m) | |
MonadTrans (ExceptT e) | |
Defined in Control.Monad.Trans.Except | |
Monad m => Monad (ExceptT e m) | |
Functor m => Functor (ExceptT e m) | |
MonadFix m => MonadFix (ExceptT e m) | |
Defined in Control.Monad.Trans.Except | |
MonadFail m => MonadFail (ExceptT e m) | |
Defined in Control.Monad.Trans.Except | |
(Functor m, Monad m) => Applicative (ExceptT e m) | |
Defined in Control.Monad.Trans.Except | |
Foldable f => Foldable (ExceptT e f) | |
Defined in Control.Monad.Trans.Except fold :: Monoid m => ExceptT e f m -> m foldMap :: Monoid m => (a -> m) -> ExceptT e f a -> m # foldMap' :: Monoid m => (a -> m) -> ExceptT e f a -> m foldr :: (a -> b -> b) -> b -> ExceptT e f a -> b # foldr' :: (a -> b -> b) -> b -> ExceptT e f a -> b foldl :: (b -> a -> b) -> b -> ExceptT e f a -> b # foldl' :: (b -> a -> b) -> b -> ExceptT e f a -> b foldr1 :: (a -> a -> a) -> ExceptT e f a -> a # foldl1 :: (a -> a -> a) -> ExceptT e f a -> a # toList :: ExceptT e f a -> [a] null :: ExceptT e f a -> Bool # length :: ExceptT e f a -> Int # elem :: Eq a => a -> ExceptT e f a -> Bool # maximum :: Ord a => ExceptT e f a -> a # minimum :: Ord a => ExceptT e f a -> a # | |
Traversable f => Traversable (ExceptT e f) | |
Defined in Control.Monad.Trans.Except | |
(Monad m, Monoid e) => MonadPlus (ExceptT e m) | |
MonadZip m => MonadZip (ExceptT e m) | |
(Eq e, Eq1 m) => Eq1 (ExceptT e m) | |
(Ord e, Ord1 m) => Ord1 (ExceptT e m) | |
Defined in Control.Monad.Trans.Except liftCompare :: (a -> b -> Ordering) -> ExceptT e m a -> ExceptT e m b -> Ordering | |
(Functor m, Monad m, Monoid e) => Alternative (ExceptT e m) | |
Contravariant m => Contravariant (ExceptT e m) | |
MonadIO m => MonadIO (ExceptT e m) | |
Defined in Control.Monad.Trans.Except | |
(Read e, Read1 m) => Read1 (ExceptT e m) | |
Defined in Control.Monad.Trans.Except liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (ExceptT e m a) liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [ExceptT e m a] liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (ExceptT e m a) liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [ExceptT e m a] | |
(Show e, Show1 m) => Show1 (ExceptT e m) | |
Defined in Control.Monad.Trans.Except | |
(Eq e, Eq1 m, Eq a) => Eq (ExceptT e m a) | |
(Ord e, Ord1 m, Ord a) => Ord (ExceptT e m a) | |
Defined in Control.Monad.Trans.Except compare :: ExceptT e m a -> ExceptT e m a -> Ordering # (<) :: ExceptT e m a -> ExceptT e m a -> Bool # (<=) :: ExceptT e m a -> ExceptT e m a -> Bool # (>) :: ExceptT e m a -> ExceptT e m a -> Bool # (>=) :: ExceptT e m a -> ExceptT e m a -> Bool # | |
(Read e, Read1 m, Read a) => Read (ExceptT e m a) | |
(Show e, Show1 m, Show a) => Show (ExceptT e m a) | |
asks :: MonadReader r m => (r -> a) -> m a #
mapReaderT :: (m a -> n b) -> ReaderT r m a -> ReaderT r n b #
withReader :: (r' -> r) -> Reader r a -> Reader r' a #
withReaderT :: forall r' r (m :: Type -> Type) a. (r' -> r) -> ReaderT r m a -> ReaderT r' m a #
class Monad m => MonadReader r (m :: Type -> Type) | m -> r where #
Instances
MonadReader r m => MonadReader r (MaybeT m) | |
MonadReader r m => MonadReader r (ListT m) | |
Monad m => MonadReader r (ReaderT r m) | |
(Monoid w, MonadReader r m) => MonadReader r (WriterT w m) | |
(Monoid w, MonadReader r m) => MonadReader r (WriterT w m) | |
MonadReader r m => MonadReader r (StateT s m) | |
MonadReader r m => MonadReader r (StateT s m) | |
MonadReader r m => MonadReader r (IdentityT m) | |
MonadReader r m => MonadReader r (ExceptT e m) | |
(Error e, MonadReader r m) => MonadReader r (ErrorT e m) | |
MonadReader r ((->) r :: Type -> Type) | |
MonadReader r' m => MonadReader r' (ContT r m) | |
(Monad m, Monoid w) => MonadReader r (RWST r w s m) | |
(Monad m, Monoid w) => MonadReader r (RWST r w s m) | |
newtype ReaderT r (m :: Type -> Type) a #
ReaderT | |
|
Instances
MonadError e m => MonadError e (ReaderT r m) | |
Defined in Control.Monad.Error.Class throwError :: e -> ReaderT r m a # catchError :: ReaderT r m a -> (e -> ReaderT r m a) -> ReaderT r m a # | |
Monad m => MonadReader r (ReaderT r m) | |
MonadState s m => MonadState s (ReaderT r m) | |
MonadTrans (ReaderT r) | |
Defined in Control.Monad.Trans.Reader | |
Monad m => Monad (ReaderT r m) | |
Functor m => Functor (ReaderT r m) | |
MonadFix m => MonadFix (ReaderT r m) | |
Defined in Control.Monad.Trans.Reader | |
MonadFail m => MonadFail (ReaderT r m) | |
Defined in Control.Monad.Trans.Reader | |
Applicative m => Applicative (ReaderT r m) | |
Defined in Control.Monad.Trans.Reader | |
MonadPlus m => MonadPlus (ReaderT r m) | |
MonadZip m => MonadZip (ReaderT r m) | |
Alternative m => Alternative (ReaderT r m) | |
Contravariant m => Contravariant (ReaderT r m) | |
MonadIO m => MonadIO (ReaderT r m) | |
Defined in Control.Monad.Trans.Reader |
gets :: MonadState s m => (s -> a) -> m a #
modify :: MonadState s m => (s -> s) -> m () #
modify' :: MonadState s m => (s -> s) -> m () #
evalStateT :: Monad m => StateT s m a -> s -> m a #
execStateT :: Monad m => StateT s m a -> s -> m s #
withStateT :: forall s (m :: Type -> Type) a. (s -> s) -> StateT s m a -> StateT s m a #
class Monad m => MonadState s (m :: Type -> Type) | m -> s where #
Instances
MonadState s m => MonadState s (MaybeT m) | |
MonadState s m => MonadState s (ListT m) | |
MonadState s m => MonadState s (ReaderT r m) | |
Monad m => MonadState s (StateT s m) | |
(Monoid w, MonadState s m) => MonadState s (WriterT w m) | |
(Monoid w, MonadState s m) => MonadState s (WriterT w m) | |
Monad m => MonadState s (StateT s m) | |
MonadState s m => MonadState s (IdentityT m) | |
MonadState s m => MonadState s (ExceptT e m) | |
(Error e, MonadState s m) => MonadState s (ErrorT e m) | |
MonadState s m => MonadState s (ContT r m) | |
(Monad m, Monoid w) => MonadState s (RWST r w s m) | |
(Monad m, Monoid w) => MonadState s (RWST r w s m) | |