| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Lorentz.Prelude
Description
Commonly used parts of regular Prelude.
Synopsis
- ($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
- (.) :: (b -> c) -> (a -> b) -> a -> c
- type ($) (f :: k1 -> k) (a :: k1) = f a
- class Eq a
- class Eq a => Ord a
- class Bounded a where
- class Semigroup a where
- class Semigroup a => Monoid a where
- class Generic a
- data Text
- data Either a b
- data Maybe a
- data Proxy (t :: k) = Proxy
- fromString :: IsString a => String -> a
- undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a
- error :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => Text -> a
Documentation
($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b infixr 0 #
Application operator. This operator is redundant, since ordinary
application (f x) means the same as (f . However, $ x)$ has
low, right-associative binding precedence, so it sometimes allows
parentheses to be omitted; for example:
f $ g $ h x = f (g (h x))
It is also useful in higher-order situations, such as map ($ 0) xszipWith ($) fs xs
Note that ( is levity-polymorphic in its result type, so that
$)foo where $ Truefoo :: Bool -> Int# is well-typed.
type ($) (f :: k1 -> k) (a :: k1) = f a infixr 2 #
Infix application.
f :: Either String $ Maybe Int = f :: Either String (Maybe Int)
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 StdGen | |
| Eq Version | Since: base-2.1 |
| Eq ByteString | |
Defined in Data.ByteString.Internal | |
| Eq ByteString | |
Defined in Data.ByteString.Lazy.Internal | |
| Eq Builder | |
| Eq Scientific | Scientific numbers can be safely compared for equality. No magnitude |
Defined in Data.Scientific | |
| Eq UTCTime | |
| Eq JSONPathElement | |
Defined in Data.Aeson.Types.Internal Methods (==) :: JSONPathElement -> JSONPathElement -> Bool # (/=) :: JSONPathElement -> JSONPathElement -> Bool # | |
| Eq Value | |
| Eq DotNetTime | |
Defined in Data.Aeson.Types.Internal | |
| Eq SumEncoding | |
Defined in Data.Aeson.Types.Internal | |
| Eq Handle | Since: base-4.1.0.0 |
| Eq ThreadId | Since: base-4.2.0.0 |
| Eq Pos | |
| Eq More | |
| 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 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 BufferMode | Since: base-4.2.0.0 |
Defined in GHC.IO.Handle.Types | |
| Eq Newline | Since: base-4.2.0.0 |
| Eq NewlineMode | Since: base-4.2.0.0 |
Defined in GHC.IO.Handle.Types | |
| 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 CChar | |
| Eq CSChar | |
| Eq CUChar | |
| Eq CShort | |
| Eq CUShort | |
| Eq CInt | |
| Eq CUInt | |
| Eq CLong | |
| Eq CULong | |
| Eq CLLong | |
| Eq CULLong | |
| Eq CBool | |
| Eq CFloat | |
| Eq CDouble | |
| Eq CPtrdiff | |
| Eq CSize | |
| Eq CWchar | |
| Eq CSigAtomic | |
Defined in Foreign.C.Types | |
| Eq CClock | |
| Eq CTime | |
| Eq CUSeconds | |
| Eq CSUSeconds | |
Defined in Foreign.C.Types | |
| Eq CIntPtr | |
| Eq CUIntPtr | |
| Eq CIntMax | |
| Eq CUIntMax | |
| Eq IOMode | Since: base-4.2.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 Alphabet | |
| Eq ASCII7_Invalid | |
| Eq ISO_8859_1_Invalid | |
| Eq UTF16_Invalid | |
| Eq UTF32_Invalid | |
| Eq Encoding | |
| Eq String | |
| Eq FileSize | |
| Eq ShortByteString | |
Defined in Data.ByteString.Short.Internal Methods (==) :: ShortByteString -> ShortByteString -> Bool # (/=) :: ShortByteString -> ShortByteString -> Bool # | |
| Eq F2Poly | |
| Eq Bit | |
| Eq Clock | |
| Eq TimeSpec | |
| Eq IntSet | |
| Eq Signature | |
| Eq PrivateKey | |
Defined in Crypto.PubKey.ECC.ECDSA | |
| Eq PublicKey | |
| Eq KeyPair | |
| Eq SecretKey | |
| Eq PublicKey | |
| Eq Signature | |
| Eq CryptoError | |
Defined in Crypto.Error.Types | |
| Eq ConstructorInfo | |
Defined in Language.Haskell.TH.Datatype Methods (==) :: ConstructorInfo -> ConstructorInfo -> Bool # (/=) :: ConstructorInfo -> ConstructorInfo -> Bool # | |
| Eq DatatypeVariant | |
Defined in Language.Haskell.TH.Datatype Methods (==) :: DatatypeVariant -> DatatypeVariant -> Bool # (/=) :: DatatypeVariant -> DatatypeVariant -> Bool # | |
| Eq Extension | |
| Eq ForeignSrcLang | |
Defined in GHC.ForeignSrcLang.Type Methods (==) :: ForeignSrcLang -> ForeignSrcLang -> Bool # (/=) :: ForeignSrcLang -> ForeignSrcLang -> Bool # | |
| Eq BigNat | |
| Eq RuleBndr | |
| Eq Phases | |
| Eq RuleMatch | |
| Eq Inline | |
| Eq Pragma | |
| Eq DerivClause | |
Defined in Language.Haskell.TH.Syntax | |
| Eq DerivStrategy | |
Defined in Language.Haskell.TH.Syntax Methods (==) :: DerivStrategy -> DerivStrategy -> Bool # (/=) :: DerivStrategy -> DerivStrategy -> Bool # | |
| Eq TySynEqn | |
| Eq Fixity | |
| Eq Info | |
| Eq Con | |
| Eq TyVarBndr | |
| Eq DefName | |
| Eq Pos | |
| Eq InvalidPosException | |
Defined in Text.Megaparsec.Pos Methods (==) :: InvalidPosException -> InvalidPosException -> Bool # (/=) :: InvalidPosException -> InvalidPosException -> Bool # | |
| Eq SourcePos | |
| Eq Backtracking | |
Defined in Options.Applicative.Types | |
| Eq ParserPrefs | |
Defined in Options.Applicative.Types | |
| Eq OptName | |
| Eq OptVisibility | |
Defined in Options.Applicative.Types Methods (==) :: OptVisibility -> OptVisibility -> Bool # (/=) :: OptVisibility -> OptVisibility -> Bool # | |
| Eq ArgPolicy | |
| Eq ArgumentReachability | |
Defined in Options.Applicative.Types Methods (==) :: ArgumentReachability -> ArgumentReachability -> Bool # (/=) :: ArgumentReachability -> ArgumentReachability -> Bool # | |
| Eq AltNodeType | |
Defined in Options.Applicative.Types | |
| Eq Doc | |
| Eq TextDetails | |
Defined in Text.PrettyPrint.Annotated.HughesPJ | |
| Eq Style | |
| Eq Mode | |
| Eq ByteArray | Since: primitive-0.6.3.0 |
| Eq UnicodeException | |
Defined in Data.Text.Encoding.Error Methods (==) :: UnicodeException -> UnicodeException -> Bool # (/=) :: UnicodeException -> UnicodeException -> Bool # | |
| Eq Mod2 | |
| Eq DependencyType | |
Defined in Test.Tasty.Core Methods (==) :: DependencyType -> DependencyType -> Bool # (/=) :: DependencyType -> DependencyType -> Bool # | |
| Eq Expr | |
| Eq ModName | |
| Eq PkgName | |
| Eq Module | |
| Eq OccName | |
| Eq NameFlavour | |
Defined in Language.Haskell.TH.Syntax | |
| Eq NameSpace | |
| Eq Loc | |
| Eq ModuleInfo | |
Defined in Language.Haskell.TH.Syntax | |
| Eq FixityDirection | |
Defined in Language.Haskell.TH.Syntax Methods (==) :: FixityDirection -> FixityDirection -> Bool # (/=) :: FixityDirection -> FixityDirection -> Bool # | |
| Eq Lit | |
| Eq Bytes | |
| Eq Body | |
| Eq Guard | |
| Eq Stmt | |
| Eq Range | |
| Eq TypeFamilyHead | |
Defined in Language.Haskell.TH.Syntax Methods (==) :: TypeFamilyHead -> TypeFamilyHead -> Bool # (/=) :: TypeFamilyHead -> TypeFamilyHead -> Bool # | |
| Eq Foreign | |
| Eq Callconv | |
| Eq Safety | |
| 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 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 Specificity | |
Defined in Language.Haskell.TH.Datatype.TyVarBndr | |
| Eq DTypeArg | |
| Eq DFunArgs | |
| Eq DVisFunArg | |
Defined in Language.Haskell.TH.Desugar.Core | |
| Eq DExp | |
| Eq DPat | |
| Eq DType | |
| Eq DTyVarBndr | |
Defined in Language.Haskell.TH.Desugar.AST | |
| Eq DMatch | |
| Eq DClause | |
| Eq DLetDec | |
| Eq NewOrData | |
| Eq DDec | |
| Eq DPatSynDir | |
Defined in Language.Haskell.TH.Desugar.AST | |
| Eq DTypeFamilyHead | |
Defined in Language.Haskell.TH.Desugar.AST Methods (==) :: DTypeFamilyHead -> DTypeFamilyHead -> Bool # (/=) :: DTypeFamilyHead -> DTypeFamilyHead -> Bool # | |
| Eq DFamilyResultSig | |
Defined in Language.Haskell.TH.Desugar.AST Methods (==) :: DFamilyResultSig -> DFamilyResultSig -> Bool # (/=) :: DFamilyResultSig -> DFamilyResultSig -> Bool # | |
| Eq DCon | |
| Eq DConFields | |
Defined in Language.Haskell.TH.Desugar.AST | |
| Eq DForeign | |
| Eq DPragma | |
| Eq DRuleBndr | |
| Eq DTySynEqn | |
| Eq DInfo | |
| Eq DDerivClause | |
Defined in Language.Haskell.TH.Desugar.AST | |
| Eq DDerivStrategy | |
Defined in Language.Haskell.TH.Desugar.AST Methods (==) :: DDerivStrategy -> DDerivStrategy -> Bool # (/=) :: DDerivStrategy -> DDerivStrategy -> Bool # | |
| Eq ForallVisFlag | |
Defined in Language.Haskell.TH.Desugar.Util Methods (==) :: ForallVisFlag -> ForallVisFlag -> Bool # (/=) :: ForallVisFlag -> ForallVisFlag -> Bool # | |
| Eq FunArgs | |
| Eq VisFunArg | |
| Eq TypeArg | |
| Eq LocalTime | |
| Eq UniversalTime | |
Defined in Data.Time.Clock.Internal.UniversalTime Methods (==) :: UniversalTime -> UniversalTime -> Bool # (/=) :: UniversalTime -> UniversalTime -> Bool # | |
| Eq AbsoluteTime | |
Defined in Data.Time.Clock.Internal.AbsoluteTime | |
| Eq DayOfWeek | |
| Eq Day | |
| Eq Undefined | |
| Eq UnpackedUUID | |
| Eq UUID | |
| Eq MText | |
| Eq AnnConvergeError | |
| Eq MutezArithErrorType | |
| Eq ShiftArithErrorType | |
| Eq ArmCoord | |
| Eq EpAddress | |
| Eq ParamEpError | |
| Eq ParseEpAddressError | |
| Eq SomeValue | |
| Eq DStorageType | |
| Eq DType | |
| Eq BadTypeForScope | |
| Eq T | |
| Eq SetDelegate | |
| Eq EpName | |
| Eq EpNameFromRefAnnError | |
| Eq OpSize | |
| Eq Address | |
| Eq Bls12381Fr | |
Defined in Morley.Tezos.Crypto.BLS12381 | |
| Eq Bls12381G1 | |
Defined in Morley.Tezos.Crypto.BLS12381 | |
| Eq Bls12381G2 | |
Defined in Morley.Tezos.Crypto.BLS12381 | |
| Eq ChainId | |
| Eq KeyHash | |
| Eq Mutez | |
| Eq PublicKey | |
| Eq Signature | |
| Eq Timestamp | |
| Eq AnnotationSet | |
| Eq EntriesOrder | |
| Eq PrintComment | |
| Eq StackFn | |
| Eq StackRef | |
| Eq StackTypePattern | |
| Eq TyVar | |
| Eq Var | |
| Eq ExpandedOp | |
| Eq ParameterType | |
| Eq T | |
| Eq Ty | |
| Eq InternalByteString | |
| Eq ContractHash | |
| Eq GlobalCounter | |
| Eq ParseAddressError | |
| Eq ParseAddressRawError | |
| Eq ParseContractAddressError | |
| Eq CryptoParseError | |
| Eq ParseChainIdError | |
| Eq KeyHashTag | |
| Eq SecretKey | |
| Eq ParseSignatureRawError | |
| Eq PublicKey | |
| Eq PublicKey | |
| Eq PublicKey | |
| Eq SecretKey | |
| Eq SecretKey | |
| Eq SecretKey | |
| Eq Signature | |
| Eq Signature | |
| Eq Signature | |
| Eq DocItemPos | |
Defined in Morley.Michelson.Doc | |
| Eq SomeDocDefinitionItem | |
Defined in Morley.Michelson.Doc Methods (==) :: SomeDocDefinitionItem -> SomeDocDefinitionItem -> Bool # (/=) :: SomeDocDefinitionItem -> SomeDocDefinitionItem -> Bool # | |
| Eq UntypingOptions | |
| Eq InstrCallStack | |
| Eq DeserializationError | |
| Eq DocItemId | |
| Eq LetName | |
| Eq Pos | |
| Eq SrcPos | |
| Eq EpCallingStep Source # | |
Defined in Lorentz.Entrypoints.Core Methods (==) :: EpCallingStep -> EpCallingStep -> Bool # (/=) :: EpCallingStep -> EpCallingStep -> Bool # | |
| Eq FromExpressionError | |
| Eq Annotation | |
| Eq Expression | |
| Eq MichelinePrimAp | |
| Eq MichelinePrimitive | |
| Eq TezosMutez | |
| Eq CustomParserException | |
| Eq ParserException | |
| Eq StringLiteralParserException | |
| Eq MichelsonSource | |
| Eq ParsedOp | |
| Eq LetEnv | |
| Eq ExtError | |
| Eq StackSize | |
| Eq TCError | |
| Eq TCTypeError | |
| Eq TopLevelType | |
| Eq TypeContext | |
| Eq SomeParamType | |
| Eq SomeHST | |
| Eq TypeCheckedOp | |
| Eq IllTypedInstr | |
| Eq HexJSONByteString | |
| Eq CadrStruct | |
| Eq LetMacro | |
| Eq Macro | |
| Eq PairStruct | |
| Eq UnpairStruct | |
| Eq Positive | |
| Eq Never Source # | |
| Eq DHashAlgorithm Source # | |
Defined in Lorentz.Bytes Methods (==) :: DHashAlgorithm -> DHashAlgorithm -> Bool # (/=) :: DHashAlgorithm -> DHashAlgorithm -> Bool # | |
| Eq UnpackError | |
| Eq DThrows Source # | |
| Eq DError Source # | |
| Eq SomeError Source # | |
| Eq Transformation | |
| Eq BimapException | |
| Eq AnalyzerRes | |
| Eq ExtConversionError Source # | |
Defined in Lorentz.Extensible Methods (==) :: ExtConversionError -> ExtConversionError -> Bool # (/=) :: ExtConversionError -> ExtConversionError -> Bool # | |
| Eq DDescribeErrorTagMap Source # | |
Defined in Lorentz.Errors.Numeric.Doc Methods (==) :: DDescribeErrorTagMap -> DDescribeErrorTagMap -> Bool # (/=) :: DDescribeErrorTagMap -> DDescribeErrorTagMap -> Bool # | |
| Eq ParamBuildingStep Source # | |
Defined in Lorentz.Entrypoints.Doc Methods (==) :: ParamBuildingStep -> ParamBuildingStep -> Bool # (/=) :: ParamBuildingStep -> ParamBuildingStep -> Bool # | |
| Eq ParamBuildingDesc Source # | |
Defined in Lorentz.Entrypoints.Doc Methods (==) :: ParamBuildingDesc -> ParamBuildingDesc -> Bool # (/=) :: ParamBuildingDesc -> ParamBuildingDesc -> Bool # | |
| Eq ParamBuilder Source # | |
Defined in Lorentz.Entrypoints.Doc | |
| Eq EntrypointLookupError Source # | |
Defined in Lorentz.UParam Methods (==) :: EntrypointLookupError -> EntrypointLookupError -> Bool # (/=) :: EntrypointLookupError -> EntrypointLookupError -> Bool # | |
| Eq MichelsonFailed | |
| Eq MichelsonFailureWithStack | |
| Eq MorleyLogs | |
| Eq RemainingSteps | |
| Eq BigMapCounter | |
| Eq OperationHash | |
| Class () (Eq a) | |
Defined in Data.Constraint | |
| () :=> (Eq Bool) | |
| () :=> (Eq Double) | |
| () :=> (Eq Float) | |
| () :=> (Eq Int) | |
| () :=> (Eq Integer) | |
| () :=> (Eq Natural) | |
| () :=> (Eq Word) | |
| () :=> (Eq ()) | |
Defined in Data.Constraint | |
| () :=> (Eq (Dict a)) | |
| () :=> (Eq (a :- b)) | |
| 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 (IResult a) | |
| Eq a => Eq (Result a) | |
| Eq (ForeignPtr a) | Since: base-2.1 |
Defined in GHC.ForeignPtr | |
| 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 (IORef a) | Pointer equality. Since: base-4.0.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 (MVar a) | Since: base-4.1.0.0 |
| Eq a => Eq (NonEmpty a) | Since: base-4.9.0.0 |
| (PrimType ty, Eq ty) => Eq (UArray ty) | |
| (PrimType ty, Eq ty) => Eq (Block ty) | |
| Eq a => Eq (NonEmpty a) | |
| Eq (Offset ty) | |
| Eq (CountOf ty) | |
| Eq (Zn64 n) | |
| Eq (Zn n) | |
| Eq a => Eq (Colour a) | |
| Eq a => Eq (AlphaColour a) | |
Defined in Data.Colour.Internal Methods (==) :: AlphaColour a -> AlphaColour a -> Bool # (/=) :: AlphaColour a -> AlphaColour a -> Bool # | |
| Eq (Dict a) | |
| Eq a => Eq (IntMap a) | |
| Eq vertex => Eq (SCC vertex) | Since: containers-0.5.9 |
| 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 (Digest a) | |
| Eq a => Eq (CryptoFailable a) | |
Defined in Crypto.Error.Types Methods (==) :: CryptoFailable a -> CryptoFailable a -> Bool # (/=) :: CryptoFailable a -> CryptoFailable a -> Bool # | |
| Eq1 f => Eq (Fix f) | |
| (Functor f, Eq1 f) => Eq (Mu f) | |
| (Functor f, Eq1 f) => Eq (Nu f) | |
| Eq a => Eq (DNonEmpty a) | |
| Eq a => Eq (DList a) | |
| Eq (Prime p) | |
| Eq (Binary p) | |
| 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) | Note that, in the presence of hash collisions, equal
In general, the lack of substitutivity can be observed with any function that depends on the key ordering, such as folds and traversals. |
| Eq a => Eq (Vector a) | |
| Eq t => Eq (ErrorItem t) | |
| Eq e => Eq (ErrorFancy e) | |
Defined in Text.Megaparsec.Error | |
| Eq s => Eq (PosState s) | |
| Eq (Mod m) | |
| 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, Prim a) => Eq (PrimArray a) | Since: primitive-0.6.4.0 |
| Eq (MutableByteArray s) | |
Defined in Data.Primitive.ByteArray Methods (==) :: MutableByteArray s -> MutableByteArray s -> Bool # (/=) :: MutableByteArray s -> MutableByteArray s -> Bool # | |
| Eq a => Eq (SmallArray a) | |
Defined in Data.Primitive.SmallArray | |
| Eq a => Eq (Array a) | |
| Eq g => Eq (AtomicGen g) | |
| Eq g => Eq (IOGen g) | |
| Eq g => Eq (STGen g) | |
| Eq g => Eq (StateGen g) | |
| Eq a => Eq (Add a) | |
| Eq a => Eq (Mul a) | |
| Eq a => Eq (WrappedNum a) | |
Defined in Data.Semiring | |
| Eq (IntSetOf a) | |
| Eq a => Eq (Maybe a) | |
| Eq a => Eq (Identity a) | |
| Eq t => Eq (ElField '(s, t)) | |
| Eq (Label name) | |
| Eq (Notes t) | |
| Eq (ParamNotes t) | |
| Eq (SomeEntrypointCallT arg) | |
| Eq (ContractRef arg) | |
Defined in Morley.Michelson.Typed.Haskell.Value Methods (==) :: ContractRef arg -> ContractRef arg -> Bool # (/=) :: ContractRef arg -> ContractRef arg -> Bool # | |
| Eq arg => Eq (Ticket arg) | |
| Eq (PrintComment st) | |
| Eq (StackRef st) | |
| Eq (Operation' instr) | |
| Eq op => Eq (Contract' op) | |
| Eq op => Eq (ContractBlock op) | |
| Eq op => Eq (ExtInstrAbstract op) | |
| Eq op => Eq (TestAssert op) | |
| Eq op => Eq (InstrAbstract op) | |
| Eq op => Eq (Elt op) | |
| Eq op => Eq (Value' op) | |
| Eq (SingNat n) | |
| Eq (PeanoNatural n) | |
| Eq a => Eq (StringEncode a) | |
| Eq (HST ts) | |
| Eq (TAddress p) Source # | |
| Eq a => Eq (ReadTicket a) Source # | |
Defined in Lorentz.Value | |
| Eq (Packed a) Source # | |
| Eq (CustomErrorRep tag) => Eq (CustomError tag) Source # | |
Defined in Lorentz.Errors Methods (==) :: CustomError tag -> CustomError tag -> Bool # (/=) :: CustomError tag -> CustomError tag -> Bool # | |
| Eq r => Eq (VoidResult r) Source # | |
Defined in Lorentz.Macro | |
| Eq (UParam entries) Source # | |
| Eq (StkEl t) | |
| Class (Eq a) (Ord a) | |
| Class (Eq a) (Bits a) | |
| (Eq a) :=> (Eq [a]) | |
| (Eq a) :=> (Eq (Maybe a)) | |
| (Eq a) :=> (Eq (Complex a)) | |
| (Eq a) :=> (Eq (Ratio a)) | |
| (Eq a) :=> (Eq (Identity a)) | |
| (Eq a) :=> (Eq (Const a b)) | |
| Eq (CustomErrorRep tag) => Eq (() -> CustomError tag) Source # | |
Defined in Lorentz.Errors Methods (==) :: (() -> CustomError tag) -> (() -> CustomError tag) -> Bool # (/=) :: (() -> CustomError tag) -> (() -> CustomError tag) -> Bool # | |
| (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) | Note that, in the presence of hash collisions, equal
In general, the lack of substitutivity can be observed with any function that depends on the key ordering, such as folds and traversals. |
| (Eq k, Eq a) => Eq (Map k a) | |
| Eq (Fixed a) | 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 |
| (Eq a, Eq b) => Eq (Bimap a b) | |
| Eq (a :- b) | Assumes |
| (Eq1 m, Eq a) => Eq (MaybeT m a) | |
| (Eq1 f, Eq a) => Eq (Cofree f a) | |
| (Eq1 f, Eq a) => Eq (Free f a) | |
| Eq k => Eq (RootsOfUnity n k) | |
Defined in Data.Field.Galois.Unity Methods (==) :: RootsOfUnity n k -> RootsOfUnity n k -> Bool # (/=) :: RootsOfUnity n k -> RootsOfUnity n k -> Bool # | |
| Eq k => Eq (Extension p k) | |
| (Eq1 f, Eq a) => Eq (Yoneda f a) | |
| (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 (ParseError s e), Eq s) => Eq (State s e) | |
| (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 (v a) => Eq (Poly v a) | |
| Eq (MutablePrimArray s a) | |
Defined in Data.Primitive.PrimArray Methods (==) :: MutablePrimArray s a -> MutablePrimArray s a -> Bool # (/=) :: MutablePrimArray s a -> MutablePrimArray 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 v => Eq (IntMapOf k v) | |
| (Eq a, Eq b) => Eq (Pair a b) | |
| (Eq a, Eq b) => Eq (These a b) | |
| (Eq a, Eq b) => Eq (Either a b) | |
| (Eq a, Eq b) => Eq (These a b) | |
| (Eq k, Eq v) => Eq (Leaf k v) | |
| (Eq n, Eq m) => Eq (ArithError n m) | |
| Eq (EntrypointCallT param arg) | |
| Eq (EpLiftSequence arg param) | |
| Eq (ContractCode cp st) => Eq (Contract cp st) | |
| Eq (TransferTokens instr p) | |
| Eq (Value' instr t) | |
| Eq (Annotation tag) | |
| Eq (Contract cp st) Source # | |
| Eq (inp :-> out) Source # | |
| Eq (NFixed p) Source # | |
| Eq (Hash alg a) Source # | |
| Eq (Extensible x) Source # | |
Defined in Lorentz.Extensible | |
| Eq a => Eq (View a r) Source # | |
| (Eq a, Eq b) :=> (Eq (a, b)) | |
| (Eq a, Eq b) :=> (Eq (Either a b)) | |
| 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 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) | |
| (Eq1 f, Eq1 g, Eq a) => Eq (These1 f g a) | |
| (RPureConstrained (IndexableField rs) rs, RecApplicative rs, Eq (Rec f rs)) => Eq (ARec f rs) | |
| Eq (Rec f ('[] :: [u])) | |
| (Eq (f r), Eq (Rec f rs)) => Eq (Rec f (r ': rs)) | |
| Eq a => Eq (Const a b) | |
| Eq (CreateContract instr cp st) | |
| 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 (instr i o) => Eq (RemFail instr i o) | |
| 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
Note that (7.) and (8.) do not require min and max to return either of
their arguments. The result is merely required to equal one of the
arguments in terms of (==).
Minimal complete definition: either compare or <=.
Using compare can be more efficient for complex types.
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 Version | Since: base-2.1 |
| Ord ByteString | |
Defined in Data.ByteString.Internal Methods compare :: ByteString -> ByteString -> Ordering # (<) :: ByteString -> ByteString -> Bool # (<=) :: ByteString -> ByteString -> Bool # (>) :: ByteString -> ByteString -> Bool # (>=) :: ByteString -> ByteString -> Bool # max :: ByteString -> ByteString -> ByteString # min :: ByteString -> ByteString -> ByteString # | |
| Ord ByteString | |
Defined in Data.ByteString.Lazy.Internal Methods compare :: ByteString -> ByteString -> Ordering # (<) :: ByteString -> ByteString -> Bool # (<=) :: ByteString -> ByteString -> Bool # (>) :: ByteString -> ByteString -> Bool # (>=) :: ByteString -> ByteString -> Bool # max :: ByteString -> ByteString -> ByteString # min :: ByteString -> ByteString -> ByteString # | |
| Ord Builder | |
Defined in Data.Text.Internal.Builder | |
| Ord Scientific | Scientific numbers can be safely compared for ordering. No magnitude |
Defined in Data.Scientific Methods compare :: Scientific -> Scientific -> Ordering # (<) :: Scientific -> Scientific -> Bool # (<=) :: Scientific -> Scientific -> Bool # (>) :: Scientific -> Scientific -> Bool # (>=) :: Scientific -> Scientific -> Bool # max :: Scientific -> Scientific -> Scientific # min :: Scientific -> Scientific -> Scientific # | |
| Ord UTCTime | |
Defined in Data.Time.Clock.Internal.UTCTime | |
| Ord JSONPathElement | |
Defined in Data.Aeson.Types.Internal Methods compare :: JSONPathElement -> JSONPathElement -> Ordering # (<) :: JSONPathElement -> JSONPathElement -> Bool # (<=) :: JSONPathElement -> JSONPathElement -> Bool # (>) :: JSONPathElement -> JSONPathElement -> Bool # (>=) :: JSONPathElement -> JSONPathElement -> Bool # max :: JSONPathElement -> JSONPathElement -> JSONPathElement # min :: JSONPathElement -> JSONPathElement -> JSONPathElement # | |
| Ord Value | The ordering is total, consistent with Since: aeson-1.5.2.0 |
| Ord DotNetTime | |
Defined in Data.Aeson.Types.Internal Methods compare :: DotNetTime -> DotNetTime -> Ordering # (<) :: DotNetTime -> DotNetTime -> Bool # (<=) :: DotNetTime -> DotNetTime -> Bool # (>) :: DotNetTime -> DotNetTime -> Bool # (>=) :: DotNetTime -> DotNetTime -> Bool # max :: DotNetTime -> DotNetTime -> DotNetTime # min :: DotNetTime -> DotNetTime -> DotNetTime # | |
| Ord ThreadId | Since: base-4.2.0.0 |
Defined in GHC.Conc.Sync | |
| Ord Pos | |
| Ord Void | Since: base-4.8.0.0 |
| 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 BufferMode | Since: base-4.2.0.0 |
Defined in GHC.IO.Handle.Types Methods compare :: BufferMode -> BufferMode -> Ordering # (<) :: BufferMode -> BufferMode -> Bool # (<=) :: BufferMode -> BufferMode -> Bool # (>) :: BufferMode -> BufferMode -> Bool # (>=) :: BufferMode -> BufferMode -> Bool # max :: BufferMode -> BufferMode -> BufferMode # min :: BufferMode -> BufferMode -> BufferMode # | |
| Ord Newline | Since: base-4.3.0.0 |
| Ord NewlineMode | Since: base-4.3.0.0 |
Defined in GHC.IO.Handle.Types Methods compare :: NewlineMode -> NewlineMode -> Ordering # (<) :: NewlineMode -> NewlineMode -> Bool # (<=) :: NewlineMode -> NewlineMode -> Bool # (>) :: NewlineMode -> NewlineMode -> Bool # (>=) :: NewlineMode -> NewlineMode -> Bool # max :: NewlineMode -> NewlineMode -> NewlineMode # min :: NewlineMode -> NewlineMode -> NewlineMode # | |
| 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 CChar | |
| Ord CSChar | |
| Ord CUChar | |
| Ord CShort | |
| Ord CUShort | |
| Ord CInt | |
| Ord CUInt | |
| Ord CLong | |
| Ord CULong | |
| Ord CLLong | |
| Ord CULLong | |
| Ord CBool | |
| Ord CFloat | |
| Ord CDouble | |
| Ord CPtrdiff | |
Defined in Foreign.C.Types | |
| Ord CSize | |
| Ord CWchar | |
| Ord CSigAtomic | |
Defined in Foreign.C.Types Methods compare :: CSigAtomic -> CSigAtomic -> Ordering # (<) :: CSigAtomic -> CSigAtomic -> Bool # (<=) :: CSigAtomic -> CSigAtomic -> Bool # (>) :: CSigAtomic -> CSigAtomic -> Bool # (>=) :: CSigAtomic -> CSigAtomic -> Bool # max :: CSigAtomic -> CSigAtomic -> CSigAtomic # min :: CSigAtomic -> CSigAtomic -> CSigAtomic # | |
| Ord CClock | |
| Ord CTime | |
| Ord CUSeconds | |
| Ord CSUSeconds | |
Defined in Foreign.C.Types Methods compare :: CSUSeconds -> CSUSeconds -> Ordering # (<) :: CSUSeconds -> CSUSeconds -> Bool # (<=) :: CSUSeconds -> CSUSeconds -> Bool # (>) :: CSUSeconds -> CSUSeconds -> Bool # (>=) :: CSUSeconds -> CSUSeconds -> Bool # max :: CSUSeconds -> CSUSeconds -> CSUSeconds # min :: CSUSeconds -> CSUSeconds -> CSUSeconds # | |
| Ord CIntPtr | |
| Ord CUIntPtr | |
Defined in Foreign.C.Types | |
| Ord CIntMax | |
| Ord CUIntMax | |
Defined in Foreign.C.Types | |
| Ord IOMode | Since: base-4.2.0.0 |
| 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 Alphabet | |
Defined in Data.ByteString.Base58.Internal | |
| Ord UTF32_Invalid | |
Defined in Basement.String.Encoding.UTF32 Methods compare :: UTF32_Invalid -> UTF32_Invalid -> Ordering # (<) :: UTF32_Invalid -> UTF32_Invalid -> Bool # (<=) :: UTF32_Invalid -> UTF32_Invalid -> Bool # (>) :: UTF32_Invalid -> UTF32_Invalid -> Bool # (>=) :: UTF32_Invalid -> UTF32_Invalid -> Bool # | |
| Ord Encoding | |
Defined in Basement.String | |
| Ord String | |
| Ord FileSize | |
Defined in Basement.Types.OffsetSize | |
| Ord ShortByteString | |
Defined in Data.ByteString.Short.Internal Methods compare :: ShortByteString -> ShortByteString -> Ordering # (<) :: ShortByteString -> ShortByteString -> Bool # (<=) :: ShortByteString -> ShortByteString -> Bool # (>) :: ShortByteString -> ShortByteString -> Bool # (>=) :: ShortByteString -> ShortByteString -> Bool # max :: ShortByteString -> ShortByteString -> ShortByteString # min :: ShortByteString -> ShortByteString -> ShortByteString # | |
| Ord F2Poly | |
| Ord Bit | |
| Ord TimeSpec | |
Defined in System.Clock | |
| Ord IntSet | |
| 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 BigNat | |
| Ord RuleBndr | |
Defined in Language.Haskell.TH.Syntax | |
| Ord Phases | |
| Ord RuleMatch | |
| Ord Inline | |
| Ord Pragma | |
| 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 TySynEqn | |
Defined in Language.Haskell.TH.Syntax | |
| Ord Fixity | |
| Ord Info | |
| Ord Con | |
| Ord TyVarBndr | |
| Ord DefName | |
Defined in Control.Lens.Internal.FieldTH | |
| Ord Pos | |
| Ord SourcePos | |
| Ord OptName | |
Defined in Options.Applicative.Types | |
| Ord OptVisibility | |
Defined in Options.Applicative.Types Methods compare :: OptVisibility -> OptVisibility -> Ordering # (<) :: OptVisibility -> OptVisibility -> Bool # (<=) :: OptVisibility -> OptVisibility -> Bool # (>) :: OptVisibility -> OptVisibility -> Bool # (>=) :: OptVisibility -> OptVisibility -> Bool # max :: OptVisibility -> OptVisibility -> OptVisibility # min :: OptVisibility -> OptVisibility -> OptVisibility # | |
| Ord ArgPolicy | |
| 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 Mod2 | |
| 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 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 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 Bytes | |
| Ord Body | |
| Ord Guard | |
| Ord Stmt | |
| Ord Range | |
| 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 Foreign | |
Defined in Language.Haskell.TH.Syntax | |
| Ord Callconv | |
Defined in Language.Haskell.TH.Syntax | |
| Ord Safety | |
| 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 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 Specificity | |
Defined in Language.Haskell.TH.Datatype.TyVarBndr Methods compare :: Specificity -> Specificity -> Ordering # (<) :: Specificity -> Specificity -> Bool # (<=) :: Specificity -> Specificity -> Bool # (>) :: Specificity -> Specificity -> Bool # (>=) :: Specificity -> Specificity -> Bool # max :: Specificity -> Specificity -> Specificity # min :: Specificity -> Specificity -> Specificity # | |
| Ord LocalTime | |
Defined in Data.Time.LocalTime.Internal.LocalTime | |
| Ord UniversalTime | |
Defined in Data.Time.Clock.Internal.UniversalTime Methods compare :: UniversalTime -> UniversalTime -> Ordering # (<) :: UniversalTime -> UniversalTime -> Bool # (<=) :: UniversalTime -> UniversalTime -> Bool # (>) :: UniversalTime -> UniversalTime -> Bool # (>=) :: UniversalTime -> UniversalTime -> Bool # max :: UniversalTime -> UniversalTime -> UniversalTime # min :: UniversalTime -> UniversalTime -> UniversalTime # | |
| Ord AbsoluteTime | |
Defined in Data.Time.Clock.Internal.AbsoluteTime Methods compare :: AbsoluteTime -> AbsoluteTime -> Ordering # (<) :: AbsoluteTime -> AbsoluteTime -> Bool # (<=) :: AbsoluteTime -> AbsoluteTime -> Bool # (>) :: AbsoluteTime -> AbsoluteTime -> Bool # (>=) :: AbsoluteTime -> AbsoluteTime -> Bool # max :: AbsoluteTime -> AbsoluteTime -> AbsoluteTime # min :: AbsoluteTime -> AbsoluteTime -> AbsoluteTime # | |
| Ord Day | |
| Ord Undefined | |
| Ord UnpackedUUID | |
Defined in Data.UUID.Types.Internal | |
| Ord UUID | |
| Ord MText | |
| Ord MutezArithErrorType | |
Defined in Morley.Michelson.Typed.Arith Methods compare :: MutezArithErrorType -> MutezArithErrorType -> Ordering # (<) :: MutezArithErrorType -> MutezArithErrorType -> Bool # (<=) :: MutezArithErrorType -> MutezArithErrorType -> Bool # (>) :: MutezArithErrorType -> MutezArithErrorType -> Bool # (>=) :: MutezArithErrorType -> MutezArithErrorType -> Bool # max :: MutezArithErrorType -> MutezArithErrorType -> MutezArithErrorType # min :: MutezArithErrorType -> MutezArithErrorType -> MutezArithErrorType # | |
| Ord ShiftArithErrorType | |
Defined in Morley.Michelson.Typed.Arith Methods compare :: ShiftArithErrorType -> ShiftArithErrorType -> Ordering # (<) :: ShiftArithErrorType -> ShiftArithErrorType -> Bool # (<=) :: ShiftArithErrorType -> ShiftArithErrorType -> Bool # (>) :: ShiftArithErrorType -> ShiftArithErrorType -> Bool # (>=) :: ShiftArithErrorType -> ShiftArithErrorType -> Bool # max :: ShiftArithErrorType -> ShiftArithErrorType -> ShiftArithErrorType # min :: ShiftArithErrorType -> ShiftArithErrorType -> ShiftArithErrorType # | |
| Ord EpAddress | |
Defined in Morley.Michelson.Typed.Entrypoints | |
| Ord DStorageType | |
Defined in Morley.Michelson.Typed.Haskell.Doc | |
| Ord DType | |
| Ord EpName | |
Defined in Morley.Michelson.Untyped.Entrypoints | |
| Ord OpSize | |
| Ord Address | |
Defined in Morley.Tezos.Address | |
| Ord Bls12381Fr | |
Defined in Morley.Tezos.Crypto.BLS12381 Methods compare :: Bls12381Fr -> Bls12381Fr -> Ordering # (<) :: Bls12381Fr -> Bls12381Fr -> Bool # (<=) :: Bls12381Fr -> Bls12381Fr -> Bool # (>) :: Bls12381Fr -> Bls12381Fr -> Bool # (>=) :: Bls12381Fr -> Bls12381Fr -> Bool # max :: Bls12381Fr -> Bls12381Fr -> Bls12381Fr # min :: Bls12381Fr -> Bls12381Fr -> Bls12381Fr # | |
| Ord ChainId | |
| Ord KeyHash | |
| Ord Mutez | |
| Ord PublicKey | |
| Ord Signature | |
| Ord Timestamp | |
| Ord Var | |
| Ord ContractHash | |
Defined in Morley.Tezos.Address | |
| Ord KeyHashTag | |
Defined in Morley.Tezos.Crypto | |
| Ord PublicKey | |
| Ord PublicKey | |
| Ord PublicKey | |
| Ord DocItemPos | |
Defined in Morley.Michelson.Doc Methods compare :: DocItemPos -> DocItemPos -> Ordering # (<) :: DocItemPos -> DocItemPos -> Bool # (<=) :: DocItemPos -> DocItemPos -> Bool # (>) :: DocItemPos -> DocItemPos -> Bool # (>=) :: DocItemPos -> DocItemPos -> Bool # max :: DocItemPos -> DocItemPos -> DocItemPos # min :: DocItemPos -> DocItemPos -> DocItemPos # | |
| Ord SomeDocDefinitionItem | |
Defined in Morley.Michelson.Doc Methods compare :: SomeDocDefinitionItem -> SomeDocDefinitionItem -> Ordering # (<) :: SomeDocDefinitionItem -> SomeDocDefinitionItem -> Bool # (<=) :: SomeDocDefinitionItem -> SomeDocDefinitionItem -> Bool # (>) :: SomeDocDefinitionItem -> SomeDocDefinitionItem -> Bool # (>=) :: SomeDocDefinitionItem -> SomeDocDefinitionItem -> Bool # max :: SomeDocDefinitionItem -> SomeDocDefinitionItem -> SomeDocDefinitionItem # min :: SomeDocDefinitionItem -> SomeDocDefinitionItem -> SomeDocDefinitionItem # | |
| Ord InstrCallStack | |
Defined in Morley.Michelson.ErrorPos Methods compare :: InstrCallStack -> InstrCallStack -> Ordering # (<) :: InstrCallStack -> InstrCallStack -> Bool # (<=) :: InstrCallStack -> InstrCallStack -> Bool # (>) :: InstrCallStack -> InstrCallStack -> Bool # (>=) :: InstrCallStack -> InstrCallStack -> Bool # | |
| Ord DocItemId | |
| Ord LetName | |
Defined in Morley.Michelson.ErrorPos | |
| Ord Pos | |
| Ord SrcPos | |
| Ord MichelinePrimitive | |
Defined in Morley.Micheline.Expression Methods compare :: MichelinePrimitive -> MichelinePrimitive -> Ordering # (<) :: MichelinePrimitive -> MichelinePrimitive -> Bool # (<=) :: MichelinePrimitive -> MichelinePrimitive -> Bool # (>) :: MichelinePrimitive -> MichelinePrimitive -> Bool # (>=) :: MichelinePrimitive -> MichelinePrimitive -> Bool # max :: MichelinePrimitive -> MichelinePrimitive -> MichelinePrimitive # min :: MichelinePrimitive -> MichelinePrimitive -> MichelinePrimitive # | |
| Ord TezosMutez | |
Defined in Morley.Micheline.Json | |
| Ord CustomParserException | |
Defined in Morley.Michelson.Parser.Error Methods compare :: CustomParserException -> CustomParserException -> Ordering # (<) :: CustomParserException -> CustomParserException -> Bool # (<=) :: CustomParserException -> CustomParserException -> Bool # (>) :: CustomParserException -> CustomParserException -> Bool # (>=) :: CustomParserException -> CustomParserException -> Bool # max :: CustomParserException -> CustomParserException -> CustomParserException # min :: CustomParserException -> CustomParserException -> CustomParserException # | |
| Ord StringLiteralParserException | |
Defined in Morley.Michelson.Parser.Error Methods compare :: StringLiteralParserException -> StringLiteralParserException -> Ordering # (<) :: StringLiteralParserException -> StringLiteralParserException -> Bool # (<=) :: StringLiteralParserException -> StringLiteralParserException -> Bool # (>) :: StringLiteralParserException -> StringLiteralParserException -> Bool # (>=) :: StringLiteralParserException -> StringLiteralParserException -> Bool # max :: StringLiteralParserException -> StringLiteralParserException -> StringLiteralParserException # min :: StringLiteralParserException -> StringLiteralParserException -> StringLiteralParserException # | |
| Ord HexJSONByteString | |
Defined in Morley.Util.ByteString Methods compare :: HexJSONByteString -> HexJSONByteString -> Ordering # (<) :: HexJSONByteString -> HexJSONByteString -> Bool # (<=) :: HexJSONByteString -> HexJSONByteString -> Bool # (>) :: HexJSONByteString -> HexJSONByteString -> Bool # (>=) :: HexJSONByteString -> HexJSONByteString -> Bool # max :: HexJSONByteString -> HexJSONByteString -> HexJSONByteString # min :: HexJSONByteString -> HexJSONByteString -> HexJSONByteString # | |
| Ord Positive | |
Defined in Morley.Util.Positive | |
| Ord Never Source # | |
| Ord DHashAlgorithm Source # | |
Defined in Lorentz.Bytes Methods compare :: DHashAlgorithm -> DHashAlgorithm -> Ordering # (<) :: DHashAlgorithm -> DHashAlgorithm -> Bool # (<=) :: DHashAlgorithm -> DHashAlgorithm -> Bool # (>) :: DHashAlgorithm -> DHashAlgorithm -> Bool # (>=) :: DHashAlgorithm -> DHashAlgorithm -> Bool # max :: DHashAlgorithm -> DHashAlgorithm -> DHashAlgorithm # min :: DHashAlgorithm -> DHashAlgorithm -> DHashAlgorithm # | |
| Ord DError Source # | |
| Ord Transformation | |
Defined in Morley.Util.Interpolate Methods compare :: Transformation -> Transformation -> Ordering # (<) :: Transformation -> Transformation -> Bool # (<=) :: Transformation -> Transformation -> Bool # (>) :: Transformation -> Transformation -> Bool # (>=) :: Transformation -> Transformation -> Bool # | |
| Ord DDescribeErrorTagMap Source # | |
Defined in Lorentz.Errors.Numeric.Doc Methods compare :: DDescribeErrorTagMap -> DDescribeErrorTagMap -> Ordering # (<) :: DDescribeErrorTagMap -> DDescribeErrorTagMap -> Bool # (<=) :: DDescribeErrorTagMap -> DDescribeErrorTagMap -> Bool # (>) :: DDescribeErrorTagMap -> DDescribeErrorTagMap -> Bool # (>=) :: DDescribeErrorTagMap -> DDescribeErrorTagMap -> Bool # max :: DDescribeErrorTagMap -> DDescribeErrorTagMap -> DDescribeErrorTagMap # min :: DDescribeErrorTagMap -> DDescribeErrorTagMap -> DDescribeErrorTagMap # | |
| Ord RemainingSteps | |
Defined in Morley.Michelson.Interpret Methods compare :: RemainingSteps -> RemainingSteps -> Ordering # (<) :: RemainingSteps -> RemainingSteps -> Bool # (<=) :: RemainingSteps -> RemainingSteps -> Bool # (>) :: RemainingSteps -> RemainingSteps -> Bool # (>=) :: RemainingSteps -> RemainingSteps -> Bool # | |
| Ord OperationHash | |
Defined in Morley.Michelson.Typed.Operation Methods compare :: OperationHash -> OperationHash -> Ordering # (<) :: OperationHash -> OperationHash -> Bool # (<=) :: OperationHash -> OperationHash -> Bool # (>) :: OperationHash -> OperationHash -> Bool # (>=) :: OperationHash -> OperationHash -> Bool # | |
| () :=> (Ord Bool) | |
| () :=> (Ord Char) | |
| () :=> (Ord Double) | |
| () :=> (Ord Float) | |
| () :=> (Ord Int) | |
| () :=> (Ord Integer) | |
| () :=> (Ord Natural) | |
| () :=> (Ord Word) | |
| () :=> (Ord ()) | |
Defined in Data.Constraint | |
| () :=> (Ord (Dict a)) | |
| () :=> (Ord (a :- b)) | |
| 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 (ForeignPtr a) | Since: base-2.1 |
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 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 |
| (PrimType ty, Ord ty) => Ord (UArray ty) | |
| (PrimType ty, Ord ty) => Ord (Block ty) | |
Defined in Basement.Block.Base | |
| Ord (Offset ty) | |
| Ord (CountOf ty) | |
Defined in Basement.Types.OffsetSize | |
| Ord (Zn64 n) | |
| Ord (Zn n) | |
| Ord (Dict a) | |
| Ord a => Ord (IntMap a) | |
Defined in Data.IntMap.Internal | |
| Ord a => Ord (Tree a) | Since: containers-0.6.5 |
| 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 (Digest a) | |
Defined in Crypto.Hash.Types | |
| Ord1 f => Ord (Fix f) | |
| (Functor f, Ord1 f) => Ord (Mu f) | |
| (Functor f, Ord1 f) => Ord (Nu f) | |
| Ord a => Ord (DNonEmpty a) | |
Defined in Data.DList.DNonEmpty.Internal | |
| Ord a => Ord (DList a) | |
| Ord (Prime p) | |
Defined in Data.Field.Galois.Prime | |
| Ord (Binary p) | |
Defined in Data.Field.Galois.Binary | |
| 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 (Mod m) | |
| (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 | |
| Ord g => Ord (AtomicGen g) | |
Defined in System.Random.Stateful | |
| Ord g => Ord (IOGen g) | |
Defined in System.Random.Stateful | |
| Ord g => Ord (STGen g) | |
Defined in System.Random.Stateful | |
| Ord g => Ord (StateGen g) | |
Defined in System.Random.Internal | |
| Ord a => Ord (Add a) | |
| Ord a => Ord (Mul a) | |
| Ord a => Ord (WrappedNum a) | |
Defined in Data.Semiring Methods compare :: WrappedNum a -> WrappedNum a -> Ordering # (<) :: WrappedNum a -> WrappedNum a -> Bool # (<=) :: WrappedNum a -> WrappedNum a -> Bool # (>) :: WrappedNum a -> WrappedNum a -> Bool # (>=) :: WrappedNum a -> WrappedNum a -> Bool # max :: WrappedNum a -> WrappedNum a -> WrappedNum a # min :: WrappedNum a -> WrappedNum a -> WrappedNum a # | |
| Ord (IntSetOf a) | |
| Ord a => Ord (Maybe a) | |
| Ord a => Ord (Identity a) | |
| Ord t => Ord (ElField '(s, t)) | |
Defined in Data.Vinyl.Functor Methods compare :: ElField '(s, t) -> ElField '(s, t) -> Ordering # (<) :: ElField '(s, t) -> ElField '(s, t) -> Bool # (<=) :: ElField '(s, t) -> ElField '(s, t) -> Bool # (>) :: ElField '(s, t) -> ElField '(s, t) -> Bool # (>=) :: ElField '(s, t) -> ElField '(s, t) -> Bool # max :: ElField '(s, t) -> ElField '(s, t) -> ElField '(s, t) # min :: ElField '(s, t) -> ElField '(s, t) -> ElField '(s, t) # | |
| Ord a => Ord (StringEncode a) | |
Defined in Morley.Micheline.Json Methods compare :: StringEncode a -> StringEncode a -> Ordering # (<) :: StringEncode a -> StringEncode a -> Bool # (<=) :: StringEncode a -> StringEncode a -> Bool # (>) :: StringEncode a -> StringEncode a -> Bool # (>=) :: StringEncode a -> StringEncode a -> Bool # | |
| Ord (TAddress p) Source # | |
| Ord a => Ord (ReadTicket a) Source # | |
Defined in Lorentz.Value Methods compare :: ReadTicket a -> ReadTicket a -> Ordering # (<) :: ReadTicket a -> ReadTicket a -> Bool # (<=) :: ReadTicket a -> ReadTicket a -> Bool # (>) :: ReadTicket a -> ReadTicket a -> Bool # (>=) :: ReadTicket a -> ReadTicket a -> Bool # max :: ReadTicket a -> ReadTicket a -> ReadTicket a # min :: ReadTicket a -> ReadTicket a -> ReadTicket a # | |
| Ord (Packed a) Source # | |
Defined in Lorentz.Bytes | |
| Class (Eq a) (Ord a) | |
| (Integral a) :=> (Ord (Ratio a)) | |
| (Ord a) :=> (Ord (Maybe a)) | |
| (Ord a) :=> (Ord [a]) | |
| (Ord a) :=> (Ord (Identity a)) | |
| (Ord a) :=> (Ord (Const a b)) | |
| (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 ordering is total and consistent with the |
Defined in Data.HashMap.Internal | |
| (Ord k, Ord v) => Ord (Map k v) | |
| Ord (Fixed a) | 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 |
| (Ord a, Ord b) => Ord (Bimap a b) | |
| Ord (a :- b) | Assumes |
Defined in Data.Constraint | |
| (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 | |
| Ord k => Ord (RootsOfUnity n k) | |
Defined in Data.Field.Galois.Unity Methods compare :: RootsOfUnity n k -> RootsOfUnity n k -> Ordering # (<) :: RootsOfUnity n k -> RootsOfUnity n k -> Bool # (<=) :: RootsOfUnity n k -> RootsOfUnity n k -> Bool # (>) :: RootsOfUnity n k -> RootsOfUnity n k -> Bool # (>=) :: RootsOfUnity n k -> RootsOfUnity n k -> Bool # max :: RootsOfUnity n k -> RootsOfUnity n k -> RootsOfUnity n k # min :: RootsOfUnity n k -> RootsOfUnity n k -> RootsOfUnity n k # | |
| Ord k => Ord (Extension p k) | |
Defined in Data.Field.Galois.Extension Methods compare :: Extension p k -> Extension p k -> Ordering # (<) :: Extension p k -> Extension p k -> Bool # (<=) :: Extension p k -> Extension p k -> Bool # (>) :: Extension p k -> Extension p k -> Bool # (>=) :: Extension p k -> Extension p k -> Bool # | |
| (Ord1 f, Ord a) => Ord (Yoneda f a) | |
Defined in Data.Functor.Yoneda | |
| Ord (v a) => Ord (Poly v a) | |
Defined in Data.Poly.Internal.Dense | |
| Ord v => Ord (IntMapOf k v) | |
Defined in Data.Semiring | |
| (Ord a, Ord b) => Ord (Pair a b) | |
Defined in Data.Strict.Tuple | |
| (Ord a, Ord b) => Ord (These a b) | |
| (Ord a, Ord b) => Ord (Either a b) | |
| (Ord a, Ord b) => Ord (These a b) | |
| (Ord n, Ord m) => Ord (ArithError n m) | |
Defined in Morley.Michelson.Typed.Arith Methods compare :: ArithError n m -> ArithError n m -> Ordering # (<) :: ArithError n m -> ArithError n m -> Bool # (<=) :: ArithError n m -> ArithError n m -> Bool # (>) :: ArithError n m -> ArithError n m -> Bool # (>=) :: ArithError n m -> ArithError n m -> Bool # | |
| Comparable e => Ord (Value' instr e) | |
Defined in Morley.Michelson.Typed.Value Methods compare :: Value' instr e -> Value' instr e -> Ordering # (<) :: Value' instr e -> Value' instr e -> Bool # (<=) :: Value' instr e -> Value' instr e -> Bool # (>) :: Value' instr e -> Value' instr e -> Bool # (>=) :: Value' instr e -> Value' instr e -> Bool # | |
| Ord (NFixed p) Source # | |
Defined in Lorentz.Value | |
| Ord (Hash alg a) Source # | |
| Class (Num a, Ord a) (Real a) | |
| (Ord a, Ord b) :=> (Ord (a, b)) | |
| (Ord a, Ord b) :=> (Ord (Either a b)) | |
| 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) | |
| (Ord1 f, Ord1 g, Ord a) => Ord (These1 f g a) | |
Defined in Data.Functor.These | |
| (RPureConstrained (IndexableField rs) rs, RecApplicative rs, Ord (Rec f rs)) => Ord (ARec f rs) | |
| Ord (Rec f ('[] :: [u])) | |
| (Ord (f r), Ord (Rec f rs)) => Ord (Rec f (r ': rs)) | |
Defined in Data.Vinyl.Core Methods compare :: Rec f (r ': rs) -> Rec f (r ': rs) -> Ordering # (<) :: Rec f (r ': rs) -> Rec f (r ': rs) -> Bool # (<=) :: Rec f (r ': rs) -> Rec f (r ': rs) -> Bool # (>) :: Rec f (r ': rs) -> Rec f (r ': rs) -> Bool # (>=) :: Rec f (r ': rs) -> Rec f (r ': rs) -> Bool # max :: Rec f (r ': rs) -> Rec f (r ': rs) -> Rec f (r ': rs) # min :: Rec f (r ': rs) -> Rec f (r ': rs) -> Rec f (r ': rs) # | |
| 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) # | |
The Bounded class is used to name the upper and lower limits of a
type. Ord is not a superclass of Bounded since types that are not
totally ordered may also have upper and lower bounds.
The Bounded class may be derived for any enumeration type;
minBound is the first constructor listed in the data declaration
and maxBound is the last.
Bounded may also be derived for single-constructor datatypes whose
constituent types are in Bounded.
Instances
The class of semigroups (types with an associative binary operation).
Instances should satisfy the following:
Since: base-4.9.0.0
Minimal complete definition
Methods
(<>) :: a -> a -> a infixr 6 #
An associative operation.
>>>[1,2,3] <> [4,5,6][1,2,3,4,5,6]
Reduce a non-empty list with <>
The default definition should be sufficient, but this can be overridden for efficiency.
>>>import Data.List.NonEmpty>>>sconcat $ "Hello" :| [" ", "Haskell", "!"]"Hello Haskell!"
stimes :: Integral b => b -> a -> a #
Repeat a value n times.
Given that this works on a Semigroup it is allowed to fail if
you request 0 or fewer repetitions, and the default definition
will do so.
By making this a member of the class, idempotent semigroups
and monoids can upgrade this to execute in \(\mathcal{O}(1)\) by
picking stimes = or stimesIdempotentstimes =
respectively.stimesIdempotentMonoid
>>>stimes 4 [1][1,1,1,1]
Instances
class Semigroup a => Monoid a where #
The class of monoids (types with an associative binary operation that has an identity). Instances should satisfy the following:
- Right identity
x<>mempty= x- Left identity
mempty<>x = x- Associativity
x(<>(y<>z) = (x<>y)<>zSemigrouplaw)- Concatenation
mconcat=foldr(<>)mempty
The method names refer to the monoid of lists under concatenation, but there are many other instances.
Some types can be viewed as a monoid in more than one way,
e.g. both addition and multiplication on numbers.
In such cases we often define newtypes and make those instances
of Monoid, e.g. Sum and Product.
NOTE: Semigroup is a superclass of Monoid since base-4.11.0.0.
Minimal complete definition
Methods
Identity of mappend
>>>"Hello world" <> mempty"Hello world"
An associative operation
NOTE: This method is redundant and has the default
implementation mappend = (<>)mappend is a synonym for
(<>), it is expected that the two functions are defined the same
way. In a future GHC release mappend will be removed from Monoid.
Fold a list using the monoid.
For most types, the default definition for mconcat will be
used, but the function is included in the class definition so
that an optimized version can be provided for specific types.
>>>mconcat ["Hello", " ", "Haskell", "!"]"Hello Haskell!"
Instances
| Monoid Ordering | Since: base-2.1 |
| Monoid () | Since: base-2.1 |
| Monoid ByteString | |
Defined in Data.ByteString.Internal Methods mempty :: ByteString # mappend :: ByteString -> ByteString -> ByteString # mconcat :: [ByteString] -> ByteString # | |
| Monoid ByteString | |
Defined in Data.ByteString.Lazy.Internal Methods mempty :: ByteString # mappend :: ByteString -> ByteString -> ByteString # mconcat :: [ByteString] -> ByteString # | |
| Monoid Builder | |
| Monoid Builder | |
| Monoid More | |
| Monoid All | Since: base-2.1 |
| Monoid Any | Since: base-2.1 |
| Monoid String | |
| Monoid ShortByteString | |
Defined in Data.ByteString.Short.Internal Methods mappend :: ShortByteString -> ShortByteString -> ShortByteString # mconcat :: [ShortByteString] -> ShortByteString # | |
| Monoid IntSet | |
| Monoid PrefsMod | |
| Monoid ParseError | |
Defined in Options.Applicative.Types Methods mempty :: ParseError # mappend :: ParseError -> ParseError -> ParseError # mconcat :: [ParseError] -> ParseError # | |
| Monoid Completer | |
| Monoid Doc | |
| Monoid ByteArray | |
| Monoid PromDPatInfos | |
| Monoid ULetDecEnv | |
| Monoid Doc | |
| Monoid MText | |
| Monoid OpSize | |
| Monoid AnnotationSet | |
| Monoid VarAnn | |
| Monoid ContractDoc | |
Defined in Morley.Michelson.Doc Methods mempty :: ContractDoc # mappend :: ContractDoc -> ContractDoc -> ContractDoc # mconcat :: [ContractDoc] -> ContractDoc # | |
| Monoid AnalyzerRes | |
| Monoid MorleyLogs | |
| Monoid MorleyLogsBuilder | |
| a :=> (Monoid (Dict a)) | |
| () :=> (Monoid [a]) | |
Defined in Data.Constraint | |
| () :=> (Monoid Ordering) | |
| () :=> (Monoid ()) | |
Defined in Data.Constraint | |
| Monoid [a] | Since: base-2.1 |
| Semigroup a => Monoid (Maybe a) | Lift a semigroup into Since 4.11.0: constraint on inner Since: base-2.1 |
| Monoid a => Monoid (IO a) | Since: base-4.9.0.0 |
| Monoid p => Monoid (Par1 p) | Since: base-4.12.0.0 |
| Monoid (IResult a) | |
| Monoid (Result a) | |
| Monoid (Parser a) | |
| (Ord a, Bounded a) => Monoid (Min a) | Since: base-4.9.0.0 |
| (Ord a, Bounded a) => Monoid (Max a) | Since: base-4.9.0.0 |
| Monoid m => Monoid (WrappedMonoid m) | Since: base-4.9.0.0 |
Defined in Data.Semigroup Methods mempty :: WrappedMonoid m # mappend :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # mconcat :: [WrappedMonoid m] -> WrappedMonoid m # | |
| Semigroup a => Monoid (Option a) | Since: base-4.9.0.0 |
| Monoid a => Monoid (Identity a) | Since: base-4.9.0.0 |
| Monoid (First a) | Since: base-2.1 |
| Monoid (Last a) | Since: base-2.1 |
| Monoid a => Monoid (Dual a) | Since: base-2.1 |
| Monoid (Endo a) | Since: base-2.1 |
| Num a => Monoid (Sum a) | Since: base-2.1 |
| Num a => Monoid (Product a) | Since: base-2.1 |
| Monoid a => Monoid (Down a) | Since: base-4.11.0.0 |
| PrimType ty => Monoid (UArray ty) | |
| PrimType ty => Monoid (Block ty) | |
| Monoid (CountOf ty) | |
| Num a => Monoid (Colour a) | |
| Num a => Monoid (AlphaColour a) | |
Defined in Data.Colour.Internal Methods mempty :: AlphaColour a # mappend :: AlphaColour a -> AlphaColour a -> AlphaColour a # mconcat :: [AlphaColour a] -> AlphaColour a # | |
| a => Monoid (Dict a) | |
| Monoid (IntMap a) | |
| Monoid (Seq a) | |
| Ord a => Monoid (Set a) | |
| Monoid (DList a) | |
| KnownNat p => Monoid (Prime p) | |
| KnownNat p => Monoid (Binary p) | |
| Prim a => Monoid (Vector a) | |
| Storable a => Monoid (Vector a) | |
| (Hashable a, Eq a) => Monoid (HashSet a) | O(n+m) To obtain good performance, the smaller set must be presented as the first argument. Examples
|
| Monoid (Vector a) | |
| Monoid a => Monoid (May a) | |
| Monoid (InfoMod a) | |
| Monoid (DefaultProp a) | |
Defined in Options.Applicative.Builder.Internal Methods mempty :: DefaultProp a # mappend :: DefaultProp a -> DefaultProp a -> DefaultProp a # mconcat :: [DefaultProp a] -> DefaultProp a # | |
| Monoid (Doc a) | |
| Monoid (PrimArray a) | Since: primitive-0.6.4.0 |
| Monoid (SmallArray a) | |
Defined in Data.Primitive.SmallArray Methods mempty :: SmallArray a # mappend :: SmallArray a -> SmallArray a -> SmallArray a # mconcat :: [SmallArray a] -> SmallArray a # | |
| Monoid (Array a) | |
| Semiring a => Monoid (Add a) | |
| Semiring a => Monoid (Mul a) | |
| Monoid (IntSetOf a) | |
| Semigroup a => Monoid (Maybe a) | |
| (KnownSymbol s, Monoid t) => Monoid (ElField '(s, t)) | |
| Monoid (ComposeResult a) | |
| Monoid (PrintComment st) | |
| Monoid (MergeSet a) | |
| Class (Semigroup a) (Monoid a) | |
| (Monoid a) :=> (Monoid (Maybe a)) | |
| (Monoid a) :=> (Monoid (Const a b)) | |
| (Monoid a) :=> (Monoid (Identity a)) | |
| (Monoid a) :=> (Monoid (IO a)) | |
| (Monoid a) :=> (Applicative ((,) a)) | |
Defined in Data.Constraint | |
| (Monoid a) :=> (Applicative (Const a :: Type -> Type)) | |
Defined in Data.Constraint | |
| Monoid b => Monoid (a -> b) | Since: base-2.1 |
| Monoid (U1 p) | Since: base-4.12.0.0 |
| (Monoid a, Monoid b) => Monoid (a, b) | Since: base-2.1 |
| Monoid a => Monoid (ST s a) | Since: base-4.11.0.0 |
| (Eq k, Hashable k) => Monoid (HashMap k v) | If a key occurs in both maps, the mapping from the first will be the mapping in the result. Examples
|
| Ord k => Monoid (Map k v) | |
| Monoid (Parser i a) | |
| Monoid (Proxy s) | Since: base-4.7.0.0 |
| (KnownNat n, GaloisField k) => Monoid (RootsOfUnity n k) | |
Defined in Data.Field.Galois.Unity Methods mempty :: RootsOfUnity n k # mappend :: RootsOfUnity n k -> RootsOfUnity n k -> RootsOfUnity n k # mconcat :: [RootsOfUnity n k] -> RootsOfUnity n k # | |
| IrreducibleMonic p k => Monoid (Extension p k) | |
| Monoid (ReifiedFold s a) | |
Defined in Control.Lens.Reified Methods mempty :: ReifiedFold s a # mappend :: ReifiedFold s a -> ReifiedFold s a -> ReifiedFold s a # mconcat :: [ReifiedFold s a] -> ReifiedFold s a # | |
| Monoid (f a) => Monoid (Indexing f a) |
|
| (Stream s, Ord e) => Monoid (ParseError s e) | |
Defined in Text.Megaparsec.Error Methods mempty :: ParseError s e # mappend :: ParseError s e -> ParseError s e -> ParseError s e # mconcat :: [ParseError s e] -> ParseError s e # | |
| Monoid a => Monoid (Err e a) | |
| Monoid (Mod f a) | |
| Monoid (IntMapOf k v) | |
| (Monoid a, Monoid b) => Monoid (Pair a b) | |
| Monoid (Instr s s) | |
| Monoid (s :-> s) Source # | |
| (Monoid a, Monoid b) :=> (Monoid (a, b)) | |
| Monoid (f p) => Monoid (Rec1 f p) | Since: base-4.12.0.0 |
| (Monoid a, Monoid b, Monoid c) => Monoid (a, b, c) | Since: base-2.1 |
| Monoid a => Monoid (Const a b) | Since: base-4.9.0.0 |
| (Applicative f, Monoid a) => Monoid (Ap f a) | Since: base-4.12.0.0 |
| Alternative f => Monoid (Alt f a) | Since: base-4.8.0.0 |
| (Semigroup a, Monoid a) => Monoid (Tagged s a) | |
| Monoid (ReifiedIndexedFold i s a) | |
Defined in Control.Lens.Reified Methods mempty :: ReifiedIndexedFold i s a # mappend :: ReifiedIndexedFold i s a -> ReifiedIndexedFold i s a -> ReifiedIndexedFold i s a # mconcat :: [ReifiedIndexedFold i s a] -> ReifiedIndexedFold i s a # | |
| (Monad m, Monoid r) => Monoid (Effect m r a) | |
| Reifies s (ReifiedMonoid a) => Monoid (ReflectedMonoid a s) | |
Defined in Data.Reflection Methods mempty :: ReflectedMonoid a s # mappend :: ReflectedMonoid a s -> ReflectedMonoid a s -> ReflectedMonoid a s # mconcat :: [ReflectedMonoid a s] -> ReflectedMonoid a s # | |
| Monoid (Rec f ('[] :: [u])) | |
| (Monoid (f r), Monoid (Rec f rs)) => Monoid (Rec f (r ': rs)) | |
| Monoid c => Monoid (K1 i c p) | Since: base-4.12.0.0 |
| (Monoid (f p), Monoid (g p)) => Monoid ((f :*: g) p) | Since: base-4.12.0.0 |
| (Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d) | Since: base-2.1 |
| Monoid (f p) => Monoid (M1 i c f p) | Since: base-4.12.0.0 |
| Monoid (f (g p)) => Monoid ((f :.: g) p) | Since: base-4.12.0.0 |
| (Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e) | Since: base-2.1 |
| Monoid (f (g a)) => Monoid (Compose f g a) | |
| Curve f c e q r => Monoid (Point f c e q r) | |
Representable types of kind *.
This class is derivable in GHC with the DeriveGeneric flag on.
A Generic instance must satisfy the following laws:
from.to≡idto.from≡id
Instances
A space efficient, packed, unboxed Unicode text type.
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
| ToJSON2 Either | |
Defined in Data.Aeson.Types.ToJSON Methods liftToJSON2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> Either a b -> Value # liftToJSONList2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> [Either a b] -> Value # liftToEncoding2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> Either a b -> Encoding # liftToEncodingList2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> [Either a b] -> Encoding # | |
| 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 | |
| () :=> (Monad (Either a)) | |
| () :=> (Functor (Either a)) | |
| () :=> (Applicative (Either a)) | |
Defined in Data.Constraint Methods ins :: () :- Applicative (Either a) # | |
| (Lift a, Lift b) => Lift (Either a b :: Type) | |
| Monad (Either e) | Since: base-4.4.0.0 |
| Functor (Either a) | Since: base-3.0 |
| 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 # 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 | |
| ToJSON a => ToJSON1 (Either a) | |
Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a0 -> Value) -> ([a0] -> Value) -> Either a a0 -> Value # liftToJSONList :: (a0 -> Value) -> ([a0] -> Value) -> [Either a a0] -> Value # liftToEncoding :: (a0 -> Encoding) -> ([a0] -> Encoding) -> Either a a0 -> Encoding # liftToEncodingList :: (a0 -> Encoding) -> ([a0] -> Encoding) -> [Either a a0] -> Encoding # | |
| 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 |
| MonadFailure (Either a) | |
| 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 | |
| PTraversable (Either a) | |
| STraversable (Either a) | |
Defined in Data.Singletons.Prelude.Traversable Methods sTraverse :: forall a0 (f :: Type -> Type) b (t1 :: a0 ~> f b) (t2 :: Either a a0). SApplicative f => Sing t1 -> Sing t2 -> Sing (Apply (Apply TraverseSym0 t1) t2) # sSequenceA :: forall (f :: Type -> Type) a0 (t1 :: Either a (f a0)). SApplicative f => Sing t1 -> Sing (Apply SequenceASym0 t1) # sMapM :: forall a0 (m :: Type -> Type) b (t1 :: a0 ~> m b) (t2 :: Either a a0). SMonad m => Sing t1 -> Sing t2 -> Sing (Apply (Apply MapMSym0 t1) t2) # sSequence :: forall (m :: Type -> Type) a0 (t1 :: Either a (m a0)). SMonad m => Sing t1 -> Sing (Apply SequenceSym0 t1) # | |
| PFoldable (Either a) | |
| SFoldable (Either a) | |
Defined in Data.Singletons.Prelude.Foldable Methods sFold :: forall m (t1 :: Either a m). SMonoid m => Sing t1 -> Sing (Apply FoldSym0 t1) # sFoldMap :: forall a0 m (t1 :: a0 ~> m) (t2 :: Either a a0). SMonoid m => Sing t1 -> Sing t2 -> Sing (Apply (Apply FoldMapSym0 t1) t2) # sFoldr :: forall a0 b (t1 :: a0 ~> (b ~> b)) (t2 :: b) (t3 :: Either a a0). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply FoldrSym0 t1) t2) t3) # sFoldr' :: forall a0 b (t1 :: a0 ~> (b ~> b)) (t2 :: b) (t3 :: Either a a0). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply Foldr'Sym0 t1) t2) t3) # sFoldl :: forall b a0 (t1 :: b ~> (a0 ~> b)) (t2 :: b) (t3 :: Either a a0). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply FoldlSym0 t1) t2) t3) # sFoldl' :: forall b a0 (t1 :: b ~> (a0 ~> b)) (t2 :: b) (t3 :: Either a a0). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply Foldl'Sym0 t1) t2) t3) # sFoldr1 :: forall a0 (t1 :: a0 ~> (a0 ~> a0)) (t2 :: Either a a0). Sing t1 -> Sing t2 -> Sing (Apply (Apply Foldr1Sym0 t1) t2) # sFoldl1 :: forall a0 (t1 :: a0 ~> (a0 ~> a0)) (t2 :: Either a a0). Sing t1 -> Sing t2 -> Sing (Apply (Apply Foldl1Sym0 t1) t2) # sToList :: forall a0 (t1 :: Either a a0). Sing t1 -> Sing (Apply ToListSym0 t1) # sNull :: forall a0 (t1 :: Either a a0). Sing t1 -> Sing (Apply NullSym0 t1) # sLength :: forall a0 (t1 :: Either a a0). Sing t1 -> Sing (Apply LengthSym0 t1) # sElem :: forall a0 (t1 :: a0) (t2 :: Either a a0). SEq a0 => Sing t1 -> Sing t2 -> Sing (Apply (Apply ElemSym0 t1) t2) # sMaximum :: forall a0 (t1 :: Either a a0). SOrd a0 => Sing t1 -> Sing (Apply MaximumSym0 t1) # sMinimum :: forall a0 (t1 :: Either a a0). SOrd a0 => Sing t1 -> Sing (Apply MinimumSym0 t1) # sSum :: forall a0 (t1 :: Either a a0). SNum a0 => Sing t1 -> Sing (Apply SumSym0 t1) # sProduct :: forall a0 (t1 :: Either a a0). SNum a0 => Sing t1 -> Sing (Apply ProductSym0 t1) # | |
| PFunctor (Either a) | |
Defined in Data.Singletons.Prelude.Monad.Internal | |
| PApplicative (Either e) | |
| PMonad (Either e) | |
| SFunctor (Either a) | |
| SApplicative (Either e) | |
Defined in Data.Singletons.Prelude.Monad.Internal Methods sPure :: forall a (t :: a). Sing t -> Sing (Apply PureSym0 t) # (%<*>) :: forall a b (t1 :: Either e (a ~> b)) (t2 :: Either e a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<*>@#@$) t1) t2) # sLiftA2 :: forall a b c (t1 :: a ~> (b ~> c)) (t2 :: Either e a) (t3 :: Either e b). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply LiftA2Sym0 t1) t2) t3) # (%*>) :: forall a b (t1 :: Either e a) (t2 :: Either e b). Sing t1 -> Sing t2 -> Sing (Apply (Apply (*>@#@$) t1) t2) # (%<*) :: forall a b (t1 :: Either e a) (t2 :: Either e b). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<*@#@$) t1) t2) # | |
| SMonad (Either e) | |
Defined in Data.Singletons.Prelude.Monad.Internal Methods (%>>=) :: forall a b (t1 :: Either e a) (t2 :: a ~> Either e b). Sing t1 -> Sing t2 -> Sing (Apply (Apply (>>=@#@$) t1) t2) # (%>>) :: forall a b (t1 :: Either e a) (t2 :: Either e b). Sing t1 -> Sing t2 -> Sing (Apply (Apply (>>@#@$) t1) t2) # sReturn :: forall a (t :: a). Sing t -> Sing (Apply ReturnSym0 t) # | |
| Generic1 (Either a :: Type -> Type) | Since: base-4.6.0.0 |
| IsoHKD (Either a :: Type -> Type) (b :: Type) | |
| (CanCastTo l1 l2, CanCastTo r1 r2) => CanCastTo (Either l1 r1 :: Type) (Either l2 r2 :: Type) Source # | |
| (Eq a, Eq b) => Eq (Either a b) | Since: base-2.1 |
| (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) | Since: base-4.6.0.0 |
| Semigroup (Either a b) | Since: base-4.9.0.0 |
| (Hashable a, Hashable b) => Hashable (Either a b) | |
Defined in Data.Hashable.Class | |
| (ToJSON a, ToJSON b) => ToJSON (Either a b) | |
Defined in Data.Aeson.Types.ToJSON | |
| (NFData a, NFData b) => NFData (Either a b) | |
Defined in Control.DeepSeq | |
| PShow (Either a b) | |
| (SShow a, SShow b) => SShow (Either a b) | |
Defined in Data.Singletons.Prelude.Show Methods sShowsPrec :: forall (t1 :: Nat) (t2 :: Either a b) (t3 :: Symbol). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply ShowsPrecSym0 t1) t2) t3) # sShow_ :: forall (t :: Either a b). Sing t -> Sing (Apply Show_Sym0 t) # sShowList :: forall (t1 :: [Either a b]) (t2 :: Symbol). Sing t1 -> Sing t2 -> Sing (Apply (Apply ShowListSym0 t1) t2) # | |
| PSemigroup (Either a b) | |
Defined in Data.Singletons.Prelude.Semigroup.Internal | |
| SSemigroup (Either a b) | |
| POrd (Either a b) | |
| (SOrd a, SOrd b) => SOrd (Either a b) | |
Defined in Data.Singletons.Prelude.Ord Methods sCompare :: forall (t1 :: Either a b) (t2 :: Either a b). Sing t1 -> Sing t2 -> Sing (Apply (Apply CompareSym0 t1) t2) # (%<) :: forall (t1 :: Either a b) (t2 :: Either a b). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<@#@$) t1) t2) # (%<=) :: forall (t1 :: Either a b) (t2 :: Either a b). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<=@#@$) t1) t2) # (%>) :: forall (t1 :: Either a b) (t2 :: Either a b). Sing t1 -> Sing t2 -> Sing (Apply (Apply (>@#@$) t1) t2) # (%>=) :: forall (t1 :: Either a b) (t2 :: Either a b). Sing t1 -> Sing t2 -> Sing (Apply (Apply (>=@#@$) t1) t2) # sMax :: forall (t1 :: Either a b) (t2 :: Either a b). Sing t1 -> Sing t2 -> Sing (Apply (Apply MaxSym0 t1) t2) # sMin :: forall (t1 :: Either a b) (t2 :: Either a b). Sing t1 -> Sing t2 -> Sing (Apply (Apply MinSym0 t1) t2) # | |
| (SEq a, SEq b) => SEq (Either a b) | |
| PEq (Either a b) | |
| (TypeError (DisallowInstance "Either") :: Constraint) => Container (Either a b) | |
Defined in Universum.Container.Class Methods toList :: Either a b -> [Element (Either a b)] # foldr :: (Element (Either a b) -> b0 -> b0) -> b0 -> Either a b -> b0 # foldl :: (b0 -> Element (Either a b) -> b0) -> b0 -> Either a b -> b0 # foldl' :: (b0 -> Element (Either a b) -> b0) -> b0 -> Either a b -> b0 # elem :: Element (Either a b) -> Either a b -> Bool # foldMap :: Monoid m => (Element (Either a b) -> m) -> Either a b -> m # fold :: Either a b -> Element (Either a b) # foldr' :: (Element (Either a b) -> b0 -> b0) -> b0 -> Either a b -> b0 # notElem :: Element (Either a b) -> Either a b -> Bool # all :: (Element (Either a b) -> Bool) -> Either a b -> Bool # any :: (Element (Either a b) -> Bool) -> Either a b -> Bool # find :: (Element (Either a b) -> Bool) -> Either a b -> Maybe (Element (Either a b)) # safeHead :: Either a b -> Maybe (Element (Either a b)) # safeMaximum :: Either a b -> Maybe (Element (Either a b)) # safeMinimum :: Either a b -> Maybe (Element (Either a b)) # safeFoldr1 :: (Element (Either a b) -> Element (Either a b) -> Element (Either a b)) -> Either a b -> Maybe (Element (Either a b)) # safeFoldl1 :: (Element (Either a b) -> Element (Either a b) -> Element (Either a b)) -> Either a b -> Maybe (Element (Either a b)) # | |
| PolyTypeHasDocC '[l, r] => TypeHasDoc (Either l r) | |
Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (Either l r) :: FieldDescriptions # Methods typeDocName :: Proxy (Either l r) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (Either l r) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (Either l r) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (Either l r) # typeDocMichelsonRep :: TypeDocMichelsonRep (Either l r) # | |
| (IsoValue l, IsoValue r) => IsoValue (Either l r) | |
| (HasAnnotation a, HasAnnotation b) => HasAnnotation (Either a b) Source # | |
Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (Either a b)) Source # | |
| (Eq a, Eq b) :=> (Eq (Either a b)) | |
| (Ord a, Ord b) :=> (Ord (Either a b)) | |
| (Read a, Read b) :=> (Read (Either a b)) | |
| (Show a, Show b) :=> (Show (Either a b)) | |
| (SDecide a, SDecide b) => TestCoercion (SEither :: Either a b -> Type) | |
Defined in Data.Singletons.Prelude.Instances | |
| (SDecide a, SDecide b) => TestEquality (SEither :: Either a b -> Type) | |
Defined in Data.Singletons.Prelude.Instances | |
| SuppressUnusedWarnings (RightsSym0 :: TyFun [Either a b] [b] -> Type) | |
Defined in Data.Singletons.Prelude.Either Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (PartitionEithersSym0 :: TyFun [Either a b] ([a], [b]) -> Type) | |
Defined in Data.Singletons.Prelude.Either Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (LeftsSym0 :: TyFun [Either a b] [a] -> Type) | |
Defined in Data.Singletons.Prelude.Either Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Null_6989586621680823386Sym0 :: TyFun (Either a1 a2) Bool -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Length_6989586621680823380Sym0 :: TyFun (Either a1 a2) Nat -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (IsRightSym0 :: TyFun (Either a b) Bool -> Type) | |
Defined in Data.Singletons.Prelude.Either Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (IsLeftSym0 :: TyFun (Either a b) Bool -> Type) | |
Defined in Data.Singletons.Prelude.Either Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Compare_6989586621679848544Sym0 :: TyFun (Either a b) (Either a b ~> Ordering) -> Type) | |
Defined in Data.Singletons.Prelude.Ord Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (TFHelper_6989586621680240804Sym0 :: TyFun (Either a b) (Either a b ~> Either a b) -> Type) | |
Defined in Data.Singletons.Prelude.Semigroup.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (ShowsPrec_6989586621680653958Sym0 :: TyFun Nat (Either a b ~> (Symbol ~> Symbol)) -> Type) | |
Defined in Data.Singletons.Prelude.Show Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Pure_6989586621680072933Sym0 :: TyFun a (Either e a) -> Type) | |
Defined in Data.Singletons.Prelude.Monad.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (RightSym0 :: TyFun b (Either a b) -> Type) | |
Defined in Data.Singletons.Prelude.Instances Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (LeftSym0 :: TyFun a (Either a b) -> Type) | |
Defined in Data.Singletons.Prelude.Instances Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Let6989586621680240813ASym0 :: TyFun k1 (Either a k1) -> Type) | |
Defined in Data.Singletons.Prelude.Semigroup.Internal Methods suppressUnusedWarnings :: () # | |
| SingI (RightsSym0 :: TyFun [Either a b] [b] -> Type) | |
Defined in Data.Singletons.Prelude.Either Methods sing :: Sing RightsSym0 # | |
| SingI (PartitionEithersSym0 :: TyFun [Either a b] ([a], [b]) -> Type) | |
Defined in Data.Singletons.Prelude.Either | |
| SingI (LeftsSym0 :: TyFun [Either a b] [a] -> Type) | |
Defined in Data.Singletons.Prelude.Either | |
| SingI (IsRightSym0 :: TyFun (Either a b) Bool -> Type) | |
Defined in Data.Singletons.Prelude.Either Methods sing :: Sing IsRightSym0 # | |
| SingI (IsLeftSym0 :: TyFun (Either a b) Bool -> Type) | |
Defined in Data.Singletons.Prelude.Either Methods sing :: Sing IsLeftSym0 # | |
| SingI (RightSym0 :: TyFun b (Either a b) -> Type) | |
Defined in Data.Singletons.Prelude.Instances | |
| SingI (LeftSym0 :: TyFun a (Either a b) -> Type) | |
Defined in Data.Singletons.Prelude.Instances | |
| (a ~ a', b ~ b') => Each (Either a a') (Either b b') a b | Since: microlens-0.4.11 |
| SuppressUnusedWarnings (ShowsPrec_6989586621680653958Sym1 a6989586621680653968 :: TyFun (Either a b) (Symbol ~> Symbol) -> Type) | |
Defined in Data.Singletons.Prelude.Show Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (TFHelper_6989586621680073027Sym0 :: TyFun (Either e a) ((a ~> Either e b) ~> Either e b) -> Type) | |
Defined in Data.Singletons.Prelude.Monad.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (TFHelper_6989586621680072943Sym0 :: TyFun (Either e (a ~> b)) (Either e a ~> Either e b) -> Type) | |
Defined in Data.Singletons.Prelude.Monad.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Compare_6989586621679848544Sym1 a6989586621679848549 :: TyFun (Either a b) Ordering -> Type) | |
Defined in Data.Singletons.Prelude.Ord Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (TFHelper_6989586621680240804Sym1 a6989586621680240809 :: TyFun (Either a b) (Either a b) -> Type) | |
Defined in Data.Singletons.Prelude.Semigroup.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (TFHelper_6989586621680072764Sym0 :: TyFun a1 (Either a2 b ~> Either a2 a1) -> Type) | |
Defined in Data.Singletons.Prelude.Monad.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Fmap_6989586621680072747Sym0 :: TyFun (a1 ~> b) (Either a2 a1 ~> Either a2 b) -> Type) | |
Defined in Data.Singletons.Prelude.Monad.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Foldr_6989586621680823366Sym0 :: TyFun (a1 ~> (b ~> b)) (b ~> (Either a2 a1 ~> b)) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (FoldMap_6989586621680823354Sym0 :: TyFun (a1 ~> m) (Either a2 a1 ~> m) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Either_Sym0 :: TyFun (a ~> c) ((b ~> c) ~> (Either a b ~> c)) -> Type) | |
Defined in Data.Singletons.Prelude.Either Methods suppressUnusedWarnings :: () # | |
| SingI (Either_Sym0 :: TyFun (a ~> c) ((b ~> c) ~> (Either a b ~> c)) -> Type) | |
Defined in Data.Singletons.Prelude.Either Methods sing :: Sing Either_Sym0 # | |
| SuppressUnusedWarnings (TFHelper_6989586621680072943Sym1 a6989586621680072948 :: TyFun (Either e a) (Either e b) -> Type) | |
Defined in Data.Singletons.Prelude.Monad.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (TFHelper_6989586621680072764Sym1 a6989586621680072769 :: TyFun (Either a2 b) (Either a2 a1) -> Type) | |
Defined in Data.Singletons.Prelude.Monad.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Fmap_6989586621680072747Sym1 a6989586621680072752 :: TyFun (Either a2 a1) (Either a2 b) -> Type) | |
Defined in Data.Singletons.Prelude.Monad.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (FoldMap_6989586621680823354Sym1 a6989586621680823359 :: TyFun (Either a2 a1) m -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Foldr_6989586621680823366Sym1 a6989586621680823372 :: TyFun b (Either a2 a1 ~> b) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Traverse_6989586621681088300Sym0 :: TyFun (a1 ~> f b) (Either a2 a1 ~> f (Either a2 b)) -> Type) | |
Defined in Data.Singletons.Prelude.Traversable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (TFHelper_6989586621680073027Sym1 a6989586621680073032 :: TyFun (a ~> Either e b) (Either e b) -> Type) | |
Defined in Data.Singletons.Prelude.Monad.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Either_Sym1 a6989586621680802341 :: TyFun (b ~> c) (Either a b ~> c) -> Type) | |
Defined in Data.Singletons.Prelude.Either Methods suppressUnusedWarnings :: () # | |
| SingI d => SingI (Either_Sym1 d :: TyFun (b ~> c) (Either a b ~> c) -> Type) | |
Defined in Data.Singletons.Prelude.Either Methods sing :: Sing (Either_Sym1 d) # | |
| SuppressUnusedWarnings (Traverse_6989586621681088300Sym1 a6989586621681088305 :: TyFun (Either a2 a1) (f (Either a2 b)) -> Type) | |
Defined in Data.Singletons.Prelude.Traversable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Foldr_6989586621680823366Sym2 a6989586621680823372 a6989586621680823373 :: TyFun (Either a2 a1) b -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Either_Sym2 a6989586621680802341 a6989586621680802342 :: TyFun (Either a b) c -> Type) | |
Defined in Data.Singletons.Prelude.Either Methods suppressUnusedWarnings :: () # | |
| (SingI d1, SingI d2) => SingI (Either_Sym2 d1 d2 :: TyFun (Either a b) c -> Type) | |
Defined in Data.Singletons.Prelude.Either Methods sing :: Sing (Either_Sym2 d1 d2) # | |
| (Functor f, Functor g) => Functor (Lift Either f g) | |
| type MapM (arg1 :: a1 ~> m b) (arg2 :: Either a2 a1) | |
| type Traverse (a3 :: a1 ~> f b) (a4 :: Either a2 a1) | |
| type LiftA2 (arg1 :: a ~> (b ~> c)) (arg2 :: Either e a) (arg3 :: Either e b) | |
| type FoldMap (a3 :: a1 ~> k2) (a4 :: Either a2 a1) | |
| type Fmap (a3 :: a1 ~> b) (a4 :: Either a2 a1) | |
| type Foldl' (arg1 :: b ~> (a1 ~> b)) (arg2 :: b) (arg3 :: Either a2 a1) | |
| type Foldl (arg1 :: b ~> (a1 ~> b)) (arg2 :: b) (arg3 :: Either a2 a1) | |
| type Foldr' (arg1 :: a1 ~> (b ~> b)) (arg2 :: b) (arg3 :: Either a2 a1) | |
| type Foldr (a3 :: a1 ~> (k2 ~> k2)) (a4 :: k2) (a5 :: Either a2 a1) | |
| type Pure (a :: k1) | |
| type Return (arg :: a) | |
| type Elem (arg1 :: a1) (arg2 :: Either a2 a1) | |
| type Foldl1 (arg1 :: a1 ~> (a1 ~> a1)) (arg2 :: Either a2 a1) | |
| type Foldr1 (arg1 :: a1 ~> (a1 ~> a1)) (arg2 :: Either a2 a1) | |
| type (a2 :: k1) <$ (a3 :: Either a1 b) | |
| type Apply (ShowsPrec_6989586621680653958Sym0 :: TyFun Nat (Either a b ~> (Symbol ~> Symbol)) -> Type) (a6989586621680653968 :: Nat) | |
| type Apply (Pure_6989586621680072933Sym0 :: TyFun a (Either e a) -> Type) (a6989586621680072939 :: a) | |
| type Apply (LeftSym0 :: TyFun a (Either a b) -> Type) (a6989586621679750173 :: a) | |
| type Apply (RightSym0 :: TyFun b (Either a b) -> Type) (a6989586621679750175 :: b) | |
| type Apply (Let6989586621680240813ASym0 :: TyFun k1 (Either a k1) -> Type) (wild_69895866216802404776989586621680240812 :: k1) | |
| type Apply (TFHelper_6989586621680072764Sym0 :: TyFun a1 (Either a2 b ~> Either a2 a1) -> Type) (a6989586621680072769 :: a1) | |
| type Apply (Foldr_6989586621680823366Sym1 a6989586621680823372 :: TyFun b (Either a2 a1 ~> b) -> Type) (a6989586621680823373 :: b) | |
| type Eval (FoldMap f ('Right x :: Either a3 a1) :: a2 -> Type) | |
| type Eval (FoldMap f ('Left _a :: Either a3 a1) :: a2 -> Type) | |
| type Eval (Foldr f y ('Right x :: Either a3 a1) :: a2 -> Type) | |
| type Eval (Foldr f y ('Left _a :: Either a3 a1) :: a2 -> Type) | |
| type Failure (Either a) | |
Defined in Basement.Monad | |
| type Product (arg :: Either a1 a2) | |
| type Sum (arg :: Either a1 a2) | |
| type Minimum (arg :: Either a1 a2) | |
| type Maximum (arg :: Either a1 a2) | |
| type Length (a3 :: Either a1 a2) | |
| type Null (a3 :: Either a1 a2) | |
| type ToList (arg :: Either a1 a2) | |
| type Fold (arg :: Either a m) | |
| type Sequence (arg :: Either a1 (m a2)) | |
| type SequenceA (arg :: Either a1 (f a2)) | |
| type (arg1 :: Either e a) <* (arg2 :: Either e b) | |
| type (arg1 :: Either e a) *> (arg2 :: Either e b) | |
| type (a2 :: Either e (a1 ~> b)) <*> (a3 :: Either e a1) | |
| type (arg1 :: Either e a) >> (arg2 :: Either e b) | |
| type (a2 :: Either e a1) >>= (a3 :: a1 ~> Either e 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 HKD (Either a :: Type -> Type) (b :: Type) | |
| type Apply (RightsSym0 :: TyFun [Either a b] [b] -> Type) (a6989586621680804025 :: [Either a b]) | |
Defined in Data.Singletons.Prelude.Either type Apply (RightsSym0 :: TyFun [Either a b] [b] -> Type) (a6989586621680804025 :: [Either a b]) = RightsSym1 a6989586621680804025 | |
| type Apply (LeftsSym0 :: TyFun [Either a b] [a] -> Type) (a6989586621680804031 :: [Either a b]) | |
| type Apply (PartitionEithersSym0 :: TyFun [Either a b] ([a], [b]) -> Type) (a6989586621680804008 :: [Either a b]) | |
| 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))) | |
| type Sing | |
Defined in Data.Singletons.Prelude.Instances | |
| type Demote (Either a b) | |
| type Element (Either a b) | |
Defined in Universum.Container.Class | |
| type TypeDocFieldDescriptions (Either l r) | |
Defined in Morley.Michelson.Typed.Haskell.Doc | |
| type ToT (Either l r) | |
Defined in Morley.Michelson.Typed.Haskell.Value | |
| type Show_ (arg :: Either a b) | |
| type Sconcat (arg :: NonEmpty (Either a b)) | |
| type ShowList (arg1 :: [Either a b]) arg2 | |
| type (a2 :: Either a1 b) <> (a3 :: Either a1 b) | |
| type Min (arg1 :: Either a b) (arg2 :: Either a b) | |
| type Max (arg1 :: Either a b) (arg2 :: Either a b) | |
| type (arg1 :: Either a b) >= (arg2 :: Either a b) | |
| type (arg1 :: Either a b) > (arg2 :: Either a b) | |
| type (arg1 :: Either a b) <= (arg2 :: Either a b) | |
| type (arg1 :: Either a b) < (arg2 :: Either a b) | |
| type Compare (a2 :: Either a1 b) (a3 :: Either a1 b) | |
| type (x :: Either a b) /= (y :: Either a b) | |
| type (a2 :: Either a1 b1) == (b2 :: Either a1 b1) | |
Defined in Data.Singletons.Prelude.Eq | |
| type ShowsPrec a2 (a3 :: Either a1 b) a4 | |
| type Apply (Length_6989586621680823380Sym0 :: TyFun (Either a1 a2) Nat -> Type) (a6989586621680823384 :: Either a1 a2) | |
| type Apply (Null_6989586621680823386Sym0 :: TyFun (Either a1 a2) Bool -> Type) (a6989586621680823392 :: Either a1 a2) | |
| type Apply (IsRightSym0 :: TyFun (Either a b) Bool -> Type) (a6989586621680804000 :: Either a b) | |
Defined in Data.Singletons.Prelude.Either type Apply (IsRightSym0 :: TyFun (Either a b) Bool -> Type) (a6989586621680804000 :: Either a b) = IsRightSym1 a6989586621680804000 | |
| type Apply (IsLeftSym0 :: TyFun (Either a b) Bool -> Type) (a6989586621680804003 :: Either a b) | |
Defined in Data.Singletons.Prelude.Either type Apply (IsLeftSym0 :: TyFun (Either a b) Bool -> Type) (a6989586621680804003 :: Either a b) = IsLeftSym1 a6989586621680804003 | |
| type Apply (Compare_6989586621679848544Sym1 a6989586621679848549 :: TyFun (Either a b) Ordering -> Type) (a6989586621679848550 :: Either a b) | |
| type Apply (FoldMap_6989586621680823354Sym1 a6989586621680823359 :: TyFun (Either a2 a1) m -> Type) (a6989586621680823360 :: Either a2 a1) | |
| type Apply (Foldr_6989586621680823366Sym2 a6989586621680823372 a6989586621680823373 :: TyFun (Either a2 a1) b -> Type) (a6989586621680823374 :: Either a2 a1) | |
| type Apply (Either_Sym2 a6989586621680802341 a6989586621680802342 :: TyFun (Either a b) c -> Type) (a6989586621680802343 :: Either a b) | |
Defined in Data.Singletons.Prelude.Either type Apply (Either_Sym2 a6989586621680802341 a6989586621680802342 :: TyFun (Either a b) c -> Type) (a6989586621680802343 :: Either a b) = Either_Sym3 a6989586621680802341 a6989586621680802342 a6989586621680802343 | |
| type Apply (Traverse_6989586621681088300Sym1 a6989586621681088305 :: TyFun (Either a2 a1) (f (Either a2 b)) -> Type) (a6989586621681088306 :: Either a2 a1) | |
| type Apply (Compare_6989586621679848544Sym0 :: TyFun (Either a b) (Either a b ~> Ordering) -> Type) (a6989586621679848549 :: Either a b) | |
| type Apply (TFHelper_6989586621680240804Sym0 :: TyFun (Either a b) (Either a b ~> Either a b) -> Type) (a6989586621680240809 :: Either a b) | |
| type Apply (ShowsPrec_6989586621680653958Sym1 a6989586621680653968 :: TyFun (Either a b) (Symbol ~> Symbol) -> Type) (a6989586621680653969 :: Either a b) | |
| type Apply (TFHelper_6989586621680072943Sym0 :: TyFun (Either e (a ~> b)) (Either e a ~> Either e b) -> Type) (a6989586621680072948 :: Either e (a ~> b)) | |
| type Apply (TFHelper_6989586621680073027Sym0 :: TyFun (Either e a) ((a ~> Either e b) ~> Either e b) -> Type) (a6989586621680073032 :: Either e a) | |
Defined in Data.Singletons.Prelude.Monad.Internal | |
| type Apply (TFHelper_6989586621680240804Sym1 a6989586621680240809 :: TyFun (Either a b) (Either a b) -> Type) (a6989586621680240810 :: Either a b) | |
| type Apply (Fmap_6989586621680072747Sym0 :: TyFun (a1 ~> b) (Either a2 a1 ~> Either a2 b) -> Type) (a6989586621680072752 :: a1 ~> b) | |
| type Apply (FoldMap_6989586621680823354Sym0 :: TyFun (a1 ~> m) (Either a2 a1 ~> m) -> Type) (a6989586621680823359 :: a1 ~> m) | |
| type Apply (Foldr_6989586621680823366Sym0 :: TyFun (a1 ~> (b ~> b)) (b ~> (Either a2 a1 ~> b)) -> Type) (a6989586621680823372 :: a1 ~> (b ~> b)) | |
| type Apply (Either_Sym0 :: TyFun (a ~> c) ((b ~> c) ~> (Either a b ~> c)) -> Type) (a6989586621680802341 :: a ~> c) | |
| type Apply (Fmap_6989586621680072747Sym1 a6989586621680072752 :: TyFun (Either a2 a1) (Either a2 b) -> Type) (a6989586621680072753 :: Either a2 a1) | |
| type Apply (TFHelper_6989586621680072764Sym1 a6989586621680072769 :: TyFun (Either a2 b) (Either a2 a1) -> Type) (a6989586621680072770 :: Either a2 b) | |
| type Apply (TFHelper_6989586621680072943Sym1 a6989586621680072948 :: TyFun (Either e a) (Either e b) -> Type) (a6989586621680072949 :: Either e a) | |
| type Apply (Traverse_6989586621681088300Sym0 :: TyFun (a1 ~> f b) (Either a2 a1 ~> f (Either a2 b)) -> Type) (a6989586621681088305 :: a1 ~> f b) | |
| type Apply (TFHelper_6989586621680073027Sym1 a6989586621680073032 :: TyFun (a ~> Either e b) (Either e b) -> Type) (a6989586621680073033 :: a ~> Either e b) | |
| type Apply (Either_Sym1 a6989586621680802341 :: TyFun (b ~> c) (Either a b ~> c) -> Type) (a6989586621680802342 :: b ~> c) | |
Defined in Data.Singletons.Prelude.Either type Apply (Either_Sym1 a6989586621680802341 :: TyFun (b ~> c) (Either a b ~> c) -> Type) (a6989586621680802342 :: b ~> c) = Either_Sym2 a6989586621680802341 a6989586621680802342 | |
| type Eval (Map f ('Right a3 :: Either a2 a1) :: Either a2 b -> Type) | |
| type Eval (Map f ('Left x :: Either a2 a1) :: Either a2 b -> Type) | |
| type Eval (Bimap f g ('Right y :: Either a b1) :: Either a' b2 -> Type) | |
| type Eval (Bimap f g ('Left x :: Either a1 b) :: Either a2 b' -> Type) | |
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 |
| 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 # 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 |
| MonadPlus Maybe | Since: base-2.1 |
| ToJSON1 Maybe | |
Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Maybe a -> Value # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Maybe a] -> Value # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Maybe a -> Encoding # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Maybe a] -> Encoding # | |
| Alternative 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 |
| MonadFailure Maybe | |
| 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 | |
| InjValue Maybe | |
Defined in Named.Internal | |
| PTraversable Maybe | |
| STraversable Maybe | |
Defined in Data.Singletons.Prelude.Traversable Methods sTraverse :: forall a (f :: Type -> Type) b (t1 :: a ~> f b) (t2 :: Maybe a). SApplicative f => Sing t1 -> Sing t2 -> Sing (Apply (Apply TraverseSym0 t1) t2) # sSequenceA :: forall (f :: Type -> Type) a (t1 :: Maybe (f a)). SApplicative f => Sing t1 -> Sing (Apply SequenceASym0 t1) # sMapM :: forall a (m :: Type -> Type) b (t1 :: a ~> m b) (t2 :: Maybe a). SMonad m => Sing t1 -> Sing t2 -> Sing (Apply (Apply MapMSym0 t1) t2) # sSequence :: forall (m :: Type -> Type) a (t1 :: Maybe (m a)). SMonad m => Sing t1 -> Sing (Apply SequenceSym0 t1) # | |
| PFoldable Maybe | |
| SFoldable Maybe | |
Defined in Data.Singletons.Prelude.Foldable Methods sFold :: forall m (t1 :: Maybe m). SMonoid m => Sing t1 -> Sing (Apply FoldSym0 t1) # sFoldMap :: forall a m (t1 :: a ~> m) (t2 :: Maybe a). SMonoid m => Sing t1 -> Sing t2 -> Sing (Apply (Apply FoldMapSym0 t1) t2) # sFoldr :: forall a b (t1 :: a ~> (b ~> b)) (t2 :: b) (t3 :: Maybe a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply FoldrSym0 t1) t2) t3) # sFoldr' :: forall a b (t1 :: a ~> (b ~> b)) (t2 :: b) (t3 :: Maybe a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply Foldr'Sym0 t1) t2) t3) # sFoldl :: forall b a (t1 :: b ~> (a ~> b)) (t2 :: b) (t3 :: Maybe a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply FoldlSym0 t1) t2) t3) # sFoldl' :: forall b a (t1 :: b ~> (a ~> b)) (t2 :: b) (t3 :: Maybe a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply Foldl'Sym0 t1) t2) t3) # sFoldr1 :: forall a (t1 :: a ~> (a ~> a)) (t2 :: Maybe a). Sing t1 -> Sing t2 -> Sing (Apply (Apply Foldr1Sym0 t1) t2) # sFoldl1 :: forall a (t1 :: a ~> (a ~> a)) (t2 :: Maybe a). Sing t1 -> Sing t2 -> Sing (Apply (Apply Foldl1Sym0 t1) t2) # sToList :: forall a (t1 :: Maybe a). Sing t1 -> Sing (Apply ToListSym0 t1) # sNull :: forall a (t1 :: Maybe a). Sing t1 -> Sing (Apply NullSym0 t1) # sLength :: forall a (t1 :: Maybe a). Sing t1 -> Sing (Apply LengthSym0 t1) # sElem :: forall a (t1 :: a) (t2 :: Maybe a). SEq a => Sing t1 -> Sing t2 -> Sing (Apply (Apply ElemSym0 t1) t2) # sMaximum :: forall a (t1 :: Maybe a). SOrd a => Sing t1 -> Sing (Apply MaximumSym0 t1) # sMinimum :: forall a (t1 :: Maybe a). SOrd a => Sing t1 -> Sing (Apply MinimumSym0 t1) # sSum :: forall a (t1 :: Maybe a). SNum a => Sing t1 -> Sing (Apply SumSym0 t1) # sProduct :: forall a (t1 :: Maybe a). SNum a => Sing t1 -> Sing (Apply ProductSym0 t1) # | |
| SMonadFail Maybe | |
| PFunctor Maybe | |
Defined in Data.Singletons.Prelude.Monad.Internal | |
| PApplicative Maybe | |
| PMonad Maybe | |
| SFunctor Maybe | |
| SApplicative Maybe | |
Defined in Data.Singletons.Prelude.Monad.Internal Methods sPure :: forall a (t :: a). Sing t -> Sing (Apply PureSym0 t) # (%<*>) :: forall a b (t1 :: Maybe (a ~> b)) (t2 :: Maybe a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<*>@#@$) t1) t2) # sLiftA2 :: forall a b c (t1 :: a ~> (b ~> c)) (t2 :: Maybe a) (t3 :: Maybe b). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply LiftA2Sym0 t1) t2) t3) # (%*>) :: forall a b (t1 :: Maybe a) (t2 :: Maybe b). Sing t1 -> Sing t2 -> Sing (Apply (Apply (*>@#@$) t1) t2) # (%<*) :: forall a b (t1 :: Maybe a) (t2 :: Maybe b). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<*@#@$) t1) t2) # | |
| SMonad Maybe | |
Defined in Data.Singletons.Prelude.Monad.Internal Methods (%>>=) :: forall a b (t1 :: Maybe a) (t2 :: a ~> Maybe b). Sing t1 -> Sing t2 -> Sing (Apply (Apply (>>=@#@$) t1) t2) # (%>>) :: forall a b (t1 :: Maybe a) (t2 :: Maybe b). Sing t1 -> Sing t2 -> Sing (Apply (Apply (>>@#@$) t1) t2) # sReturn :: forall a (t :: a). Sing t -> Sing (Apply ReturnSym0 t) # | |
| SAlternative Maybe | |
| SMonadPlus Maybe | |
| KnownNamedFunctor Maybe | |
| LorentzFunctor Maybe Source # | |
Defined in Lorentz.Instr | |
| (Selector s, GToJSON' enc arity (K1 i (Maybe a) :: Type -> Type), KeyValuePair enc pairs, Monoid pairs) => RecordToPairs enc pairs arity (S1 s (K1 i (Maybe a) :: Type -> Type)) | |
Defined in Data.Aeson.Types.ToJSON | |
| Lift a => Lift (Maybe a :: Type) | |
| () :=> (Functor Maybe) | |
| () :=> (Applicative Maybe) | |
Defined in Data.Constraint Methods ins :: () :- Applicative Maybe # | |
| () :=> (MonadPlus Maybe) | |
| () :=> (Alternative Maybe) | |
Defined in Data.Constraint Methods ins :: () :- Alternative Maybe # | |
| Eq a => Eq (Maybe a) | Since: base-2.1 |
| 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) | Since: base-4.6.0.0 |
| 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 |
| Hashable a => Hashable (Maybe a) | |
Defined in Data.Hashable.Class | |
| ToJSON a => ToJSON (Maybe a) | |
Defined in Data.Aeson.Types.ToJSON | |
| NFData a => NFData (Maybe a) | |
Defined in Control.DeepSeq | |
| Default (Maybe a) | |
Defined in Data.Default.Class | |
| Buildable a => Buildable (Maybe a) | |
Defined in Formatting.Buildable | |
| Ixed (Maybe a) | |
Defined in Control.Lens.At | |
| At (Maybe a) | |
| Semiring a => Semiring (Maybe a) | |
| PMonoid (Maybe a) | |
| SSemigroup a => SMonoid (Maybe a) | |
| PShow (Maybe a) | |
| SShow a => SShow (Maybe a) | |
Defined in Data.Singletons.Prelude.Show Methods sShowsPrec :: forall (t1 :: Nat) (t2 :: Maybe a) (t3 :: Symbol). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply ShowsPrecSym0 t1) t2) t3) # sShow_ :: forall (t :: Maybe a). Sing t -> Sing (Apply Show_Sym0 t) # sShowList :: forall (t1 :: [Maybe a]) (t2 :: Symbol). Sing t1 -> Sing t2 -> Sing (Apply (Apply ShowListSym0 t1) t2) # | |
| PSemigroup (Maybe a) | |
Defined in Data.Singletons.Prelude.Semigroup.Internal | |
| SSemigroup a => SSemigroup (Maybe a) | |
| POrd (Maybe a) | |
| SOrd a => SOrd (Maybe a) | |
Defined in Data.Singletons.Prelude.Ord Methods sCompare :: forall (t1 :: Maybe a) (t2 :: Maybe a). Sing t1 -> Sing t2 -> Sing (Apply (Apply CompareSym0 t1) t2) # (%<) :: forall (t1 :: Maybe a) (t2 :: Maybe a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<@#@$) t1) t2) # (%<=) :: forall (t1 :: Maybe a) (t2 :: Maybe a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<=@#@$) t1) t2) # (%>) :: forall (t1 :: Maybe a) (t2 :: Maybe a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (>@#@$) t1) t2) # (%>=) :: forall (t1 :: Maybe a) (t2 :: Maybe a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (>=@#@$) t1) t2) # sMax :: forall (t1 :: Maybe a) (t2 :: Maybe a). Sing t1 -> Sing t2 -> Sing (Apply (Apply MaxSym0 t1) t2) # sMin :: forall (t1 :: Maybe a) (t2 :: Maybe a). Sing t1 -> Sing t2 -> Sing (Apply (Apply MinSym0 t1) t2) # | |
| SEq a => SEq (Maybe a) | |
| PEq (Maybe a) | |
| (TypeError (DisallowInstance "Maybe") :: Constraint) => Container (Maybe a) | |
Defined in Universum.Container.Class Methods toList :: Maybe a -> [Element (Maybe a)] # foldr :: (Element (Maybe a) -> b -> b) -> b -> Maybe a -> b # foldl :: (b -> Element (Maybe a) -> b) -> b -> Maybe a -> b # foldl' :: (b -> Element (Maybe a) -> b) -> b -> Maybe a -> b # elem :: Element (Maybe a) -> Maybe a -> Bool # foldMap :: Monoid m => (Element (Maybe a) -> m) -> Maybe a -> m # fold :: Maybe a -> Element (Maybe a) # foldr' :: (Element (Maybe a) -> b -> b) -> b -> Maybe a -> b # notElem :: Element (Maybe a) -> Maybe a -> Bool # all :: (Element (Maybe a) -> Bool) -> Maybe a -> Bool # any :: (Element (Maybe a) -> Bool) -> Maybe a -> Bool # find :: (Element (Maybe a) -> Bool) -> Maybe a -> Maybe (Element (Maybe a)) # safeHead :: Maybe a -> Maybe (Element (Maybe a)) # safeMaximum :: Maybe a -> Maybe (Element (Maybe a)) # safeMinimum :: Maybe a -> Maybe (Element (Maybe a)) # safeFoldr1 :: (Element (Maybe a) -> Element (Maybe a) -> Element (Maybe a)) -> Maybe a -> Maybe (Element (Maybe a)) # safeFoldl1 :: (Element (Maybe a) -> Element (Maybe a) -> Element (Maybe a)) -> Maybe a -> Maybe (Element (Maybe a)) # | |
| Pretty a => Pretty (Maybe a) | |
Defined in Text.PrettyPrint.Leijen.Text | |
| SingKind a => SingKind (Maybe a) | Since: base-4.9.0.0 |
Defined in GHC.Generics Associated Types type DemoteRep (Maybe a) | |
| PolyTypeHasDocC '[a] => TypeHasDoc (Maybe a) | |
Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (Maybe a) :: FieldDescriptions # Methods typeDocName :: Proxy (Maybe a) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (Maybe a) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (Maybe a) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (Maybe a) # typeDocMichelsonRep :: TypeDocMichelsonRep (Maybe a) # | |
| IsoValue a => IsoValue (Maybe a) | |
| HasAnnotation a => HasAnnotation (Maybe a) Source # | |
Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (Maybe a)) Source # | |
| Generic1 Maybe | Since: base-4.6.0.0 |
| PMonadFail Maybe | |
Defined in Data.Singletons.Prelude.Monad.Fail | |
| PAlternative Maybe | |
Defined in Data.Singletons.Prelude.Monad.Internal | |
| PMonadPlus Maybe | |
Defined in Data.Singletons.Prelude.Monad.Internal | |
| IsoHKD Maybe (a :: Type) | |
| SDecide a => TestCoercion (SMaybe :: Maybe a -> Type) | |
Defined in Data.Singletons.Prelude.Instances | |
| SDecide a => TestEquality (SMaybe :: Maybe a -> Type) | |
Defined in Data.Singletons.Prelude.Instances | |
| (Eq a) :=> (Eq (Maybe a)) | |
| (Ord a) :=> (Ord (Maybe a)) | |
| (Read a) :=> (Read (Maybe a)) | |
| (Show a) :=> (Show (Maybe a)) | |
| (Semigroup a) :=> (Semigroup (Maybe a)) | |
| (Monoid a) :=> (Monoid (Maybe a)) | |
| SingI ('Nothing :: Maybe a) | Since: base-4.9.0.0 |
Defined in GHC.Generics | |
| Each (Maybe a) (Maybe b) a b | |
| CanCastTo a b => CanCastTo (Maybe a :: Type) (Maybe b :: Type) Source # | |
| SingI a2 => SingI ('Just a2 :: Maybe a1) | Since: base-4.9.0.0 |
Defined in GHC.Generics | |
| SuppressUnusedWarnings (Fail_6989586621680156221Sym0 :: TyFun [Char] (Maybe a) -> Type) | |
Defined in Data.Singletons.Prelude.Monad.Fail Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (CatMaybesSym0 :: TyFun [Maybe a] [a] -> Type) | |
Defined in Data.Singletons.Prelude.Maybe Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (ListToMaybeSym0 :: TyFun [a] (Maybe a) -> Type) | |
Defined in Data.Singletons.Prelude.Maybe Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (StripPrefixSym0 :: TyFun [a] ([a] ~> Maybe [a]) -> Type) | |
Defined in Data.Singletons.Prelude.List.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (TFHelper_6989586621680073042Sym0 :: TyFun (Maybe a) (Maybe a ~> Maybe a) -> Type) | |
Defined in Data.Singletons.Prelude.Monad.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (MaybeToListSym0 :: TyFun (Maybe a) [a] -> Type) | |
Defined in Data.Singletons.Prelude.Maybe Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (IsNothingSym0 :: TyFun (Maybe a) Bool -> Type) | |
Defined in Data.Singletons.Prelude.Maybe Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (IsJustSym0 :: TyFun (Maybe a) Bool -> Type) | |
Defined in Data.Singletons.Prelude.Maybe Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (FromJustSym0 :: TyFun (Maybe a) a -> Type) | |
Defined in Data.Singletons.Prelude.Maybe Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (MinInternalSym0 :: TyFun (Maybe a) (MinInternal a) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (MaxInternalSym0 :: TyFun (Maybe a) (MaxInternal a) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Compare_6989586621679848468Sym0 :: TyFun (Maybe a) (Maybe a ~> Ordering) -> Type) | |
Defined in Data.Singletons.Prelude.Ord Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (TFHelper_6989586621680240791Sym0 :: TyFun (Maybe a) (Maybe a ~> Maybe a) -> Type) | |
Defined in Data.Singletons.Prelude.Semigroup.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (OptionSym0 :: TyFun (Maybe a) (Option a) -> Type) | |
Defined in Data.Singletons.Prelude.Semigroup.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (LastSym0 :: TyFun (Maybe a) (Last a) -> Type) | |
Defined in Data.Singletons.Prelude.Monoid Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (FirstSym0 :: TyFun (Maybe a) (First a) -> Type) | |
Defined in Data.Singletons.Prelude.Monoid Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (ShowsPrec_6989586621680653904Sym0 :: TyFun Nat (Maybe a ~> (Symbol ~> Symbol)) -> Type) | |
Defined in Data.Singletons.Prelude.Show Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Pure_6989586621680072784Sym0 :: TyFun a (Maybe a) -> Type) | |
Defined in Data.Singletons.Prelude.Monad.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Let6989586621680073051LSym0 :: TyFun k1 (Maybe k1) -> Type) | |
Defined in Data.Singletons.Prelude.Monad.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (FromMaybeSym0 :: TyFun a (Maybe a ~> a) -> Type) | |
Defined in Data.Singletons.Prelude.Maybe Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (ElemIndexSym0 :: TyFun a ([a] ~> Maybe Nat) -> Type) | |
Defined in Data.Singletons.Prelude.List.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (JustSym0 :: TyFun a (Maybe a) -> Type) | |
Defined in Data.Singletons.Prelude.Instances Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (GetOptionSym0 :: TyFun (Option a) (Maybe a) -> Type) | |
Defined in Data.Singletons.Prelude.Semigroup.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (GetFirstSym0 :: TyFun (First a) (Maybe a) -> Type) | |
Defined in Data.Singletons.Prelude.Monoid Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (GetLastSym0 :: TyFun (Last a) (Maybe a) -> Type) | |
Defined in Data.Singletons.Prelude.Monoid Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (FindSym0 :: TyFun (a ~> Bool) ([a] ~> Maybe a) -> Type) | |
Defined in Data.Singletons.Prelude.List.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (FindIndexSym0 :: TyFun (a ~> Bool) ([a] ~> Maybe Nat) -> Type) | |
Defined in Data.Singletons.Prelude.List.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (GetMaxInternalSym0 :: TyFun (MaxInternal a) (Maybe a) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (GetMinInternalSym0 :: TyFun (MinInternal a) (Maybe a) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SingI (CatMaybesSym0 :: TyFun [Maybe a] [a] -> Type) | |
Defined in Data.Singletons.Prelude.Maybe Methods sing :: Sing CatMaybesSym0 # | |
| SingI (ListToMaybeSym0 :: TyFun [a] (Maybe a) -> Type) | |
Defined in Data.Singletons.Prelude.Maybe Methods sing :: Sing ListToMaybeSym0 # | |
| SingI (MaybeToListSym0 :: TyFun (Maybe a) [a] -> Type) | |
Defined in Data.Singletons.Prelude.Maybe Methods sing :: Sing MaybeToListSym0 # | |
| SingI (IsNothingSym0 :: TyFun (Maybe a) Bool -> Type) | |
Defined in Data.Singletons.Prelude.Maybe Methods sing :: Sing IsNothingSym0 # | |
| SingI (IsJustSym0 :: TyFun (Maybe a) Bool -> Type) | |
Defined in Data.Singletons.Prelude.Maybe Methods sing :: Sing IsJustSym0 # | |
| SingI (FromJustSym0 :: TyFun (Maybe a) a -> Type) | |
Defined in Data.Singletons.Prelude.Maybe Methods sing :: Sing FromJustSym0 # | |
| SingI (MinInternalSym0 :: TyFun (Maybe a) (MinInternal a) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable | |
| SingI (MaxInternalSym0 :: TyFun (Maybe a) (MaxInternal a) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable | |
| SingI (OptionSym0 :: TyFun (Maybe a) (Option a) -> Type) | |
Defined in Data.Singletons.Prelude.Semigroup.Internal Methods sing :: Sing OptionSym0 # | |
| SingI (LastSym0 :: TyFun (Maybe a) (Last a) -> Type) | |
Defined in Data.Singletons.Prelude.Monoid | |
| SingI (FirstSym0 :: TyFun (Maybe a) (First a) -> Type) | |
Defined in Data.Singletons.Prelude.Monoid | |
| SingI (FromMaybeSym0 :: TyFun a (Maybe a ~> a) -> Type) | |
Defined in Data.Singletons.Prelude.Maybe Methods sing :: Sing FromMaybeSym0 # | |
| SEq a => SingI (ElemIndexSym0 :: TyFun a ([a] ~> Maybe Nat) -> Type) | |
Defined in Data.Singletons.Prelude.List.Internal Methods sing :: Sing ElemIndexSym0 # | |
| SingI (JustSym0 :: TyFun a (Maybe a) -> Type) | |
Defined in Data.Singletons.Prelude.Instances | |
| SingI (GetOptionSym0 :: TyFun (Option a) (Maybe a) -> Type) | |
Defined in Data.Singletons.Prelude.Semigroup.Internal Methods sing :: Sing GetOptionSym0 # | |
| SingI (GetFirstSym0 :: TyFun (First a) (Maybe a) -> Type) | |
Defined in Data.Singletons.Prelude.Monoid Methods sing :: Sing GetFirstSym0 # | |
| SingI (GetLastSym0 :: TyFun (Last a) (Maybe a) -> Type) | |
Defined in Data.Singletons.Prelude.Monoid Methods sing :: Sing GetLastSym0 # | |
| SingI (FindSym0 :: TyFun (a ~> Bool) ([a] ~> Maybe a) -> Type) | |
Defined in Data.Singletons.Prelude.List.Internal | |
| SingI (FindIndexSym0 :: TyFun (a ~> Bool) ([a] ~> Maybe Nat) -> Type) | |
Defined in Data.Singletons.Prelude.List.Internal Methods sing :: Sing FindIndexSym0 # | |
| SingI (GetMaxInternalSym0 :: TyFun (MaxInternal a) (Maybe a) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable | |
| SingI (GetMinInternalSym0 :: TyFun (MinInternal a) (Maybe a) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable | |
| SuppressUnusedWarnings (StripPrefixSym1 a6989586621680498961 :: TyFun [a] (Maybe [a]) -> Type) | |
Defined in Data.Singletons.Prelude.List.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (FindSym1 a6989586621680379639 :: TyFun [a] (Maybe a) -> Type) | |
Defined in Data.Singletons.Prelude.List.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (FindIndexSym1 a6989586621680379612 :: TyFun [a] (Maybe Nat) -> Type) | |
Defined in Data.Singletons.Prelude.List.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (ElemIndexSym1 a6989586621680379630 :: TyFun [a] (Maybe Nat) -> Type) | |
Defined in Data.Singletons.Prelude.List.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (ShowsPrec_6989586621680653904Sym1 a6989586621680653914 :: TyFun (Maybe a) (Symbol ~> Symbol) -> Type) | |
Defined in Data.Singletons.Prelude.Show Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (TFHelper_6989586621680073042Sym1 a6989586621680073047 :: TyFun (Maybe a) (Maybe a) -> Type) | |
Defined in Data.Singletons.Prelude.Monad.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (TFHelper_6989586621680072966Sym0 :: TyFun (Maybe a) (Maybe b ~> Maybe b) -> Type) | |
Defined in Data.Singletons.Prelude.Monad.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (TFHelper_6989586621680072955Sym0 :: TyFun (Maybe a) ((a ~> Maybe b) ~> Maybe b) -> Type) | |
Defined in Data.Singletons.Prelude.Monad.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (TFHelper_6989586621680072821Sym0 :: TyFun (Maybe a) (Maybe b ~> Maybe b) -> Type) | |
Defined in Data.Singletons.Prelude.Monad.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (FromMaybeSym1 a6989586621679959410 :: TyFun (Maybe a) a -> Type) | |
Defined in Data.Singletons.Prelude.Maybe Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Compare_6989586621679848468Sym1 a6989586621679848473 :: TyFun (Maybe a) Ordering -> Type) | |
Defined in Data.Singletons.Prelude.Ord Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (TFHelper_6989586621680240791Sym1 a6989586621680240796 :: TyFun (Maybe a) (Maybe a) -> Type) | |
Defined in Data.Singletons.Prelude.Semigroup.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (TFHelper_6989586621680072794Sym0 :: TyFun (Maybe (a ~> b)) (Maybe a ~> Maybe b) -> Type) | |
Defined in Data.Singletons.Prelude.Monad.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (TFHelper_6989586621680072673Sym0 :: TyFun a (Maybe b ~> Maybe a) -> Type) | |
Defined in Data.Singletons.Prelude.Monad.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Maybe_Sym0 :: TyFun b ((a ~> b) ~> (Maybe a ~> b)) -> Type) | |
Defined in Data.Singletons.Prelude.Maybe Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (LookupSym0 :: TyFun a ([(a, b)] ~> Maybe b) -> Type) | |
Defined in Data.Singletons.Prelude.List.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Let6989586621680823018MkJustSym0 :: TyFun k (TyFun a6989586621680822176 (Maybe a6989586621680822176) -> Type) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Let6989586621680823003MkJustSym0 :: TyFun k (TyFun a6989586621680822175 (Maybe a6989586621680822175) -> Type) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Let6989586621680814087NSym0 :: TyFun k (TyFun k1 (Maybe k1) -> Type) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Let6989586621680814087MSym0 :: TyFun k1 (TyFun k (Maybe k1) -> Type) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Let6989586621680814063NSym0 :: TyFun k (TyFun k1 (Maybe k1) -> Type) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Let6989586621680814063MSym0 :: TyFun k1 (TyFun k (Maybe k1) -> Type) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (OptionalSym0 :: TyFun (f a) (f (Maybe a)) -> Type) | |
Defined in Data.Singletons.Prelude.Applicative Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Fmap_6989586621680072661Sym0 :: TyFun (a ~> b) (Maybe a ~> Maybe b) -> Type) | |
Defined in Data.Singletons.Prelude.Monad.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (MapMaybeSym0 :: TyFun (a ~> Maybe b) ([a] ~> [b]) -> Type) | |
Defined in Data.Singletons.Prelude.Maybe Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (UnfoldrSym0 :: TyFun (b ~> Maybe (a, b)) (b ~> [a]) -> Type) | |
Defined in Data.Singletons.Prelude.List.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Foldr_6989586621680823060Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Maybe a ~> b)) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Foldl_6989586621680823076Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Maybe a ~> b)) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (FoldMap_6989586621680823044Sym0 :: TyFun (a ~> m) (Maybe a ~> m) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (FindSym0 :: TyFun (a ~> Bool) (t a ~> Maybe a) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SingI d => SingI (FindSym1 d :: TyFun [a] (Maybe a) -> Type) | |
Defined in Data.Singletons.Prelude.List.Internal | |
| SingI d => SingI (FindIndexSym1 d :: TyFun [a] (Maybe Nat) -> Type) | |
Defined in Data.Singletons.Prelude.List.Internal Methods sing :: Sing (FindIndexSym1 d) # | |
| (SEq a, SingI d) => SingI (ElemIndexSym1 d :: TyFun [a] (Maybe Nat) -> Type) | |
Defined in Data.Singletons.Prelude.List.Internal Methods sing :: Sing (ElemIndexSym1 d) # | |
| SingI d => SingI (FromMaybeSym1 d :: TyFun (Maybe a) a -> Type) | |
Defined in Data.Singletons.Prelude.Maybe Methods sing :: Sing (FromMaybeSym1 d) # | |
| SingI (Maybe_Sym0 :: TyFun b ((a ~> b) ~> (Maybe a ~> b)) -> Type) | |
Defined in Data.Singletons.Prelude.Maybe Methods sing :: Sing Maybe_Sym0 # | |
| SEq a => SingI (LookupSym0 :: TyFun a ([(a, b)] ~> Maybe b) -> Type) | |
Defined in Data.Singletons.Prelude.List.Internal Methods sing :: Sing LookupSym0 # | |
| SAlternative f => SingI (OptionalSym0 :: TyFun (f a) (f (Maybe a)) -> Type) | |
Defined in Data.Singletons.Prelude.Applicative Methods sing :: Sing OptionalSym0 # | |
| SingI (MapMaybeSym0 :: TyFun (a ~> Maybe b) ([a] ~> [b]) -> Type) | |
Defined in Data.Singletons.Prelude.Maybe Methods sing :: Sing MapMaybeSym0 # | |
| SingI (UnfoldrSym0 :: TyFun (b ~> Maybe (a, b)) (b ~> [a]) -> Type) | |
Defined in Data.Singletons.Prelude.List.Internal Methods sing :: Sing UnfoldrSym0 # | |
| SFoldable t => SingI (FindSym0 :: TyFun (a ~> Bool) (t a ~> Maybe a) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable | |
| SuppressUnusedWarnings (LookupSym1 a6989586621680379337 :: TyFun [(a, b)] (Maybe b) -> Type) | |
Defined in Data.Singletons.Prelude.List.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (TFHelper_6989586621680072966Sym1 a6989586621680072975 :: TyFun (Maybe b) (Maybe b) -> Type) | |
Defined in Data.Singletons.Prelude.Monad.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (TFHelper_6989586621680072821Sym1 a6989586621680072826 :: TyFun (Maybe b) (Maybe b) -> Type) | |
Defined in Data.Singletons.Prelude.Monad.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (TFHelper_6989586621680072794Sym1 a6989586621680072799 :: TyFun (Maybe a) (Maybe b) -> Type) | |
Defined in Data.Singletons.Prelude.Monad.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (TFHelper_6989586621680072673Sym1 a6989586621680072678 :: TyFun (Maybe b) (Maybe a) -> Type) | |
Defined in Data.Singletons.Prelude.Monad.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Fmap_6989586621680072661Sym1 a6989586621680072666 :: TyFun (Maybe a) (Maybe b) -> Type) | |
Defined in Data.Singletons.Prelude.Monad.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (FoldMap_6989586621680823044Sym1 a6989586621680823053 :: TyFun (Maybe a) m -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Let6989586621680823018MkJustSym1 a_69895866216808230126989586621680823017 :: TyFun a6989586621680822176 (Maybe a6989586621680822176) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Let6989586621680823003MkJustSym1 a_69895866216808229976989586621680823002 :: TyFun a6989586621680822175 (Maybe a6989586621680822175) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Let6989586621680814087NSym1 x6989586621680814085 :: TyFun k1 (Maybe k1) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Let6989586621680814087MSym1 x6989586621680814085 :: TyFun k (Maybe k1) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Let6989586621680814063NSym1 x6989586621680814061 :: TyFun k1 (Maybe k1) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Let6989586621680814063MSym1 x6989586621680814061 :: TyFun k (Maybe k1) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Foldr_6989586621680823060Sym1 a6989586621680823066 :: TyFun b (Maybe a ~> b) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Foldl_6989586621680823076Sym1 a6989586621680823082 :: TyFun b (Maybe a ~> b) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (FindSym1 a6989586621680822510 :: TyFun (t a) (Maybe a) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Lambda_6989586621680701092Sym0 :: TyFun k (TyFun (k1 ~> Last a) (TyFun k1 (Maybe a) -> Type) -> Type) -> Type) | |
Defined in Data.Singletons.Prelude.Monoid Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Lambda_6989586621680701013Sym0 :: TyFun k (TyFun (k1 ~> First a) (TyFun k1 (Maybe a) -> Type) -> Type) -> Type) | |
Defined in Data.Singletons.Prelude.Monoid Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Traverse_6989586621681088263Sym0 :: TyFun (a ~> f b) (Maybe a ~> f (Maybe b)) -> Type) | |
Defined in Data.Singletons.Prelude.Traversable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (TFHelper_6989586621680072955Sym1 a6989586621680072960 :: TyFun (a ~> Maybe b) (Maybe b) -> Type) | |
Defined in Data.Singletons.Prelude.Monad.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (LiftA2_6989586621680072807Sym0 :: TyFun (a ~> (b ~> c)) (Maybe a ~> (Maybe b ~> Maybe c)) -> Type) | |
Defined in Data.Singletons.Prelude.Monad.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Maybe_Sym1 a6989586621679957844 :: TyFun (a ~> b) (Maybe a ~> b) -> Type) | |
Defined in Data.Singletons.Prelude.Maybe Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Let6989586621679959385RsSym0 :: TyFun (a ~> Maybe k1) (TyFun k (TyFun [a] [k1] -> Type) -> Type) -> Type) | |
Defined in Data.Singletons.Prelude.Maybe Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Let6989586621680822925MfSym0 :: TyFun (k2 ~> (k3 ~> k3)) (TyFun k (TyFun (Maybe k2) (TyFun k3 (Maybe k3) -> Type) -> Type) -> Type) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Let6989586621680822904MfSym0 :: TyFun (k2 ~> (k3 ~> k2)) (TyFun k (TyFun k2 (TyFun (Maybe k3) (Maybe k2) -> Type) -> Type) -> Type) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| (SEq a, SingI d) => SingI (LookupSym1 d :: TyFun [(a, b)] (Maybe b) -> Type) | |
Defined in Data.Singletons.Prelude.List.Internal Methods sing :: Sing (LookupSym1 d) # | |
| (SFoldable t, SingI d) => SingI (FindSym1 d :: TyFun (t a) (Maybe a) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable | |
| SingI d => SingI (Maybe_Sym1 d :: TyFun (a ~> b) (Maybe a ~> b) -> Type) | |
Defined in Data.Singletons.Prelude.Maybe Methods sing :: Sing (Maybe_Sym1 d) # | |
| SuppressUnusedWarnings (Traverse_6989586621681088263Sym1 a6989586621681088268 :: TyFun (Maybe a) (f (Maybe b)) -> Type) | |
Defined in Data.Singletons.Prelude.Traversable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (LiftA2_6989586621680072807Sym1 a6989586621680072813 :: TyFun (Maybe a) (Maybe b ~> Maybe c) -> Type) | |
Defined in Data.Singletons.Prelude.Monad.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Maybe_Sym2 a6989586621679957844 a6989586621679957845 :: TyFun (Maybe a) b -> Type) | |
Defined in Data.Singletons.Prelude.Maybe Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Foldr_6989586621680823060Sym2 a6989586621680823066 a6989586621680823067 :: TyFun (Maybe a) b -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Foldl_6989586621680823076Sym2 a6989586621680823082 a6989586621680823083 :: TyFun (Maybe a) b -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Let6989586621680822925MfSym1 f6989586621680822923 :: TyFun k (TyFun (Maybe k2) (TyFun k3 (Maybe k3) -> Type) -> Type) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Let6989586621680822904MfSym1 f6989586621680822902 :: TyFun k (TyFun k2 (TyFun (Maybe k3) (Maybe k2) -> Type) -> Type) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Lambda_6989586621680701092Sym1 a6989586621680701090 :: TyFun (k1 ~> Last a) (TyFun k1 (Maybe a) -> Type) -> Type) | |
Defined in Data.Singletons.Prelude.Monoid Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Lambda_6989586621680701013Sym1 a6989586621680701011 :: TyFun (k1 ~> First a) (TyFun k1 (Maybe a) -> Type) -> Type) | |
Defined in Data.Singletons.Prelude.Monoid Methods suppressUnusedWarnings :: () # | |
| (SingI d1, SingI d2) => SingI (Maybe_Sym2 d1 d2 :: TyFun (Maybe a) b -> Type) | |
Defined in Data.Singletons.Prelude.Maybe Methods sing :: Sing (Maybe_Sym2 d1 d2) # | |
| SuppressUnusedWarnings (LiftA2_6989586621680072807Sym2 a6989586621680072813 a6989586621680072814 :: TyFun (Maybe b) (Maybe c) -> Type) | |
Defined in Data.Singletons.Prelude.Monad.Internal Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Let6989586621680822925MfSym2 f6989586621680822923 xs6989586621680822924 :: TyFun (Maybe k2) (TyFun k3 (Maybe k3) -> Type) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Let6989586621680822904MfSym2 f6989586621680822902 xs6989586621680822903 :: TyFun k2 (TyFun (Maybe k3) (Maybe k2) -> Type) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Lambda_6989586621680701092Sym2 a6989586621680701090 k6989586621680701091 :: TyFun k1 (Maybe a) -> Type) | |
Defined in Data.Singletons.Prelude.Monoid Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Lambda_6989586621680701013Sym2 a6989586621680701011 k6989586621680701012 :: TyFun k1 (Maybe a) -> Type) | |
Defined in Data.Singletons.Prelude.Monoid Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Let6989586621680822904MfSym3 f6989586621680822902 xs6989586621680822903 a6989586621680822905 :: TyFun (Maybe k3) (Maybe k2) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Let6989586621680822925MfSym3 f6989586621680822923 xs6989586621680822924 a6989586621680822926 :: TyFun k3 (Maybe k3) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| IsoValue a => IsoValue (NamedF Maybe a name) | |
| (HasAnnotation (Maybe a), KnownSymbol name) => HasAnnotation (NamedF Maybe a name) Source # | |
Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (NamedF Maybe a name)) Source # | |
| Wrappable (NamedF Maybe a name) Source # | |
Defined in Lorentz.Wrappable | |
| Unwrappable (NamedF Maybe a name) Source # | |
Defined in Lorentz.Wrappable Associated Types type Unwrappabled (NamedF Maybe a name) Source # | |
| type Failure Maybe | |
Defined in Basement.Monad | |
| type Product (arg :: Maybe a) | |
| type Sum (arg :: Maybe a) | |
| type Minimum (arg :: Maybe a) | |
| type Maximum (arg :: Maybe a) | |
| type Length (arg :: Maybe a) | |
| type Null (arg :: Maybe a) | |
| type ToList (arg :: Maybe a) | |
| type Fold (arg :: Maybe m) | |
| type Pure (a :: k1) | |
| type Return (arg :: a) | |
| type Sequence (arg :: Maybe (m a)) | |
| type SequenceA (arg :: Maybe (f a)) | |
| type Elem (arg1 :: a) (arg2 :: Maybe a) | |
| type Foldl1 (arg1 :: a ~> (a ~> a)) (arg2 :: Maybe a) | |
| type Foldr1 (arg1 :: a ~> (a ~> a)) (arg2 :: Maybe a) | |
| type FoldMap (a2 :: a1 ~> k2) (a3 :: Maybe a1) | |
| type (a1 :: k1) <$ (a2 :: Maybe b) | |
| type Fmap (a2 :: a1 ~> b) (a3 :: Maybe a1) | |
| type (arg1 :: Maybe a) <* (arg2 :: Maybe b) | |
| type (a2 :: Maybe a1) *> (a3 :: Maybe b) | |
| type (a2 :: Maybe (a1 ~> b)) <*> (a3 :: Maybe a1) | |
| type (a2 :: Maybe a1) >> (a3 :: Maybe b) | |
| type (a2 :: Maybe a1) >>= (a3 :: a1 ~> Maybe b) | |
| type MapM (arg1 :: a ~> m b) (arg2 :: Maybe a) | |
| type Traverse (a2 :: a1 ~> f b) (a3 :: Maybe a1) | |
| type Foldl' (arg1 :: b ~> (a ~> b)) (arg2 :: b) (arg3 :: Maybe a) | |
| type Foldl (a2 :: k2 ~> (a1 ~> k2)) (a3 :: k2) (a4 :: Maybe a1) | |
| type Foldr' (arg1 :: a ~> (b ~> b)) (arg2 :: b) (arg3 :: Maybe a) | |
| type Foldr (a2 :: a1 ~> (k2 ~> k2)) (a3 :: k2) (a4 :: Maybe a1) | |
| type LiftA2 (a2 :: a1 ~> (b ~> c)) (a3 :: Maybe a1) (a4 :: Maybe b) | |
| type Apply (Pure_6989586621680072784Sym0 :: TyFun a (Maybe a) -> Type) (a6989586621680072790 :: a) | |
Defined in Data.Singletons.Prelude.Monad.Internal | |
| type Apply (Let6989586621680073051LSym0 :: TyFun k1 (Maybe k1) -> Type) (wild_69895866216800721496989586621680073050 :: k1) | |
Defined in Data.Singletons.Prelude.Monad.Internal | |
| type Apply (JustSym0 :: TyFun a (Maybe a) -> Type) (a6989586621679750104 :: a) | |
| type Apply (Let6989586621680814063NSym1 x6989586621680814061 :: TyFun k1 (Maybe k1) -> Type) (y6989586621680814062 :: k1) | |
Defined in Data.Singletons.Prelude.Foldable | |
| type Apply (Let6989586621680814063MSym1 x6989586621680814061 :: TyFun k (Maybe k1) -> Type) (y6989586621680814062 :: k) | |
Defined in Data.Singletons.Prelude.Foldable | |
| type Apply (Let6989586621680814087NSym1 x6989586621680814085 :: TyFun k1 (Maybe k1) -> Type) (y6989586621680814086 :: k1) | |
Defined in Data.Singletons.Prelude.Foldable | |
| type Apply (Let6989586621680814087MSym1 x6989586621680814085 :: TyFun k (Maybe k1) -> Type) (y6989586621680814086 :: k) | |
Defined in Data.Singletons.Prelude.Foldable | |
| type Apply (Let6989586621680823003MkJustSym1 a_69895866216808229976989586621680823002 :: TyFun a6989586621680822175 (Maybe a6989586621680822175) -> Type) (a6989586621680823006 :: a6989586621680822175) | |
Defined in Data.Singletons.Prelude.Foldable | |
| type Apply (Let6989586621680823018MkJustSym1 a_69895866216808230126989586621680823017 :: TyFun a6989586621680822176 (Maybe a6989586621680822176) -> Type) (a6989586621680823021 :: a6989586621680822176) | |
Defined in Data.Singletons.Prelude.Foldable | |
| type Apply (Lambda_6989586621680701013Sym2 a6989586621680701011 k6989586621680701012 :: TyFun k1 (Maybe a) -> Type) (x6989586621680701015 :: k1) | |
Defined in Data.Singletons.Prelude.Monoid | |
| type Apply (Lambda_6989586621680701092Sym2 a6989586621680701090 k6989586621680701091 :: TyFun k1 (Maybe a) -> Type) (x6989586621680701094 :: k1) | |
Defined in Data.Singletons.Prelude.Monoid | |
| type Apply (Let6989586621680822925MfSym3 f6989586621680822923 xs6989586621680822924 a6989586621680822926 :: TyFun k3 (Maybe k3) -> Type) (a6989586621680822927 :: k3) | |
Defined in Data.Singletons.Prelude.Foldable | |
| type Apply (ShowsPrec_6989586621680653904Sym0 :: TyFun Nat (Maybe a ~> (Symbol ~> Symbol)) -> Type) (a6989586621680653914 :: Nat) | |
| type Apply (FromMaybeSym0 :: TyFun a (Maybe a ~> a) -> Type) (a6989586621679959410 :: a) | |
Defined in Data.Singletons.Prelude.Maybe type Apply (FromMaybeSym0 :: TyFun a (Maybe a ~> a) -> Type) (a6989586621679959410 :: a) = FromMaybeSym1 a6989586621679959410 | |
| type Apply (ElemIndexSym0 :: TyFun a ([a] ~> Maybe Nat) -> Type) (a6989586621680379630 :: a) | |
Defined in Data.Singletons.Prelude.List.Internal type Apply (ElemIndexSym0 :: TyFun a ([a] ~> Maybe Nat) -> Type) (a6989586621680379630 :: a) = ElemIndexSym1 a6989586621680379630 | |
| type Apply (TFHelper_6989586621680072673Sym0 :: TyFun a (Maybe b ~> Maybe a) -> Type) (a6989586621680072678 :: a) | |
| type Apply (Maybe_Sym0 :: TyFun b ((a ~> b) ~> (Maybe a ~> b)) -> Type) (a6989586621679957844 :: b) | |
Defined in Data.Singletons.Prelude.Maybe | |
| type Apply (LookupSym0 :: TyFun a ([(a, b)] ~> Maybe b) -> Type) (a6989586621680379337 :: a) | |
Defined in Data.Singletons.Prelude.List.Internal type Apply (LookupSym0 :: TyFun a ([(a, b)] ~> Maybe b) -> Type) (a6989586621680379337 :: a) = LookupSym1 a6989586621680379337 :: TyFun [(a, b)] (Maybe b) -> Type | |
| type Apply (Let6989586621680814063NSym0 :: TyFun k (TyFun k1 (Maybe k1) -> Type) -> Type) (x6989586621680814061 :: k) | |
| type Apply (Let6989586621680814063MSym0 :: TyFun k1 (TyFun k (Maybe k1) -> Type) -> Type) (x6989586621680814061 :: k1) | |
| type Apply (Let6989586621680814087NSym0 :: TyFun k (TyFun k1 (Maybe k1) -> Type) -> Type) (x6989586621680814085 :: k) | |
| type Apply (Let6989586621680814087MSym0 :: TyFun k1 (TyFun k (Maybe k1) -> Type) -> Type) (x6989586621680814085 :: k1) | |
| type Apply (Let6989586621680823003MkJustSym0 :: TyFun k (TyFun a6989586621680822175 (Maybe a6989586621680822175) -> Type) -> Type) (a_69895866216808229976989586621680823002 :: k) | |
Defined in Data.Singletons.Prelude.Foldable type Apply (Let6989586621680823003MkJustSym0 :: TyFun k (TyFun a6989586621680822175 (Maybe a6989586621680822175) -> Type) -> Type) (a_69895866216808229976989586621680823002 :: k) = Let6989586621680823003MkJustSym1 a_69895866216808229976989586621680823002 :: TyFun a6989586621680822175 (Maybe a6989586621680822175) -> Type | |
| type Apply (Let6989586621680823018MkJustSym0 :: TyFun k (TyFun a6989586621680822176 (Maybe a6989586621680822176) -> Type) -> Type) (a_69895866216808230126989586621680823017 :: k) | |
Defined in Data.Singletons.Prelude.Foldable type Apply (Let6989586621680823018MkJustSym0 :: TyFun k (TyFun a6989586621680822176 (Maybe a6989586621680822176) -> Type) -> Type) (a_69895866216808230126989586621680823017 :: k) = Let6989586621680823018MkJustSym1 a_69895866216808230126989586621680823017 :: TyFun a6989586621680822176 (Maybe a6989586621680822176) -> Type | |
| type Apply (Foldr_6989586621680823060Sym1 a6989586621680823066 :: TyFun b (Maybe a ~> b) -> Type) (a6989586621680823067 :: b) | |
| type Apply (Foldl_6989586621680823076Sym1 a6989586621680823082 :: TyFun b (Maybe a ~> b) -> Type) (a6989586621680823083 :: b) | |
| type Apply (Lambda_6989586621680701013Sym0 :: TyFun k (TyFun (k1 ~> First a) (TyFun k1 (Maybe a) -> Type) -> Type) -> Type) (a6989586621680701011 :: k) | |
Defined in Data.Singletons.Prelude.Monoid | |
| type Apply (Lambda_6989586621680701092Sym0 :: TyFun k (TyFun (k1 ~> Last a) (TyFun k1 (Maybe a) -> Type) -> Type) -> Type) (a6989586621680701090 :: k) | |
Defined in Data.Singletons.Prelude.Monoid | |
| type Apply (Let6989586621680822904MfSym1 f6989586621680822902 :: TyFun k (TyFun k2 (TyFun (Maybe k3) (Maybe k2) -> Type) -> Type) -> Type) (xs6989586621680822903 :: k) | |
| type Apply (Let6989586621680822925MfSym1 f6989586621680822923 :: TyFun k (TyFun (Maybe k2) (TyFun k3 (Maybe k3) -> Type) -> Type) -> Type) (xs6989586621680822924 :: k) | |
| type Apply (Let6989586621680822904MfSym2 f6989586621680822902 xs6989586621680822903 :: TyFun k2 (TyFun (Maybe k3) (Maybe k2) -> Type) -> Type) (a6989586621680822905 :: k2) | |
Defined in Data.Singletons.Prelude.Foldable | |
| type Eval (FoldMap f ('Just x) :: a2 -> Type) | |
| type Eval (FoldMap f ('Nothing :: Maybe a1) :: a2 -> Type) | |
| type Eval (Foldr f y ('Just x) :: a2 -> Type) | |
| type Eval (Foldr f y ('Nothing :: Maybe a1) :: a2 -> Type) | |
| type Rep (Maybe a) | |
Defined in GHC.Generics | |
| type MEmpty | |
Defined in Fcf.Class.Monoid | |
| type Index (Maybe a) | |
Defined in Control.Lens.At | |
| type IxValue (Maybe a) | |
Defined in Control.Lens.At | |
| type Mempty | |
Defined in Data.Singletons.Prelude.Monoid | |
| type Sing | |
Defined in Data.Singletons.Prelude.Instances | |
| type Demote (Maybe a) | |
Defined in Data.Singletons.Prelude.Instances | |
| type Element (Maybe a) | |
Defined in Universum.Container.Class | |
| type DemoteRep (Maybe a) | |
Defined in GHC.Generics | |
| data Sing (b :: Maybe a) | |
| type TypeDocFieldDescriptions (Maybe a) | |
Defined in Morley.Michelson.Typed.Haskell.Doc | |
| type ToT (Maybe a) | |
Defined in Morley.Michelson.Typed.Haskell.Value | |
| type Rep1 Maybe | |
| type Mconcat (arg :: [Maybe a]) | |
| type Show_ (arg :: Maybe a) | |
| type Sconcat (arg :: NonEmpty (Maybe a)) | |
| type Mappend (arg1 :: Maybe a) (arg2 :: Maybe a) | |
| type ShowList (arg1 :: [Maybe a]) arg2 | |
| type (a2 :: Maybe a1) <> (a3 :: Maybe a1) | |
| type Empty | |
Defined in Data.Singletons.Prelude.Monad.Internal | |
| type Mzero | |
Defined in Data.Singletons.Prelude.Monad.Internal | |
| type Min (arg1 :: Maybe a) (arg2 :: Maybe a) | |
| type Max (arg1 :: Maybe a) (arg2 :: Maybe a) | |
| type (arg1 :: Maybe a) >= (arg2 :: Maybe a) | |
| type (arg1 :: Maybe a) > (arg2 :: Maybe a) | |
| type (arg1 :: Maybe a) <= (arg2 :: Maybe a) | |
| type (arg1 :: Maybe a) < (arg2 :: Maybe a) | |
| type Compare (a2 :: Maybe a1) (a3 :: Maybe a1) | |
| type (x :: Maybe a) /= (y :: Maybe a) | |
| type (a2 :: Maybe a1) == (b :: Maybe a1) | |
Defined in Data.Singletons.Prelude.Eq | |
| type HKD Maybe (a :: Type) | |
Defined in Data.Vinyl.XRec | |
| type ShowsPrec a2 (a3 :: Maybe a1) a4 | |
| type Fail a2 | |
| type (a2 :: Maybe a1) <|> (a3 :: Maybe a1) | |
| type Mplus (arg1 :: Maybe a) (arg2 :: Maybe a) | |
| type (a2 :: Maybe a1) <> ('Nothing :: Maybe a1) | |
Defined in Fcf.Class.Monoid | |
| type Apply (FromJustSym0 :: TyFun (Maybe a) a -> Type) (a6989586621679959420 :: Maybe a) | |
Defined in Data.Singletons.Prelude.Maybe type Apply (FromJustSym0 :: TyFun (Maybe a) a -> Type) (a6989586621679959420 :: Maybe a) = FromJustSym1 a6989586621679959420 | |
| type Apply (IsNothingSym0 :: TyFun (Maybe a) Bool -> Type) (a6989586621679959424 :: Maybe a) | |
Defined in Data.Singletons.Prelude.Maybe type Apply (IsNothingSym0 :: TyFun (Maybe a) Bool -> Type) (a6989586621679959424 :: Maybe a) = IsNothingSym1 a6989586621679959424 | |
| type Apply (IsJustSym0 :: TyFun (Maybe a) Bool -> Type) (a6989586621679959427 :: Maybe a) | |
Defined in Data.Singletons.Prelude.Maybe type Apply (IsJustSym0 :: TyFun (Maybe a) Bool -> Type) (a6989586621679959427 :: Maybe a) = IsJustSym1 a6989586621679959427 | |
| type Apply (FromMaybeSym1 a6989586621679959410 :: TyFun (Maybe a) a -> Type) (a6989586621679959411 :: Maybe a) | |
Defined in Data.Singletons.Prelude.Maybe type Apply (FromMaybeSym1 a6989586621679959410 :: TyFun (Maybe a) a -> Type) (a6989586621679959411 :: Maybe a) = FromMaybeSym2 a6989586621679959410 a6989586621679959411 | |
| type Apply (Compare_6989586621679848468Sym1 a6989586621679848473 :: TyFun (Maybe a) Ordering -> Type) (a6989586621679848474 :: Maybe a) | |
| type Apply (FoldMap_6989586621680823044Sym1 a6989586621680823053 :: TyFun (Maybe a) m -> Type) (a6989586621680823054 :: Maybe a) | |
| type Apply (Maybe_Sym2 a6989586621679957844 a6989586621679957845 :: TyFun (Maybe a) b -> Type) (a6989586621679957846 :: Maybe a) | |
Defined in Data.Singletons.Prelude.Maybe type Apply (Maybe_Sym2 a6989586621679957844 a6989586621679957845 :: TyFun (Maybe a) b -> Type) (a6989586621679957846 :: Maybe a) = Maybe_Sym3 a6989586621679957844 a6989586621679957845 a6989586621679957846 | |
| type Apply (Foldr_6989586621680823060Sym2 a6989586621680823066 a6989586621680823067 :: TyFun (Maybe a) b -> Type) (a6989586621680823068 :: Maybe a) | |
| type Apply (Foldl_6989586621680823076Sym2 a6989586621680823082 a6989586621680823083 :: TyFun (Maybe a) b -> Type) (a6989586621680823084 :: Maybe a) | |
| type ('Nothing :: Maybe a) <> (b :: Maybe a) | |
Defined in Fcf.Class.Monoid | |
| type Apply (Fail_6989586621680156221Sym0 :: TyFun [Char] (Maybe a) -> Type) (a6989586621680156225 :: [Char]) | |
| type Apply (CatMaybesSym0 :: TyFun [Maybe a] [a] -> Type) (a6989586621679959395 :: [Maybe a]) | |
Defined in Data.Singletons.Prelude.Maybe type Apply (CatMaybesSym0 :: TyFun [Maybe a] [a] -> Type) (a6989586621679959395 :: [Maybe a]) = CatMaybesSym1 a6989586621679959395 | |
| type Apply (ListToMaybeSym0 :: TyFun [a] (Maybe a) -> Type) (a6989586621679959401 :: [a]) | |
Defined in Data.Singletons.Prelude.Maybe type Apply (ListToMaybeSym0 :: TyFun [a] (Maybe a) -> Type) (a6989586621679959401 :: [a]) = ListToMaybeSym1 a6989586621679959401 | |
| type Apply (MaybeToListSym0 :: TyFun (Maybe a) [a] -> Type) (a6989586621679959405 :: Maybe a) | |
Defined in Data.Singletons.Prelude.Maybe type Apply (MaybeToListSym0 :: TyFun (Maybe a) [a] -> Type) (a6989586621679959405 :: Maybe a) = MaybeToListSym1 a6989586621679959405 | |
| type Apply (MaxInternalSym0 :: TyFun (Maybe a) (MaxInternal a) -> Type) (a6989586621680812483 :: Maybe a) | |
| type Apply (MinInternalSym0 :: TyFun (Maybe a) (MinInternal a) -> Type) (a6989586621680812486 :: Maybe a) | |
| type Apply (OptionSym0 :: TyFun (Maybe a) (Option a) -> Type) (a6989586621680249994 :: Maybe a) | |
Defined in Data.Singletons.Prelude.Semigroup.Internal type Apply (OptionSym0 :: TyFun (Maybe a) (Option a) -> Type) (a6989586621680249994 :: Maybe a) = OptionSym1 a6989586621680249994 | |
| type Apply (FirstSym0 :: TyFun (Maybe a) (First a) -> Type) (a6989586621680694787 :: Maybe a) | |
| type Apply (LastSym0 :: TyFun (Maybe a) (Last a) -> Type) (a6989586621680694814 :: Maybe a) | |
| type Apply (GetOptionSym0 :: TyFun (Option a) (Maybe a) -> Type) (a6989586621680249997 :: Option a) | |
Defined in Data.Singletons.Prelude.Semigroup.Internal type Apply (GetOptionSym0 :: TyFun (Option a) (Maybe a) -> Type) (a6989586621680249997 :: Option a) = GetOptionSym1 a6989586621680249997 | |
| type Apply (GetFirstSym0 :: TyFun (First a) (Maybe a) -> Type) (a6989586621680694790 :: First a) | |
Defined in Data.Singletons.Prelude.Monoid type Apply (GetFirstSym0 :: TyFun (First a) (Maybe a) -> Type) (a6989586621680694790 :: First a) = GetFirstSym1 a6989586621680694790 | |
| type Apply (GetLastSym0 :: TyFun (Last a) (Maybe a) -> Type) (a6989586621680694817 :: Last a) | |
Defined in Data.Singletons.Prelude.Monoid type Apply (GetLastSym0 :: TyFun (Last a) (Maybe a) -> Type) (a6989586621680694817 :: Last a) = GetLastSym1 a6989586621680694817 | |
| type Apply (GetMaxInternalSym0 :: TyFun (MaxInternal a) (Maybe a) -> Type) (a6989586621680812493 :: MaxInternal a) | |
Defined in Data.Singletons.Prelude.Foldable | |
| type Apply (GetMinInternalSym0 :: TyFun (MinInternal a) (Maybe a) -> Type) (a6989586621680812489 :: MinInternal a) | |
Defined in Data.Singletons.Prelude.Foldable | |
| type Apply (FindSym1 a6989586621680379639 :: TyFun [a] (Maybe a) -> Type) (a6989586621680379640 :: [a]) | |
Defined in Data.Singletons.Prelude.List.Internal | |
| type Apply (FindIndexSym1 a6989586621680379612 :: TyFun [a] (Maybe Nat) -> Type) (a6989586621680379613 :: [a]) | |
Defined in Data.Singletons.Prelude.List.Internal type Apply (FindIndexSym1 a6989586621680379612 :: TyFun [a] (Maybe Nat) -> Type) (a6989586621680379613 :: [a]) = FindIndexSym2 a6989586621680379612 a6989586621680379613 | |
| type Apply (ElemIndexSym1 a6989586621680379630 :: TyFun [a] (Maybe Nat) -> Type) (a6989586621680379631 :: [a]) | |
Defined in Data.Singletons.Prelude.List.Internal type Apply (ElemIndexSym1 a6989586621680379630 :: TyFun [a] (Maybe Nat) -> Type) (a6989586621680379631 :: [a]) = ElemIndexSym2 a6989586621680379630 a6989586621680379631 | |
| type Apply (StripPrefixSym1 a6989586621680498961 :: TyFun [a] (Maybe [a]) -> Type) (a6989586621680498962 :: [a]) | |
Defined in Data.Singletons.Prelude.List.Internal type Apply (StripPrefixSym1 a6989586621680498961 :: TyFun [a] (Maybe [a]) -> Type) (a6989586621680498962 :: [a]) = StripPrefixSym2 a6989586621680498961 a6989586621680498962 | |
| type Apply (TFHelper_6989586621680073042Sym1 a6989586621680073047 :: TyFun (Maybe a) (Maybe a) -> Type) (a6989586621680073048 :: Maybe a) | |
| type Apply (TFHelper_6989586621680240791Sym1 a6989586621680240796 :: TyFun (Maybe a) (Maybe a) -> Type) (a6989586621680240797 :: Maybe a) | |
| type Apply (OptionalSym0 :: TyFun (f a) (f (Maybe a)) -> Type) (a6989586621681492707 :: f a) | |
Defined in Data.Singletons.Prelude.Applicative type Apply (OptionalSym0 :: TyFun (f a) (f (Maybe a)) -> Type) (a6989586621681492707 :: f a) = OptionalSym1 a6989586621681492707 | |
| type Apply (LookupSym1 a6989586621680379337 :: TyFun [(a, b)] (Maybe b) -> Type) (a6989586621680379338 :: [(a, b)]) | |
Defined in Data.Singletons.Prelude.List.Internal type Apply (LookupSym1 a6989586621680379337 :: TyFun [(a, b)] (Maybe b) -> Type) (a6989586621680379338 :: [(a, b)]) = LookupSym2 a6989586621680379337 a6989586621680379338 | |
| type Apply (Fmap_6989586621680072661Sym1 a6989586621680072666 :: TyFun (Maybe a) (Maybe b) -> Type) (a6989586621680072667 :: Maybe a) | |
| type Apply (TFHelper_6989586621680072673Sym1 a6989586621680072678 :: TyFun (Maybe b) (Maybe a) -> Type) (a6989586621680072679 :: Maybe b) | |
| type Apply (TFHelper_6989586621680072794Sym1 a6989586621680072799 :: TyFun (Maybe a) (Maybe b) -> Type) (a6989586621680072800 :: Maybe a) | |
| type Apply (TFHelper_6989586621680072821Sym1 a6989586621680072826 :: TyFun (Maybe b) (Maybe b) -> Type) (a6989586621680072827 :: Maybe b) | |
| type Apply (TFHelper_6989586621680072966Sym1 a6989586621680072975 :: TyFun (Maybe b) (Maybe b) -> Type) (a6989586621680072976 :: Maybe b) | |
| type Apply (FindSym1 a6989586621680822510 :: TyFun (t a) (Maybe a) -> Type) (a6989586621680822511 :: t a) | |
| type Apply (Traverse_6989586621681088263Sym1 a6989586621681088268 :: TyFun (Maybe a) (f (Maybe b)) -> Type) (a6989586621681088269 :: Maybe a) | |
| type Apply (LiftA2_6989586621680072807Sym2 a6989586621680072813 a6989586621680072814 :: TyFun (Maybe b) (Maybe c) -> Type) (a6989586621680072815 :: Maybe b) | |
Defined in Data.Singletons.Prelude.Monad.Internal | |
| type Apply (Let6989586621680822904MfSym3 f6989586621680822902 xs6989586621680822903 a6989586621680822905 :: TyFun (Maybe k3) (Maybe k2) -> Type) (a6989586621680822906 :: Maybe k3) | |
Defined in Data.Singletons.Prelude.Foldable | |
| type Eval (Init '[a2] :: Maybe [a1] -> Type) | |
| type Eval (Init ('[] :: [a]) :: Maybe [a] -> Type) | |
| type Eval (Tail (_a ': as) :: Maybe [a] -> Type) | |
| type Eval (Tail ('[] :: [a]) :: Maybe [a] -> Type) | |
| type Eval (Init (a2 ': (b ': as)) :: Maybe [a1] -> Type) | |
| type Eval (Head (a2 ': _as) :: Maybe a1 -> Type) | |
| type Eval (Head ('[] :: [a]) :: Maybe a -> Type) | |
| type Eval (Last (a2 ': (b ': as)) :: Maybe a1 -> Type) | |
| type Eval (Last '[a2] :: Maybe a1 -> Type) | |
| type Eval (Last ('[] :: [a]) :: Maybe a -> Type) | |
| type Apply (StripPrefixSym0 :: TyFun [a] ([a] ~> Maybe [a]) -> Type) (a6989586621680498961 :: [a]) | |
Defined in Data.Singletons.Prelude.List.Internal type Apply (StripPrefixSym0 :: TyFun [a] ([a] ~> Maybe [a]) -> Type) (a6989586621680498961 :: [a]) = StripPrefixSym1 a6989586621680498961 | |
| type Apply (TFHelper_6989586621680073042Sym0 :: TyFun (Maybe a) (Maybe a ~> Maybe a) -> Type) (a6989586621680073047 :: Maybe a) | |
| type Apply (Compare_6989586621679848468Sym0 :: TyFun (Maybe a) (Maybe a ~> Ordering) -> Type) (a6989586621679848473 :: Maybe a) | |
| type Apply (TFHelper_6989586621680240791Sym0 :: TyFun (Maybe a) (Maybe a ~> Maybe a) -> Type) (a6989586621680240796 :: Maybe a) | |
| type ('Just a2 :: Maybe a1) <> ('Just b :: Maybe a1) | |
| type Apply (ShowsPrec_6989586621680653904Sym1 a6989586621680653914 :: TyFun (Maybe a) (Symbol ~> Symbol) -> Type) (a6989586621680653915 :: Maybe a) | |
| type Apply (TFHelper_6989586621680072821Sym0 :: TyFun (Maybe a) (Maybe b ~> Maybe b) -> Type) (a6989586621680072826 :: Maybe a) | |
| type Apply (TFHelper_6989586621680072955Sym0 :: TyFun (Maybe a) ((a ~> Maybe b) ~> Maybe b) -> Type) (a6989586621680072960 :: Maybe a) | |
| type Apply (TFHelper_6989586621680072966Sym0 :: TyFun (Maybe a) (Maybe b ~> Maybe b) -> Type) (a6989586621680072975 :: Maybe a) | |
| type Apply (TFHelper_6989586621680072794Sym0 :: TyFun (Maybe (a ~> b)) (Maybe a ~> Maybe b) -> Type) (a6989586621680072799 :: Maybe (a ~> b)) | |
| type Apply (LiftA2_6989586621680072807Sym1 a6989586621680072813 :: TyFun (Maybe a) (Maybe b ~> Maybe c) -> Type) (a6989586621680072814 :: Maybe a) | |
| type Apply (Let6989586621680822925MfSym2 f6989586621680822923 xs6989586621680822924 :: TyFun (Maybe k2) (TyFun k3 (Maybe k3) -> Type) -> Type) (a6989586621680822926 :: Maybe k2) | |
Defined in Data.Singletons.Prelude.Foldable | |
| type Eval (FindIndex p (a2 ': as) :: Maybe Nat -> Type) | |
| type Eval (FindIndex _p ('[] :: [a]) :: Maybe Nat -> Type) | |
| type Eval (NumIter a s :: Maybe (k, Nat) -> Type) | |
| type Eval (Find p (a2 ': as) :: Maybe a1 -> Type) | |
| type Eval (Find _p ('[] :: [a]) :: Maybe a -> Type) | |
| type Eval (Lookup a as :: Maybe b -> Type) | |
| type Eval (Map f ('Just a3) :: Maybe a2 -> Type) | |
| type Eval (Map f ('Nothing :: Maybe a) :: Maybe b -> Type) | |
| type Eval ('Just x <|> _1 :: Maybe a -> Type) | |
| type Eval (('Nothing :: Maybe a) <|> m :: Maybe a -> Type) | |
| type Apply (TFHelper_6989586621680072955Sym1 a6989586621680072960 :: TyFun (a ~> Maybe b) (Maybe b) -> Type) (a6989586621680072961 :: a ~> Maybe b) | |
| type Apply (FindSym0 :: TyFun (a ~> Bool) ([a] ~> Maybe a) -> Type) (a6989586621680379639 :: a ~> Bool) | |
| type Apply (FindIndexSym0 :: TyFun (a ~> Bool) ([a] ~> Maybe Nat) -> Type) (a6989586621680379612 :: a ~> Bool) | |
Defined in Data.Singletons.Prelude.List.Internal | |
| type Apply (Fmap_6989586621680072661Sym0 :: TyFun (a ~> b) (Maybe a ~> Maybe b) -> Type) (a6989586621680072666 :: a ~> b) | |
| type Apply (MapMaybeSym0 :: TyFun (a ~> Maybe b) ([a] ~> [b]) -> Type) (a6989586621679959380 :: a ~> Maybe b) | |
Defined in Data.Singletons.Prelude.Maybe type Apply (MapMaybeSym0 :: TyFun (a ~> Maybe b) ([a] ~> [b]) -> Type) (a6989586621679959380 :: a ~> Maybe b) = MapMaybeSym1 a6989586621679959380 | |
| type Apply (UnfoldrSym0 :: TyFun (b ~> Maybe (a, b)) (b ~> [a]) -> Type) (a6989586621680380029 :: b ~> Maybe (a, b)) | |
Defined in Data.Singletons.Prelude.List.Internal type Apply (UnfoldrSym0 :: TyFun (b ~> Maybe (a, b)) (b ~> [a]) -> Type) (a6989586621680380029 :: b ~> Maybe (a, b)) = UnfoldrSym1 a6989586621680380029 | |
| type Apply (FindSym0 :: TyFun (a ~> Bool) (t a ~> Maybe a) -> Type) (a6989586621680822510 :: a ~> Bool) | |
| type Apply (FoldMap_6989586621680823044Sym0 :: TyFun (a ~> m) (Maybe a ~> m) -> Type) (a6989586621680823053 :: a ~> m) | |
| type Apply (Foldr_6989586621680823060Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Maybe a ~> b)) -> Type) (a6989586621680823066 :: a ~> (b ~> b)) | |
| type Apply (Foldl_6989586621680823076Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Maybe a ~> b)) -> Type) (a6989586621680823082 :: b ~> (a ~> b)) | |
| type Apply (Traverse_6989586621681088263Sym0 :: TyFun (a ~> f b) (Maybe a ~> f (Maybe b)) -> Type) (a6989586621681088268 :: a ~> f b) | |
| type Apply (LiftA2_6989586621680072807Sym0 :: TyFun (a ~> (b ~> c)) (Maybe a ~> (Maybe b ~> Maybe c)) -> Type) (a6989586621680072813 :: a ~> (b ~> c)) | |
| type Apply (Maybe_Sym1 a6989586621679957844 :: TyFun (a ~> b) (Maybe a ~> b) -> Type) (a6989586621679957845 :: a ~> b) | |
Defined in Data.Singletons.Prelude.Maybe type Apply (Maybe_Sym1 a6989586621679957844 :: TyFun (a ~> b) (Maybe a ~> b) -> Type) (a6989586621679957845 :: a ~> b) = Maybe_Sym2 a6989586621679957844 a6989586621679957845 | |
| type Apply (Let6989586621679959385RsSym0 :: TyFun (a ~> Maybe k1) (TyFun k (TyFun [a] [k1] -> Type) -> Type) -> Type) (f6989586621679959382 :: a ~> Maybe k1) | |
| type Apply (Let6989586621680822904MfSym0 :: TyFun (k2 ~> (k3 ~> k2)) (TyFun k (TyFun k2 (TyFun (Maybe k3) (Maybe k2) -> Type) -> Type) -> Type) -> Type) (f6989586621680822902 :: k2 ~> (k3 ~> k2)) | |
Defined in Data.Singletons.Prelude.Foldable type Apply (Let6989586621680822904MfSym0 :: TyFun (k2 ~> (k3 ~> k2)) (TyFun k (TyFun k2 (TyFun (Maybe k3) (Maybe k2) -> Type) -> Type) -> Type) -> Type) (f6989586621680822902 :: k2 ~> (k3 ~> k2)) = Let6989586621680822904MfSym1 f6989586621680822902 :: TyFun k (TyFun k2 (TyFun (Maybe k3) (Maybe k2) -> Type) -> Type) -> Type | |
| type Apply (Let6989586621680822925MfSym0 :: TyFun (k2 ~> (k3 ~> k3)) (TyFun k (TyFun (Maybe k2) (TyFun k3 (Maybe k3) -> Type) -> Type) -> Type) -> Type) (f6989586621680822923 :: k2 ~> (k3 ~> k3)) | |
Defined in Data.Singletons.Prelude.Foldable type Apply (Let6989586621680822925MfSym0 :: TyFun (k2 ~> (k3 ~> k3)) (TyFun k (TyFun (Maybe k2) (TyFun k3 (Maybe k3) -> Type) -> Type) -> Type) -> Type) (f6989586621680822923 :: k2 ~> (k3 ~> k3)) = Let6989586621680822925MfSym1 f6989586621680822923 :: TyFun k (TyFun (Maybe k2) (TyFun k3 (Maybe k3) -> Type) -> Type) -> Type | |
| type Apply (Lambda_6989586621680701013Sym1 a6989586621680701011 :: TyFun (k1 ~> First a) (TyFun k1 (Maybe a) -> Type) -> Type) (k6989586621680701012 :: k1 ~> First a) | |
| type Apply (Lambda_6989586621680701092Sym1 a6989586621680701090 :: TyFun (k1 ~> Last a) (TyFun k1 (Maybe a) -> Type) -> Type) (k6989586621680701091 :: k1 ~> Last a) | |
| type ToT (NamedF Maybe a name) | |
| type Unwrappabled (NamedF Maybe a name) Source # | |
Defined in Lorentz.Wrappable | |
Proxy is a type that holds no data, but has a phantom parameter of
arbitrary type (or even kind). Its use is to provide type information, even
though there is no value available of that type (or it may be too costly to
create one).
Historically, Proxy :: Proxy aundefined :: a
>>>Proxy :: Proxy (Void, Int -> Int)Proxy
Proxy can even hold types of higher kinds,
>>>Proxy :: Proxy EitherProxy
>>>Proxy :: Proxy FunctorProxy
>>>Proxy :: Proxy complicatedStructureProxy
Constructors
| Proxy |
Instances
| Generic1 (Proxy :: k -> Type) | Since: base-4.6.0.0 |
| Monad (Proxy :: Type -> Type) | Since: base-4.7.0.0 |
| Functor (Proxy :: Type -> Type) | Since: base-4.7.0.0 |
| Applicative (Proxy :: Type -> Type) | Since: base-4.7.0.0 |
| Foldable (Proxy :: Type -> Type) | Since: base-4.7.0.0 |
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 # elem :: Eq a => a -> Proxy a -> Bool # maximum :: Ord a => Proxy a -> a # minimum :: Ord a => Proxy a -> a # | |
| Traversable (Proxy :: Type -> Type) | Since: base-4.7.0.0 |
| MonadPlus (Proxy :: Type -> Type) | Since: base-4.9.0.0 |
| Representable (Proxy :: Type -> Type) | |
| ToJSON1 (Proxy :: Type -> Type) | |
Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Proxy a -> Value # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Proxy a] -> Value # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Proxy a -> Encoding # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Proxy a] -> Encoding # | |
| Alternative (Proxy :: Type -> Type) | Since: base-4.9.0.0 |
| Eq1 (Proxy :: Type -> Type) | Since: base-4.9.0.0 |
| Ord1 (Proxy :: Type -> Type) | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
| Read1 (Proxy :: Type -> Type) | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
| Show1 (Proxy :: Type -> Type) | Since: base-4.9.0.0 |
| NFData1 (Proxy :: Type -> Type) | Since: deepseq-1.4.3.0 |
Defined in Control.DeepSeq | |
| Hashable1 (Proxy :: Type -> Type) | |
Defined in Data.Hashable.Class | |
| PTraversable (Proxy :: Type -> Type) | |
| STraversable (Proxy :: Type -> Type) | |
Defined in Data.Singletons.Prelude.Traversable Methods sTraverse :: forall a (f :: Type -> Type) b (t1 :: a ~> f b) (t2 :: Proxy a). SApplicative f => Sing t1 -> Sing t2 -> Sing (Apply (Apply TraverseSym0 t1) t2) # sSequenceA :: forall (f :: Type -> Type) a (t1 :: Proxy (f a)). SApplicative f => Sing t1 -> Sing (Apply SequenceASym0 t1) # sMapM :: forall a (m :: Type -> Type) b (t1 :: a ~> m b) (t2 :: Proxy a). SMonad m => Sing t1 -> Sing t2 -> Sing (Apply (Apply MapMSym0 t1) t2) # sSequence :: forall (m :: Type -> Type) a (t1 :: Proxy (m a)). SMonad m => Sing t1 -> Sing (Apply SequenceSym0 t1) # | |
| PFoldable (Proxy :: Type -> Type) | |
| SFoldable (Proxy :: Type -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods sFold :: forall m (t1 :: Proxy m). SMonoid m => Sing t1 -> Sing (Apply FoldSym0 t1) # sFoldMap :: forall a m (t1 :: a ~> m) (t2 :: Proxy a). SMonoid m => Sing t1 -> Sing t2 -> Sing (Apply (Apply FoldMapSym0 t1) t2) # sFoldr :: forall a b (t1 :: a ~> (b ~> b)) (t2 :: b) (t3 :: Proxy a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply FoldrSym0 t1) t2) t3) # sFoldr' :: forall a b (t1 :: a ~> (b ~> b)) (t2 :: b) (t3 :: Proxy a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply Foldr'Sym0 t1) t2) t3) # sFoldl :: forall b a (t1 :: b ~> (a ~> b)) (t2 :: b) (t3 :: Proxy a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply FoldlSym0 t1) t2) t3) # sFoldl' :: forall b a (t1 :: b ~> (a ~> b)) (t2 :: b) (t3 :: Proxy a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply Foldl'Sym0 t1) t2) t3) # sFoldr1 :: forall a (t1 :: a ~> (a ~> a)) (t2 :: Proxy a). Sing t1 -> Sing t2 -> Sing (Apply (Apply Foldr1Sym0 t1) t2) # sFoldl1 :: forall a (t1 :: a ~> (a ~> a)) (t2 :: Proxy a). Sing t1 -> Sing t2 -> Sing (Apply (Apply Foldl1Sym0 t1) t2) # sToList :: forall a (t1 :: Proxy a). Sing t1 -> Sing (Apply ToListSym0 t1) # sNull :: forall a (t1 :: Proxy a). Sing t1 -> Sing (Apply NullSym0 t1) # sLength :: forall a (t1 :: Proxy a). Sing t1 -> Sing (Apply LengthSym0 t1) # sElem :: forall a (t1 :: a) (t2 :: Proxy a). SEq a => Sing t1 -> Sing t2 -> Sing (Apply (Apply ElemSym0 t1) t2) # sMaximum :: forall a (t1 :: Proxy a). SOrd a => Sing t1 -> Sing (Apply MaximumSym0 t1) # sMinimum :: forall a (t1 :: Proxy a). SOrd a => Sing t1 -> Sing (Apply MinimumSym0 t1) # sSum :: forall a (t1 :: Proxy a). SNum a => Sing t1 -> Sing (Apply SumSym0 t1) # sProduct :: forall a (t1 :: Proxy a). SNum a => Sing t1 -> Sing (Apply ProductSym0 t1) # | |
| Bounded (Proxy t) | Since: base-4.7.0.0 |
| Enum (Proxy s) | Since: base-4.7.0.0 |
| Eq (Proxy s) | Since: base-4.7.0.0 |
| Ord (Proxy s) | Since: base-4.7.0.0 |
| Read (Proxy t) | Since: base-4.7.0.0 |
| Show (Proxy s) | Since: base-4.7.0.0 |
| Ix (Proxy s) | Since: base-4.7.0.0 |
Defined in Data.Proxy | |
| Generic (Proxy t) | Since: base-4.6.0.0 |
| Semigroup (Proxy s) | Since: base-4.9.0.0 |
| Monoid (Proxy s) | Since: base-4.7.0.0 |
| Hashable (Proxy a) | |
Defined in Data.Hashable.Class | |
| ToJSON (Proxy a) | |
Defined in Data.Aeson.Types.ToJSON | |
| NFData (Proxy a) | Since: deepseq-1.4.0.0 |
Defined in Control.DeepSeq | |
| Semiring (Proxy a) | |
| SuppressUnusedWarnings (Elem_6989586621680823467Sym0 :: TyFun a (Proxy a ~> Bool) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Pure_6989586621680787290Sym0 :: TyFun a (Proxy a) -> Type) | |
Defined in Data.Singletons.Prelude.Proxy Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Sum_6989586621680823475Sym0 :: TyFun (Proxy a) a -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Product_6989586621680823481Sym0 :: TyFun (Proxy a) a -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Fold_6989586621680823404Sym0 :: TyFun (Proxy m) m -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Foldr1_6989586621680823446Sym0 :: TyFun (a ~> (a ~> a)) (Proxy a ~> a) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Foldl1_6989586621680823437Sym0 :: TyFun (a ~> (a ~> a)) (Proxy a ~> a) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| TestCoercion (SProxy :: Proxy t -> Type) | |
Defined in Data.Singletons.Prelude.Proxy | |
| TestEquality (SProxy :: Proxy t -> Type) | |
Defined in Data.Singletons.Prelude.Proxy | |
| SuppressUnusedWarnings (Mconcat_6989586621680787275Sym0 :: TyFun [Proxy s] (Proxy s) -> Type) | |
Defined in Data.Singletons.Prelude.Proxy Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (ToEnum_6989586621680787224Sym0 :: TyFun Nat (Proxy s) -> Type) | |
Defined in Data.Singletons.Prelude.Proxy Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (ShowsPrec_6989586621680787193Sym0 :: TyFun Nat (Proxy s ~> (Symbol ~> Symbol)) -> Type) | |
Defined in Data.Singletons.Prelude.Proxy Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Sequence_6989586621681088348Sym0 :: TyFun (Proxy (m a)) (m (Proxy a)) -> Type) | |
Defined in Data.Singletons.Prelude.Traversable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (SequenceA_6989586621681088333Sym0 :: TyFun (Proxy (f a)) (f (Proxy a)) -> Type) | |
Defined in Data.Singletons.Prelude.Traversable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Foldr1_6989586621680823446Sym1 a6989586621680823451 :: TyFun (Proxy a) a -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Foldl1_6989586621680823437Sym1 a6989586621680823442 :: TyFun (Proxy a) a -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (TFHelper_6989586621680787297Sym0 :: TyFun (Proxy (a ~> b)) (Proxy a ~> Proxy b) -> Type) | |
Defined in Data.Singletons.Prelude.Proxy Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Elem_6989586621680823467Sym1 a6989586621680823472 :: TyFun (Proxy a) Bool -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Null_6989586621680823460Sym0 :: TyFun (Proxy a) Bool -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Length_6989586621680823454Sym0 :: TyFun (Proxy a) Nat -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (TFHelper_6989586621680787309Sym0 :: TyFun (Proxy a) (Proxy a ~> Proxy a) -> Type) | |
Defined in Data.Singletons.Prelude.Proxy Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (TFHelper_6989586621680787258Sym0 :: TyFun (Proxy s) (Proxy s ~> Proxy s) -> Type) | |
Defined in Data.Singletons.Prelude.Proxy Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (TFHelper_6989586621680787174Sym0 :: TyFun (Proxy s) (Proxy s ~> Bool) -> Type) | |
Defined in Data.Singletons.Prelude.Proxy Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Succ_6989586621680787206Sym0 :: TyFun (Proxy s) (Proxy s) -> Type) | |
Defined in Data.Singletons.Prelude.Proxy Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Pred_6989586621680787212Sym0 :: TyFun (Proxy s) (Proxy s) -> Type) | |
Defined in Data.Singletons.Prelude.Proxy Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (FromEnum_6989586621680787218Sym0 :: TyFun (Proxy s) Nat -> Type) | |
Defined in Data.Singletons.Prelude.Proxy Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (EnumFromTo_6989586621680787249Sym0 :: TyFun (Proxy s) (Proxy s ~> [Proxy s]) -> Type) | |
Defined in Data.Singletons.Prelude.Proxy Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (EnumFromThenTo_6989586621680787238Sym0 :: TyFun (Proxy s) (Proxy s ~> (Proxy s ~> [Proxy s])) -> Type) | |
Defined in Data.Singletons.Prelude.Proxy Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Compare_6989586621680787183Sym0 :: TyFun (Proxy s) (Proxy s ~> Ordering) -> Type) | |
Defined in Data.Singletons.Prelude.Proxy Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Sconcat_6989586621680787266Sym0 :: TyFun (NonEmpty (Proxy s)) (Proxy s) -> Type) | |
Defined in Data.Singletons.Prelude.Proxy Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Foldr_6989586621680823412Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Proxy a ~> b)) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Foldl_6989586621680823425Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Proxy a ~> b)) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (FoldMap_6989586621680823396Sym0 :: TyFun (a ~> m) (Proxy a ~> m) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Fmap_6989586621680787282Sym0 :: TyFun (a ~> b) (Proxy a ~> Proxy b) -> Type) | |
Defined in Data.Singletons.Prelude.Proxy Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Foldr_6989586621680823412Sym1 a6989586621680823418 :: TyFun b (Proxy a ~> b) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Foldl_6989586621680823425Sym1 a6989586621680823431 :: TyFun b (Proxy a ~> b) -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (FoldMap_6989586621680823396Sym1 a6989586621680823401 :: TyFun (Proxy a) m -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (TFHelper_6989586621680787318Sym0 :: TyFun (Proxy a) ((a ~> Proxy b) ~> Proxy b) -> Type) | |
Defined in Data.Singletons.Prelude.Proxy Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (TFHelper_6989586621680787297Sym1 a6989586621680787302 :: TyFun (Proxy a) (Proxy b) -> Type) | |
Defined in Data.Singletons.Prelude.Proxy Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Fmap_6989586621680787282Sym1 a6989586621680787287 :: TyFun (Proxy a) (Proxy b) -> Type) | |
Defined in Data.Singletons.Prelude.Proxy Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (TFHelper_6989586621680787309Sym1 a6989586621680787314 :: TyFun (Proxy a) (Proxy a) -> Type) | |
Defined in Data.Singletons.Prelude.Proxy Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (TFHelper_6989586621680787258Sym1 a6989586621680787263 :: TyFun (Proxy s) (Proxy s) -> Type) | |
Defined in Data.Singletons.Prelude.Proxy Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (TFHelper_6989586621680787174Sym1 a6989586621680787179 :: TyFun (Proxy s) Bool -> Type) | |
Defined in Data.Singletons.Prelude.Proxy Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (ShowsPrec_6989586621680787193Sym1 a6989586621680787201 :: TyFun (Proxy s) (Symbol ~> Symbol) -> Type) | |
Defined in Data.Singletons.Prelude.Proxy Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (EnumFromTo_6989586621680787249Sym1 a6989586621680787254 :: TyFun (Proxy s) [Proxy s] -> Type) | |
Defined in Data.Singletons.Prelude.Proxy Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (EnumFromThenTo_6989586621680787238Sym1 a6989586621680787244 :: TyFun (Proxy s) (Proxy s ~> [Proxy s]) -> Type) | |
Defined in Data.Singletons.Prelude.Proxy Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Compare_6989586621680787183Sym1 a6989586621680787188 :: TyFun (Proxy s) Ordering -> Type) | |
Defined in Data.Singletons.Prelude.Proxy Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Traverse_6989586621681088325Sym0 :: TyFun (a ~> f b) (Proxy a ~> f (Proxy b)) -> Type) | |
Defined in Data.Singletons.Prelude.Traversable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (MapM_6989586621681088340Sym0 :: TyFun (a ~> m b) (Proxy a ~> m (Proxy b)) -> Type) | |
Defined in Data.Singletons.Prelude.Traversable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Traverse_6989586621681088325Sym1 a6989586621681088330 :: TyFun (Proxy a) (f (Proxy b)) -> Type) | |
Defined in Data.Singletons.Prelude.Traversable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (MapM_6989586621681088340Sym1 a6989586621681088345 :: TyFun (Proxy a) (m (Proxy b)) -> Type) | |
Defined in Data.Singletons.Prelude.Traversable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Foldr_6989586621680823412Sym2 a6989586621680823418 a6989586621680823419 :: TyFun (Proxy a) b -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (Foldl_6989586621680823425Sym2 a6989586621680823431 a6989586621680823432 :: TyFun (Proxy a) b -> Type) | |
Defined in Data.Singletons.Prelude.Foldable Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (EnumFromThenTo_6989586621680787238Sym2 a6989586621680787244 a6989586621680787245 :: TyFun (Proxy s) [Proxy s] -> Type) | |
Defined in Data.Singletons.Prelude.Proxy Methods suppressUnusedWarnings :: () # | |
| SuppressUnusedWarnings (TFHelper_6989586621680787318Sym1 a6989586621680787323 :: TyFun (a ~> Proxy b) (Proxy b) -> Type) | |
Defined in Data.Singletons.Prelude.Proxy Methods suppressUnusedWarnings :: () # | |
| type MapM (a2 :: a1 ~> m b) (a3 :: Proxy a1) | |
| type Traverse (a2 :: a1 ~> f b) (a3 :: Proxy a1) | |
| type LiftA2 (arg1 :: a ~> (b ~> c)) (arg2 :: Proxy a) (arg3 :: Proxy b) | |
| type FoldMap (a2 :: a1 ~> k2) (a3 :: Proxy a1) | |
| type Fmap (a2 :: a1 ~> b) (a3 :: Proxy a1) | |
| type Foldl' (arg1 :: b ~> (a ~> b)) (arg2 :: b) (arg3 :: Proxy a) | |
| type Foldl (a2 :: k2 ~> (a1 ~> k2)) (a3 :: k2) (a4 :: Proxy a1) | |
| type Foldr' (arg1 :: a ~> (b ~> b)) (arg2 :: b) (arg3 :: Proxy a) | |
| type Foldr (a2 :: a1 ~> (k2 ~> k2)) (a3 :: k2) (a4 :: Proxy a1) | |
| type Rep1 (Proxy :: k -> Type) | |
| type Pure (a :: k1) | |
| type Return (arg :: a) | |
| type Empty | |
Defined in Data.Singletons.Prelude.Proxy | |
| type Mzero | |
Defined in Data.Singletons.Prelude.Proxy | |
| type Elem (a1 :: k1) (a2 :: Proxy k1) | |
| type Foldl1 (a1 :: k2 ~> (k2 ~> k2)) (a2 :: Proxy k2) | |
| type Foldr1 (a1 :: k2 ~> (k2 ~> k2)) (a2 :: Proxy k2) | |
| type (arg1 :: a) <$ (arg2 :: Proxy b) | |
| type (a2 :: Proxy a1) <|> (a3 :: Proxy a1) | |
| type Mplus (arg1 :: Proxy a) (arg2 :: Proxy a) | |
| type Apply (Elem_6989586621680823467Sym0 :: TyFun a (Proxy a ~> Bool) -> Type) (a6989586621680823472 :: a) | |
| type Apply (Pure_6989586621680787290Sym0 :: TyFun a (Proxy a) -> Type) (a6989586621680787294 :: a) | |
Defined in Data.Singletons.Prelude.Proxy | |
| type Apply (ToEnum_6989586621680787224Sym0 :: TyFun Nat (Proxy s) -> Type) (a6989586621680787228 :: Nat) | |
| type Apply (ShowsPrec_6989586621680787193Sym0 :: TyFun Nat (Proxy s ~> (Symbol ~> Symbol)) -> Type) (a6989586621680787201 :: Nat) | |
| type Apply (Foldr_6989586621680823412Sym1 a6989586621680823418 :: TyFun b (Proxy a ~> b) -> Type) (a6989586621680823419 :: b) | |
| type Apply (Foldl_6989586621680823425Sym1 a6989586621680823431 :: TyFun b (Proxy a ~> b) -> Type) (a6989586621680823432 :: b) | |
| type Rep (Proxy :: Type -> Type) | |
| type Product (a :: Proxy k2) | |
| type Sum (a :: Proxy k2) | |
| type Minimum (arg :: Proxy a) | |
| type Maximum (arg :: Proxy a) | |
| type Length (a2 :: Proxy a1) | |
| type Null (a2 :: Proxy a1) | |
| type ToList (arg :: Proxy a) | |
| type Fold (a :: Proxy k2) | |
| type Sequence (a2 :: Proxy (m a1)) | |
| type SequenceA (a2 :: Proxy (f a1)) | |
| type (arg1 :: Proxy a) <* (arg2 :: Proxy b) | |
| type (arg1 :: Proxy a) *> (arg2 :: Proxy b) | |
| type (a2 :: Proxy (a1 ~> b)) <*> (a3 :: Proxy a1) | |
| type (arg1 :: Proxy a) >> (arg2 :: Proxy b) | |
| type (a2 :: Proxy a1) >>= (a3 :: a1 ~> Proxy b) | |
| type Apply (Mconcat_6989586621680787275Sym0 :: TyFun [Proxy s] (Proxy s) -> Type) (a6989586621680787279 :: [Proxy s]) | |
| type Apply (Sconcat_6989586621680787266Sym0 :: TyFun (NonEmpty (Proxy s)) (Proxy s) -> Type) (a6989586621680787270 :: NonEmpty (Proxy s)) | |
| type Rep (Proxy t) | |
| type Mempty | |
Defined in Data.Singletons.Prelude.Proxy | |
| type MaxBound | |
Defined in Data.Singletons.Prelude.Proxy | |
| type MinBound | |
Defined in Data.Singletons.Prelude.Proxy | |
| type Sing | |
Defined in Data.Singletons.Prelude.Proxy | |
| type Demote (Proxy t) | |
Defined in Data.Singletons.Prelude.Proxy | |
| type Mconcat (a :: [Proxy s]) | |
| type Show_ (arg :: Proxy s) | |
| type Sconcat (a :: NonEmpty (Proxy s)) | |
| type FromEnum (a :: Proxy s) | |
| type ToEnum a | |
| type Pred (a :: Proxy s) | |
| type Succ (a :: Proxy s) | |
| type Mappend (arg1 :: Proxy s) (arg2 :: Proxy s) | |
| type ShowList (arg1 :: [Proxy s]) arg2 | |
| type (a1 :: Proxy s) <> (a2 :: Proxy s) | |
| type EnumFromTo (a1 :: Proxy s) (a2 :: Proxy s) | |
| type Min (arg1 :: Proxy s) (arg2 :: Proxy s) | |
| type Max (arg1 :: Proxy s) (arg2 :: Proxy s) | |
| type (arg1 :: Proxy s) >= (arg2 :: Proxy s) | |
| type (arg1 :: Proxy s) > (arg2 :: Proxy s) | |
| type (arg1 :: Proxy s) <= (arg2 :: Proxy s) | |
| type (arg1 :: Proxy s) < (arg2 :: Proxy s) | |
| type Compare (a1 :: Proxy s) (a2 :: Proxy s) | |
| type (x :: Proxy s) /= (y :: Proxy s) | |
| type (a1 :: Proxy s) == (a2 :: Proxy s) | |
| type ShowsPrec a1 (a2 :: Proxy s) a3 | |
| type EnumFromThenTo (a1 :: Proxy s) (a2 :: Proxy s) (a3 :: Proxy s) | |
| type Apply (Fold_6989586621680823404Sym0 :: TyFun (Proxy m) m -> Type) (a6989586621680823408 :: Proxy m) | |
| type Apply (Sum_6989586621680823475Sym0 :: TyFun (Proxy a) a -> Type) (a6989586621680823479 :: Proxy a) | |
| type Apply (Product_6989586621680823481Sym0 :: TyFun (Proxy a) a -> Type) (a6989586621680823485 :: Proxy a) | |
| type Apply (Foldl1_6989586621680823437Sym1 a6989586621680823442 :: TyFun (Proxy a) a -> Type) (a6989586621680823443 :: Proxy a) | |
| type Apply (Foldr1_6989586621680823446Sym1 a6989586621680823451 :: TyFun (Proxy a) a -> Type) (a6989586621680823452 :: Proxy a) | |
| type Apply (Elem_6989586621680823467Sym1 a6989586621680823472 :: TyFun (Proxy a) Bool -> Type) (a6989586621680823473 :: Proxy a) | |
| type Apply (Length_6989586621680823454Sym0 :: TyFun (Proxy a) Nat -> Type) (a6989586621680823458 :: Proxy a) | |
| type Apply (Null_6989586621680823460Sym0 :: TyFun (Proxy a) Bool -> Type) (a6989586621680823464 :: Proxy a) | |
| type Apply (FromEnum_6989586621680787218Sym0 :: TyFun (Proxy s) Nat -> Type) (a6989586621680787222 :: Proxy s) | |
| type Apply (FoldMap_6989586621680823396Sym1 a6989586621680823401 :: TyFun (Proxy a) m -> Type) (a6989586621680823402 :: Proxy a) | |
| type Apply (TFHelper_6989586621680787174Sym1 a6989586621680787179 :: TyFun (Proxy s) Bool -> Type) (a6989586621680787180 :: Proxy s) | |
| type Apply (Compare_6989586621680787183Sym1 a6989586621680787188 :: TyFun (Proxy s) Ordering -> Type) (a6989586621680787189 :: Proxy s) | |
| type Apply (Foldr_6989586621680823412Sym2 a6989586621680823418 a6989586621680823419 :: TyFun (Proxy a) b -> Type) (a6989586621680823420 :: Proxy a) | |
| type Apply (Foldl_6989586621680823425Sym2 a6989586621680823431 a6989586621680823432 :: TyFun (Proxy a) b -> Type) (a6989586621680823433 :: Proxy a) | |
| type Apply (SequenceA_6989586621681088333Sym0 :: TyFun (Proxy (f a)) (f (Proxy a)) -> Type) (a6989586621681088337 :: Proxy (f a)) | |
| type Apply (Sequence_6989586621681088348Sym0 :: TyFun (Proxy (m a)) (m (Proxy a)) -> Type) (a6989586621681088352 :: Proxy (m a)) | |
| type Apply (EnumFromTo_6989586621680787249Sym1 a6989586621680787254 :: TyFun (Proxy s) [Proxy s] -> Type) (a6989586621680787255 :: Proxy s) | |
| type Apply (Traverse_6989586621681088325Sym1 a6989586621681088330 :: TyFun (Proxy a) (f (Proxy b)) -> Type) (a6989586621681088331 :: Proxy a) | |
| type Apply (MapM_6989586621681088340Sym1 a6989586621681088345 :: TyFun (Proxy a) (m (Proxy b)) -> Type) (a6989586621681088346 :: Proxy a) | |
| type Apply (EnumFromThenTo_6989586621680787238Sym2 a6989586621680787244 a6989586621680787245 :: TyFun (Proxy s) [Proxy s] -> Type) (a6989586621680787246 :: Proxy s) | |
Defined in Data.Singletons.Prelude.Proxy | |
| type Apply (Foldl1_6989586621680823437Sym0 :: TyFun (a ~> (a ~> a)) (Proxy a ~> a) -> Type) (a6989586621680823442 :: a ~> (a ~> a)) | |
| type Apply (Foldr1_6989586621680823446Sym0 :: TyFun (a ~> (a ~> a)) (Proxy a ~> a) -> Type) (a6989586621680823451 :: a ~> (a ~> a)) | |
| type Apply (TFHelper_6989586621680787297Sym0 :: TyFun (Proxy (a ~> b)) (Proxy a ~> Proxy b) -> Type) (a6989586621680787302 :: Proxy (a ~> b)) | |
| type Apply (TFHelper_6989586621680787174Sym0 :: TyFun (Proxy s) (Proxy s ~> Bool) -> Type) (a6989586621680787179 :: Proxy s) | |
| type Apply (Compare_6989586621680787183Sym0 :: TyFun (Proxy s) (Proxy s ~> Ordering) -> Type) (a6989586621680787188 :: Proxy s) | |
| type Apply (Succ_6989586621680787206Sym0 :: TyFun (Proxy s) (Proxy s) -> Type) (a6989586621680787210 :: Proxy s) | |
| type Apply (Pred_6989586621680787212Sym0 :: TyFun (Proxy s) (Proxy s) -> Type) (a6989586621680787216 :: Proxy s) | |
| type Apply (EnumFromThenTo_6989586621680787238Sym0 :: TyFun (Proxy s) (Proxy s ~> (Proxy s ~> [Proxy s])) -> Type) (a6989586621680787244 :: Proxy s) | |
| type Apply (EnumFromTo_6989586621680787249Sym0 :: TyFun (Proxy s) (Proxy s ~> [Proxy s]) -> Type) (a6989586621680787254 :: Proxy s) | |
| type Apply (TFHelper_6989586621680787258Sym0 :: TyFun (Proxy s) (Proxy s ~> Proxy s) -> Type) (a6989586621680787263 :: Proxy s) | |
| type Apply (TFHelper_6989586621680787309Sym0 :: TyFun (Proxy a) (Proxy a ~> Proxy a) -> Type) (a6989586621680787314 :: Proxy a) | |
| type Apply (FoldMap_6989586621680823396Sym0 :: TyFun (a ~> m) (Proxy a ~> m) -> Type) (a6989586621680823401 :: a ~> m) | |
| type Apply (Foldr_6989586621680823412Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Proxy a ~> b)) -> Type) (a6989586621680823418 :: a ~> (b ~> b)) | |
| type Apply (Foldl_6989586621680823425Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Proxy a ~> b)) -> Type) (a6989586621680823431 :: b ~> (a ~> b)) | |
| type Apply (Fmap_6989586621680787282Sym0 :: TyFun (a ~> b) (Proxy a ~> Proxy b) -> Type) (a6989586621680787287 :: a ~> b) | |
| type Apply (Fmap_6989586621680787282Sym1 a6989586621680787287 :: TyFun (Proxy a) (Proxy b) -> Type) (a6989586621680787288 :: Proxy a) | |
| type Apply (TFHelper_6989586621680787297Sym1 a6989586621680787302 :: TyFun (Proxy a) (Proxy b) -> Type) (a6989586621680787303 :: Proxy a) | |
| type Apply (TFHelper_6989586621680787318Sym0 :: TyFun (Proxy a) ((a ~> Proxy b) ~> Proxy b) -> Type) (a6989586621680787323 :: Proxy a) | |
| type Apply (ShowsPrec_6989586621680787193Sym1 a6989586621680787201 :: TyFun (Proxy s) (Symbol ~> Symbol) -> Type) (a6989586621680787202 :: Proxy s) | |
| type Apply (EnumFromThenTo_6989586621680787238Sym1 a6989586621680787244 :: TyFun (Proxy s) (Proxy s ~> [Proxy s]) -> Type) (a6989586621680787245 :: Proxy s) | |
| type Apply (TFHelper_6989586621680787258Sym1 a6989586621680787263 :: TyFun (Proxy s) (Proxy s) -> Type) (a6989586621680787264 :: Proxy s) | |
| type Apply (TFHelper_6989586621680787309Sym1 a6989586621680787314 :: TyFun (Proxy a) (Proxy a) -> Type) (a6989586621680787315 :: Proxy a) | |
| type Apply (Traverse_6989586621681088325Sym0 :: TyFun (a ~> f b) (Proxy a ~> f (Proxy b)) -> Type) (a6989586621681088330 :: a ~> f b) | |
| type Apply (MapM_6989586621681088340Sym0 :: TyFun (a ~> m b) (Proxy a ~> m (Proxy b)) -> Type) (a6989586621681088345 :: a ~> m b) | |
| type Apply (TFHelper_6989586621680787318Sym1 a6989586621680787323 :: TyFun (a ~> Proxy b) (Proxy b) -> Type) (a6989586621680787324 :: a ~> Proxy b) | |
fromString :: IsString a => String -> a #
undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a #
undefined that leaves a warning in code on every usage.
error :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => Text -> a #