| Safe Haskell | Trustworthy |
|---|---|
| Language | Haskell2010 |
Prelude.Compat
Documentation
(^^) :: (Fractional a, Integral b) => a -> b -> a #
fromIntegral :: (Integral a, Num b) => a -> b #
realToFrac :: (Real a, Fractional b) => a -> b #
showString :: String -> ShowS #
appendFile :: FilePath -> String -> IO () #
getContents :: IO String #
errorWithoutStackTrace :: forall (r :: RuntimeRep) (a :: TYPE r). [Char] -> a #
mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b) #
sequence :: (Traversable t, Monad m) => t (m a) -> m (t a) #
sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a) #
traverse :: (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b) #
(*>) :: Applicative f => f a -> f b -> f b #
(<*) :: Applicative f => f a -> f b -> f a #
(<*>) :: Applicative f => f (a -> b) -> f a -> f b #
pure :: Applicative f => a -> f a #
liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c #
enumFromThen :: Enum a => a -> a -> [a] #
enumFromThenTo :: Enum a => a -> a -> a -> [a] #
enumFromTo :: Enum a => a -> a -> [a] #
decodeFloat :: RealFloat a => a -> (Integer, Int) #
encodeFloat :: RealFloat a => Integer -> Int -> a #
floatDigits :: RealFloat a => a -> Int #
floatRadix :: RealFloat a => a -> Integer #
floatRange :: RealFloat a => a -> (Int, Int) #
isDenormalized :: RealFloat a => a -> Bool #
isInfinite :: RealFloat a => a -> Bool #
isNegativeZero :: RealFloat a => a -> Bool #
scaleFloat :: RealFloat a => Int -> a -> a #
significand :: RealFloat a => a -> a #
(/) :: Fractional a => a -> a -> a #
fromRational :: Fractional a => Rational -> a #
recip :: Fractional a => a -> a #
toRational :: Real a => a -> Rational #
properFraction :: (RealFrac a, Integral b) => a -> (b, a) #
class Functor f => Applicative (f :: Type -> Type) #
Instances
| Applicative ZipList | |
| Applicative Complex | |
| Applicative Identity | |
| Applicative First | |
| Applicative Last | |
| Applicative Down | |
| Applicative First | |
| Applicative Last | |
| Applicative Max | |
| Applicative Min | |
| Applicative Dual | |
| Applicative Product | |
| Applicative Sum | |
| Applicative STM | |
| Applicative Par1 | |
| Applicative P | |
| Applicative ReadP | |
| Applicative ReadPrec | |
| Applicative IO | |
| Applicative NonEmpty | |
| Applicative Maybe | |
| Applicative Solo | |
| Applicative [] | |
| Monad m => Applicative (WrappedMonad m) | |
Defined in Control.Applicative Methods 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 (ST s) | |
| Applicative (Either e) | |
| Applicative (Proxy :: Type -> Type) | |
| Applicative (U1 :: Type -> Type) | |
| Applicative (ST s) | |
| Monoid a => Applicative ((,) a) | |
| Arrow a => Applicative (WrappedArrow a b) | |
Defined in Control.Applicative Methods 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 # | |
| Monoid m => Applicative (Const m :: Type -> Type) | |
| Applicative f => Applicative (Ap f) | |
| Applicative f => Applicative (Alt f) | |
| Applicative f => Applicative (Rec1 f) | |
| (Monoid a, Monoid b) => Applicative ((,,) a b) | |
| (Applicative f, Applicative g) => Applicative (Product f g) | |
Defined in Data.Functor.Product | |
| (Applicative f, Applicative g) => Applicative (f :*: g) | |
| Monoid c => Applicative (K1 i c :: Type -> Type) | |
| (Monoid a, Monoid b, Monoid c) => Applicative ((,,,) a b c) | |
Defined in GHC.Base | |
| Applicative ((->) r) | |
| (Applicative f, Applicative g) => Applicative (Compose f g) | |
Defined in Data.Functor.Compose | |
| (Applicative f, Applicative g) => Applicative (f :.: g) | |
| Applicative f => Applicative (M1 i c f) | |
Instances
Instances
| Enum IntPtr | |
Defined in Foreign.Ptr | |
| Enum WordPtr | |
Defined in Foreign.Ptr Methods enumFrom :: WordPtr -> [WordPtr] # enumFromThen :: WordPtr -> WordPtr -> [WordPtr] # enumFromTo :: WordPtr -> WordPtr -> [WordPtr] # enumFromThenTo :: WordPtr -> WordPtr -> WordPtr -> [WordPtr] # | |
| Enum Associativity | |
Defined in GHC.Generics Methods 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 Methods 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 Methods 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 Methods 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] # | |
| Enum SeekMode | |
Defined in GHC.IO.Device Methods 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 Int16 | |
| Enum Int32 | |
| Enum Int64 | |
| Enum Int8 | |
| Enum Word16 | |
Defined in GHC.Word | |
| Enum Word32 | |
Defined in GHC.Word | |
| Enum Word64 | |
Defined in GHC.Word | |
| Enum Word8 | |
| Enum Ordering | |
| Enum Integer | |
| Enum Natural | |
Defined in GHC.Enum Methods enumFrom :: Natural -> [Natural] # enumFromThen :: Natural -> Natural -> [Natural] # enumFromTo :: Natural -> Natural -> [Natural] # enumFromThenTo :: Natural -> Natural -> Natural -> [Natural] # | |
| Enum () | |
| Enum Bool | |
| Enum Char | |
| Enum Int | |
| Enum Levity | |
Defined in GHC.Enum | |
| Enum VecCount | |
Defined in GHC.Enum Methods 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 Methods enumFrom :: VecElem -> [VecElem] # enumFromThen :: VecElem -> VecElem -> [VecElem] # enumFromTo :: VecElem -> VecElem -> [VecElem] # enumFromThenTo :: VecElem -> VecElem -> VecElem -> [VecElem] # | |
| Enum Word | |
| Enum a => Enum (And a) | |
| Enum a => Enum (Iff a) | |
| Enum a => Enum (Ior a) | |
| Enum a => Enum (Xor a) | |
| Enum a => Enum (Identity a) | |
Defined in Data.Functor.Identity Methods 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 (First a) | |
| Enum a => Enum (Last a) | |
Defined in Data.Semigroup | |
| Enum a => Enum (Max a) | |
| Enum a => Enum (Min a) | |
| Enum a => Enum (WrappedMonoid a) | |
Defined in Data.Semigroup Methods 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] # | |
| Integral a => Enum (Ratio a) | |
Defined in GHC.Real Methods 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 (a) | |
| Enum (Proxy s) | |
Defined in Data.Proxy Methods 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 Methods 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 (Ap f a) | |
Defined in Data.Monoid | |
| Enum (f a) => Enum (Alt f a) | |
| Coercible a b => Enum (Coercion a b) | |
Defined in Data.Type.Coercion Methods succ :: Coercion a b -> Coercion a b # pred :: Coercion a b -> Coercion a b # toEnum :: Int -> Coercion a b # fromEnum :: Coercion a b -> Int # enumFrom :: Coercion a b -> [Coercion a b] # enumFromThen :: Coercion a b -> Coercion a b -> [Coercion a b] # enumFromTo :: Coercion a b -> Coercion a b -> [Coercion a b] # enumFromThenTo :: Coercion a b -> Coercion a b -> Coercion a b -> [Coercion a b] # | |
| a ~ b => Enum (a :~: b) | |
Defined in Data.Type.Equality Methods succ :: (a :~: b) -> a :~: b # pred :: (a :~: b) -> a :~: b # fromEnum :: (a :~: b) -> Int # enumFrom :: (a :~: b) -> [a :~: b] # enumFromThen :: (a :~: b) -> (a :~: b) -> [a :~: b] # enumFromTo :: (a :~: b) -> (a :~: b) -> [a :~: b] # enumFromThenTo :: (a :~: b) -> (a :~: b) -> (a :~: b) -> [a :~: b] # | |
| a ~~ b => Enum (a :~~: b) | |
Defined in Data.Type.Equality Methods succ :: (a :~~: b) -> a :~~: b # pred :: (a :~~: b) -> a :~~: b # fromEnum :: (a :~~: b) -> Int # enumFrom :: (a :~~: b) -> [a :~~: b] # enumFromThen :: (a :~~: b) -> (a :~~: b) -> [a :~~: b] # enumFromTo :: (a :~~: b) -> (a :~~: b) -> [a :~~: b] # enumFromThenTo :: (a :~~: b) -> (a :~~: b) -> (a :~~: b) -> [a :~~: b] # | |
Instances
| Eq All | |
| Eq Any | |
| Eq SomeTypeRep | |
| Eq Version | |
| Eq Void | |
| Eq IntPtr | |
| Eq WordPtr | |
| Eq BlockReason | |
| Eq ThreadId | |
| Eq ThreadStatus | |
| Eq ErrorCall | |
| Eq ArithException | |
| Eq Associativity | |
| Eq DecidedStrictness | |
| Eq Fixity | |
| Eq SourceStrictness | |
| Eq SourceUnpackedness | |
| Eq MaskingState | |
| Eq IODeviceType | |
| Eq SeekMode | |
| Eq CodingProgress | |
| Eq ArrayException | |
| Eq AsyncException | |
| Eq ExitCode | |
| Eq IOErrorType | |
| Eq IOException | |
| Eq HandlePosn | |
| Eq BufferMode | |
| Eq Handle | |
| Eq Newline | |
| Eq NewlineMode | |
| Eq IOMode | |
| Eq Int16 | |
| Eq Int32 | |
| Eq Int64 | |
| Eq Int8 | |
| Eq SrcLoc | |
| Eq Word16 | |
| Eq Word32 | |
| Eq Word64 | |
| Eq Word8 | |
| Eq Lexeme | |
| Eq Number | |
| Eq Module | |
| Eq Ordering | |
| Eq TrName | |
| Eq TyCon | |
| Eq Integer | |
| Eq Natural | |
| Eq () | |
| Eq Bool | |
| Eq Char | |
| Eq Double | |
| Eq Float | |
| Eq Int | |
| Eq Word | |
| Eq a => Eq (ZipList a) | |
| Eq (Chan a) | |
| Eq a => Eq (And a) | |
| Eq a => Eq (Iff a) | |
| Eq a => Eq (Ior a) | |
| Eq a => Eq (Xor a) | |
| Eq a => Eq (Complex a) | |
| Eq a => Eq (Identity a) | |
| Eq a => Eq (First a) | |
| Eq a => Eq (Last a) | |
| Eq a => Eq (Down 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) | |
Defined in Data.Semigroup Methods (==) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (/=) :: WrappedMonoid m -> WrappedMonoid m -> Bool # | |
| Eq a => Eq (Dual a) | |
| Eq a => Eq (Product a) | |
| Eq a => Eq (Sum a) | |
| Eq (TVar a) | |
| Eq (ForeignPtr a) | |
Defined in GHC.ForeignPtr | |
| Eq p => Eq (Par1 p) | |
| Eq (IORef a) | |
| Eq (MVar a) | |
| Eq (FunPtr a) | |
| Eq (Ptr a) | |
| Eq a => Eq (Ratio a) | |
| Eq (StablePtr a) | |
| Eq a => Eq (NonEmpty a) | |
| Eq a => Eq (Maybe a) | |
| Eq a => Eq (a) | |
| Eq a => Eq [a] | |
| (Eq a, Eq b) => Eq (Either a b) | |
| Eq (Proxy s) | |
| Eq a => Eq (Arg a b) | |
| Eq (TypeRep a) | |
| (Ix i, Eq e) => Eq (Array i e) | |
| Eq (U1 p) | |
| Eq (V1 p) | |
| Eq (STRef s a) | |
| (Eq a, Eq b) => Eq (a, b) | |
| Eq a => Eq (Const a b) | |
| Eq (f a) => Eq (Ap f a) | |
| Eq (f a) => Eq (Alt f a) | |
| Eq (Coercion a b) | |
| Eq (a :~: b) | |
| Eq (STArray s i e) | |
| 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) | |
| (Eq1 f, Eq1 g, Eq a) => Eq (Product f g a) | |
| (Eq1 f, Eq1 g, Eq a) => Eq (Sum f g a) | |
| Eq (a :~~: b) | |
| (Eq (f p), Eq (g p)) => Eq ((f :*: g) p) | |
| (Eq (f p), Eq (g p)) => Eq ((f :+: g) p) | |
| Eq c => Eq (K1 i c p) | |
| (Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d) | |
| (Eq1 f, Eq1 g, Eq a) => Eq (Compose f g a) | |
| Eq (f (g p)) => Eq ((f :.: g) p) | |
| Eq (f p) => Eq (M1 i c f 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 #
Minimal complete definition
pi, exp, log, sin, cos, asin, acos, atan, sinh, cosh, asinh, acosh, atanh
Instances
| Floating Double | |
| Floating Float | |
| RealFloat a => Floating (Complex a) | |
Defined in Data.Complex Methods exp :: Complex a -> Complex a # log :: Complex a -> Complex a # sqrt :: Complex a -> Complex a # (**) :: Complex a -> Complex a -> Complex a # logBase :: Complex a -> Complex a -> Complex a # sin :: Complex a -> Complex a # cos :: Complex a -> Complex a # tan :: Complex a -> Complex a # asin :: Complex a -> Complex a # acos :: Complex a -> Complex a # atan :: Complex a -> Complex a # sinh :: Complex a -> Complex a # cosh :: Complex a -> Complex a # tanh :: Complex a -> Complex a # asinh :: Complex a -> Complex a # acosh :: Complex a -> Complex a # atanh :: Complex a -> Complex a # log1p :: Complex a -> Complex a expm1 :: Complex a -> Complex a log1pexp :: Complex a -> Complex a log1mexp :: Complex a -> Complex a | |
| Floating a => Floating (Identity a) | |
Defined in Data.Functor.Identity Methods 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 (Op a b) | |
| Floating a => Floating (Const a b) | |
Defined in Data.Functor.Const Methods 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 Foldable (t :: TYPE LiftedRep -> Type) #
Instances
| Foldable ZipList | |
Defined in Control.Applicative Methods 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 # toList :: ZipList a -> [a] elem :: Eq a => a -> ZipList a -> Bool # maximum :: Ord a => ZipList a -> a # minimum :: Ord a => ZipList a -> a # | |
| Foldable Complex | |
Defined in Data.Complex Methods fold :: Monoid m => Complex m -> m foldMap :: Monoid m => (a -> m) -> Complex a -> m # foldMap' :: Monoid m => (a -> m) -> Complex a -> m foldr :: (a -> b -> b) -> b -> Complex a -> b # foldr' :: (a -> b -> b) -> b -> Complex a -> b foldl :: (b -> a -> b) -> b -> Complex a -> b # foldl' :: (b -> a -> b) -> b -> Complex a -> b foldr1 :: (a -> a -> a) -> Complex a -> a # foldl1 :: (a -> a -> a) -> Complex a -> a # toList :: Complex a -> [a] elem :: Eq a => a -> Complex a -> Bool # maximum :: Ord a => Complex a -> a # minimum :: Ord a => Complex a -> a # | |
| Foldable Identity | |
Defined in Data.Functor.Identity Methods 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 First | |
Defined in Data.Foldable Methods 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 # 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 Methods 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 # elem :: Eq a => a -> Last a -> Bool # maximum :: Ord a => Last a -> a # | |
| Foldable Down | |
Defined in Data.Foldable Methods 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.Semigroup Methods 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 # 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 Methods 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 # elem :: Eq a => a -> Last a -> Bool # maximum :: Ord a => Last a -> a # | |
| Foldable Max | |
Defined in Data.Semigroup Methods 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 # elem :: Eq a => a -> Max a -> Bool # maximum :: Ord a => Max a -> a # | |
| Foldable Min | |
Defined in Data.Semigroup Methods 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 # elem :: Eq a => a -> Min a -> Bool # maximum :: Ord a => Min a -> a # | |
| Foldable Dual | |
Defined in Data.Foldable Methods 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 # elem :: Eq a => a -> Dual a -> Bool # maximum :: Ord a => Dual a -> a # | |
| Foldable Product | |
Defined in Data.Foldable Methods 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 # 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 Methods 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 # elem :: Eq a => a -> Sum a -> Bool # maximum :: Ord a => Sum a -> a # | |
| Foldable Par1 | |
Defined in Data.Foldable Methods 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 NonEmpty | |
Defined in Data.Foldable Methods 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 # elem :: Eq a => a -> NonEmpty a -> Bool # maximum :: Ord a => NonEmpty a -> a # minimum :: Ord a => NonEmpty a -> a # | |
| Foldable Maybe | |
Defined in Data.Foldable Methods 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 Solo | |
Defined in Data.Foldable Methods fold :: Monoid m => Solo m -> m foldMap :: Monoid m => (a -> m) -> Solo a -> m # foldMap' :: Monoid m => (a -> m) -> Solo a -> m foldr :: (a -> b -> b) -> b -> Solo a -> b # foldr' :: (a -> b -> b) -> b -> Solo a -> b foldl :: (b -> a -> b) -> b -> Solo a -> b # foldl' :: (b -> a -> b) -> b -> Solo a -> b foldr1 :: (a -> a -> a) -> Solo a -> a # foldl1 :: (a -> a -> a) -> Solo a -> a # elem :: Eq a => a -> Solo a -> Bool # maximum :: Ord a => Solo a -> a # | |
| Foldable [] | |
Defined in Data.Foldable Methods 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 (Either a) | |
Defined in Data.Foldable Methods 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 (Proxy :: TYPE LiftedRep -> Type) | |
Defined in Data.Foldable Methods 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 (Arg a) | |
Defined in Data.Semigroup Methods 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 # elem :: Eq a0 => a0 -> Arg a a0 -> Bool # maximum :: Ord a0 => Arg a a0 -> a0 # minimum :: Ord a0 => Arg a a0 -> a0 # | |
| Foldable (Array i) | |
Defined in Data.Foldable Methods 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 (U1 :: TYPE LiftedRep -> Type) | |
Defined in Data.Foldable Methods 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 LiftedRep -> Type) | |
Defined in Data.Foldable Methods 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 LiftedRep -> Type) | |
Defined in Data.Foldable Methods 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 LiftedRep -> Type) | |
Defined in Data.Foldable Methods 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 LiftedRep -> Type) | |
Defined in Data.Foldable Methods 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 LiftedRep -> Type) | |
Defined in Data.Foldable Methods 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 LiftedRep -> Type) | |
Defined in Data.Foldable Methods 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 (V1 :: TYPE LiftedRep -> Type) | |
Defined in Data.Foldable Methods 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 ((,) a) | |
Defined in Data.Foldable Methods 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 (Const m :: TYPE LiftedRep -> Type) | |
Defined in Data.Functor.Const Methods 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 (Ap f) | |
Defined in Data.Foldable Methods 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 # elem :: Eq a => a -> Ap f a -> Bool # maximum :: Ord a => Ap f a -> a # | |
| Foldable f => Foldable (Alt f) | |
Defined in Data.Foldable Methods 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 # 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 (Rec1 f) | |
Defined in Data.Foldable Methods 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 f, Foldable g) => Foldable (Product f g) | |
Defined in Data.Functor.Product Methods fold :: Monoid m => Product f g m -> m foldMap :: Monoid m => (a -> m) -> Product f g a -> m # foldMap' :: Monoid m => (a -> m) -> Product f g a -> m foldr :: (a -> b -> b) -> b -> Product f g a -> b # foldr' :: (a -> b -> b) -> b -> Product f g a -> b foldl :: (b -> a -> b) -> b -> Product f g a -> b # foldl' :: (b -> a -> b) -> b -> Product f g a -> b foldr1 :: (a -> a -> a) -> Product f g a -> a # foldl1 :: (a -> a -> a) -> Product f g a -> a # toList :: Product f g a -> [a] null :: Product f g a -> Bool # length :: Product f g a -> Int # elem :: Eq a => a -> Product f g a -> Bool # maximum :: Ord a => Product f g a -> a # minimum :: Ord a => Product f g a -> a # | |
| (Foldable f, Foldable g) => Foldable (Sum f g) | |
Defined in Data.Functor.Sum Methods fold :: Monoid m => Sum f g m -> m foldMap :: Monoid m => (a -> m) -> Sum f g a -> m # foldMap' :: Monoid m => (a -> m) -> Sum f g a -> m foldr :: (a -> b -> b) -> b -> Sum f g a -> b # foldr' :: (a -> b -> b) -> b -> Sum f g a -> b foldl :: (b -> a -> b) -> b -> Sum f g a -> b # foldl' :: (b -> a -> b) -> b -> Sum f g a -> b foldr1 :: (a -> a -> a) -> Sum f g a -> a # foldl1 :: (a -> a -> a) -> Sum f g a -> a # toList :: Sum f g a -> [a] elem :: Eq a => a -> Sum f g a -> Bool # maximum :: Ord a => Sum f g a -> a # minimum :: Ord a => Sum f g a -> a # | |
| (Foldable f, Foldable g) => Foldable (f :*: g) | |
Defined in Data.Foldable Methods 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 Methods 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 (K1 i c :: TYPE LiftedRep -> Type) | |
Defined in Data.Foldable Methods 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 (Compose f g) | |
Defined in Data.Functor.Compose Methods fold :: Monoid m => Compose f g m -> m foldMap :: Monoid m => (a -> m) -> Compose f g a -> m # foldMap' :: Monoid m => (a -> m) -> Compose f g a -> m foldr :: (a -> b -> b) -> b -> Compose f g a -> b # foldr' :: (a -> b -> b) -> b -> Compose f g a -> b foldl :: (b -> a -> b) -> b -> Compose f g a -> b # foldl' :: (b -> a -> b) -> b -> Compose f g a -> b foldr1 :: (a -> a -> a) -> Compose f g a -> a # foldl1 :: (a -> a -> a) -> Compose f g a -> a # toList :: Compose f g a -> [a] null :: Compose f g a -> Bool # length :: Compose f g a -> Int # elem :: Eq a => a -> Compose f g a -> Bool # maximum :: Ord a => Compose f g a -> a # minimum :: Ord a => Compose f g a -> a # | |
| (Foldable f, Foldable g) => Foldable (f :.: g) | |
Defined in Data.Foldable Methods 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 Methods 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 # | |
class Num a => Fractional a #
Minimal complete definition
fromRational, (recip | (/))
Instances
| RealFloat a => Fractional (Complex a) | |
Defined in Data.Complex | |
| Fractional a => Fractional (Identity a) | |
Defined in Data.Functor.Identity | |
| Fractional a => Fractional (Down a) | |
| Integral a => Fractional (Ratio a) | |
| Fractional a => Fractional (Op a b) | |
Defined in Data.Functor.Contravariant | |
| Fractional a => Fractional (Const a b) | |
class Functor (f :: Type -> Type) #
Minimal complete definition
Instances
| Functor ZipList | |
Defined in Control.Applicative | |
| Functor Handler | |
Defined in Control.Exception | |
| Functor Complex | |
Defined in Data.Complex | |
| Functor Identity | |
Defined in Data.Functor.Identity | |
| Functor First | |
| Functor Last | |
| Functor Down | |
| Functor First | |
| Functor Last | |
| Functor Max | |
| Functor Min | |
| Functor Dual | |
| Functor Product | |
| Functor Sum | |
| Functor STM | |
Defined in GHC.Conc.Sync | |
| Functor Par1 | |
Defined in GHC.Generics | |
| Functor P | |
Defined in Text.ParserCombinators.ReadP | |
| Functor ReadP | |
Defined in Text.ParserCombinators.ReadP | |
| Functor ReadPrec | |
Defined in Text.ParserCombinators.ReadPrec | |
| Functor IO | |
| Functor NonEmpty | |
| Functor Maybe | |
| Functor Solo | |
| Functor [] | |
| Monad m => Functor (WrappedMonad m) | |
Defined in Control.Applicative | |
| Functor (ST s) | |
Defined in Control.Monad.ST.Lazy.Imp | |
| Functor (Either a) | |
| Functor (Proxy :: Type -> Type) | |
Defined in Data.Proxy | |
| Functor (Arg a) | |
| Functor (Array i) | |
| Functor (U1 :: Type -> Type) | |
Defined in GHC.Generics | |
| Functor (V1 :: TYPE LiftedRep -> Type) | |
Defined in GHC.Generics | |
| Functor (ST s) | |
| Functor ((,) a) | |
| Arrow a => Functor (WrappedArrow a b) | |
Defined in Control.Applicative | |
| Functor (Const m :: Type -> Type) | |
| Functor f => Functor (Ap f) | |
| Functor f => Functor (Alt f) | |
| Functor f => Functor (Rec1 f) | |
Defined in GHC.Generics | |
| Functor (URec (Ptr ()) :: TYPE LiftedRep -> Type) | |
Defined in GHC.Generics | |
| Functor (URec Char :: TYPE LiftedRep -> Type) | |
| Functor (URec Double :: TYPE LiftedRep -> Type) | |
| Functor (URec Float :: TYPE LiftedRep -> Type) | |
| Functor (URec Int :: TYPE LiftedRep -> Type) | |
| Functor (URec Word :: TYPE LiftedRep -> Type) | |
| Functor ((,,) a b) | |
| (Functor f, Functor g) => Functor (Product f g) | |
Defined in Data.Functor.Product | |
| (Functor f, Functor g) => Functor (Sum f g) | |
Defined in Data.Functor.Sum | |
| (Functor f, Functor g) => Functor (f :*: g) | |
Defined in GHC.Generics | |
| (Functor f, Functor g) => Functor (f :+: g) | |
Defined in GHC.Generics | |
| Functor (K1 i c :: TYPE LiftedRep -> Type) | |
Defined in GHC.Generics | |
| Functor ((,,,) a b c) | |
| Functor ((->) r) | |
| (Functor f, Functor g) => Functor (Compose f g) | |
Defined in Data.Functor.Compose | |
| (Functor f, Functor g) => Functor (f :.: g) | |
Defined in GHC.Generics | |
| Functor f => Functor (M1 i c f) | |
Defined in GHC.Generics | |
class (Real a, Enum a) => Integral a #
Instances
| Integral IntPtr | |
Defined in Foreign.Ptr | |
| Integral WordPtr | |
Defined in Foreign.Ptr | |
| Integral Int16 | |
| Integral Int32 | |
| Integral Int64 | |
| Integral Int8 | |
| Integral Word16 | |
| Integral Word32 | |
| Integral Word64 | |
| Integral Word8 | |
| Integral Integer | |
Defined in GHC.Real | |
| Integral Natural | |
Defined in GHC.Real | |
| Integral Int | |
| Integral Word | |
| Integral a => Integral (Identity a) | |
Defined in Data.Functor.Identity Methods 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 (Const a b) | |
Defined in Data.Functor.Const Methods quot :: Const a b -> Const a b -> Const a b # rem :: Const a b -> Const a b -> Const a b # div :: Const a b -> Const a b -> Const a b # mod :: Const a b -> Const a b -> Const a b # quotRem :: Const a b -> Const a b -> (Const a b, Const a b) # divMod :: Const a b -> Const a b -> (Const a b, Const a b) # | |
class Applicative m => Monad (m :: Type -> Type) #
Minimal complete definition
Instances
| Monad Complex | |
| Monad Identity | |
| Monad First | |
| Monad Last | |
| Monad Down | |
| Monad First | |
| Monad Last | |
| Monad Max | |
| Monad Min | |
| Monad Dual | |
| Monad Product | |
| Monad Sum | |
| Monad STM | |
| Monad Par1 | |
| Monad P | |
| Monad ReadP | |
| Monad ReadPrec | |
| Monad IO | |
| Monad NonEmpty | |
| Monad Maybe | |
| Monad Solo | |
| Monad [] | |
| Monad m => Monad (WrappedMonad m) | |
| Monad (ST s) | |
| Monad (Either e) | |
| Monad (Proxy :: Type -> Type) | |
| Monad (U1 :: Type -> Type) | |
| Monad (ST s) | |
| Monoid a => Monad ((,) a) | |
| Monad f => Monad (Ap f) | |
| Monad f => Monad (Alt f) | |
| Monad f => Monad (Rec1 f) | |
| (Monoid a, Monoid b) => Monad ((,,) a b) | |
| (Monad f, Monad g) => Monad (Product f g) | |
| (Monad f, Monad g) => Monad (f :*: g) | |
| (Monoid a, Monoid b, Monoid c) => Monad ((,,,) a b c) | |
| Monad ((->) r) | |
| Monad f => Monad (M1 i c f) | |
class Monad m => MonadFail (m :: Type -> Type) #
Minimal complete definition
Instances
| MonadFail P | |
Defined in Text.ParserCombinators.ReadP | |
| MonadFail ReadP | |
Defined in Text.ParserCombinators.ReadP | |
| MonadFail ReadPrec | |
Defined in Text.ParserCombinators.ReadPrec | |
| MonadFail IO | |
Defined in Control.Monad.Fail | |
| MonadFail Maybe | |
Defined in Control.Monad.Fail | |
| MonadFail [] | |
Defined in Control.Monad.Fail | |
| MonadFail (ST s) | |
Defined in Control.Monad.ST.Lazy.Imp | |
| MonadFail (ST s) | |
| MonadFail f => MonadFail (Ap f) | |
Defined in Data.Monoid | |
class Semigroup a => Monoid a #
Minimal complete definition
Instances
| Monoid All | |
| Monoid Any | |
| Monoid Ordering | |
| Monoid () | |
| FiniteBits a => Monoid (And a) | |
| FiniteBits a => Monoid (Iff a) | |
| Bits a => Monoid (Ior a) | |
| Bits a => Monoid (Xor a) | |
| Monoid (Comparison a) | |
| Monoid (Equivalence a) | |
| Monoid (Predicate a) | |
| Monoid a => Monoid (Identity a) | |
| Monoid (First a) | |
| Monoid (Last a) | |
| Monoid a => Monoid (Down a) | |
| (Ord a, Bounded a) => Monoid (Max a) | |
| (Ord a, Bounded a) => Monoid (Min a) | |
| Monoid m => Monoid (WrappedMonoid m) | |
Defined in Data.Semigroup Methods mempty :: WrappedMonoid m # mappend :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # mconcat :: [WrappedMonoid m] -> WrappedMonoid m # | |
| Monoid a => Monoid (Dual a) | |
| Monoid (Endo a) | |
| Num a => Monoid (Product a) | |
| Num a => Monoid (Sum a) | |
| Monoid p => Monoid (Par1 p) | |
| Monoid a => Monoid (IO a) | |
| Semigroup a => Monoid (Maybe a) | |
| Monoid a => Monoid (a) | |
| Monoid [a] | |
| Monoid a => Monoid (Op a b) | |
| Monoid (Proxy s) | |
| Monoid (U1 p) | |
| Monoid a => Monoid (ST s a) | |
| Monoid b => Monoid (a -> b) | |
| (Monoid a, Monoid b) => Monoid (a, b) | |
| Monoid a => Monoid (Const a b) | |
| (Applicative f, Monoid a) => Monoid (Ap f a) | |
| Alternative f => Monoid (Alt f a) | |
| Monoid (f p) => Monoid (Rec1 f p) | |
| (Monoid a, Monoid b, Monoid c) => Monoid (a, b, c) | |
| (Monoid (f a), Monoid (g a)) => Monoid (Product f g a) | |
| (Monoid (f p), Monoid (g p)) => Monoid ((f :*: g) p) | |
| Monoid c => Monoid (K1 i c p) | |
| (Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d) | |
| Monoid (f (g a)) => Monoid (Compose f g a) | |
| Monoid (f (g p)) => Monoid ((f :.: g) p) | |
| Monoid (f p) => Monoid (M1 i c f p) | |
| (Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e) | |
Methods
fromInteger :: Integer -> a #
Instances
| Num IntPtr | |
| Num WordPtr | |
| Num Int16 | |
| Num Int32 | |
| Num Int64 | |
| Num Int8 | |
| Num Word16 | |
| Num Word32 | |
| Num Word64 | |
| Num Word8 | |
| Num Integer | |
| Num Natural | |
| Num Int | |
| Num Word | |
| RealFloat a => Num (Complex a) | |
| Num a => Num (Identity a) | |
Defined in Data.Functor.Identity | |
| Num a => Num (Down a) | |
| Num a => Num (Max a) | |
| Num a => Num (Min a) | |
| Num a => Num (Product a) | |
Defined in Data.Semigroup.Internal | |
| Num a => Num (Sum a) | |
| Integral a => Num (Ratio a) | |
| Num a => Num (Op a b) | |
| Num a => Num (Const a b) | |
Defined in Data.Functor.Const | |
| (Applicative f, Num a) => Num (Ap f a) | |
| Num (f a) => Num (Alt f a) | |
Instances
| Ord All | |
| Ord Any | |
| Ord SomeTypeRep | |
Defined in Data.Typeable.Internal | |
| Ord Version | |
| Ord Void | |
| Ord IntPtr | |
| Ord WordPtr | |
| Ord BlockReason | |
Defined in GHC.Conc.Sync | |
| Ord ThreadId | |
Defined in GHC.Conc.Sync | |
| Ord ThreadStatus | |
Defined in GHC.Conc.Sync | |
| Ord ErrorCall | |
| Ord ArithException | |
Defined in GHC.Exception.Type Methods compare :: ArithException -> ArithException -> Ordering # (<) :: ArithException -> ArithException -> Bool # (<=) :: ArithException -> ArithException -> Bool # (>) :: ArithException -> ArithException -> Bool # (>=) :: ArithException -> ArithException -> Bool # | |
| Ord Associativity | |
Defined in GHC.Generics Methods compare :: Associativity -> Associativity -> Ordering # (<) :: Associativity -> Associativity -> Bool # (<=) :: Associativity -> Associativity -> Bool # (>) :: Associativity -> Associativity -> Bool # (>=) :: Associativity -> Associativity -> Bool # | |
| Ord DecidedStrictness | |
Defined in GHC.Generics Methods 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 Methods 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 Methods 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 SeekMode | |
Defined in GHC.IO.Device | |
| Ord ArrayException | |
Defined in GHC.IO.Exception Methods compare :: ArrayException -> ArrayException -> Ordering # (<) :: ArrayException -> ArrayException -> Bool # (<=) :: ArrayException -> ArrayException -> Bool # (>) :: ArrayException -> ArrayException -> Bool # (>=) :: ArrayException -> ArrayException -> Bool # | |
| Ord AsyncException | |
Defined in GHC.IO.Exception Methods compare :: AsyncException -> AsyncException -> Ordering # (<) :: AsyncException -> AsyncException -> Bool # (<=) :: AsyncException -> AsyncException -> Bool # (>) :: AsyncException -> AsyncException -> Bool # (>=) :: AsyncException -> AsyncException -> Bool # | |
| Ord ExitCode | |
Defined in GHC.IO.Exception | |
| Ord BufferMode | |
Defined in GHC.IO.Handle.Types | |
| Ord Newline | |
| Ord NewlineMode | |
Defined in GHC.IO.Handle.Types | |
| Ord IOMode | |
| Ord Int16 | |
| Ord Int32 | |
| Ord Int64 | |
| Ord Int8 | |
| Ord Word16 | |
| Ord Word32 | |
| Ord Word64 | |
| Ord Word8 | |
| Ord Ordering | |
Defined in GHC.Classes | |
| Ord TyCon | |
| Ord Integer | |
| Ord Natural | |
| Ord () | |
| Ord Bool | |
| Ord Char | |
| Ord Double | |
| Ord Float | |
| Ord Int | |
| Ord Word | |
| Ord a => Ord (ZipList a) | |
| Ord a => Ord (Identity a) | |
Defined in Data.Functor.Identity | |
| Ord a => Ord (First a) | |
| Ord a => Ord (Last a) | |
| Ord a => Ord (Down 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 Methods 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 (Dual a) | |
| Ord a => Ord (Product a) | |
| Ord a => Ord (Sum a) | |
| Ord (ForeignPtr a) | |
Defined in GHC.ForeignPtr Methods compare :: ForeignPtr a -> ForeignPtr a -> Ordering # (<) :: ForeignPtr a -> ForeignPtr a -> Bool # (<=) :: ForeignPtr a -> ForeignPtr a -> Bool # (>) :: ForeignPtr a -> ForeignPtr a -> Bool # (>=) :: ForeignPtr a -> ForeignPtr a -> Bool # max :: ForeignPtr a -> ForeignPtr a -> ForeignPtr a # min :: ForeignPtr a -> ForeignPtr a -> ForeignPtr a # | |
| Ord p => Ord (Par1 p) | |
| Ord (FunPtr a) | |
Defined in GHC.Ptr | |
| Ord (Ptr a) | |
| Integral a => Ord (Ratio a) | |
| Ord a => Ord (NonEmpty a) | |
| Ord a => Ord (Maybe a) | |
| Ord a => Ord (a) | |
| Ord a => Ord [a] | |
| (Ord a, Ord b) => Ord (Either a b) | |
| Ord (Proxy s) | |
| Ord a => Ord (Arg a b) | |
| Ord (TypeRep a) | |
| (Ix i, Ord e) => Ord (Array i e) | |
| Ord (U1 p) | |
| Ord (V1 p) | |
| (Ord a, Ord b) => Ord (a, b) | |
| Ord a => Ord (Const a b) | |
| Ord (f a) => Ord (Ap f a) | |
| Ord (f a) => Ord (Alt f a) | |
Defined in Data.Semigroup.Internal | |
| Ord (Coercion a b) | |
Defined in Data.Type.Coercion | |
| Ord (a :~: b) | |
Defined in Data.Type.Equality | |
| Ord (f p) => Ord (Rec1 f p) | |
Defined in GHC.Generics | |
| Ord (URec (Ptr ()) p) | |
Defined in GHC.Generics Methods 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) | |
Defined in GHC.Generics | |
| Ord (URec Double p) | |
Defined in GHC.Generics Methods 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) | |
Defined in GHC.Generics | |
| (Ord a, Ord b, Ord c) => Ord (a, b, c) | |
| (Ord1 f, Ord1 g, Ord a) => Ord (Product f g a) | |
Defined in Data.Functor.Product Methods compare :: Product f g a -> Product f g a -> Ordering # (<) :: Product f g a -> Product f g a -> Bool # (<=) :: Product f g a -> Product f g a -> Bool # (>) :: Product f g a -> Product f g a -> Bool # (>=) :: Product f g a -> Product f g a -> Bool # | |
| (Ord1 f, Ord1 g, Ord a) => Ord (Sum f g a) | |
| Ord (a :~~: b) | |
| (Ord (f p), Ord (g p)) => Ord ((f :*: g) p) | |
Defined in GHC.Generics | |
| (Ord (f p), Ord (g p)) => Ord ((f :+: g) p) | |
Defined in GHC.Generics | |
| Ord c => Ord (K1 i c p) | |
Defined in GHC.Generics | |
| (Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d) | |
Defined in GHC.Classes | |
| (Ord1 f, Ord1 g, Ord a) => Ord (Compose f g a) | |
Defined in Data.Functor.Compose Methods compare :: Compose f g a -> Compose f g a -> Ordering # (<) :: Compose f g a -> Compose f g a -> Bool # (<=) :: Compose f g a -> Compose f g a -> Bool # (>) :: Compose f g a -> Compose f g a -> Bool # (>=) :: Compose f g a -> Compose f g a -> Bool # | |
| Ord (f (g p)) => Ord ((f :.: g) p) | |
Defined in GHC.Generics | |
| Ord (f p) => Ord (M1 i c f p) | |
| (Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e) | |
Defined in GHC.Classes Methods 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 Methods 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 Methods 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 Methods 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 Methods 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 Methods 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 Methods 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 Methods 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 Methods 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 Methods 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 Methods 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) # | |
Instances
| Read All | |
| Read Any | |
| Read Version | |
| Read Void | |
| Read IntPtr | |
| Read WordPtr | |
| Read Associativity | |
| Read DecidedStrictness | |
| Read Fixity | |
| Read SourceStrictness | |
| Read SourceUnpackedness | |
| Read SeekMode | |
| Read ExitCode | |
| Read BufferMode | |
| Read Newline | |
| Read NewlineMode | |
| Read IOMode | |
| Read Int16 | |
| Read Int32 | |
| Read Int64 | |
| Read Int8 | |
| Read GeneralCategory | |
| Read Word16 | |
| Read Word32 | |
| Read Word64 | |
| Read Word8 | |
| Read Lexeme | |
| Read Ordering | |
| Read Integer | |
| Read Natural | |
| Read () | |
| Read Bool | |
| Read Char | |
| Read Double | |
| Read Float | |
| Read Int | |
| Read Word | |
| Read a => Read (ZipList a) | |
| Read a => Read (And a) | |
| Read a => Read (Iff a) | |
| Read a => Read (Ior a) | |
| Read a => Read (Xor a) | |
| Read a => Read (Complex a) | |
| Read a => Read (Identity a) | |
| Read a => Read (First a) | |
| Read a => Read (Last a) | |
| Read a => Read (Down a) | |
| Read a => Read (First a) | |
| Read a => Read (Last a) | |
| Read a => Read (Max a) | |
| Read a => Read (Min a) | |
| Read m => Read (WrappedMonoid m) | |
Defined in Data.Semigroup Methods readsPrec :: Int -> ReadS (WrappedMonoid m) # readList :: ReadS [WrappedMonoid m] # readPrec :: ReadPrec (WrappedMonoid m) # readListPrec :: ReadPrec [WrappedMonoid m] # | |
| Read a => Read (Dual a) | |
| Read a => Read (Product a) | |
| Read a => Read (Sum a) | |
| Read p => Read (Par1 p) | |
| (Integral a, Read a) => Read (Ratio a) | |
| Read a => Read (NonEmpty a) | |
| Read a => Read (Maybe a) | |
| Read a => Read (a) | |
| Read a => Read [a] | |
| (Read a, Read b) => Read (Either a b) | |
| Read (Proxy t) | |
| (Read a, Read b) => Read (Arg a b) | |
| (Ix a, Read a, Read b) => Read (Array a b) | |
| Read (U1 p) | |
| Read (V1 p) | |
| (Read a, Read b) => Read (a, b) | |
| Read a => Read (Const a b) | |
| Read (f a) => Read (Ap f a) | |
| Read (f a) => Read (Alt f a) | |
| Coercible a b => Read (Coercion a b) | |
| a ~ b => Read (a :~: b) | |
| Read (f p) => Read (Rec1 f p) | |
| (Read a, Read b, Read c) => Read (a, b, c) | |
| (Read1 f, Read1 g, Read a) => Read (Product f g a) | |
| (Read1 f, Read1 g, Read a) => Read (Sum f g a) | |
| a ~~ b => Read (a :~~: b) | |
| (Read (f p), Read (g p)) => Read ((f :*: g) p) | |
| (Read (f p), Read (g p)) => Read ((f :+: g) p) | |
| Read c => Read (K1 i c p) | |
| (Read a, Read b, Read c, Read d) => Read (a, b, c, d) | |
| (Read1 f, Read1 g, Read a) => Read (Compose f g a) | |
| Read (f (g p)) => Read ((f :.: g) p) | |
| Read (f p) => Read (M1 i c f p) | |
| (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) | |
Defined in GHC.Read | |
class (Num a, Ord a) => Real a #
Minimal complete definition
Instances
| Real IntPtr | |
Defined in Foreign.Ptr Methods toRational :: IntPtr -> Rational # | |
| Real WordPtr | |
Defined in Foreign.Ptr Methods toRational :: WordPtr -> Rational # | |
| Real Int16 | |
Defined in GHC.Int Methods toRational :: Int16 -> Rational # | |
| Real Int32 | |
Defined in GHC.Int Methods toRational :: Int32 -> Rational # | |
| Real Int64 | |
Defined in GHC.Int Methods toRational :: Int64 -> Rational # | |
| Real Int8 | |
Defined in GHC.Int Methods toRational :: Int8 -> Rational # | |
| Real Word16 | |
Defined in GHC.Word Methods toRational :: Word16 -> Rational # | |
| Real Word32 | |
Defined in GHC.Word Methods toRational :: Word32 -> Rational # | |
| Real Word64 | |
Defined in GHC.Word Methods toRational :: Word64 -> Rational # | |
| Real Word8 | |
Defined in GHC.Word Methods toRational :: Word8 -> Rational # | |
| Real Integer | |
Defined in GHC.Real Methods toRational :: Integer -> Rational # | |
| Real Natural | |
Defined in GHC.Real Methods toRational :: Natural -> Rational # | |
| Real Int | |
Defined in GHC.Real Methods toRational :: Int -> Rational # | |
| Real Word | |
Defined in GHC.Real Methods toRational :: Word -> Rational # | |
| Real a => Real (Identity a) | |
Defined in Data.Functor.Identity Methods toRational :: Identity a -> Rational # | |
| Real a => Real (Down a) | |
Defined in Data.Ord Methods toRational :: Down a -> Rational # | |
| Integral a => Real (Ratio a) | |
Defined in GHC.Real Methods toRational :: Ratio a -> Rational # | |
| Real a => Real (Const a b) | |
Defined in Data.Functor.Const Methods toRational :: Const a b -> Rational # | |
class (RealFrac a, Floating a) => RealFloat a #
Minimal complete definition
floatRadix, floatDigits, floatRange, decodeFloat, encodeFloat, isNaN, isInfinite, isDenormalized, isNegativeZero, isIEEE
Instances
class (Real a, Fractional a) => RealFrac a #
Minimal complete definition
Minimal complete definition
Instances
Instances
| Show NestedAtomically | |
| Show NoMethodError | |
| Show NonTermination | |
| Show PatternMatchFail | |
| Show RecConError | |
| Show RecSelError | |
| Show RecUpdError | |
| Show TypeError | |
| Show All | |
| Show Any | |
| Show SomeTypeRep | |
| Show Version | |
| Show Void | |
| Show IntPtr | |
| Show WordPtr | |
| Show BlockReason | |
| Show ThreadId | |
| Show ThreadStatus | |
| Show ErrorCall | |
| Show ArithException | |
| Show SomeException | |
| Show Associativity | |
| Show DecidedStrictness | |
| Show Fixity | |
| Show SourceStrictness | |
| Show SourceUnpackedness | |
| Show MaskingState | |
| Show SeekMode | |
| Show CodingProgress | |
| Show TextEncoding | |
| Show AllocationLimitExceeded | |
| Show ArrayException | |
| Show AssertionFailed | |
| Show AsyncException | |
| Show BlockedIndefinitelyOnMVar | |
| Show BlockedIndefinitelyOnSTM | |
| Show CompactionFailed | |
| Show Deadlock | |
| Show ExitCode | |
| Show FixIOException | |
| Show IOErrorType | |
| Show IOException | |
| Show SomeAsyncException | |
| Show HandlePosn | |
| Show BufferMode | |
| Show Handle | |
| Show HandleType | |
| Show Newline | |
| Show NewlineMode | |
| Show IOMode | |
| Show Int16 | |
| Show Int32 | |
| Show Int64 | |
| Show Int8 | |
| Show FractionalExponentBase | |
| Show CallStack | |
| Show SrcLoc | |
| Show Word16 | |
| Show Word32 | |
| Show Word64 | |
| Show Word8 | |
| Show Lexeme | |
| Show Number | |
| Show KindRep | |
| Show Module | |
| Show Ordering | |
| Show TrName | |
| Show TyCon | |
| Show TypeLitSort | |
| Show Integer | |
| Show Natural | |
| Show () | |
| Show Bool | |
| Show Char | |
| Show Int | |
| Show Levity | |
| Show RuntimeRep | |
| Show VecCount | |
| Show VecElem | |
| Show Word | |
| Show a => Show (ZipList a) | |
| Show a => Show (And a) | |
| Show a => Show (Iff a) | |
| Show a => Show (Ior a) | |
| Show a => Show (Xor a) | |
| Show a => Show (Complex a) | |
| Show a => Show (Identity a) | |
| Show a => Show (First a) | |
| Show a => Show (Last a) | |
| Show a => Show (Down a) | |
| 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) | |
Defined in Data.Semigroup Methods showsPrec :: Int -> WrappedMonoid m -> ShowS # show :: WrappedMonoid m -> String # showList :: [WrappedMonoid m] -> ShowS # | |
| Show a => Show (Dual a) | |
| Show a => Show (Product a) | |
| Show a => Show (Sum a) | |
| Show (ForeignPtr a) | |
Defined in GHC.ForeignPtr Methods showsPrec :: Int -> ForeignPtr a -> ShowS # show :: ForeignPtr a -> String # showList :: [ForeignPtr a] -> ShowS # | |
| Show p => Show (Par1 p) | |
| Show (FunPtr a) | |
| Show (Ptr a) | |
| Show a => Show (Ratio a) | |
| Show a => Show (NonEmpty a) | |
| Show a => Show (Maybe a) | |
| Show a => Show (a) | |
| Show a => Show [a] | |
| (Show a, Show b) => Show (Either a b) | |
| Show (Proxy s) | |
| (Show a, Show b) => Show (Arg a b) | |
| Show (TypeRep a) | |
| (Ix a, Show a, Show b) => Show (Array a b) | |
| Show (U1 p) | |
| Show (V1 p) | |
| Show (ST s a) | |
| (Show a, Show b) => Show (a, b) | |
| Show a => Show (Const a b) | |
| Show (f a) => Show (Ap f a) | |
| Show (f a) => Show (Alt f a) | |
| Show (Coercion a b) | |
| Show (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) | |
| (Show1 f, Show1 g, Show a) => Show (Product f g a) | |
| (Show1 f, Show1 g, Show a) => Show (Sum f g a) | |
| Show (a :~~: b) | |
| (Show (f p), Show (g p)) => Show ((f :*: g) p) | |
| (Show (f p), Show (g p)) => Show ((f :+: g) p) | |
| Show c => Show (K1 i c p) | |
| (Show a, Show b, Show c, Show d) => Show (a, b, c, d) | |
| (Show1 f, Show1 g, Show a) => Show (Compose f g a) | |
| Show (f (g p)) => Show ((f :.: g) p) | |
| Show (f p) => Show (M1 i c f 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 (Functor t, Foldable t) => Traversable (t :: Type -> Type) #
Instances
Instances
| Storable Char | |
Defined in Foreign.Storable | |
| Bounded Char | |
| Enum Char | |
| Ix Char | |
| Read Char | |
| Show Char | |
| Eq Char | |
| Ord Char | |
| Generic1 (URec Char :: k -> Type) | |
| Foldable (UChar :: TYPE LiftedRep -> Type) | |
Defined in Data.Foldable Methods 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 LiftedRep -> Type) | |
| Generic (URec Char p) | |
| Show (URec Char p) | |
| Eq (URec Char p) | |
| Ord (URec Char p) | |
Defined in GHC.Generics | |
| data URec Char (p :: k) | |
Defined in GHC.Generics | |
| type Rep1 (URec Char :: k -> Type) | |
Defined in GHC.Generics | |
| type Rep (URec Char p) | |
Defined in GHC.Generics | |
Instances
| Storable Double | |
Defined in Foreign.Storable | |
| Floating Double | |
| RealFloat Double | |
Defined in GHC.Float Methods 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 # | |
| Read Double | |
| Eq Double | |
| Ord Double | |
| Generic1 (URec Double :: k -> Type) | |
| Foldable (UDouble :: TYPE LiftedRep -> Type) | |
Defined in Data.Foldable Methods 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 LiftedRep -> Type) | |
| Generic (URec Double p) | |
| Show (URec Double p) | |
| Eq (URec Double p) | |
| Ord (URec Double p) | |
Defined in GHC.Generics Methods 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 # | |
| data URec Double (p :: k) | |
Defined in GHC.Generics | |
| type Rep1 (URec Double :: k -> Type) | |
Defined in GHC.Generics | |
| type Rep (URec Double p) | |
Defined in GHC.Generics | |
Instances
| Storable Float | |
Defined in Foreign.Storable | |
| Floating Float | |
| RealFloat Float | |
Defined in GHC.Float Methods 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 # | |
| Read Float | |
| Eq Float | |
| Ord Float | |
| Generic1 (URec Float :: k -> Type) | |
| Foldable (UFloat :: TYPE LiftedRep -> Type) | |
Defined in Data.Foldable Methods 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 LiftedRep -> Type) | |
| Generic (URec Float p) | |
| Show (URec Float p) | |
| Eq (URec Float p) | |
| Ord (URec Float p) | |
Defined in GHC.Generics | |
| data URec Float (p :: k) | |
Defined in GHC.Generics | |
| type Rep1 (URec Float :: k -> Type) | |
Defined in GHC.Generics | |
| type Rep (URec Float p) | |
Defined in GHC.Generics | |
Instances
| Storable Int | |
| Bits Int | |
Defined in GHC.Bits Methods complement :: Int -> Int complementBit :: Int -> Int -> Int bitSizeMaybe :: Int -> Maybe Int unsafeShiftL :: Int -> Int -> Int unsafeShiftR :: Int -> Int -> Int | |
| FiniteBits Int | |
Defined in GHC.Bits | |
| Bounded Int | |
| Enum Int | |
| Ix Int | |
| Num Int | |
| Read Int | |
| Integral Int | |
| Real Int | |
Defined in GHC.Real Methods toRational :: Int -> Rational # | |
| Show Int | |
| Eq Int | |
| Ord Int | |
| Generic1 (URec Int :: k -> Type) | |
| Foldable (UInt :: TYPE LiftedRep -> Type) | |
Defined in Data.Foldable Methods 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 LiftedRep -> Type) | |
| Generic (URec Int p) | |
| Show (URec Int p) | |
| Eq (URec Int p) | |
| Ord (URec Int p) | |
| data URec Int (p :: k) | |
Defined in GHC.Generics | |
| type Rep1 (URec Int :: k -> Type) | |
Defined in GHC.Generics | |
| type Rep (URec Int p) | |
Defined in GHC.Generics | |
Instances
| Bits Integer | |
Defined in GHC.Bits Methods (.&.) :: Integer -> Integer -> Integer (.|.) :: Integer -> Integer -> Integer xor :: Integer -> Integer -> Integer complement :: Integer -> Integer shift :: Integer -> Int -> Integer rotate :: Integer -> Int -> Integer setBit :: Integer -> Int -> Integer clearBit :: Integer -> Int -> Integer complementBit :: Integer -> Int -> Integer testBit :: Integer -> Int -> Bool bitSizeMaybe :: Integer -> Maybe Int shiftL :: Integer -> Int -> Integer unsafeShiftL :: Integer -> Int -> Integer shiftR :: Integer -> Int -> Integer unsafeShiftR :: Integer -> Int -> Integer rotateL :: Integer -> Int -> Integer | |
| Enum Integer | |
| Ix Integer | |
| Num Integer | |
| Read Integer | |
| Integral Integer | |
Defined in GHC.Real | |
| Real Integer | |
Defined in GHC.Real Methods toRational :: Integer -> Rational # | |
| Show Integer | |
| Eq Integer | |
| Ord Integer | |
Instances
| Storable Word | |
Defined in Foreign.Storable | |
| Bits Word | |
Defined in GHC.Bits | |
| FiniteBits Word | |
Defined in GHC.Bits Methods finiteBitSize :: Word -> Int countLeadingZeros :: Word -> Int countTrailingZeros :: Word -> Int | |
| Bounded Word | |
| Enum Word | |
| Ix Word | |
| Num Word | |
| Read Word | |
| Integral Word | |
| Real Word | |
Defined in GHC.Real Methods toRational :: Word -> Rational # | |
| Show Word | |
| Eq Word | |
| Ord Word | |
| Generic1 (URec Word :: k -> Type) | |
| Foldable (UWord :: TYPE LiftedRep -> Type) | |
Defined in Data.Foldable Methods 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 LiftedRep -> Type) | |
| Generic (URec Word p) | |
| Show (URec Word p) | |
| Eq (URec Word p) | |
| Ord (URec Word p) | |
Defined in GHC.Generics | |
| data URec Word (p :: k) | |
Defined in GHC.Generics | |
| type Rep1 (URec Word :: k -> Type) | |
Defined in GHC.Generics | |
| type Rep (URec Word p) | |
Defined in GHC.Generics | |
Instances
| Storable Bool | |
Defined in Foreign.Storable | |
| Bits Bool | |
Defined in GHC.Bits | |
| FiniteBits Bool | |
Defined in GHC.Bits Methods finiteBitSize :: Bool -> Int countLeadingZeros :: Bool -> Int countTrailingZeros :: Bool -> Int | |
| Bounded Bool | |
| Enum Bool | |
| Generic Bool | |
| SingKind Bool | |
Defined in GHC.Generics Associated Types type DemoteRep Bool | |
| Ix Bool | |
| Read Bool | |
| Show Bool | |
| Eq Bool | |
| Ord Bool | |
| SingI 'False | |
Defined in GHC.Generics | |
| SingI 'True | |
Defined in GHC.Generics | |
| type DemoteRep Bool | |
Defined in GHC.Generics | |
| type Rep Bool | |
Defined in GHC.Generics | |
| data Sing (a :: Bool) | |
Instances
| Bifoldable Either | |
| Bifunctor Either | |
| Bitraversable Either | |
Defined in Data.Bitraversable Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Either a b -> f (Either c d) | |
| Eq2 Either | |
| Ord2 Either | |
Defined in Data.Functor.Classes | |
| Read2 Either | |
Defined in Data.Functor.Classes Methods 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] | |
| Show2 Either | |
| Generic1 (Either a :: Type -> Type) | |
| Foldable (Either a) | |
Defined in Data.Foldable Methods 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 # | |
| Eq a => Eq1 (Either a) | |
| Ord a => Ord1 (Either a) | |
Defined in Data.Functor.Classes Methods liftCompare :: (a0 -> b -> Ordering) -> Either a a0 -> Either a b -> Ordering | |
| Read a => Read1 (Either a) | |
Defined in Data.Functor.Classes Methods 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 | |
| Traversable (Either a) | |
Defined in Data.Traversable | |
| Applicative (Either e) | |
| Functor (Either a) | |
| Monad (Either e) | |
| Semigroup (Either a b) | |
| Generic (Either a b) | |
| (Read a, Read b) => Read (Either a b) | |
| (Show a, Show b) => Show (Either a b) | |
| (Eq a, Eq b) => Eq (Either a b) | |
| (Ord a, Ord b) => Ord (Either a b) | |
| 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))) | |
Instances
| MonadFail Maybe | |
Defined in Control.Monad.Fail | |
| Foldable Maybe | |
Defined in Data.Foldable Methods 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 # | |
| Eq1 Maybe | |
| Ord1 Maybe | |
Defined in Data.Functor.Classes Methods liftCompare :: (a -> b -> Ordering) -> Maybe a -> Maybe b -> Ordering | |
| Read1 Maybe | |
Defined in Data.Functor.Classes Methods 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 | |
| Traversable Maybe | |
| Alternative Maybe | |
| Applicative Maybe | |
| Functor Maybe | |
| Monad Maybe | |
| MonadPlus Maybe | |
| Generic1 Maybe | |
| Semigroup a => Monoid (Maybe a) | |
| Semigroup a => Semigroup (Maybe a) | |
| Generic (Maybe a) | |
| SingKind a => SingKind (Maybe a) | |
Defined in GHC.Generics Associated Types type DemoteRep (Maybe a) | |
| Read a => Read (Maybe a) | |
| Show a => Show (Maybe a) | |
| Eq a => Eq (Maybe a) | |
| Ord a => Ord (Maybe a) | |
| SingI ('Nothing :: Maybe a) | |
Defined in GHC.Generics | |
| SingI a2 => SingI ('Just a2 :: Maybe a1) | |
Defined in GHC.Generics | |
| type Rep1 Maybe | |
| type DemoteRep (Maybe a) | |
Defined in GHC.Generics | |
| type Rep (Maybe a) | |
Defined in GHC.Generics | |
| data Sing (b :: Maybe a) | |
Instances
| Monoid Ordering | |
| Semigroup Ordering | |
| Bounded Ordering | |
| Enum Ordering | |
| Generic Ordering | |
| Ix Ordering | |
Defined in GHC.Ix | |
| Read Ordering | |
| Show Ordering | |
| Eq Ordering | |
| Ord Ordering | |
Defined in GHC.Classes | |
| type Rep Ordering | |