| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Prologue.Data.Basic
Contents
Synopsis
- swap :: (a, b) -> (b, a)
- (||.) :: (a -> Bool) -> (a -> Bool) -> a -> Bool
- (&&.) :: (a -> Bool) -> (a -> Bool) -> a -> Bool
- const1 :: a -> t1 -> a
- const2 :: a -> t1 -> t2 -> a
- const3 :: a -> t1 -> t2 -> t3 -> a
- const4 :: a -> t1 -> t2 -> t3 -> t4 -> a
- const5 :: a -> t1 -> t2 -> t3 -> t4 -> t5 -> a
- const6 :: a -> t1 -> t2 -> t3 -> t4 -> t5 -> t6 -> a
- const7 :: a -> t1 -> t2 -> t3 -> t4 -> t5 -> t6 -> t7 -> a
- const8 :: a -> t1 -> t2 -> t3 -> t4 -> t5 -> t6 -> t7 -> t8 -> a
- const9 :: a -> t1 -> t2 -> t3 -> t4 -> t5 -> t6 -> t7 -> t8 -> t9 -> a
- ifThenElse :: Bool -> a -> a -> a
- ifThenElseId :: Bool -> (a -> a) -> a -> a
- ifThenMempty :: Mempty a => Bool -> a -> a
- ifM :: Monad m => m Bool -> m a -> m a -> m a
- switch :: a -> a -> Bool -> a
- switchM :: Monad m => m a -> m a -> m Bool -> m a
- unlines :: (IsString a, Monoid a, Foldable f) => f a -> a
- replicate :: (Num a, Ord a) => a -> t -> [t]
- unsafeReplicate :: (Num a, Ord a) => a -> t -> [t]
- fst :: (a, b) -> a
- snd :: (a, b) -> b
- otherwise :: Bool
- class Eq a where
- class Eq a => Ord a where
- data Bool
- data Char
- data Double
- data Float
- data Int
- data Integer
- data Maybe a
- data Ordering
- type Rational = Ratio Integer
- data Word
- data Either a b
- either :: (a -> c) -> (b -> c) -> Either a b -> c
- type String = [Char]
- maybe :: b -> (a -> b) -> Maybe a -> b
- (&&) :: Bool -> Bool -> Bool
- (||) :: Bool -> Bool -> Bool
- not :: Bool -> Bool
Documentation
ifThenElse :: Bool -> a -> a -> a Source #
ifThenElseId :: Bool -> (a -> a) -> a -> a Source #
ifThenMempty :: Mempty a => Bool -> a -> a Source #
unsafeReplicate :: (Num a, Ord a) => a -> t -> [t] Source #
The Eq class defines equality (==) and inequality (/=).
All the basic datatypes exported by the Prelude are instances of Eq,
and Eq may be derived for any datatype whose constituents are also
instances of Eq.
The Haskell Report defines no laws for Eq. However, == is customarily
expected to implement an equivalence relationship where two values comparing
equal are indistinguishable by "public" functions, with a "public" function
being one not allowing to see implementation details. For example, for a
type representing non-normalised natural numbers modulo 100, a "public"
function doesn't make the difference between 1 and 201. It is expected to
have the following properties:
Instances
| Eq Bool | |
| Eq Char | |
| Eq Double | Note that due to the presence of
Also note that
|
| Eq Float | Note that due to the presence of
Also note that
|
| Eq Int | |
| Eq Int8 | Since: base-2.1 |
| Eq Int16 | Since: base-2.1 |
| Eq Int32 | Since: base-2.1 |
| Eq Int64 | Since: base-2.1 |
| Eq Integer | |
| Eq Natural | Since: base-4.8.0.0 |
| Eq Ordering | |
| Eq Word | |
| Eq Word8 | Since: base-2.1 |
| Eq Word16 | Since: base-2.1 |
| Eq Word32 | Since: base-2.1 |
| Eq Word64 | Since: base-2.1 |
| Eq SomeTypeRep | |
Defined in Data.Typeable.Internal | |
| Eq Exp | |
| Eq Match | |
| Eq Clause | |
| Eq Pat | |
| Eq Type | |
| Eq Dec | |
| Eq Name | |
| Eq FunDep | |
| Eq InjectivityAnn | |
Defined in Language.Haskell.TH.Syntax Methods (==) :: InjectivityAnn -> InjectivityAnn -> Bool # (/=) :: InjectivityAnn -> InjectivityAnn -> Bool # | |
| Eq Overlap | |
| Eq () | |
| Eq TyCon | |
| Eq Module | |
| Eq TrName | |
| Eq Con | |
| Eq BigNat | |
| Eq Void | Since: base-4.8.0.0 |
| Eq SpecConstrAnnotation | Since: base-4.3.0.0 |
Defined in GHC.Exts Methods (==) :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool # (/=) :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool # | |
| Eq Constr | Equality of constructors Since: base-4.0.0.0 |
| Eq DataRep | Since: base-4.0.0.0 |
| Eq ConstrRep | Since: base-4.0.0.0 |
| Eq Fixity | Since: base-4.0.0.0 |
| Eq Version | Since: base-2.1 |
| Eq ThreadId | Since: base-4.2.0.0 |
| Eq BlockReason | Since: base-4.3.0.0 |
Defined in GHC.Conc.Sync | |
| Eq ThreadStatus | Since: base-4.3.0.0 |
Defined in GHC.Conc.Sync | |
| Eq AsyncException | Since: base-4.2.0.0 |
Defined in GHC.IO.Exception Methods (==) :: AsyncException -> AsyncException -> Bool # (/=) :: AsyncException -> AsyncException -> Bool # | |
| Eq ArrayException | Since: base-4.2.0.0 |
Defined in GHC.IO.Exception Methods (==) :: ArrayException -> ArrayException -> Bool # (/=) :: ArrayException -> ArrayException -> Bool # | |
| Eq ExitCode | |
| Eq IOErrorType | Since: base-4.1.0.0 |
Defined in GHC.IO.Exception | |
| Eq MaskingState | Since: base-4.3.0.0 |
Defined in GHC.IO | |
| Eq IOException | Since: base-4.1.0.0 |
Defined in GHC.IO.Exception | |
| Eq ErrorCall | Since: base-4.7.0.0 |
| Eq ArithException | Since: base-3.0 |
Defined in GHC.Exception.Type Methods (==) :: ArithException -> ArithException -> Bool # (/=) :: ArithException -> ArithException -> Bool # | |
| Eq All | Since: base-2.1 |
| Eq Any | Since: base-2.1 |
| Eq Fixity | Since: base-4.6.0.0 |
| Eq Associativity | Since: base-4.6.0.0 |
Defined in GHC.Generics Methods (==) :: Associativity -> Associativity -> Bool # (/=) :: Associativity -> Associativity -> Bool # | |
| Eq SourceUnpackedness | Since: base-4.9.0.0 |
Defined in GHC.Generics Methods (==) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (/=) :: SourceUnpackedness -> SourceUnpackedness -> Bool # | |
| Eq SourceStrictness | Since: base-4.9.0.0 |
Defined in GHC.Generics Methods (==) :: SourceStrictness -> SourceStrictness -> Bool # (/=) :: SourceStrictness -> SourceStrictness -> Bool # | |
| Eq DecidedStrictness | Since: base-4.9.0.0 |
Defined in GHC.Generics Methods (==) :: DecidedStrictness -> DecidedStrictness -> Bool # (/=) :: DecidedStrictness -> DecidedStrictness -> Bool # | |
| Eq SomeSymbol | Since: base-4.7.0.0 |
Defined in GHC.TypeLits | |
| Eq SomeNat | Since: base-4.7.0.0 |
| Eq Fingerprint | Since: base-4.4.0.0 |
Defined in GHC.Fingerprint.Type | |
| Eq Lexeme | Since: base-2.1 |
| Eq Number | Since: base-4.6.0.0 |
| Eq GeneralCategory | Since: base-2.1 |
Defined in GHC.Unicode Methods (==) :: GeneralCategory -> GeneralCategory -> Bool # (/=) :: GeneralCategory -> GeneralCategory -> Bool # | |
| Eq SrcLoc | Since: base-4.9.0.0 |
| Eq BiFun | |
| Eq Options | |
| Eq IntSet | |
| Eq Sign | |
| Eq NumRange | |
| Eq NumType | |
| Eq ShowOptions | |
Defined in Text.Show.Deriving.Internal | |
| Eq ReadOptions | |
Defined in Text.Read.Deriving.Internal | |
| Eq Extension | |
| Eq ForeignSrcLang | |
Defined in GHC.ForeignSrcLang.Type Methods (==) :: ForeignSrcLang -> ForeignSrcLang -> Bool # (/=) :: ForeignSrcLang -> ForeignSrcLang -> Bool # | |
| Eq TyVarBndr | |
| Eq DefName | |
| Eq Pos | |
| Eq InvalidPosException | |
Defined in Text.Megaparsec.Pos Methods (==) :: InvalidPosException -> InvalidPosException -> Bool # (/=) :: InvalidPosException -> InvalidPosException -> Bool # | |
| Eq SourcePos | |
| Eq Doc | |
| Eq TextDetails | |
Defined in Text.PrettyPrint.Annotated.HughesPJ | |
| Eq Style | |
| Eq Mode | |
| Eq Value | |
| Eq ByteArray | Since: primitive-0.6.3.0 |
| Eq Addr | |
| Eq ModName | |
| Eq PkgName | |
| Eq Module | |
| Eq OccName | |
| Eq NameFlavour | |
Defined in Language.Haskell.TH.Syntax | |
| Eq NameSpace | |
| Eq Loc | |
| Eq Info | |
| Eq ModuleInfo | |
Defined in Language.Haskell.TH.Syntax | |
| Eq Fixity | |
| Eq FixityDirection | |
Defined in Language.Haskell.TH.Syntax Methods (==) :: FixityDirection -> FixityDirection -> Bool # (/=) :: FixityDirection -> FixityDirection -> Bool # | |
| Eq Lit | |
| Eq Body | |
| Eq Guard | |
| Eq Stmt | |
| Eq Range | |
| Eq DerivClause | |
Defined in Language.Haskell.TH.Syntax | |
| Eq DerivStrategy | |
Defined in Language.Haskell.TH.Syntax Methods (==) :: DerivStrategy -> DerivStrategy -> Bool # (/=) :: DerivStrategy -> DerivStrategy -> Bool # | |
| Eq TypeFamilyHead | |
Defined in Language.Haskell.TH.Syntax Methods (==) :: TypeFamilyHead -> TypeFamilyHead -> Bool # (/=) :: TypeFamilyHead -> TypeFamilyHead -> Bool # | |
| Eq TySynEqn | |
| Eq Foreign | |
| Eq Callconv | |
| Eq Safety | |
| Eq Pragma | |
| Eq Inline | |
| Eq RuleMatch | |
| Eq Phases | |
| Eq RuleBndr | |
| Eq AnnTarget | |
| Eq SourceUnpackedness | |
Defined in Language.Haskell.TH.Syntax Methods (==) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (/=) :: SourceUnpackedness -> SourceUnpackedness -> Bool # | |
| Eq SourceStrictness | |
Defined in Language.Haskell.TH.Syntax Methods (==) :: SourceStrictness -> SourceStrictness -> Bool # (/=) :: SourceStrictness -> SourceStrictness -> Bool # | |
| Eq DecidedStrictness | |
Defined in Language.Haskell.TH.Syntax Methods (==) :: DecidedStrictness -> DecidedStrictness -> Bool # (/=) :: DecidedStrictness -> DecidedStrictness -> Bool # | |
| Eq Bang | |
| Eq PatSynDir | |
| Eq PatSynArgs | |
Defined in Language.Haskell.TH.Syntax | |
| Eq FamilyResultSig | |
Defined in Language.Haskell.TH.Syntax Methods (==) :: FamilyResultSig -> FamilyResultSig -> Bool # (/=) :: FamilyResultSig -> FamilyResultSig -> Bool # | |
| Eq TyLit | |
| Eq Role | |
| Eq AnnLookup | |
| Eq DatatypeInfo | |
Defined in Language.Haskell.TH.Datatype | |
| Eq DatatypeVariant | |
Defined in Language.Haskell.TH.Datatype Methods (==) :: DatatypeVariant -> DatatypeVariant -> Bool # (/=) :: DatatypeVariant -> DatatypeVariant -> Bool # | |
| Eq ConstructorInfo | |
Defined in Language.Haskell.TH.Datatype Methods (==) :: ConstructorInfo -> ConstructorInfo -> Bool # (/=) :: ConstructorInfo -> ConstructorInfo -> Bool # | |
| Eq ConstructorVariant | |
Defined in Language.Haskell.TH.Datatype Methods (==) :: ConstructorVariant -> ConstructorVariant -> Bool # (/=) :: ConstructorVariant -> ConstructorVariant -> Bool # | |
| Eq FieldStrictness | |
Defined in Language.Haskell.TH.Datatype Methods (==) :: FieldStrictness -> FieldStrictness -> Bool # (/=) :: FieldStrictness -> FieldStrictness -> Bool # | |
| Eq Unpackedness | |
Defined in Language.Haskell.TH.Datatype | |
| Eq Strictness | |
Defined in Language.Haskell.TH.Datatype | |
| Eq OrdFun | |
| Eq a => Eq [a] | |
| Eq a => Eq (Maybe a) | Since: base-2.1 |
| Eq a => Eq (Ratio a) | Since: base-2.1 |
| Eq (Ptr a) | Since: base-2.1 |
| Eq (FunPtr a) | |
| Eq p => Eq (Par1 p) | Since: base-4.7.0.0 |
| Eq a => Eq (Complex a) | Since: base-2.1 |
| Eq a => Eq (Min a) | Since: base-4.9.0.0 |
| Eq a => Eq (Max a) | Since: base-4.9.0.0 |
| Eq a => Eq (First a) | Since: base-4.9.0.0 |
| Eq a => Eq (Last a) | Since: base-4.9.0.0 |
| Eq m => Eq (WrappedMonoid m) | Since: base-4.9.0.0 |
Defined in Data.Semigroup Methods (==) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (/=) :: WrappedMonoid m -> WrappedMonoid m -> Bool # | |
| Eq a => Eq (Option a) | Since: base-4.9.0.0 |
| Eq a => Eq (ZipList a) | Since: base-4.7.0.0 |
| Eq a => Eq (Identity a) | Since: base-4.8.0.0 |
| Eq (TVar a) | Since: base-4.8.0.0 |
| Eq a => Eq (First a) | Since: base-2.1 |
| Eq a => Eq (Last a) | Since: base-2.1 |
| Eq a => Eq (Dual a) | Since: base-2.1 |
| Eq a => Eq (Sum a) | Since: base-2.1 |
| Eq a => Eq (Product a) | Since: base-2.1 |
| Eq a => Eq (Down a) | Since: base-4.6.0.0 |
| Eq a => Eq (NonEmpty a) | Since: base-4.9.0.0 |
| Eq a => Eq (IntMap a) | |
| Eq a => Eq (Tree a) | |
| Eq a => Eq (Seq a) | |
| Eq a => Eq (ViewL a) | |
| Eq a => Eq (ViewR a) | |
| Eq a => Eq (Set a) | |
| Eq a => Eq (DList a) | |
| Eq a => Eq (Hashed a) | Uses precomputed hash to detect inequality faster |
| (Prim a, Eq a) => Eq (Vector a) | |
| (Storable a, Eq a) => Eq (Vector a) | |
| Eq a => Eq (HashSet a) | |
| Eq a => Eq (Vector a) | |
| Eq t => Eq (ErrorItem t) | |
| Eq e => Eq (ErrorFancy e) | |
Defined in Text.Megaparsec.Error | |
| Eq s => Eq (State s) | |
| Eq s => Eq (PosState s) | |
| Eq (Doc a) | |
| Eq a => Eq (AnnotDetails a) | |
Defined in Text.PrettyPrint.Annotated.HughesPJ Methods (==) :: AnnotDetails a -> AnnotDetails a -> Bool # (/=) :: AnnotDetails a -> AnnotDetails a -> Bool # | |
| Eq a => Eq (Span a) | |
| (Eq a, PrimUnlifted a) => Eq (UnliftedArray a) | |
Defined in Data.Primitive.UnliftedArray Methods (==) :: UnliftedArray a -> UnliftedArray a -> Bool # (/=) :: UnliftedArray a -> UnliftedArray a -> Bool # | |
| (Eq a, Prim a) => Eq (PrimArray a) | Since: primitive-0.6.4.0 |
| Eq a => Eq (SmallArray a) | |
Defined in Data.Primitive.SmallArray | |
| Eq a => Eq (Array a) | |
| Eq1 f => Eq (Fix f) | |
| (Functor f, Eq1 f) => Eq (Mu f) | |
| (Functor f, Eq1 f) => Eq (Nu f) | |
| Eq a => Eq (OneTuple a) Source # | |
| (Eq a, Eq b) => Eq (Either a b) | Since: base-2.1 |
| Eq (V1 p) | Since: base-4.9.0.0 |
| Eq (U1 p) | Since: base-4.9.0.0 |
| Eq (TypeRep a) | Since: base-2.1 |
| (Eq a, Eq b) => Eq (a, b) | |
| (Eq k, Eq v) => Eq (HashMap k v) | |
| (Eq k, Eq a) => Eq (Map k a) | |
| (Ix i, Eq e) => Eq (Array i e) | Since: base-2.1 |
| Eq a => Eq (Arg a b) | Since: base-4.9.0.0 |
| Eq (Proxy s) | Since: base-4.7.0.0 |
| (Eq1 m, Eq a) => Eq (MaybeT m a) | |
| (Eq1 f, Eq a) => Eq (Cofree f a) | |
| (Eq1 f, Eq a) => Eq (Free f a) | |
| (Eq1 f, Eq a) => Eq (Yoneda f a) | |
| (Eq i, Eq a) => Eq (Level i a) | |
| (Eq (Token s), Eq e) => Eq (ParseError s e) | |
Defined in Text.Megaparsec.Error Methods (==) :: ParseError s e -> ParseError s e -> Bool # (/=) :: ParseError s e -> ParseError s e -> Bool # | |
| (Eq s, Eq (Token s), Eq e) => Eq (ParseErrorBundle s e) | |
Defined in Text.Megaparsec.Error Methods (==) :: ParseErrorBundle s e -> ParseErrorBundle s e -> Bool # (/=) :: ParseErrorBundle s e -> ParseErrorBundle s e -> Bool # | |
| Eq (MutableUnliftedArray s a) | |
Defined in Data.Primitive.UnliftedArray Methods (==) :: MutableUnliftedArray s a -> MutableUnliftedArray s a -> Bool # (/=) :: MutableUnliftedArray s a -> MutableUnliftedArray s a -> Bool # | |
| Eq (SmallMutableArray s a) | |
Defined in Data.Primitive.SmallArray Methods (==) :: SmallMutableArray s a -> SmallMutableArray s a -> Bool # (/=) :: SmallMutableArray s a -> SmallMutableArray s a -> Bool # | |
| Eq (MutableArray s a) | |
Defined in Data.Primitive.Array Methods (==) :: MutableArray s a -> MutableArray s a -> Bool # (/=) :: MutableArray s a -> MutableArray s a -> Bool # | |
| (Eq a, Eq b) => Eq (ListF a b) | |
| (Eq a, Eq b) => Eq (NonEmptyF a b) | |
| (Eq k, Eq v) => Eq (Leaf k v) | |
| Eq (f p) => Eq (Rec1 f p) | Since: base-4.7.0.0 |
| Eq (URec (Ptr ()) p) | Since: base-4.9.0.0 |
| Eq (URec Char p) | Since: base-4.9.0.0 |
| Eq (URec Double p) | Since: base-4.9.0.0 |
| Eq (URec Float p) | |
| Eq (URec Int p) | Since: base-4.9.0.0 |
| Eq (URec Word p) | Since: base-4.9.0.0 |
| (Eq a, Eq b, Eq c) => Eq (a, b, c) | |
| Eq (STArray s i e) | Since: base-2.1 |
| Eq a => Eq (Const a b) | Since: base-4.9.0.0 |
| Eq (f a) => Eq (Ap f a) | Since: base-4.12.0.0 |
| Eq (f a) => Eq (Alt f a) | Since: base-4.8.0.0 |
| Eq (a :~: b) | Since: base-4.7.0.0 |
| Eq (p a a) => Eq (Join p a) | |
| Eq (p (Fix p a) a) => Eq (Fix p a) | |
| (Eq1 f, Eq a) => Eq (IdentityT f a) | |
| (Eq e, Eq1 m, Eq a) => Eq (ExceptT e m a) | |
| (Eq a, Eq (f b)) => Eq (FreeF f a b) | |
| (Eq1 f, Eq1 m, Eq a) => Eq (FreeT f m a) | |
| (Eq a, Eq (f b)) => Eq (CofreeF f a b) | |
| Eq (w (CofreeF f a (CofreeT f w a))) => Eq (CofreeT f w a) | |
| (Eq e, Eq1 m, Eq a) => Eq (ErrorT e m a) | |
| Eq b => Eq (Tagged s b) | |
| Eq c => Eq (K1 i c p) | Since: base-4.7.0.0 |
| (Eq (f p), Eq (g p)) => Eq ((f :+: g) p) | Since: base-4.7.0.0 |
| (Eq (f p), Eq (g p)) => Eq ((f :*: g) p) | Since: base-4.7.0.0 |
| (Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d) | |
| (Eq1 f, Eq1 g, Eq a) => Eq (Product f g a) | Since: base-4.9.0.0 |
| (Eq1 f, Eq1 g, Eq a) => Eq (Sum f g a) | Since: base-4.9.0.0 |
| Eq (a :~~: b) | Since: base-4.10.0.0 |
| Eq (f p) => Eq (M1 i c f p) | Since: base-4.7.0.0 |
| Eq (f (g p)) => Eq ((f :.: g) p) | Since: base-4.7.0.0 |
| (Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e) | |
| (Eq1 f, Eq1 g, Eq a) => Eq (Compose f g a) | Since: base-4.9.0.0 |
| Eq (p a b) => Eq (WrappedBifunctor p a b) | |
Defined in Data.Bifunctor.Wrapped Methods (==) :: WrappedBifunctor p a b -> WrappedBifunctor p a b -> Bool # (/=) :: WrappedBifunctor p a b -> WrappedBifunctor p a b -> Bool # | |
| Eq (g b) => Eq (Joker g a b) | |
| Eq (p b a) => Eq (Flip p a b) | |
| Eq (f a) => Eq (Clown f a b) | |
| (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) => Eq (a, b, c, d, e, f) | |
| (Eq (p a b), Eq (q a b)) => Eq (Sum p q a b) | |
| (Eq (f a b), Eq (g a b)) => Eq (Product f g a b) | |
| (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) => Eq (a, b, c, d, e, f, g) | |
| Eq (f (p a b)) => Eq (Tannen f p a b) | |
| (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 (p (f a) (g b)) => Eq (Biff p f g a b) | |
| (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) | |
The Ord class is used for totally ordered datatypes.
Instances of Ord can be derived for any user-defined datatype whose
constituent types are in Ord. The declared order of the constructors in
the data declaration determines the ordering in derived Ord instances. The
Ordering datatype allows a single comparison to determine the precise
ordering of two objects.
The Haskell Report defines no laws for Ord. However, <= is customarily
expected to implement a non-strict partial order and have the following
properties:
- Transitivity
- if
x <= y && y <= z=True, thenx <= z=True - Reflexivity
x <= x=True- Antisymmetry
- if
x <= y && y <= x=True, thenx == y=True
Note that the following operator interactions are expected to hold:
x >= y=y <= xx < y=x <= y && x /= yx > y=y < xx < y=compare x y == LTx > y=compare x y == GTx == y=compare x y == EQmin x y == if x <= y then x else y=Truemax x y == if x >= y then x else y=True
Minimal complete definition: either compare or <=.
Using compare can be more efficient for complex types.
Methods
compare :: a -> a -> Ordering #
(<) :: a -> a -> Bool infix 4 #
(<=) :: a -> a -> Bool infix 4 #
(>) :: a -> a -> Bool infix 4 #
Instances
| Ord Bool | |
| Ord Char | |
| Ord Double | Note that due to the presence of
Also note that, due to the same,
|
| Ord Float | Note that due to the presence of
Also note that, due to the same,
|
| Ord Int | |
| Ord Int8 | Since: base-2.1 |
| Ord Int16 | Since: base-2.1 |
| Ord Int32 | Since: base-2.1 |
| Ord Int64 | Since: base-2.1 |
| Ord Integer | |
| Ord Natural | Since: base-4.8.0.0 |
| Ord Ordering | |
Defined in GHC.Classes | |
| Ord Word | |
| Ord Word8 | Since: base-2.1 |
| Ord Word16 | Since: base-2.1 |
| Ord Word32 | Since: base-2.1 |
| Ord Word64 | Since: base-2.1 |
| Ord SomeTypeRep | |
Defined in Data.Typeable.Internal Methods compare :: SomeTypeRep -> SomeTypeRep -> Ordering # (<) :: SomeTypeRep -> SomeTypeRep -> Bool # (<=) :: SomeTypeRep -> SomeTypeRep -> Bool # (>) :: SomeTypeRep -> SomeTypeRep -> Bool # (>=) :: SomeTypeRep -> SomeTypeRep -> Bool # max :: SomeTypeRep -> SomeTypeRep -> SomeTypeRep # min :: SomeTypeRep -> SomeTypeRep -> SomeTypeRep # | |
| Ord Exp | |
| Ord Match | |
| Ord Clause | |
| Ord Pat | |
| Ord Type | |
| Ord Dec | |
| Ord Name | |
| Ord FunDep | |
| Ord InjectivityAnn | |
Defined in Language.Haskell.TH.Syntax Methods compare :: InjectivityAnn -> InjectivityAnn -> Ordering # (<) :: InjectivityAnn -> InjectivityAnn -> Bool # (<=) :: InjectivityAnn -> InjectivityAnn -> Bool # (>) :: InjectivityAnn -> InjectivityAnn -> Bool # (>=) :: InjectivityAnn -> InjectivityAnn -> Bool # max :: InjectivityAnn -> InjectivityAnn -> InjectivityAnn # min :: InjectivityAnn -> InjectivityAnn -> InjectivityAnn # | |
| Ord Overlap | |
Defined in Language.Haskell.TH.Syntax | |
| Ord () | |
| Ord TyCon | |
| Ord Con | |
| Ord BigNat | |
| Ord Void | Since: base-4.8.0.0 |
| Ord Version | Since: base-2.1 |
| Ord ThreadId | Since: base-4.2.0.0 |
Defined in GHC.Conc.Sync | |
| Ord BlockReason | Since: base-4.3.0.0 |
Defined in GHC.Conc.Sync Methods compare :: BlockReason -> BlockReason -> Ordering # (<) :: BlockReason -> BlockReason -> Bool # (<=) :: BlockReason -> BlockReason -> Bool # (>) :: BlockReason -> BlockReason -> Bool # (>=) :: BlockReason -> BlockReason -> Bool # max :: BlockReason -> BlockReason -> BlockReason # min :: BlockReason -> BlockReason -> BlockReason # | |
| Ord ThreadStatus | Since: base-4.3.0.0 |
Defined in GHC.Conc.Sync Methods compare :: ThreadStatus -> ThreadStatus -> Ordering # (<) :: ThreadStatus -> ThreadStatus -> Bool # (<=) :: ThreadStatus -> ThreadStatus -> Bool # (>) :: ThreadStatus -> ThreadStatus -> Bool # (>=) :: ThreadStatus -> ThreadStatus -> Bool # max :: ThreadStatus -> ThreadStatus -> ThreadStatus # min :: ThreadStatus -> ThreadStatus -> ThreadStatus # | |
| Ord AsyncException | Since: base-4.2.0.0 |
Defined in GHC.IO.Exception Methods compare :: AsyncException -> AsyncException -> Ordering # (<) :: AsyncException -> AsyncException -> Bool # (<=) :: AsyncException -> AsyncException -> Bool # (>) :: AsyncException -> AsyncException -> Bool # (>=) :: AsyncException -> AsyncException -> Bool # max :: AsyncException -> AsyncException -> AsyncException # min :: AsyncException -> AsyncException -> AsyncException # | |
| Ord ArrayException | Since: base-4.2.0.0 |
Defined in GHC.IO.Exception Methods compare :: ArrayException -> ArrayException -> Ordering # (<) :: ArrayException -> ArrayException -> Bool # (<=) :: ArrayException -> ArrayException -> Bool # (>) :: ArrayException -> ArrayException -> Bool # (>=) :: ArrayException -> ArrayException -> Bool # max :: ArrayException -> ArrayException -> ArrayException # min :: ArrayException -> ArrayException -> ArrayException # | |
| Ord ExitCode | |
Defined in GHC.IO.Exception | |
| Ord ErrorCall | Since: base-4.7.0.0 |
| Ord ArithException | Since: base-3.0 |
Defined in GHC.Exception.Type Methods compare :: ArithException -> ArithException -> Ordering # (<) :: ArithException -> ArithException -> Bool # (<=) :: ArithException -> ArithException -> Bool # (>) :: ArithException -> ArithException -> Bool # (>=) :: ArithException -> ArithException -> Bool # max :: ArithException -> ArithException -> ArithException # min :: ArithException -> ArithException -> ArithException # | |
| Ord All | Since: base-2.1 |
| Ord Any | Since: base-2.1 |
| Ord Fixity | Since: base-4.6.0.0 |
| Ord Associativity | Since: base-4.6.0.0 |
Defined in GHC.Generics Methods compare :: Associativity -> Associativity -> Ordering # (<) :: Associativity -> Associativity -> Bool # (<=) :: Associativity -> Associativity -> Bool # (>) :: Associativity -> Associativity -> Bool # (>=) :: Associativity -> Associativity -> Bool # max :: Associativity -> Associativity -> Associativity # min :: Associativity -> Associativity -> Associativity # | |
| Ord SourceUnpackedness | Since: base-4.9.0.0 |
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 SourceStrictness | Since: base-4.9.0.0 |
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 DecidedStrictness | Since: base-4.9.0.0 |
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 SomeSymbol | Since: base-4.7.0.0 |
Defined in GHC.TypeLits Methods compare :: SomeSymbol -> SomeSymbol -> Ordering # (<) :: SomeSymbol -> SomeSymbol -> Bool # (<=) :: SomeSymbol -> SomeSymbol -> Bool # (>) :: SomeSymbol -> SomeSymbol -> Bool # (>=) :: SomeSymbol -> SomeSymbol -> Bool # max :: SomeSymbol -> SomeSymbol -> SomeSymbol # min :: SomeSymbol -> SomeSymbol -> SomeSymbol # | |
| Ord SomeNat | Since: base-4.7.0.0 |
| Ord Fingerprint | Since: base-4.4.0.0 |
Defined in GHC.Fingerprint.Type Methods compare :: Fingerprint -> Fingerprint -> Ordering # (<) :: Fingerprint -> Fingerprint -> Bool # (<=) :: Fingerprint -> Fingerprint -> Bool # (>) :: Fingerprint -> Fingerprint -> Bool # (>=) :: Fingerprint -> Fingerprint -> Bool # max :: Fingerprint -> Fingerprint -> Fingerprint # min :: Fingerprint -> Fingerprint -> Fingerprint # | |
| Ord GeneralCategory | Since: base-2.1 |
Defined in GHC.Unicode Methods compare :: GeneralCategory -> GeneralCategory -> Ordering # (<) :: GeneralCategory -> GeneralCategory -> Bool # (<=) :: GeneralCategory -> GeneralCategory -> Bool # (>) :: GeneralCategory -> GeneralCategory -> Bool # (>=) :: GeneralCategory -> GeneralCategory -> Bool # max :: GeneralCategory -> GeneralCategory -> GeneralCategory # min :: GeneralCategory -> GeneralCategory -> GeneralCategory # | |
| Ord Options | |
| Ord IntSet | |
| Ord ShowOptions | |
Defined in Text.Show.Deriving.Internal Methods compare :: ShowOptions -> ShowOptions -> Ordering # (<) :: ShowOptions -> ShowOptions -> Bool # (<=) :: ShowOptions -> ShowOptions -> Bool # (>) :: ShowOptions -> ShowOptions -> Bool # (>=) :: ShowOptions -> ShowOptions -> Bool # max :: ShowOptions -> ShowOptions -> ShowOptions # min :: ShowOptions -> ShowOptions -> ShowOptions # | |
| Ord ReadOptions | |
Defined in Text.Read.Deriving.Internal Methods compare :: ReadOptions -> ReadOptions -> Ordering # (<) :: ReadOptions -> ReadOptions -> Bool # (<=) :: ReadOptions -> ReadOptions -> Bool # (>) :: ReadOptions -> ReadOptions -> Bool # (>=) :: ReadOptions -> ReadOptions -> Bool # max :: ReadOptions -> ReadOptions -> ReadOptions # min :: ReadOptions -> ReadOptions -> ReadOptions # | |
| Ord TyVarBndr | |
| Ord DefName | |
Defined in Control.Lens.Internal.FieldTH | |
| Ord Pos | |
| Ord SourcePos | |
| Ord ByteArray | Non-lexicographic ordering. This compares the lengths of the byte arrays first and uses a lexicographic ordering if the lengths are equal. Subject to change between major versions. Since: primitive-0.6.3.0 |
| Ord Addr | |
| Ord ModName | |
Defined in Language.Haskell.TH.Syntax | |
| Ord PkgName | |
Defined in Language.Haskell.TH.Syntax | |
| Ord Module | |
| Ord OccName | |
Defined in Language.Haskell.TH.Syntax | |
| Ord NameFlavour | |
Defined in Language.Haskell.TH.Syntax Methods compare :: NameFlavour -> NameFlavour -> Ordering # (<) :: NameFlavour -> NameFlavour -> Bool # (<=) :: NameFlavour -> NameFlavour -> Bool # (>) :: NameFlavour -> NameFlavour -> Bool # (>=) :: NameFlavour -> NameFlavour -> Bool # max :: NameFlavour -> NameFlavour -> NameFlavour # min :: NameFlavour -> NameFlavour -> NameFlavour # | |
| Ord NameSpace | |
| Ord Loc | |
| Ord Info | |
| Ord ModuleInfo | |
Defined in Language.Haskell.TH.Syntax Methods compare :: ModuleInfo -> ModuleInfo -> Ordering # (<) :: ModuleInfo -> ModuleInfo -> Bool # (<=) :: ModuleInfo -> ModuleInfo -> Bool # (>) :: ModuleInfo -> ModuleInfo -> Bool # (>=) :: ModuleInfo -> ModuleInfo -> Bool # max :: ModuleInfo -> ModuleInfo -> ModuleInfo # min :: ModuleInfo -> ModuleInfo -> ModuleInfo # | |
| Ord Fixity | |
| Ord FixityDirection | |
Defined in Language.Haskell.TH.Syntax Methods compare :: FixityDirection -> FixityDirection -> Ordering # (<) :: FixityDirection -> FixityDirection -> Bool # (<=) :: FixityDirection -> FixityDirection -> Bool # (>) :: FixityDirection -> FixityDirection -> Bool # (>=) :: FixityDirection -> FixityDirection -> Bool # max :: FixityDirection -> FixityDirection -> FixityDirection # min :: FixityDirection -> FixityDirection -> FixityDirection # | |
| Ord Lit | |
| Ord Body | |
| Ord Guard | |
| Ord Stmt | |
| Ord Range | |
| Ord DerivClause | |
Defined in Language.Haskell.TH.Syntax Methods compare :: DerivClause -> DerivClause -> Ordering # (<) :: DerivClause -> DerivClause -> Bool # (<=) :: DerivClause -> DerivClause -> Bool # (>) :: DerivClause -> DerivClause -> Bool # (>=) :: DerivClause -> DerivClause -> Bool # max :: DerivClause -> DerivClause -> DerivClause # min :: DerivClause -> DerivClause -> DerivClause # | |
| Ord DerivStrategy | |
Defined in Language.Haskell.TH.Syntax Methods compare :: DerivStrategy -> DerivStrategy -> Ordering # (<) :: DerivStrategy -> DerivStrategy -> Bool # (<=) :: DerivStrategy -> DerivStrategy -> Bool # (>) :: DerivStrategy -> DerivStrategy -> Bool # (>=) :: DerivStrategy -> DerivStrategy -> Bool # max :: DerivStrategy -> DerivStrategy -> DerivStrategy # min :: DerivStrategy -> DerivStrategy -> DerivStrategy # | |
| Ord TypeFamilyHead | |
Defined in Language.Haskell.TH.Syntax Methods compare :: TypeFamilyHead -> TypeFamilyHead -> Ordering # (<) :: TypeFamilyHead -> TypeFamilyHead -> Bool # (<=) :: TypeFamilyHead -> TypeFamilyHead -> Bool # (>) :: TypeFamilyHead -> TypeFamilyHead -> Bool # (>=) :: TypeFamilyHead -> TypeFamilyHead -> Bool # max :: TypeFamilyHead -> TypeFamilyHead -> TypeFamilyHead # min :: TypeFamilyHead -> TypeFamilyHead -> TypeFamilyHead # | |
| Ord TySynEqn | |
Defined in Language.Haskell.TH.Syntax | |
| Ord Foreign | |
Defined in Language.Haskell.TH.Syntax | |
| Ord Callconv | |
Defined in Language.Haskell.TH.Syntax | |
| Ord Safety | |
| Ord Pragma | |
| Ord Inline | |
| Ord RuleMatch | |
| Ord Phases | |
| Ord RuleBndr | |
Defined in Language.Haskell.TH.Syntax | |
| Ord AnnTarget | |
| Ord SourceUnpackedness | |
Defined in Language.Haskell.TH.Syntax 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 SourceStrictness | |
Defined in Language.Haskell.TH.Syntax 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 DecidedStrictness | |
Defined in Language.Haskell.TH.Syntax 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 Bang | |
| Ord PatSynDir | |
| Ord PatSynArgs | |
Defined in Language.Haskell.TH.Syntax Methods compare :: PatSynArgs -> PatSynArgs -> Ordering # (<) :: PatSynArgs -> PatSynArgs -> Bool # (<=) :: PatSynArgs -> PatSynArgs -> Bool # (>) :: PatSynArgs -> PatSynArgs -> Bool # (>=) :: PatSynArgs -> PatSynArgs -> Bool # max :: PatSynArgs -> PatSynArgs -> PatSynArgs # min :: PatSynArgs -> PatSynArgs -> PatSynArgs # | |
| Ord FamilyResultSig | |
Defined in Language.Haskell.TH.Syntax Methods compare :: FamilyResultSig -> FamilyResultSig -> Ordering # (<) :: FamilyResultSig -> FamilyResultSig -> Bool # (<=) :: FamilyResultSig -> FamilyResultSig -> Bool # (>) :: FamilyResultSig -> FamilyResultSig -> Bool # (>=) :: FamilyResultSig -> FamilyResultSig -> Bool # max :: FamilyResultSig -> FamilyResultSig -> FamilyResultSig # min :: FamilyResultSig -> FamilyResultSig -> FamilyResultSig # | |
| Ord TyLit | |
| Ord Role | |
| Ord AnnLookup | |
| Ord DatatypeVariant | |
Defined in Language.Haskell.TH.Datatype Methods compare :: DatatypeVariant -> DatatypeVariant -> Ordering # (<) :: DatatypeVariant -> DatatypeVariant -> Bool # (<=) :: DatatypeVariant -> DatatypeVariant -> Bool # (>) :: DatatypeVariant -> DatatypeVariant -> Bool # (>=) :: DatatypeVariant -> DatatypeVariant -> Bool # max :: DatatypeVariant -> DatatypeVariant -> DatatypeVariant # min :: DatatypeVariant -> DatatypeVariant -> DatatypeVariant # | |
| Ord ConstructorVariant | |
Defined in Language.Haskell.TH.Datatype Methods compare :: ConstructorVariant -> ConstructorVariant -> Ordering # (<) :: ConstructorVariant -> ConstructorVariant -> Bool # (<=) :: ConstructorVariant -> ConstructorVariant -> Bool # (>) :: ConstructorVariant -> ConstructorVariant -> Bool # (>=) :: ConstructorVariant -> ConstructorVariant -> Bool # max :: ConstructorVariant -> ConstructorVariant -> ConstructorVariant # min :: ConstructorVariant -> ConstructorVariant -> ConstructorVariant # | |
| Ord FieldStrictness | |
Defined in Language.Haskell.TH.Datatype Methods compare :: FieldStrictness -> FieldStrictness -> Ordering # (<) :: FieldStrictness -> FieldStrictness -> Bool # (<=) :: FieldStrictness -> FieldStrictness -> Bool # (>) :: FieldStrictness -> FieldStrictness -> Bool # (>=) :: FieldStrictness -> FieldStrictness -> Bool # max :: FieldStrictness -> FieldStrictness -> FieldStrictness # min :: FieldStrictness -> FieldStrictness -> FieldStrictness # | |
| Ord Unpackedness | |
Defined in Language.Haskell.TH.Datatype Methods compare :: Unpackedness -> Unpackedness -> Ordering # (<) :: Unpackedness -> Unpackedness -> Bool # (<=) :: Unpackedness -> Unpackedness -> Bool # (>) :: Unpackedness -> Unpackedness -> Bool # (>=) :: Unpackedness -> Unpackedness -> Bool # max :: Unpackedness -> Unpackedness -> Unpackedness # min :: Unpackedness -> Unpackedness -> Unpackedness # | |
| Ord Strictness | |
Defined in Language.Haskell.TH.Datatype Methods compare :: Strictness -> Strictness -> Ordering # (<) :: Strictness -> Strictness -> Bool # (<=) :: Strictness -> Strictness -> Bool # (>) :: Strictness -> Strictness -> Bool # (>=) :: Strictness -> Strictness -> Bool # max :: Strictness -> Strictness -> Strictness # min :: Strictness -> Strictness -> Strictness # | |
| Ord a => Ord [a] | |
| Ord a => Ord (Maybe a) | Since: base-2.1 |
| Integral a => Ord (Ratio a) | Since: base-2.0.1 |
| Ord (Ptr a) | Since: base-2.1 |
| Ord (FunPtr a) | |
Defined in GHC.Ptr | |
| Ord p => Ord (Par1 p) | Since: base-4.7.0.0 |
| Ord a => Ord (Min a) | Since: base-4.9.0.0 |
| Ord a => Ord (Max a) | Since: base-4.9.0.0 |
| Ord a => Ord (First a) | Since: base-4.9.0.0 |
| Ord a => Ord (Last a) | Since: base-4.9.0.0 |
| Ord m => Ord (WrappedMonoid m) | Since: base-4.9.0.0 |
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 (Option a) | Since: base-4.9.0.0 |
Defined in Data.Semigroup | |
| Ord a => Ord (ZipList a) | Since: base-4.7.0.0 |
| Ord a => Ord (Identity a) | Since: base-4.8.0.0 |
Defined in Data.Functor.Identity | |
| Ord a => Ord (First a) | Since: base-2.1 |
| Ord a => Ord (Last a) | Since: base-2.1 |
| Ord a => Ord (Dual a) | Since: base-2.1 |
| Ord a => Ord (Sum a) | Since: base-2.1 |
| Ord a => Ord (Product a) | Since: base-2.1 |
| Ord a => Ord (Down a) | Since: base-4.6.0.0 |
| Ord a => Ord (NonEmpty a) | Since: base-4.9.0.0 |
| Ord a => Ord (IntMap a) | |
Defined in Data.IntMap.Internal | |
| Ord a => Ord (Seq a) | |
| Ord a => Ord (ViewL a) | |
Defined in Data.Sequence.Internal | |
| Ord a => Ord (ViewR a) | |
Defined in Data.Sequence.Internal | |
| Ord a => Ord (Set a) | |
| Ord a => Ord (DList a) | |
| Ord a => Ord (Hashed a) | |
Defined in Data.Hashable.Class | |
| (Prim a, Ord a) => Ord (Vector a) | |
Defined in Data.Vector.Primitive | |
| (Storable a, Ord a) => Ord (Vector a) | |
Defined in Data.Vector.Storable | |
| Ord a => Ord (HashSet a) | |
| Ord a => Ord (Vector a) | |
Defined in Data.Vector | |
| Ord t => Ord (ErrorItem t) | |
Defined in Text.Megaparsec.Error | |
| Ord e => Ord (ErrorFancy e) | |
Defined in Text.Megaparsec.Error Methods compare :: ErrorFancy e -> ErrorFancy e -> Ordering # (<) :: ErrorFancy e -> ErrorFancy e -> Bool # (<=) :: ErrorFancy e -> ErrorFancy e -> Bool # (>) :: ErrorFancy e -> ErrorFancy e -> Bool # (>=) :: ErrorFancy e -> ErrorFancy e -> Bool # max :: ErrorFancy e -> ErrorFancy e -> ErrorFancy e # min :: ErrorFancy e -> ErrorFancy e -> ErrorFancy e # | |
| (Ord a, PrimUnlifted a) => Ord (UnliftedArray a) | Lexicographic ordering. Subject to change between major versions. Since: primitive-0.6.4.0 |
Defined in Data.Primitive.UnliftedArray Methods compare :: UnliftedArray a -> UnliftedArray a -> Ordering # (<) :: UnliftedArray a -> UnliftedArray a -> Bool # (<=) :: UnliftedArray a -> UnliftedArray a -> Bool # (>) :: UnliftedArray a -> UnliftedArray a -> Bool # (>=) :: UnliftedArray a -> UnliftedArray a -> Bool # max :: UnliftedArray a -> UnliftedArray a -> UnliftedArray a # min :: UnliftedArray a -> UnliftedArray a -> UnliftedArray a # | |
| (Ord a, Prim a) => Ord (PrimArray a) | Lexicographic ordering. Subject to change between major versions. Since: primitive-0.6.4.0 |
Defined in Data.Primitive.PrimArray | |
| Ord a => Ord (SmallArray a) | Lexicographic ordering. Subject to change between major versions. |
Defined in Data.Primitive.SmallArray Methods compare :: SmallArray a -> SmallArray a -> Ordering # (<) :: SmallArray a -> SmallArray a -> Bool # (<=) :: SmallArray a -> SmallArray a -> Bool # (>) :: SmallArray a -> SmallArray a -> Bool # (>=) :: SmallArray a -> SmallArray a -> Bool # max :: SmallArray a -> SmallArray a -> SmallArray a # min :: SmallArray a -> SmallArray a -> SmallArray a # | |
| Ord a => Ord (Array a) | Lexicographic ordering. Subject to change between major versions. |
Defined in Data.Primitive.Array | |
| Ord1 f => Ord (Fix f) | |
| (Functor f, Ord1 f) => Ord (Mu f) | |
| (Functor f, Ord1 f) => Ord (Nu f) | |
| Ord a => Ord (OneTuple a) Source # | |
Defined in Prologue.Data.OneTuple | |
| (Ord a, Ord b) => Ord (Either a b) | Since: base-2.1 |
| Ord (V1 p) | Since: base-4.9.0.0 |
| Ord (U1 p) | Since: base-4.7.0.0 |
| Ord (TypeRep a) | Since: base-4.4.0.0 |
| (Ord a, Ord b) => Ord (a, b) | |
| (Ord k, Ord v) => Ord (HashMap k v) | The order is total. Note: Because the hash is not guaranteed to be stable across library
versions, OSes, or architectures, neither is an actual order of elements in
|
Defined in Data.HashMap.Base | |
| (Ord k, Ord v) => Ord (Map k v) | |
| (Ix i, Ord e) => Ord (Array i e) | Since: base-2.1 |
| Ord a => Ord (Arg a b) | Since: base-4.9.0.0 |
| Ord (Proxy s) | Since: base-4.7.0.0 |
| (Ord1 m, Ord a) => Ord (MaybeT m a) | |
Defined in Control.Monad.Trans.Maybe | |
| (Ord1 f, Ord a) => Ord (Cofree f a) | |
Defined in Control.Comonad.Cofree | |
| (Ord1 f, Ord a) => Ord (Free f a) | |
Defined in Control.Monad.Free | |
| (Ord1 f, Ord a) => Ord (Yoneda f a) | |
Defined in Data.Functor.Yoneda | |
| (Ord i, Ord a) => Ord (Level i a) | |
| (Ord a, Ord b) => Ord (ListF a b) | |
| (Ord a, Ord b) => Ord (NonEmptyF a b) | |
Defined in Data.Functor.Base Methods compare :: NonEmptyF a b -> NonEmptyF a b -> Ordering # (<) :: NonEmptyF a b -> NonEmptyF a b -> Bool # (<=) :: NonEmptyF a b -> NonEmptyF a b -> Bool # (>) :: NonEmptyF a b -> NonEmptyF a b -> Bool # (>=) :: NonEmptyF a b -> NonEmptyF a b -> Bool # | |
| Ord (f p) => Ord (Rec1 f p) | Since: base-4.7.0.0 |
Defined in GHC.Generics | |
| Ord (URec (Ptr ()) p) | Since: base-4.9.0.0 |
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) | Since: base-4.9.0.0 |
Defined in GHC.Generics | |
| Ord (URec Double p) | Since: base-4.9.0.0 |
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) | Since: base-4.9.0.0 |
| Ord (URec Word p) | Since: base-4.9.0.0 |
Defined in GHC.Generics | |
| (Ord a, Ord b, Ord c) => Ord (a, b, c) | |
| Ord a => Ord (Const a b) | Since: base-4.9.0.0 |
| Ord (f a) => Ord (Ap f a) | Since: base-4.12.0.0 |
| Ord (f a) => Ord (Alt f a) | Since: base-4.8.0.0 |
Defined in Data.Semigroup.Internal | |
| Ord (a :~: b) | Since: base-4.7.0.0 |
Defined in Data.Type.Equality | |
| Ord (p a a) => Ord (Join p a) | |
Defined in Data.Bifunctor.Join | |
| Ord (p (Fix p a) a) => Ord (Fix p a) | |
| (Ord1 f, Ord a) => Ord (IdentityT f a) | |
Defined in Control.Monad.Trans.Identity Methods compare :: IdentityT f a -> IdentityT f a -> Ordering # (<) :: IdentityT f a -> IdentityT f a -> Bool # (<=) :: IdentityT f a -> IdentityT f a -> Bool # (>) :: IdentityT f a -> IdentityT f a -> Bool # (>=) :: IdentityT f a -> IdentityT f a -> Bool # | |
| (Ord e, Ord1 m, Ord a) => Ord (ExceptT e m a) | |
Defined in Control.Monad.Trans.Except Methods compare :: ExceptT e m a -> ExceptT e m a -> Ordering # (<) :: ExceptT e m a -> ExceptT e m a -> Bool # (<=) :: ExceptT e m a -> ExceptT e m a -> Bool # (>) :: ExceptT e m a -> ExceptT e m a -> Bool # (>=) :: ExceptT e m a -> ExceptT e m a -> Bool # | |
| (Ord a, Ord (f b)) => Ord (FreeF f a b) | |
Defined in Control.Monad.Trans.Free | |
| (Ord1 f, Ord1 m, Ord a) => Ord (FreeT f m a) | |
Defined in Control.Monad.Trans.Free | |
| (Ord a, Ord (f b)) => Ord (CofreeF f a b) | |
Defined in Control.Comonad.Trans.Cofree Methods compare :: CofreeF f a b -> CofreeF f a b -> Ordering # (<) :: CofreeF f a b -> CofreeF f a b -> Bool # (<=) :: CofreeF f a b -> CofreeF f a b -> Bool # (>) :: CofreeF f a b -> CofreeF f a b -> Bool # (>=) :: CofreeF f a b -> CofreeF f a b -> Bool # | |
| Ord (w (CofreeF f a (CofreeT f w a))) => Ord (CofreeT f w a) | |
Defined in Control.Comonad.Trans.Cofree Methods compare :: CofreeT f w a -> CofreeT f w a -> Ordering # (<) :: CofreeT f w a -> CofreeT f w a -> Bool # (<=) :: CofreeT f w a -> CofreeT f w a -> Bool # (>) :: CofreeT f w a -> CofreeT f w a -> Bool # (>=) :: CofreeT f w a -> CofreeT f w a -> Bool # | |
| (Ord e, Ord1 m, Ord a) => Ord (ErrorT e m a) | |
Defined in Control.Monad.Trans.Error | |
| Ord b => Ord (Tagged s b) | |
| Ord c => Ord (K1 i c p) | Since: base-4.7.0.0 |
Defined in GHC.Generics | |
| (Ord (f p), Ord (g p)) => Ord ((f :+: g) p) | Since: base-4.7.0.0 |
Defined in GHC.Generics | |
| (Ord (f p), Ord (g p)) => Ord ((f :*: g) p) | Since: base-4.7.0.0 |
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 (Product f g a) | Since: base-4.9.0.0 |
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) | Since: base-4.9.0.0 |
| Ord (a :~~: b) | Since: base-4.10.0.0 |
| Ord (f p) => Ord (M1 i c f p) | Since: base-4.7.0.0 |
| Ord (f (g p)) => Ord ((f :.: g) p) | Since: base-4.7.0.0 |
Defined in GHC.Generics | |
| (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) # | |
| (Ord1 f, Ord1 g, Ord a) => Ord (Compose f g a) | Since: base-4.9.0.0 |
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 (p a b) => Ord (WrappedBifunctor p a b) | |
Defined in Data.Bifunctor.Wrapped Methods compare :: WrappedBifunctor p a b -> WrappedBifunctor p a b -> Ordering # (<) :: WrappedBifunctor p a b -> WrappedBifunctor p a b -> Bool # (<=) :: WrappedBifunctor p a b -> WrappedBifunctor p a b -> Bool # (>) :: WrappedBifunctor p a b -> WrappedBifunctor p a b -> Bool # (>=) :: WrappedBifunctor p a b -> WrappedBifunctor p a b -> Bool # max :: WrappedBifunctor p a b -> WrappedBifunctor p a b -> WrappedBifunctor p a b # min :: WrappedBifunctor p a b -> WrappedBifunctor p a b -> WrappedBifunctor p a b # | |
| Ord (g b) => Ord (Joker g a b) | |
Defined in Data.Bifunctor.Joker | |
| Ord (p b a) => Ord (Flip p a b) | |
Defined in Data.Bifunctor.Flip | |
| Ord (f a) => Ord (Clown f a b) | |
Defined in Data.Bifunctor.Clown | |
| (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 (p a b), Ord (q a b)) => Ord (Sum p q a b) | |
Defined in Data.Bifunctor.Sum | |
| (Ord (f a b), Ord (g a b)) => Ord (Product f g a b) | |
Defined in Data.Bifunctor.Product Methods compare :: Product f g a b -> Product f g a b -> Ordering # (<) :: Product f g a b -> Product f g a b -> Bool # (<=) :: Product f g a b -> Product f g a b -> Bool # (>) :: Product f g a b -> Product f g a b -> Bool # (>=) :: Product f g a b -> Product f g a b -> Bool # max :: Product f g a b -> Product f g a b -> Product f g a b # min :: Product f g a b -> Product f g a b -> Product f g a b # | |
| (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 (f (p a b)) => Ord (Tannen f p a b) | |
Defined in Data.Bifunctor.Tannen Methods compare :: Tannen f p a b -> Tannen f p a b -> Ordering # (<) :: Tannen f p a b -> Tannen f p a b -> Bool # (<=) :: Tannen f p a b -> Tannen f p a b -> Bool # (>) :: Tannen f p a b -> Tannen f p a b -> Bool # (>=) :: Tannen f p a b -> Tannen f p a b -> Bool # | |
| (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 (p (f a) (g b)) => Ord (Biff p f g a b) | |
Defined in Data.Bifunctor.Biff Methods compare :: Biff p f g a b -> Biff p f g a b -> Ordering # (<) :: Biff p f g a b -> Biff p f g a b -> Bool # (<=) :: Biff p f g a b -> Biff p f g a b -> Bool # (>) :: Biff p f g a b -> Biff p f g a b -> Bool # (>=) :: Biff p f g a b -> Biff p f g a b -> Bool # | |
| (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
The character type Char is an enumeration whose values represent
Unicode (or equivalently ISO/IEC 10646) code points (i.e. characters, see
http://www.unicode.org/ for details). This set extends the ISO 8859-1
(Latin-1) character set (the first 256 characters), which is itself an extension
of the ASCII character set (the first 128 characters). A character literal in
Haskell has type Char.
To convert a Char to or from the corresponding Int value defined
by Unicode, use toEnum and fromEnum from the
Enum class respectively (or equivalently ord and chr).
Instances
Double-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE double-precision type.
Instances
Single-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE single-precision type.
Instances
A fixed-precision integer type with at least the range [-2^29 .. 2^29-1].
The exact range for a given implementation can be determined by using
minBound and maxBound from the Bounded class.
Instances
Invariant: Jn# and Jp# are used iff value doesn't fit in S#
Useful properties resulting from the invariants:
Instances
The Maybe type encapsulates an optional value. A value of type
Maybe aa (represented as Just aNothing). Using Maybe is a good way to
deal with errors or exceptional cases without resorting to drastic
measures such as error.
The Maybe type is also a monad. It is a simple kind of error
monad, where all errors are represented by Nothing. A richer
error monad can be built using the Either type.
Instances
| Monad Maybe | Since: base-2.1 |
| Functor Maybe | Since: base-2.1 |
| MonadFix Maybe | Since: base-2.1 |
Defined in Control.Monad.Fix | |
| MonadFail Maybe | Since: base-4.9.0.0 |
Defined in Control.Monad.Fail | |
| Applicative Maybe | Since: base-2.1 |
| Foldable Maybe | Since: base-2.1 |
Defined in Data.Foldable Methods fold :: Monoid m => Maybe m -> m # foldMap :: Monoid m => (a -> m) -> Maybe a -> m # foldr :: (a -> b -> b) -> b -> Maybe a -> b # foldr' :: (a -> b -> b) -> b -> Maybe a -> b # foldl :: (b -> a -> b) -> b -> Maybe a -> b # foldl' :: (b -> a -> b) -> b -> Maybe a -> b # foldr1 :: (a -> a -> a) -> Maybe a -> a # foldl1 :: (a -> a -> a) -> Maybe a -> a # elem :: Eq a => a -> Maybe a -> Bool # maximum :: Ord a => Maybe a -> a # minimum :: Ord a => Maybe a -> a # | |
| Traversable Maybe | Since: base-2.1 |
| Alternative Maybe | Since: base-2.1 |
| MonadPlus Maybe | Since: base-2.1 |
| Eq1 Maybe | Since: base-4.9.0.0 |
| Ord1 Maybe | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
| Read1 Maybe | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
| Show1 Maybe | Since: base-4.9.0.0 |
| NFData1 Maybe | Since: deepseq-1.4.3.0 |
Defined in Control.DeepSeq | |
| MonadThrow Maybe | |
Defined in Control.Monad.Catch | |
| Hashable1 Maybe | |
Defined in Data.Hashable.Class | |
| Apply Maybe | |
| Pointed Maybe | |
Defined in Data.Pointed | |
| Alt Maybe | |
| Bind Maybe | |
| FunctorWithIndex () Maybe | |
Defined in Control.Lens.Indexed | |
| FoldableWithIndex () Maybe | |
| TraversableWithIndex () Maybe | |
Defined in Control.Lens.Indexed Methods itraverse :: Applicative f => (() -> a -> f b) -> Maybe a -> f (Maybe b) # itraversed :: IndexedTraversal () (Maybe a) (Maybe b) a b # | |
| Eq a => Eq (Maybe a) | Since: base-2.1 |
| Data a => Data (Maybe a) | Since: base-4.0.0.0 |
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Maybe a -> c (Maybe a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Maybe a) # toConstr :: Maybe a -> Constr # dataTypeOf :: Maybe a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Maybe a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Maybe a)) # gmapT :: (forall b. Data b => b -> b) -> Maybe a -> Maybe a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r # gmapQ :: (forall d. Data d => d -> u) -> Maybe a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Maybe a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) # | |
| Ord a => Ord (Maybe a) | Since: base-2.1 |
| Read a => Read (Maybe a) | Since: base-2.1 |
| Show a => Show (Maybe a) | Since: base-2.1 |
| Generic (Maybe a) | |
| Semigroup a => Semigroup (Maybe a) | Since: base-4.9.0.0 |
| Semigroup a => Monoid (Maybe a) | Lift a semigroup into Since 4.11.0: constraint on inner Since: base-2.1 |
| Lift a => Lift (Maybe a) | |
| Hashable a => Hashable (Maybe a) | |
Defined in Data.Hashable.Class | |
| SingKind a => SingKind (Maybe a) | Since: base-4.9.0.0 |
Defined in GHC.Generics | |
| Default (Maybe a) | |
Defined in Data.Default.Class | |
| NFData a => NFData (Maybe a) | |
Defined in Control.DeepSeq | |
| Ixed (Maybe a) | |
Defined in Control.Lens.At | |
| At (Maybe a) | |
| AsEmpty (Maybe a) | |
Defined in Control.Lens.Empty | |
| Mempty (Maybe a) | |
Defined in Data.Monoids | |
| Recursive (Maybe a) | |
Defined in Data.Functor.Foldable Methods project :: Maybe a -> Base (Maybe a) (Maybe a) # cata :: (Base (Maybe a) a0 -> a0) -> Maybe a -> a0 # para :: (Base (Maybe a) (Maybe a, a0) -> a0) -> Maybe a -> a0 # gpara :: (Corecursive (Maybe a), Comonad w) => (forall b. Base (Maybe a) (w b) -> w (Base (Maybe a) b)) -> (Base (Maybe a) (EnvT (Maybe a) w a0) -> a0) -> Maybe a -> a0 # prepro :: Corecursive (Maybe a) => (forall b. Base (Maybe a) b -> Base (Maybe a) b) -> (Base (Maybe a) a0 -> a0) -> Maybe a -> a0 # gprepro :: (Corecursive (Maybe a), Comonad w) => (forall b. Base (Maybe a) (w b) -> w (Base (Maybe a) b)) -> (forall c. Base (Maybe a) c -> Base (Maybe a) c) -> (Base (Maybe a) (w a0) -> a0) -> Maybe a -> a0 # | |
| Corecursive (Maybe a) | |
Defined in Data.Functor.Foldable Methods embed :: Base (Maybe a) (Maybe a) -> Maybe a # ana :: (a0 -> Base (Maybe a) a0) -> a0 -> Maybe a # apo :: (a0 -> Base (Maybe a) (Either (Maybe a) a0)) -> a0 -> Maybe a # postpro :: Recursive (Maybe a) => (forall b. Base (Maybe a) b -> Base (Maybe a) b) -> (a0 -> Base (Maybe a) a0) -> a0 -> Maybe a # gpostpro :: (Recursive (Maybe a), Monad m) => (forall b. m (Base (Maybe a) b) -> Base (Maybe a) (m b)) -> (forall c. Base (Maybe a) c -> Base (Maybe a) c) -> (a0 -> Base (Maybe a) (m a0)) -> a0 -> Maybe a # | |
| Generic1 Maybe | |
| SingI (Nothing :: Maybe a) | Since: base-4.9.0.0 |
Defined in GHC.Generics | |
| Each (Maybe a) (Maybe b) a b |
|
| SingI a2 => SingI (Just a2 :: Maybe a1) | Since: base-4.9.0.0 |
Defined in GHC.Generics | |
| type Rep (Maybe a) | Since: base-4.6.0.0 |
| data Sing (b :: Maybe a) | |
| type DemoteRep (Maybe a) | |
Defined in GHC.Generics | |
| type Index (Maybe a) | |
Defined in Control.Lens.At | |
| type IxValue (Maybe a) | |
Defined in Control.Lens.At | |
| type Base (Maybe a) | Example boring stub for non-recursive data types |
| type Rep1 Maybe | Since: base-4.6.0.0 |
Instances
| Bounded Ordering | Since: base-2.1 |
| Enum Ordering | Since: base-2.1 |
| Eq Ordering | |
| Data Ordering | Since: base-4.0.0.0 |
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ordering -> c Ordering # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Ordering # toConstr :: Ordering -> Constr # dataTypeOf :: Ordering -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Ordering) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ordering) # gmapT :: (forall b. Data b => b -> b) -> Ordering -> Ordering # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ordering -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ordering -> r # gmapQ :: (forall d. Data d => d -> u) -> Ordering -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Ordering -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering # | |
| Ord Ordering | |
Defined in GHC.Classes | |
| Read Ordering | Since: base-2.1 |
| Show Ordering | Since: base-2.1 |
| Ix Ordering | Since: base-2.1 |
Defined in GHC.Arr | |
| Generic Ordering | |
| Semigroup Ordering | Since: base-4.9.0.0 |
| Monoid Ordering | Since: base-2.1 |
| Hashable Ordering | |
Defined in Data.Hashable.Class | |
| Default Ordering | |
Defined in Data.Default.Class | |
| NFData Ordering | |
Defined in Control.DeepSeq | |
| AsEmpty Ordering | |
Defined in Control.Lens.Empty | |
| type Rep Ordering | Since: base-4.6.0.0 |
Instances
The Either type represents values with two possibilities: a value of
type Either a bLeft aRight b
The Either type is sometimes used to represent a value which is
either correct or an error; by convention, the Left constructor is
used to hold an error value and the Right constructor is used to
hold a correct value (mnemonic: "right" also means "correct").
Examples
The type Either String IntString or an Int. The Left constructor can be used only on
Strings, and the Right constructor can be used only on Ints:
>>>let s = Left "foo" :: Either String Int>>>sLeft "foo">>>let n = Right 3 :: Either String Int>>>nRight 3>>>:type ss :: Either String Int>>>:type nn :: Either String Int
The fmap from our Functor instance will ignore Left values, but
will apply the supplied function to values contained in a Right:
>>>let s = Left "foo" :: Either String Int>>>let n = Right 3 :: Either String Int>>>fmap (*2) sLeft "foo">>>fmap (*2) nRight 6
The Monad instance for Either allows us to chain together multiple
actions which may fail, and fail overall if any of the individual
steps failed. First we'll write a function that can either parse an
Int from a Char, or fail.
>>>import Data.Char ( digitToInt, isDigit )>>>:{let parseEither :: Char -> Either String Int parseEither c | isDigit c = Right (digitToInt c) | otherwise = Left "parse error">>>:}
The following should work, since both '1' and '2' can be
parsed as Ints.
>>>:{let parseMultiple :: Either String Int parseMultiple = do x <- parseEither '1' y <- parseEither '2' return (x + y)>>>:}
>>>parseMultipleRight 3
But the following should fail overall, since the first operation where
we attempt to parse 'm' as an Int will fail:
>>>:{let parseMultiple :: Either String Int parseMultiple = do x <- parseEither 'm' y <- parseEither '2' return (x + y)>>>:}
>>>parseMultipleLeft "parse error"
Instances
| Bitraversable Either | Since: base-4.10.0.0 |
Defined in Data.Bitraversable Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Either a b -> f (Either c d) # | |
| Bifoldable Either | Since: base-4.10.0.0 |
| Bifunctor Either | Since: base-4.8.0.0 |
| Eq2 Either | Since: base-4.9.0.0 |
| Ord2 Either | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
| Read2 Either | Since: base-4.9.0.0 |
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 | Since: base-4.9.0.0 |
| NFData2 Either | Since: deepseq-1.4.3.0 |
Defined in Control.DeepSeq | |
| Hashable2 Either | |
Defined in Data.Hashable.Class | |
| Bitraversable1 Either | |
Defined in Data.Semigroup.Traversable.Class Methods bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> Either a c -> f (Either b d) # bisequence1 :: Apply f => Either (f a) (f b) -> f (Either a b) # | |
| Swapped Either | |
| Bifoldable1 Either | |
Defined in Data.Semigroup.Foldable.Class | |
| Monad (Either e) | Since: base-4.4.0.0 |
| Functor (Either a) | Since: base-3.0 |
| MonadFix (Either e) | Since: base-4.3.0.0 |
Defined in Control.Monad.Fix | |
| Applicative (Either e) | Since: base-3.0 |
| Foldable (Either a) | Since: base-4.7.0.0 |
Defined in Data.Foldable Methods fold :: Monoid m => Either a m -> 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 # toList :: Either a a0 -> [a0] # length :: Either a a0 -> Int # elem :: Eq a0 => a0 -> Either a a0 -> Bool # maximum :: Ord a0 => Either a a0 -> a0 # minimum :: Ord a0 => Either a a0 -> a0 # | |
| Traversable (Either a) | Since: base-4.7.0.0 |
Defined in Data.Traversable | |
| Eq a => Eq1 (Either a) | Since: base-4.9.0.0 |
| Ord a => Ord1 (Either a) | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
| Read a => Read1 (Either a) | Since: base-4.9.0.0 |
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) | Since: base-4.9.0.0 |
| NFData a => NFData1 (Either a) | Since: deepseq-1.4.3.0 |
Defined in Control.DeepSeq | |
| e ~ SomeException => MonadThrow (Either e) | |
Defined in Control.Monad.Catch | |
| e ~ SomeException => MonadCatch (Either e) | Since: exceptions-0.8.3 |
| e ~ SomeException => MonadMask (Either e) | Since: exceptions-0.8.3 |
Defined in Control.Monad.Catch | |
| Hashable a => Hashable1 (Either a) | |
Defined in Data.Hashable.Class | |
| Apply (Either a) | |
| Pointed (Either a) | |
Defined in Data.Pointed | |
| Alt (Either a) | |
| Bind (Either a) | |
| Generic1 (Either a :: Type -> Type) | |
| (Eq a, Eq b) => Eq (Either a b) | Since: base-2.1 |
| (Data a, Data b) => Data (Either a b) | Since: base-4.0.0.0 |
Defined in Data.Data Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Either a b -> c (Either a b) # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Either a b) # toConstr :: Either a b -> Constr # dataTypeOf :: Either a b -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Either a b)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Either a b)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> Either a b -> Either a b # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Either a b -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Either a b -> r # gmapQ :: (forall d. Data d => d -> u) -> Either a b -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Either a b -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) # | |
| (Ord a, Ord b) => Ord (Either a b) | Since: base-2.1 |
| (Read a, Read b) => Read (Either a b) | Since: base-3.0 |
| (Show a, Show b) => Show (Either a b) | Since: base-3.0 |
| Generic (Either a b) | |
| Semigroup (Either a b) | Since: base-4.9.0.0 |
| (Lift a, Lift b) => Lift (Either a b) | |
| (Hashable a, Hashable b) => Hashable (Either a b) | |
Defined in Data.Hashable.Class | |
| (NFData a, NFData b) => NFData (Either a b) | |
Defined in Control.DeepSeq | |
| Recursive (Either a b) | |
Defined in Data.Functor.Foldable Methods project :: Either a b -> Base (Either a b) (Either a b) # cata :: (Base (Either a b) a0 -> a0) -> Either a b -> a0 # para :: (Base (Either a b) (Either a b, a0) -> a0) -> Either a b -> a0 # gpara :: (Corecursive (Either a b), Comonad w) => (forall b0. Base (Either a b) (w b0) -> w (Base (Either a b) b0)) -> (Base (Either a b) (EnvT (Either a b) w a0) -> a0) -> Either a b -> a0 # prepro :: Corecursive (Either a b) => (forall b0. Base (Either a b) b0 -> Base (Either a b) b0) -> (Base (Either a b) a0 -> a0) -> Either a b -> a0 # gprepro :: (Corecursive (Either a b), Comonad w) => (forall b0. Base (Either a b) (w b0) -> w (Base (Either a b) b0)) -> (forall c. Base (Either a b) c -> Base (Either a b) c) -> (Base (Either a b) (w a0) -> a0) -> Either a b -> a0 # | |
| Corecursive (Either a b) | |
Defined in Data.Functor.Foldable Methods embed :: Base (Either a b) (Either a b) -> Either a b # ana :: (a0 -> Base (Either a b) a0) -> a0 -> Either a b # apo :: (a0 -> Base (Either a b) (Either (Either a b) a0)) -> a0 -> Either a b # postpro :: Recursive (Either a b) => (forall b0. Base (Either a b) b0 -> Base (Either a b) b0) -> (a0 -> Base (Either a b) a0) -> a0 -> Either a b # gpostpro :: (Recursive (Either a b), Monad m) => (forall b0. m (Base (Either a b) b0) -> Base (Either a b) (m b0)) -> (forall c. Base (Either a b) c -> Base (Either a b) c) -> (a0 -> Base (Either a b) (m a0)) -> a0 -> Either a b # | |
| (FunctorWithIndex i f, FunctorWithIndex j g) => FunctorWithIndex (Either i j) (Sum f g) | |
| (FunctorWithIndex i f, FunctorWithIndex j g) => FunctorWithIndex (Either i j) (Product f g) | |
| (FunctorWithIndex i f, FunctorWithIndex j g) => FunctorWithIndex (Either i j) (f :+: g) | |
| (FunctorWithIndex i f, FunctorWithIndex j g) => FunctorWithIndex (Either i j) (f :*: g) | |
| (FoldableWithIndex i f, FoldableWithIndex j g) => FoldableWithIndex (Either i j) (Sum f g) | |
Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (Either i j -> a -> m) -> Sum f g a -> m # ifolded :: IndexedFold (Either i j) (Sum f g a) a # ifoldr :: (Either i j -> a -> b -> b) -> b -> Sum f g a -> b # ifoldl :: (Either i j -> b -> a -> b) -> b -> Sum f g a -> b # ifoldr' :: (Either i j -> a -> b -> b) -> b -> Sum f g a -> b # ifoldl' :: (Either i j -> b -> a -> b) -> b -> Sum f g a -> b # | |
| (FoldableWithIndex i f, FoldableWithIndex j g) => FoldableWithIndex (Either i j) (Product f g) | |
Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (Either i j -> a -> m) -> Product f g a -> m # ifolded :: IndexedFold (Either i j) (Product f g a) a # ifoldr :: (Either i j -> a -> b -> b) -> b -> Product f g a -> b # ifoldl :: (Either i j -> b -> a -> b) -> b -> Product f g a -> b # ifoldr' :: (Either i j -> a -> b -> b) -> b -> Product f g a -> b # ifoldl' :: (Either i j -> b -> a -> b) -> b -> Product f g a -> b # | |
| (FoldableWithIndex i f, FoldableWithIndex j g) => FoldableWithIndex (Either i j) (f :+: g) | |
Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (Either i j -> a -> m) -> (f :+: g) a -> m # ifolded :: IndexedFold (Either i j) ((f :+: g) a) a # ifoldr :: (Either i j -> a -> b -> b) -> b -> (f :+: g) a -> b # ifoldl :: (Either i j -> b -> a -> b) -> b -> (f :+: g) a -> b # ifoldr' :: (Either i j -> a -> b -> b) -> b -> (f :+: g) a -> b # ifoldl' :: (Either i j -> b -> a -> b) -> b -> (f :+: g) a -> b # | |
| (FoldableWithIndex i f, FoldableWithIndex j g) => FoldableWithIndex (Either i j) (f :*: g) | |
Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (Either i j -> a -> m) -> (f :*: g) a -> m # ifolded :: IndexedFold (Either i j) ((f :*: g) a) a # ifoldr :: (Either i j -> a -> b -> b) -> b -> (f :*: g) a -> b # ifoldl :: (Either i j -> b -> a -> b) -> b -> (f :*: g) a -> b # ifoldr' :: (Either i j -> a -> b -> b) -> b -> (f :*: g) a -> b # ifoldl' :: (Either i j -> b -> a -> b) -> b -> (f :*: g) a -> b # | |
| (TraversableWithIndex i f, TraversableWithIndex j g) => TraversableWithIndex (Either i j) (Sum f g) | |
Defined in Control.Lens.Indexed Methods itraverse :: Applicative f0 => (Either i j -> a -> f0 b) -> Sum f g a -> f0 (Sum f g b) # itraversed :: IndexedTraversal (Either i j) (Sum f g a) (Sum f g b) a b # | |
| (TraversableWithIndex i f, TraversableWithIndex j g) => TraversableWithIndex (Either i j) (Product f g) | |
Defined in Control.Lens.Indexed Methods itraverse :: Applicative f0 => (Either i j -> a -> f0 b) -> Product f g a -> f0 (Product f g b) # itraversed :: IndexedTraversal (Either i j) (Product f g a) (Product f g b) a b # | |
| (TraversableWithIndex i f, TraversableWithIndex j g) => TraversableWithIndex (Either i j) (f :+: g) | |
Defined in Control.Lens.Indexed Methods itraverse :: Applicative f0 => (Either i j -> a -> f0 b) -> (f :+: g) a -> f0 ((f :+: g) b) # itraversed :: IndexedTraversal (Either i j) ((f :+: g) a) ((f :+: g) b) a b # | |
| (TraversableWithIndex i f, TraversableWithIndex j g) => TraversableWithIndex (Either i j) (f :*: g) | |
Defined in Control.Lens.Indexed Methods itraverse :: Applicative f0 => (Either i j -> a -> f0 b) -> (f :*: g) a -> f0 ((f :*: g) b) # itraversed :: IndexedTraversal (Either i j) ((f :*: g) a) ((f :*: g) b) a b # | |
| type Rep1 (Either a :: Type -> Type) | Since: base-4.6.0.0 |
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) | Since: base-4.6.0.0 |
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))) | |
| type Base (Either a b) | Example boring stub for non-recursive data types |
either :: (a -> c) -> (b -> c) -> Either a b -> c #
Case analysis for the Either type.
If the value is Left aa;
if it is Right bb.
Examples
We create two values of type Either String IntLeft constructor and another using the Right constructor. Then
we apply "either" the length function (if we have a String)
or the "times-two" function (if we have an Int):
>>>let s = Left "foo" :: Either String Int>>>let n = Right 3 :: Either String Int>>>either length (*2) s3>>>either length (*2) n6
maybe :: b -> (a -> b) -> Maybe a -> b #
The maybe function takes a default value, a function, and a Maybe
value. If the Maybe value is Nothing, the function returns the
default value. Otherwise, it applies the function to the value inside
the Just and returns the result.
Examples
Basic usage:
>>>maybe False odd (Just 3)True
>>>maybe False odd NothingFalse
Read an integer from a string using readMaybe. If we succeed,
return twice the integer; that is, apply (*2) to it. If instead
we fail to parse an integer, return 0 by default:
>>>import Text.Read ( readMaybe )>>>maybe 0 (*2) (readMaybe "5")10>>>maybe 0 (*2) (readMaybe "")0
Apply show to a Maybe Int. If we have Just n, we want to show
the underlying Int n. But if we have Nothing, we return the
empty string instead of (for example) "Nothing":
>>>maybe "" show (Just 5)"5">>>maybe "" show Nothing""
Orphan instances
| Functor ((,,) t1 t2) Source # | |
| Functor ((,,,) t1 t2 t3) Source # | |
| Functor ((,,,,) t1 t2 t3 t4) Source # | |
| Functor ((,,,,,) t1 t2 t3 t4 t5) Source # | |
| Functor ((,,,,,,) t1 t2 t3 t4 t5 t6) Source # | |
| Functor ((,,,,,,,) t1 t2 t3 t4 t5 t6 t7) Source # | |
| Functor ((,,,,,,,,) t1 t2 t3 t4 t5 t6 t7 t8) Source # | |
| Functor ((,,,,,,,,,) t1 t2 t3 t4 t5 t6 t7 t8 t9) Source # | |