Copyright | (c) 2016 Stephen Diehl (c) 2016-2018 Serokell (c) 2018-2023 Kowainik |
---|---|
License | MIT |
Maintainer | Kowainik <xrom.xkov@gmail.com> |
Stability | Stable |
Portability | Portable |
Safe Haskell | Trustworthy |
Language | Haskell2010 |
Relude.Base
Description
Reexports from Data.*
and GHC.*
modules of
base package.
Synopsis
- data Char
- chr :: Int -> Char
- class Eq a where
- class Eq a => Ord a where
- newtype Down a = Down {
- getDown :: a
- data Ordering
- comparing :: Ord a => (b -> a) -> b -> b -> Ordering
- type FilePath = String
- data IO a
- data IOMode
- class a ~R# b => Coercible (a :: k) (b :: k)
- coerce :: forall {k :: RuntimeRep} (a :: TYPE k) (b :: TYPE k). Coercible a b => a -> b
- type Constraint = CONSTRAINT LiftedRep
- type Type = TYPE LiftedRep
- data Proxy (t :: k) = Proxy
- class a ~# b => (a :: k) ~ (b :: k)
- class Typeable (a :: k)
- data Void
- absurd :: Void -> a
- vacuous :: Functor f => f Void -> f a
- asTypeOf :: a -> a -> a
- ord :: Char -> Int
- seq :: forall {r :: RuntimeRep} a (b :: TYPE r). a -> b -> b
- ($!) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
- class Generic a
- class Show a
- type family CmpNat (a :: Natural) (b :: Natural) :: Ordering where ...
- class KnownNat (n :: Nat)
- type Nat = Natural
- data SomeNat = KnownNat n => SomeNat (Proxy n)
- natVal :: forall (n :: Nat) proxy. KnownNat n => proxy n -> Natural
- someNatVal :: Natural -> SomeNat
- class IsLabel (x :: Symbol) a where
- fromLabel :: a
- getStackTrace :: IO (Maybe [Location])
- showStackTrace :: IO (Maybe String)
- data CallStack
- type HasCallStack = ?callStack :: CallStack
- callStack :: HasCallStack => CallStack
- currentCallStack :: IO [String]
- getCallStack :: CallStack -> [([Char], SrcLoc)]
- prettyCallStack :: CallStack -> String
- prettySrcLoc :: SrcLoc -> String
- withFrozenCallStack :: HasCallStack => (HasCallStack => a) -> a
Base types
Instances
Data Char | |
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Char -> c Char gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Char dataTypeOf :: Char -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Char) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Char) gmapT :: (forall b. Data b => b -> b) -> Char -> Char gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r gmapQ :: (forall d. Data d => d -> u) -> Char -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Char -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Char -> m Char gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char | |
Bounded Char | |
Enum Char | |
Read Char | |
Show Char | |
NFData Char | |
Defined in Control.DeepSeq | |
Eq Char | |
Ord Char | |
Hashable Char | |
Defined in Data.Hashable.Class | |
ToLText String Source # | |
ToString String Source # | |
ToText String Source # | |
TestCoercion SChar | |
Defined in GHC.TypeLits Methods testCoercion :: forall (a :: k) (b :: k). SChar a -> SChar b -> Maybe (Coercion a b) | |
TestEquality SChar | |
Defined in GHC.TypeLits Methods testEquality :: forall (a :: k) (b :: k). SChar a -> SChar b -> Maybe (a :~: b) | |
ConvertUtf8 String ByteString Source # | |
Defined in Relude.String.Conversion Methods encodeUtf8 :: String -> ByteString Source # decodeUtf8 :: ByteString -> String Source # decodeUtf8Strict :: ByteString -> Either UnicodeException String Source # | |
ConvertUtf8 String ShortByteString Source # | Since: 0.6.0.0 |
Defined in Relude.String.Conversion Methods encodeUtf8 :: String -> ShortByteString Source # decodeUtf8 :: ShortByteString -> String Source # decodeUtf8Strict :: ShortByteString -> Either UnicodeException String Source # | |
ConvertUtf8 String LByteString Source # | Converting |
Defined in Relude.String.Conversion Methods encodeUtf8 :: String -> LByteString Source # decodeUtf8 :: LByteString -> String Source # decodeUtf8Strict :: LByteString -> Either UnicodeException String Source # | |
Lift Char | |
Generic1 (URec Char :: k -> Type) | |
Foldable (UChar :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => UChar m -> m # foldMap :: Monoid m => (a -> m) -> UChar a -> m # foldMap' :: Monoid m => (a -> m) -> UChar a -> m # foldr :: (a -> b -> b) -> b -> UChar a -> b # foldr' :: (a -> b -> b) -> b -> UChar a -> b foldl :: (b -> a -> b) -> b -> UChar a -> b foldl' :: (b -> a -> b) -> b -> UChar a -> b # foldr1 :: (a -> a -> a) -> UChar a -> a foldl1 :: (a -> a -> a) -> UChar a -> a elem :: Eq a => a -> UChar a -> Bool maximum :: Ord a => UChar a -> a | |
Traversable (UChar :: Type -> Type) | |
Defined in Data.Traversable | |
Functor (URec Char :: Type -> Type) | |
Generic (URec Char p) | |
Show (URec Char p) | |
Eq (URec Char p) | |
Ord (URec Char p) | |
Defined in GHC.Generics | |
data URec Char (p :: k) | |
Defined in GHC.Generics | |
type Compare (a :: Char) (b :: Char) | |
Defined in Data.Type.Ord | |
type Rep1 (URec Char :: k -> Type) | |
type Rep (URec Char p) | |
Base type classes
Instances
Eq ByteArray | |
Eq Constr | |
Eq ConstrRep | |
Eq DataRep | |
Eq Fixity | |
Eq All | |
Eq Any | |
Eq SomeTypeRep | |
Eq Version | |
Eq Void | |
Eq BlockReason | |
Eq ThreadId | |
Eq ThreadStatus | |
Eq ErrorCall | |
Eq ArithException | |
Eq SpecConstrAnnotation | |
Eq Associativity | |
Eq DecidedStrictness | |
Eq Fixity | |
Eq SourceStrictness | |
Eq SourceUnpackedness | |
Eq MaskingState | |
Eq ArrayException | |
Eq AsyncException | |
Eq ExitCode | |
Eq IOErrorType | |
Eq IOException | |
Eq HandlePosn | |
Eq BufferMode | |
Defined in GHC.IO.Handle.Types | |
Eq Handle | |
Eq Newline | |
Eq NewlineMode | |
Eq IOMode | |
Eq Int16 | |
Eq Int32 | |
Eq Int64 | |
Eq Int8 | |
Eq IoSubSystem | |
Eq SrcLoc | |
Eq SomeChar | |
Eq SomeSymbol | |
Eq SomeNat | |
Eq Word16 | |
Eq Word32 | |
Eq Word64 | |
Eq Word8 | |
Eq Lexeme | |
Eq Number | |
Eq ByteString | |
Defined in Data.ByteString.Internal.Type | |
Eq ByteString | |
Eq ShortByteString | |
Defined in Data.ByteString.Short.Internal Methods (==) :: ShortByteString -> ShortByteString -> Bool # (/=) :: ShortByteString -> ShortByteString -> Bool # | |
Eq IntSet | |
Eq OsChar | |
Eq OsString | |
Eq PosixChar | |
Eq PosixString | |
Eq WindowsChar | |
Eq WindowsString | |
Eq ForeignSrcLang | |
Eq Extension | |
Eq Module | |
Eq Ordering | |
Eq TrName | |
Eq TyCon | |
Eq OsChar | |
Eq OsString | |
Eq PosixChar | |
Eq PosixString | |
Eq WindowsChar | |
Eq WindowsString | |
Eq Mode | |
Eq Style | |
Eq TextDetails | |
Eq Doc | |
Eq Undefined Source # | |
Eq AnnLookup | |
Eq AnnTarget | |
Eq Bang | |
Eq Body | |
Eq Bytes | |
Eq Callconv | |
Eq Clause | |
Eq Con | |
Eq Dec | |
Eq DecidedStrictness | |
Eq DerivClause | |
Eq DerivStrategy | |
Eq DocLoc | |
Eq Exp | |
Eq FamilyResultSig | |
Eq Fixity | |
Eq FixityDirection | |
Eq Foreign | |
Eq FunDep | |
Eq Guard | |
Eq Info | |
Eq InjectivityAnn | |
Eq Inline | |
Eq Lit | |
Eq Loc | |
Eq Match | |
Eq ModName | |
Eq Module | |
Eq ModuleInfo | |
Eq Name | |
Eq NameFlavour | |
Eq NameSpace | |
Eq OccName | |
Eq Overlap | |
Eq Pat | |
Eq PatSynArgs | |
Eq PatSynDir | |
Eq Phases | |
Eq PkgName | |
Eq Pragma | |
Eq Range | |
Eq Role | |
Eq RuleBndr | |
Eq RuleMatch | |
Eq Safety | |
Eq SourceStrictness | |
Eq SourceUnpackedness | |
Eq Specificity | |
Eq Stmt | |
Eq TyLit | |
Eq TySynEqn | |
Eq Type | |
Eq TypeFamilyHead | |
Eq UnicodeException | |
Defined in Data.Text.Encoding.Error Methods (==) :: UnicodeException -> UnicodeException -> Bool # (/=) :: UnicodeException -> UnicodeException -> Bool # | |
Eq Integer | |
Eq Natural | |
Eq () | |
Eq Bool | |
Eq Char | |
Eq Double | |
Eq Float | |
Eq Int | |
Eq Word | |
Eq a => Eq (ZipList a) | |
Eq (MutableByteArray s) | |
Eq a => Eq (And a) | |
Eq a => Eq (Iff a) | |
Eq a => Eq (Ior a) | |
Eq a => Eq (Xor a) | |
Eq a => Eq (Complex a) | |
Eq a => Eq (Identity a) | |
Eq a => Eq (First a) | |
Eq a => Eq (Last a) | |
Eq a => Eq (Down a) | |
Eq a => Eq (First a) | |
Eq a => Eq (Last a) | |
Eq a => Eq (Max a) | |
Eq a => Eq (Min a) | |
Eq m => Eq (WrappedMonoid m) | |
Defined in Data.Semigroup Methods (==) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (/=) :: WrappedMonoid m -> WrappedMonoid m -> Bool # | |
Eq a => Eq (Dual a) | |
Eq a => Eq (Product a) | |
Eq a => Eq (Sum a) | |
Eq a => Eq (NonEmpty a) | |
Eq (TVar a) | |
Eq p => Eq (Par1 p) | |
Eq (IORef a) | |
Eq (MVar a) | |
Eq a => Eq (Ratio a) | |
Eq a => Eq (IntMap a) | |
Eq a => Eq (Seq a) | |
Eq a => Eq (ViewL a) | |
Eq a => Eq (ViewR a) | |
Eq a => Eq (Intersection a) | |
Eq a => Eq (Set a) | |
Eq a => Eq (Tree a) | |
Eq a => Eq (Hashed a) | |
Eq a => Eq (AnnotDetails a) | |
Eq (Doc a) | |
Eq a => Eq (Span a) | |
Eq (TMVar a) | |
Eq flag => Eq (TyVarBndr flag) | |
Eq a => Eq (HashSet a) | |
Eq a => Eq (Maybe a) | |
Eq a => Eq (a) | |
Eq a => Eq [a] | |
(Eq a, Eq b) => Eq (Either a b) | |
Eq (Proxy s) | |
Eq a => Eq (Arg a b) | |
Eq (TypeRep a) | |
Eq (U1 p) | |
Eq (V1 p) | |
(Eq k, Eq a) => Eq (Map k a) | |
(Eq1 m, Eq a) => Eq (MaybeT m a) | |
(Eq k, Eq v) => Eq (HashMap k v) | |
(Eq k, Eq v) => Eq (Leaf k v) | |
(Eq a, Eq b) => Eq (a, b) | |
Eq a => Eq (Const a b) | |
Eq (f a) => Eq (Ap f a) | |
Eq (f a) => Eq (Alt f a) | |
Eq (a :~: b) | |
Eq (OrderingI a b) | |
(Generic1 f, Eq (Rep1 f a)) => Eq (Generically1 f a) | |
Eq (f p) => Eq (Rec1 f p) | |
Eq (URec (Ptr ()) p) | |
Eq (URec Char p) | |
Eq (URec Double p) | |
Eq (URec Float p) | |
Eq (URec Int p) | |
Eq (URec Word p) | |
(Eq e, Eq1 m, Eq a) => Eq (ExceptT e m a) | |
(Eq1 f, Eq a) => Eq (IdentityT f a) | |
(Eq w, Eq1 m, Eq a) => Eq (WriterT w m a) | |
(Eq w, Eq1 m, Eq a) => Eq (WriterT w m a) | |
(Eq a, Eq b, Eq c) => Eq (a, b, c) | |
(Eq (f a), Eq (g a)) => Eq (Product f g a) | |
(Eq (f a), Eq (g a)) => Eq (Sum f g a) | |
Eq (a :~~: b) | |
(Eq (f p), Eq (g p)) => Eq ((f :*: g) p) | |
(Eq (f p), Eq (g p)) => Eq ((f :+: g) p) | |
Eq c => Eq (K1 i c p) | |
(Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d) | |
Eq (f (g a)) => Eq (Compose f g a) | |
Eq (f (g p)) => Eq ((f :.: g) p) | |
Eq (f p) => Eq (M1 i c f p) | |
(Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) => Eq (a, b, c, d, e, f) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) => Eq (a, b, c, d, e, f, g) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h) => Eq (a, b, c, d, e, f, g, h) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i) => Eq (a, b, c, d, e, f, g, h, i) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j) => Eq (a, b, c, d, e, f, g, h, i, j) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k) => Eq (a, b, c, d, e, f, g, h, i, j, k) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l) => Eq (a, b, c, d, e, f, g, h, i, j, k, l) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n, Eq o) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) | |
Instances
Ord ByteArray | |
Ord All | |
Ord Any | |
Ord SomeTypeRep | |
Defined in Data.Typeable.Internal | |
Ord Version | |
Ord Void | |
Ord BlockReason | |
Defined in GHC.Conc.Sync | |
Ord ThreadId | |
Defined in GHC.Conc.Sync | |
Ord ThreadStatus | |
Defined in GHC.Conc.Sync | |
Ord ErrorCall | |
Ord ArithException | |
Defined in GHC.Exception.Type Methods compare :: ArithException -> ArithException -> Ordering # (<) :: ArithException -> ArithException -> Bool # (<=) :: ArithException -> ArithException -> Bool # (>) :: ArithException -> ArithException -> Bool # (>=) :: ArithException -> ArithException -> Bool # | |
Ord Associativity | |
Defined in GHC.Generics Methods compare :: Associativity -> Associativity -> Ordering # (<) :: Associativity -> Associativity -> Bool # (<=) :: Associativity -> Associativity -> Bool # (>) :: Associativity -> Associativity -> Bool # (>=) :: Associativity -> Associativity -> Bool # | |
Ord DecidedStrictness | |
Defined in GHC.Generics Methods compare :: DecidedStrictness -> DecidedStrictness -> Ordering # (<) :: DecidedStrictness -> DecidedStrictness -> Bool # (<=) :: DecidedStrictness -> DecidedStrictness -> Bool # (>) :: DecidedStrictness -> DecidedStrictness -> Bool # (>=) :: DecidedStrictness -> DecidedStrictness -> Bool # max :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness # min :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness # | |
Ord Fixity | |
Ord SourceStrictness | |
Defined in GHC.Generics Methods compare :: SourceStrictness -> SourceStrictness -> Ordering # (<) :: SourceStrictness -> SourceStrictness -> Bool # (<=) :: SourceStrictness -> SourceStrictness -> Bool # (>) :: SourceStrictness -> SourceStrictness -> Bool # (>=) :: SourceStrictness -> SourceStrictness -> Bool # max :: SourceStrictness -> SourceStrictness -> SourceStrictness # min :: SourceStrictness -> SourceStrictness -> SourceStrictness # | |
Ord SourceUnpackedness | |
Defined in GHC.Generics Methods compare :: SourceUnpackedness -> SourceUnpackedness -> Ordering # (<) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (<=) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (>) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (>=) :: SourceUnpackedness -> SourceUnpackedness -> Bool # max :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness # min :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness # | |
Ord ArrayException | |
Defined in GHC.IO.Exception Methods compare :: ArrayException -> ArrayException -> Ordering # (<) :: ArrayException -> ArrayException -> Bool # (<=) :: ArrayException -> ArrayException -> Bool # (>) :: ArrayException -> ArrayException -> Bool # (>=) :: ArrayException -> ArrayException -> Bool # | |
Ord AsyncException | |
Defined in GHC.IO.Exception Methods compare :: AsyncException -> AsyncException -> Ordering # (<) :: AsyncException -> AsyncException -> Bool # (<=) :: AsyncException -> AsyncException -> Bool # (>) :: AsyncException -> AsyncException -> Bool # (>=) :: AsyncException -> AsyncException -> Bool # | |
Ord ExitCode | |
Defined in GHC.IO.Exception | |
Ord BufferMode | |
Defined in GHC.IO.Handle.Types 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 | |
Ord NewlineMode | |
Defined in GHC.IO.Handle.Types | |
Ord IOMode | |
Ord Int16 | |
Ord Int32 | |
Ord Int64 | |
Ord Int8 | |
Ord SomeChar | |
Defined in GHC.TypeLits | |
Ord SomeSymbol | |
Ord SomeNat | |
Ord Word16 | |
Ord Word32 | |
Ord Word64 | |
Ord Word8 | |
Ord ByteString | |
Defined in Data.ByteString.Internal.Type 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 | |
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 IntSet | |
Ord OsChar | |
Defined in System.OsString.Internal.Types.Hidden | |
Ord OsString | |
Defined in System.OsString.Internal.Types.Hidden | |
Ord PosixChar | |
Defined in System.OsString.Internal.Types.Hidden | |
Ord PosixString | |
Defined in System.OsString.Internal.Types.Hidden | |
Ord WindowsChar | |
Defined in System.OsString.Internal.Types.Hidden | |
Ord WindowsString | |
Defined in System.OsString.Internal.Types.Hidden Methods compare :: WindowsString -> WindowsString -> Ordering # (<) :: WindowsString -> WindowsString -> Bool # (<=) :: WindowsString -> WindowsString -> Bool # (>) :: WindowsString -> WindowsString -> Bool # (>=) :: WindowsString -> WindowsString -> Bool # | |
Ord Extension | |
Ord Ordering | |
Defined in GHC.Classes | |
Ord TyCon | |
Ord OsChar | |
Ord OsString | |
Defined in System.OsString.Internal.Types | |
Ord PosixChar | |
Ord PosixString | |
Defined in System.OsString.Internal.Types | |
Ord WindowsChar | |
Defined in System.OsString.Internal.Types | |
Ord WindowsString | |
Defined in System.OsString.Internal.Types Methods compare :: WindowsString -> WindowsString -> Ordering # (<) :: WindowsString -> WindowsString -> Bool # (<=) :: WindowsString -> WindowsString -> Bool # (>) :: WindowsString -> WindowsString -> Bool # (>=) :: WindowsString -> WindowsString -> Bool # | |
Ord Undefined Source # | |
Ord AnnLookup | |
Ord AnnTarget | |
Ord Bang | |
Ord Body | |
Ord Bytes | |
Ord Callconv | |
Defined in Language.Haskell.TH.Syntax | |
Ord Clause | |
Ord Con | |
Ord Dec | |
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 DerivClause | |
Defined in Language.Haskell.TH.Syntax | |
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 # | |
Ord DocLoc | |
Ord Exp | |
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 Fixity | |
Ord FixityDirection | |
Defined in Language.Haskell.TH.Syntax Methods compare :: FixityDirection -> FixityDirection -> Ordering # (<) :: FixityDirection -> FixityDirection -> Bool # (<=) :: FixityDirection -> FixityDirection -> Bool # (>) :: FixityDirection -> FixityDirection -> Bool # (>=) :: FixityDirection -> FixityDirection -> Bool # max :: FixityDirection -> FixityDirection -> FixityDirection # min :: FixityDirection -> FixityDirection -> FixityDirection # | |
Ord Foreign | |
Defined in Language.Haskell.TH.Syntax | |
Ord FunDep | |
Ord Guard | |
Ord Info | |
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 # | |
Ord Inline | |
Ord Lit | |
Ord Loc | |
Ord Match | |
Ord ModName | |
Defined in Language.Haskell.TH.Syntax | |
Ord Module | |
Ord ModuleInfo | |
Defined in Language.Haskell.TH.Syntax | |
Ord Name | |
Ord NameFlavour | |
Defined in Language.Haskell.TH.Syntax | |
Ord NameSpace | |
Ord OccName | |
Defined in Language.Haskell.TH.Syntax | |
Ord Overlap | |
Defined in Language.Haskell.TH.Syntax | |
Ord Pat | |
Ord PatSynArgs | |
Defined in Language.Haskell.TH.Syntax | |
Ord PatSynDir | |
Ord Phases | |
Ord PkgName | |
Defined in Language.Haskell.TH.Syntax | |
Ord Pragma | |
Ord Range | |
Ord Role | |
Ord RuleBndr | |
Defined in Language.Haskell.TH.Syntax | |
Ord RuleMatch | |
Ord Safety | |
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 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 Specificity | |
Defined in Language.Haskell.TH.Syntax | |
Ord Stmt | |
Ord TyLit | |
Ord TySynEqn | |
Defined in Language.Haskell.TH.Syntax | |
Ord Type | |
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 # | |
Ord Integer | |
Ord Natural | |
Ord () | |
Ord Bool | |
Ord Char | |
Ord Double | |
Ord Float | |
Ord Int | |
Ord Word | |
Ord a => Ord (ZipList a) | |
Ord a => Ord (Identity a) | |
Defined in Data.Functor.Identity | |
Ord a => Ord (First a) | |
Ord a => Ord (Last a) | |
Ord a => Ord (Down a) | |
Ord a => Ord (First a) | |
Ord a => Ord (Last a) | |
Ord a => Ord (Max a) | |
Ord a => Ord (Min a) | |
Ord m => Ord (WrappedMonoid m) | |
Defined in Data.Semigroup Methods compare :: WrappedMonoid m -> WrappedMonoid m -> Ordering # (<) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (<=) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (>) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (>=) :: WrappedMonoid m -> WrappedMonoid m -> Bool # max :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # min :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # | |
Ord a => Ord (Dual a) | |
Ord a => Ord (Product a) | |
Ord a => Ord (Sum a) | |
Ord a => Ord (NonEmpty a) | |
Ord p => Ord (Par1 p) | |
Integral a => Ord (Ratio a) | |
Ord a => Ord (IntMap a) | |
Defined in Data.IntMap.Internal | |
Ord a => Ord (Seq a) | |
Ord a => Ord (ViewL a) | |
Defined in Data.Sequence.Internal | |
Ord a => Ord (ViewR a) | |
Defined in Data.Sequence.Internal | |
Ord a => Ord (Intersection a) | |
Defined in Data.Set.Internal Methods compare :: Intersection a -> Intersection a -> Ordering # (<) :: Intersection a -> Intersection a -> Bool # (<=) :: Intersection a -> Intersection a -> Bool # (>) :: Intersection a -> Intersection a -> Bool # (>=) :: Intersection a -> Intersection a -> Bool # | |
Ord a => Ord (Set a) | |
Ord a => Ord (Tree a) | |
Ord a => Ord (Hashed a) | |
Defined in Data.Hashable.Class | |
Ord flag => Ord (TyVarBndr flag) | |
Defined in Language.Haskell.TH.Syntax Methods compare :: TyVarBndr flag -> TyVarBndr flag -> Ordering # (<) :: TyVarBndr flag -> TyVarBndr flag -> Bool # (<=) :: TyVarBndr flag -> TyVarBndr flag -> Bool # (>) :: TyVarBndr flag -> TyVarBndr flag -> Bool # (>=) :: TyVarBndr flag -> TyVarBndr flag -> Bool # | |
Ord a => Ord (HashSet a) | |
Ord a => Ord (Maybe a) | |
Ord a => Ord (a) | |
Ord a => Ord [a] | |
(Ord a, Ord b) => Ord (Either a b) | |
Ord (Proxy s) | |
Ord a => Ord (Arg a b) | |
Ord (TypeRep a) | |
Ord (U1 p) | |
Ord (V1 p) | |
(Ord k, Ord v) => Ord (Map k v) | |
(Ord1 m, Ord a) => Ord (MaybeT m a) | |
Defined in Control.Monad.Trans.Maybe | |
(Ord k, Ord v) => Ord (HashMap k v) | |
Defined in Data.HashMap.Internal | |
(Ord a, Ord b) => Ord (a, b) | |
Ord a => Ord (Const a b) | |
Ord (f a) => Ord (Ap f a) | |
Ord (f a) => Ord (Alt f a) | |
Defined in Data.Semigroup.Internal | |
Ord (a :~: b) | |
Defined in Data.Type.Equality | |
(Generic1 f, Ord (Rep1 f a)) => Ord (Generically1 f a) | |
Defined in GHC.Generics Methods compare :: Generically1 f a -> Generically1 f a -> Ordering # (<) :: Generically1 f a -> Generically1 f a -> Bool # (<=) :: Generically1 f a -> Generically1 f a -> Bool # (>) :: Generically1 f a -> Generically1 f a -> Bool # (>=) :: Generically1 f a -> Generically1 f a -> Bool # max :: Generically1 f a -> Generically1 f a -> Generically1 f a # min :: Generically1 f a -> Generically1 f a -> Generically1 f a # | |
Ord (f p) => Ord (Rec1 f p) | |
Defined in GHC.Generics | |
Ord (URec (Ptr ()) p) | |
Defined in GHC.Generics Methods compare :: URec (Ptr ()) p -> URec (Ptr ()) p -> Ordering # (<) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (<=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (>) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (>=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # max :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p # min :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p # | |
Ord (URec Char p) | |
Defined in GHC.Generics | |
Ord (URec Double p) | |
Defined in GHC.Generics Methods compare :: URec Double p -> URec Double p -> Ordering # (<) :: URec Double p -> URec Double p -> Bool # (<=) :: URec Double p -> URec Double p -> Bool # (>) :: URec Double p -> URec Double p -> Bool # (>=) :: URec Double p -> URec Double p -> Bool # | |
Ord (URec Float p) | |
Defined in GHC.Generics | |
Ord (URec Int p) | |
Ord (URec Word p) | |
Defined in GHC.Generics | |
(Ord 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 # | |
(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 w, Ord1 m, Ord a) => Ord (WriterT w m a) | |
Defined in Control.Monad.Trans.Writer.Lazy Methods compare :: WriterT w m a -> WriterT w m a -> Ordering # (<) :: WriterT w m a -> WriterT w m a -> Bool # (<=) :: WriterT w m a -> WriterT w m a -> Bool # (>) :: WriterT w m a -> WriterT w m a -> Bool # (>=) :: WriterT w m a -> WriterT w m a -> Bool # | |
(Ord w, Ord1 m, Ord a) => Ord (WriterT w m a) | |
Defined in Control.Monad.Trans.Writer.Strict Methods compare :: WriterT w m a -> WriterT w m a -> Ordering # (<) :: WriterT w m a -> WriterT w m a -> Bool # (<=) :: WriterT w m a -> WriterT w m a -> Bool # (>) :: WriterT w m a -> WriterT w m a -> Bool # (>=) :: WriterT w m a -> WriterT w m a -> Bool # | |
(Ord a, Ord b, Ord c) => Ord (a, b, c) | |
(Ord (f a), Ord (g a)) => Ord (Product f g a) | |
Defined in Data.Functor.Product Methods compare :: Product f g a -> Product f g a -> Ordering # (<) :: Product f g a -> Product f g a -> Bool # (<=) :: Product f g a -> Product f g a -> Bool # (>) :: Product f g a -> Product f g a -> Bool # (>=) :: Product f g a -> Product f g a -> Bool # | |
(Ord (f a), Ord (g a)) => Ord (Sum f g a) | |
Ord (a :~~: b) | |
(Ord (f p), Ord (g p)) => Ord ((f :*: g) p) | |
Defined in GHC.Generics | |
(Ord (f p), Ord (g p)) => Ord ((f :+: g) p) | |
Defined in GHC.Generics | |
Ord c => Ord (K1 i c p) | |
Defined in GHC.Generics | |
(Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d) | |
Defined in GHC.Classes | |
Ord (f (g a)) => Ord (Compose f g a) | |
Defined in Data.Functor.Compose Methods compare :: Compose f g a -> Compose f g a -> Ordering # (<) :: Compose f g a -> Compose f g a -> Bool # (<=) :: Compose f g a -> Compose f g a -> Bool # (>) :: Compose f g a -> Compose f g a -> Bool # (>=) :: Compose f g a -> Compose f g a -> Bool # | |
Ord (f (g p)) => Ord ((f :.: g) p) | |
Defined in GHC.Generics | |
Ord (f p) => Ord (M1 i c f p) | |
(Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e) -> (a, b, c, d, e) -> Ordering # (<) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # (<=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # (>) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # (>=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # max :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) # min :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f) => Ord (a, b, c, d, e, f) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Ordering # (<) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool # (<=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool # (>) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool # (>=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool # max :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) # min :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g) => Ord (a, b, c, d, e, f, g) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Ordering # (<) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool # (<=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool # (>) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool # (>=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool # max :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) # min :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h) => Ord (a, b, c, d, e, f, g, h) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Ordering # (<) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool # (<=) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool # (>) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool # (>=) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool # max :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) # min :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i) => Ord (a, b, c, d, e, f, g, h, i) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool # max :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) # min :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j) => Ord (a, b, c, d, e, f, g, h, i, j) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) # min :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k) => Ord (a, b, c, d, e, f, g, h, i, j, k) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) # min :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l) => Ord (a, b, c, d, e, f, g, h, i, j, k, l) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) # min :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) # min :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) # min :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n, Ord o) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) # min :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) # |
Instances
Foldable Down | |
Defined in Data.Foldable Methods fold :: Monoid m => Down m -> m # foldMap :: Monoid m => (a -> m) -> Down a -> m # foldMap' :: Monoid m => (a -> m) -> Down a -> m # foldr :: (a -> b -> b) -> b -> Down a -> b # foldr' :: (a -> b -> b) -> b -> Down a -> b foldl :: (b -> a -> b) -> b -> Down a -> b foldl' :: (b -> a -> b) -> b -> Down a -> b # foldr1 :: (a -> a -> a) -> Down a -> a foldl1 :: (a -> a -> a) -> Down a -> a elem :: Eq a => a -> Down a -> Bool maximum :: Ord a => Down a -> a | |
Traversable Down | |
Applicative Down | |
Functor Down | |
Monad Down | |
NFData1 Down | |
Defined in Control.DeepSeq | |
Generic1 Down | |
Data a => Data (Down a) | |
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Down a -> c (Down a) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Down a) dataTypeOf :: Down a -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Down a)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Down a)) gmapT :: (forall b. Data b => b -> b) -> Down a -> Down a gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Down a -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Down a -> r gmapQ :: (forall d. Data d => d -> u) -> Down a -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Down a -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Down a -> m (Down a) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Down a -> m (Down a) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Down a -> m (Down a) | |
Storable a => Storable (Down a) | |
Monoid a => Monoid (Down a) | |
Semigroup a => Semigroup (Down a) | |
Bits a => Bits (Down a) | |
Defined in Data.Ord Methods (.&.) :: Down a -> Down a -> Down a (.|.) :: Down a -> Down a -> Down a xor :: Down a -> Down a -> Down a # complement :: Down a -> Down a shift :: Down a -> Int -> Down a rotate :: Down a -> Int -> Down a setBit :: Down a -> Int -> Down a clearBit :: Down a -> Int -> Down a complementBit :: Down a -> Int -> Down a testBit :: Down a -> Int -> Bool bitSizeMaybe :: Down a -> Maybe Int shiftL :: Down a -> Int -> Down a unsafeShiftL :: Down a -> Int -> Down a shiftR :: Down a -> Int -> Down a unsafeShiftR :: Down a -> Int -> Down a rotateL :: Down a -> Int -> Down a | |
FiniteBits a => FiniteBits (Down a) | |
Defined in Data.Ord Methods finiteBitSize :: Down a -> Int countLeadingZeros :: Down a -> Int countTrailingZeros :: Down a -> Int | |
Bounded a => Bounded (Down a) | |
(Enum a, Bounded a, Eq a) => Enum (Down a) | |
Defined in Data.Ord | |
Floating a => Floating (Down a) | |
RealFloat a => RealFloat (Down a) | |
Defined in Data.Ord Methods floatRadix :: Down a -> Integer # floatDigits :: Down a -> Int # floatRange :: Down a -> (Int, Int) # decodeFloat :: Down a -> (Integer, Int) # encodeFloat :: Integer -> Int -> Down a # significand :: Down a -> Down a scaleFloat :: Int -> Down a -> Down a isInfinite :: Down a -> Bool # isDenormalized :: Down a -> Bool # isNegativeZero :: Down a -> Bool # | |
Generic (Down a) | |
Ix a => Ix (Down a) | |
Num a => Num (Down a) | |
Read a => Read (Down a) | |
Fractional a => Fractional (Down a) | |
Real a => Real (Down a) | |
Defined in Data.Ord Methods toRational :: Down a -> Rational # | |
RealFrac a => RealFrac (Down a) | |
Show a => Show (Down a) | |
NFData a => NFData (Down a) | |
Defined in Control.DeepSeq | |
Eq a => Eq (Down a) | |
Ord a => Ord (Down a) | |
type Rep1 Down | |
Defined in GHC.Generics | |
type Rep (Down a) | |
Defined in GHC.Generics |
Instances
Data Ordering | |
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ordering -> c Ordering gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Ordering toConstr :: Ordering -> Constr dataTypeOf :: Ordering -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Ordering) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ordering) gmapT :: (forall b. Data b => b -> b) -> Ordering -> Ordering gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ordering -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ordering -> r gmapQ :: (forall d. Data d => d -> u) -> Ordering -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Ordering -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering | |
Monoid Ordering | |
Semigroup Ordering | |
Bounded Ordering | |
Enum Ordering | |
Generic Ordering | |
Read Ordering | |
Show Ordering | |
NFData Ordering | |
Defined in Control.DeepSeq | |
Eq Ordering | |
Ord Ordering | |
Defined in GHC.Classes | |
Hashable Ordering | |
Defined in Data.Hashable.Class | |
type Rep Ordering | |
System IO
Instances
Constructors
ReadMode | |
WriteMode | |
AppendMode | |
ReadWriteMode |
Types for type-level computation
type Constraint = CONSTRAINT LiftedRep #
Constructors
Proxy |
Instances
Generic1 (Proxy :: k -> Type) | |
Foldable (Proxy :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => Proxy m -> m # foldMap :: Monoid m => (a -> m) -> Proxy a -> m # foldMap' :: Monoid m => (a -> m) -> Proxy a -> m # foldr :: (a -> b -> b) -> b -> Proxy a -> b # foldr' :: (a -> b -> b) -> b -> Proxy a -> b foldl :: (b -> a -> b) -> b -> Proxy a -> b foldl' :: (b -> a -> b) -> b -> Proxy a -> b # foldr1 :: (a -> a -> a) -> Proxy a -> a foldl1 :: (a -> a -> a) -> Proxy a -> a elem :: Eq a => a -> Proxy a -> Bool maximum :: Ord a => Proxy a -> a | |
Contravariant (Proxy :: Type -> Type) | |
Traversable (Proxy :: Type -> Type) | |
Alternative (Proxy :: Type -> Type) | |
Applicative (Proxy :: Type -> Type) | |
Functor (Proxy :: Type -> Type) | |
Monad (Proxy :: Type -> Type) | |
MonadPlus (Proxy :: Type -> Type) | |
NFData1 (Proxy :: Type -> Type) | |
Defined in Control.DeepSeq | |
Hashable1 (Proxy :: Type -> Type) | |
Defined in Data.Hashable.Class | |
Data t => Data (Proxy t) | |
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Proxy t -> c (Proxy t) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Proxy t) dataTypeOf :: Proxy t -> DataType dataCast1 :: Typeable t0 => (forall d. Data d => c (t0 d)) -> Maybe (c (Proxy t)) dataCast2 :: Typeable t0 => (forall d e. (Data d, Data e) => c (t0 d e)) -> Maybe (c (Proxy t)) gmapT :: (forall b. Data b => b -> b) -> Proxy t -> Proxy t gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Proxy t -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Proxy t -> r gmapQ :: (forall d. Data d => d -> u) -> Proxy t -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Proxy t -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Proxy t -> m (Proxy t) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Proxy t -> m (Proxy t) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Proxy t -> m (Proxy t) | |
Monoid (Proxy s) | |
Semigroup (Proxy s) | |
Bounded (Proxy t) | |
Enum (Proxy s) | |
Generic (Proxy t) | |
Ix (Proxy s) | |
Read (Proxy t) | |
Defined in Data.Proxy | |
Show (Proxy s) | |
NFData (Proxy a) | |
Defined in Control.DeepSeq | |
Eq (Proxy s) | |
Ord (Proxy s) | |
Hashable (Proxy a) | |
Defined in Data.Hashable.Class | |
type Rep1 (Proxy :: k -> Type) | |
type Rep (Proxy t) | |
Instances
Data Void | |
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Void -> c Void gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Void dataTypeOf :: Void -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Void) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Void) gmapT :: (forall b. Data b => b -> b) -> Void -> Void gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Void -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Void -> r gmapQ :: (forall d. Data d => d -> u) -> Void -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Void -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Void -> m Void gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Void -> m Void gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Void -> m Void | |
Semigroup Void | |
Exception Void | |
Defined in GHC.Exception.Type Methods toException :: Void -> SomeException # fromException :: SomeException -> Maybe Void # displayException :: Void -> String # | |
Generic Void | |
Read Void | |
Show Void | |
NFData Void | |
Defined in Control.DeepSeq | |
Eq Void | |
Ord Void | |
Hashable Void | |
Defined in Data.Hashable.Class | |
Lift Void | |
type Rep Void | |
Defined in GHC.Generics |
Basic type classes
Minimal complete definition
from, to
Instances
Minimal complete definition
showsPrec | show
Instances
Show NestedAtomically | |
Show NoMatchingContinuationPrompt | |
Show NoMethodError | |
Show NonTermination | |
Show PatternMatchFail | |
Show RecConError | |
Show RecSelError | |
Show RecUpdError | |
Show TypeError | |
Show ByteArray | |
Show Constr | |
Show ConstrRep | |
Show DataRep | |
Show DataType | |
Show Fixity | |
Show All | |
Show Any | |
Show SomeTypeRep | |
Show Version | |
Show Void | |
Show BlockReason | |
Show ThreadId | |
Show ThreadStatus | |
Show ErrorCall | |
Show ArithException | |
Show SomeException | |
Defined in GHC.Exception.Type Methods showsPrec :: Int -> SomeException -> ShowS show :: SomeException -> String showList :: [SomeException] -> ShowS | |
Show Associativity | |
Show DecidedStrictness | |
Show Fixity | |
Show SourceStrictness | |
Show SourceUnpackedness | |
Show MaskingState | |
Show AllocationLimitExceeded | |
Show ArrayException | |
Show AssertionFailed | |
Show AsyncException | |
Show BlockedIndefinitelyOnMVar | |
Show BlockedIndefinitelyOnSTM | |
Show CompactionFailed | |
Show Deadlock | |
Show ExitCode | |
Show FixIOException | |
Show IOErrorType | |
Show IOException | |
Show SomeAsyncException | |
Show HandlePosn | |
Show BufferMode | |
Defined in GHC.IO.Handle.Types Methods showsPrec :: Int -> BufferMode -> ShowS show :: BufferMode -> String showList :: [BufferMode] -> ShowS | |
Show Handle | |
Show HandleType | |
Show Newline | |
Show NewlineMode | |
Show IOMode | |
Show Int16 | |
Show Int32 | |
Show Int64 | |
Show Int8 | |
Show CCFlags | |
Show ConcFlags | |
Show DebugFlags | |
Show DoCostCentres | |
Show DoHeapProfile | |
Show DoTrace | |
Show GCFlags | |
Show GiveGCStats | |
Show IoSubSystem | |
Show MiscFlags | |
Show ParFlags | |
Show ProfFlags | |
Show RTSFlags | |
Show TickyFlags | |
Show TraceFlags | |
Show FractionalExponentBase | |
Show CallStack | |
Show SrcLoc | |
Show SomeChar | |
Show SomeSymbol | |
Show SomeNat | |
Show Word16 | |
Show Word32 | |
Show Word64 | |
Show Word8 | |
Show Lexeme | |
Show Number | |
Show ByteString | |
Defined in Data.ByteString.Internal.Type Methods showsPrec :: Int -> ByteString -> ShowS show :: ByteString -> String showList :: [ByteString] -> ShowS | |
Show ByteString | |
Show ShortByteString | |
Defined in Data.ByteString.Short.Internal Methods showsPrec :: Int -> ShortByteString -> ShowS show :: ShortByteString -> String showList :: [ShortByteString] -> ShowS | |
Show IntSet | |
Show OsChar | |
Show OsString | |
Show PosixChar | |
Show PosixString | |
Show WindowsChar | |
Show WindowsString | |
Show ForeignSrcLang | |
Show Extension | |
Show KindRep | |
Show Module | |
Show Ordering | |
Show TrName | |
Show TyCon | |
Show TypeLitSort | |
Show OsChar | |
Show OsString | |
Show PosixChar | |
Show PosixString | |
Show WindowsChar | |
Show WindowsString | |
Show Mode | |
Show Style | |
Show TextDetails | |
Show Doc | |
Show Undefined Source # | |
Show Bug Source # | |
Show AnnLookup | |
Show AnnTarget | |
Show Bang | |
Show Body | |
Show Bytes | |
Show Callconv | |
Show Clause | |
Show Con | |
Show Dec | |
Show DecidedStrictness | |
Show DerivClause | |
Show DerivStrategy | |
Show DocLoc | |
Show Exp | |
Show FamilyResultSig | |
Show Fixity | |
Show FixityDirection | |
Show Foreign | |
Show FunDep | |
Show Guard | |
Show Info | |
Show InjectivityAnn | |
Show Inline | |
Show Lit | |
Show Loc | |
Show Match | |
Show ModName | |
Show Module | |
Show ModuleInfo | |
Show Name | |
Show NameFlavour | |
Show NameSpace | |
Show OccName | |
Show Overlap | |
Show Pat | |
Show PatSynArgs | |
Show PatSynDir | |
Show Phases | |
Show PkgName | |
Show Pragma | |
Show Range | |
Show Role | |
Show RuleBndr | |
Show RuleMatch | |
Show Safety | |
Show SourceStrictness | |
Show SourceUnpackedness | |
Show Specificity | |
Show Stmt | |
Show TyLit | |
Show TySynEqn | |
Show Type | |
Show TypeFamilyHead | |
Show Decoding | |
Show UnicodeException | |
Defined in Data.Text.Encoding.Error Methods showsPrec :: Int -> UnicodeException -> ShowS show :: UnicodeException -> String showList :: [UnicodeException] -> ShowS | |
Show Integer | |
Show Natural | |
Show () | |
Show Bool | |
Show Char | |
Show Int | |
Show Levity | |
Show RuntimeRep | |
Show VecCount | |
Show VecElem | |
Show Word | |
Show a => Show (ZipList a) | |
Show a => Show (And a) | |
Show a => Show (Iff a) | |
Show a => Show (Ior a) | |
Show a => Show (Xor a) | |
Show a => Show (Complex a) | |
Show a => Show (Identity a) | |
Show a => Show (First a) | |
Show a => Show (Last a) | |
Show a => Show (Down a) | |
Show a => Show (First a) | |
Show a => Show (Last a) | |
Show a => Show (Max a) | |
Show a => Show (Min a) | |
Show m => Show (WrappedMonoid m) | |
Defined in Data.Semigroup Methods showsPrec :: Int -> WrappedMonoid m -> ShowS show :: WrappedMonoid m -> String showList :: [WrappedMonoid m] -> ShowS | |
Show a => Show (Dual a) | |
Show a => Show (Product a) | |
Show a => Show (Sum a) | |
Show a => Show (NonEmpty a) | |
Show p => Show (Par1 p) | |
Show a => Show (Ratio a) | |
Show (SChar c) | |
Show (SSymbol s) | |
Show (SNat n) | |
Show a => Show (IntMap a) | |
Show a => Show (Seq a) | |
Show a => Show (ViewL a) | |
Show a => Show (ViewR a) | |
Show a => Show (Intersection a) | |
Show a => Show (Set a) | |
Show a => Show (Tree a) | |
Show a => Show (Hashed a) | |
Show a => Show (AnnotDetails a) | |
Show (Doc a) | |
Show a => Show (Span a) | |
Show flag => Show (TyVarBndr flag) | |
Show a => Show (HashSet a) | |
Show a => Show (Maybe a) | |
Show a => Show (a) | |
Show a => Show [a] | |
(Show a, Show b) => Show (Either a b) | |
Show (Proxy s) | |
(Show a, Show b) => Show (Arg a b) | |
Show (TypeRep a) | |
Show (U1 p) | |
Show (V1 p) | |
(Show k, Show a) => Show (Map k a) | |
(Show1 m, Show a) => Show (MaybeT m a) | |
(Show k, Show v) => Show (HashMap k v) | |
(Show a, Show b) => Show (a, b) | |
Show a => Show (Const a b) | |
Show (f a) => Show (Ap f a) | |
Show (f a) => Show (Alt f a) | |
Show (a :~: b) | |
Show (OrderingI a b) | |
Show (f p) => Show (Rec1 f p) | |
Show (URec Char p) | |
Show (URec Double p) | |
Show (URec Float p) | |
Show (URec Int p) | |
Show (URec Word p) | |
(Show e, Show1 m, Show a) => Show (ExceptT e m a) | |
(Show1 f, Show a) => Show (IdentityT f a) | |
(Show w, Show1 m, Show a) => Show (WriterT w m a) | |
(Show w, Show1 m, Show a) => Show (WriterT w m a) | |
(Show a, Show b, Show c) => Show (a, b, c) | |
(Show (f a), Show (g a)) => Show (Product f g a) | |
(Show (f a), Show (g a)) => Show (Sum f g a) | |
Show (a :~~: b) | |
(Show (f p), Show (g p)) => Show ((f :*: g) p) | |
(Show (f p), Show (g p)) => Show ((f :+: g) p) | |
Show c => Show (K1 i c p) | |
(Show a, Show b, Show c, Show d) => Show (a, b, c, d) | |
Show (f (g a)) => Show (Compose f g a) | |
Show (f (g p)) => Show ((f :.: g) p) | |
Show (f p) => Show (M1 i c f p) | |
(Show a, Show b, Show c, Show d, Show e) => Show (a, b, c, d, e) | |
(Show a, Show b, Show c, Show d, Show e, Show f) => Show (a, b, c, d, e, f) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g) => Show (a, b, c, d, e, f, g) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h) => Show (a, b, c, d, e, f, g, h) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i) => Show (a, b, c, d, e, f, g, h, i) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j) => Show (a, b, c, d, e, f, g, h, i, j) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k) => Show (a, b, c, d, e, f, g, h, i, j, k) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l) => Show (a, b, c, d, e, f, g, h, i, j, k, l) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m, Show n) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m, Show n, Show o) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) | |
GHC-specific functionality
someNatVal :: Natural -> SomeNat #
getStackTrace :: IO (Maybe [Location]) #
showStackTrace :: IO (Maybe String) #
Instances
IsList CallStack | |
Show CallStack | |
NFData CallStack | |
Defined in Control.DeepSeq | |
type Item CallStack | |
Defined in GHC.IsList |
type HasCallStack = ?callStack :: CallStack #
callStack :: HasCallStack => CallStack #
currentCallStack :: IO [String] #
getCallStack :: CallStack -> [([Char], SrcLoc)] #
prettyCallStack :: CallStack -> String #
prettySrcLoc :: SrcLoc -> String #
withFrozenCallStack :: HasCallStack => (HasCallStack => a) -> a #