| License | BSD-style | 
|---|---|
| Maintainer | Vincent Hanquez <[email protected]> | 
| Stability | experimental | 
| Portability | portable | 
| Safe Haskell | Safe-Inferred | 
| Language | Haskell2010 | 
Basement.Imports
Description
re-export of all the base prelude and basic primitive stuffs
Synopsis
- ($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
 - ($!) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
 - (&&) :: Bool -> Bool -> Bool
 - (||) :: Bool -> Bool -> Bool
 - (.) :: forall (b :: k) (c :: k) (a :: k). Category cat => cat b c -> cat a b -> cat a c
 - (<$>) :: Functor f => (a -> b) -> f a -> f b
 - not :: Bool -> Bool
 - otherwise :: Bool
 - fst :: (a, b) -> a
 - snd :: (a, b) -> b
 - id :: forall (a :: k). Category cat => cat a a
 - maybe :: b -> (a -> b) -> Maybe a -> b
 - either :: (a -> c) -> (b -> c) -> Either a b -> c
 - flip :: (a -> b -> c) -> b -> a -> c
 - const :: a -> b -> a
 - error :: forall (r :: RuntimeRep). forall (a :: TYPE r). HasCallStack => String -> a
 - and :: Foldable t => t Bool -> Bool
 - undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a
 - seq :: forall {r :: RuntimeRep} a (b :: TYPE r). a -> b -> b
 - class Show a
 - show :: Show a => a -> String
 - class Eq a => Ord a where
 - class Eq a where
 - class Bounded a where
 - class Enum a where
- succ :: a -> a
 - pred :: a -> a
 - toEnum :: Int -> a
 - fromEnum :: a -> Int
 - enumFrom :: a -> [a]
 - enumFromThen :: a -> a -> [a]
 - enumFromTo :: a -> a -> [a]
 - enumFromThenTo :: a -> a -> a -> [a]
 
 - class Functor (f :: Type -> Type) where
 - class Functor f => Applicative (f :: Type -> Type) where
 - class Applicative m => Monad (m :: Type -> Type) where
 - when :: Applicative f => Bool -> f () -> f ()
 - unless :: Applicative f => Bool -> f () -> f ()
 - data Maybe a
 - data Ordering
 - data Bool
 - data Int
 - data Integer
 - data Natural
 - data Offset ty
 - data CountOf ty
 - data Char
 - class Eq ty => PrimType ty
 - data Char7
 - data AsciiString
 - data String
 - data UArray ty
 - data Array a
 - class Integral a where
- fromInteger :: Integer -> a
 
 - class Fractional a where
- fromRational :: Rational -> a
 
 - class HasNegation a where
- negate :: a -> a
 
 - data Int8
 - data Int16
 - data Int32
 - data Int64
 - data Word8
 - data Word16
 - data Word32
 - data Word64
 - data Word
 - data Double
 - data Float
 - data IO a
 - type FP32 = Float
 - type FP64 = Double
 - class IsList l where
 - class IsString a where
- fromString :: String -> a
 
 - class Generic a where
 - data Either a b
 - class Typeable a => Data a where
- gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> a -> c a
 - gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c a
 - toConstr :: a -> Constr
 - dataTypeOf :: a -> DataType
 - dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c a)
 - dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a)
 - gmapT :: (forall b. Data b => b -> b) -> a -> a
 - gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r
 - gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r
 - gmapQ :: (forall d. Data d => d -> u) -> a -> [u]
 - gmapQi :: Int -> (forall d. Data d => d -> u) -> a -> u
 - gmapM :: Monad m => (forall d. Data d => d -> m d) -> a -> m a
 - gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> a -> m a
 - gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> a -> m a
 
 - mkNoRepType :: String -> DataType
 - data DataType
 - class Typeable (a :: k)
 - class Semigroup a => Monoid a where
 - class Semigroup a where
 - class (Typeable e, Show e) => Exception e
 - throw :: forall (r :: RuntimeRep) (a :: TYPE r) e. Exception e => e -> a
 - throwIO :: Exception e => e -> IO a
 - data Ptr a = Ptr Addr#
 - ifThenElse :: Bool -> a -> a -> a
 
Documentation
($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b infixr 0 Source #
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 ,
 or map ($ 0) xs.zipWith ($) fs xs
Note that ( is levity-polymorphic in its result type, so that
 $)foo  where $ Truefoo :: Bool -> Int# is well-typed.
($!) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b infixr 0 Source #
Strict (call-by-value) application operator. It takes a function and an argument, evaluates the argument to weak head normal form (WHNF), then calls the function with that value.
(.) :: forall (b :: k) (c :: k) (a :: k). Category cat => cat b c -> cat a b -> cat a c infixr 9 Source #
morphism composition
(<$>) :: Functor f => (a -> b) -> f a -> f b infixl 4 Source #
An infix synonym for fmap.
The name of this operator is an allusion to $.
 Note the similarities between their types:
($) :: (a -> b) -> a -> b (<$>) :: Functor f => (a -> b) -> f a -> f b
Whereas $ is function application, <$> is function
 application lifted over a Functor.
Examples
Convert from a  to a Maybe Int using Maybe
 Stringshow:
>>>show <$> NothingNothing>>>show <$> Just 3Just "3"
Convert from an  to an
 Either Int IntEither IntString using show:
>>>show <$> Left 17Left 17>>>show <$> Right 17Right "17"
Double each element of a list:
>>>(*2) <$> [1,2,3][2,4,6]
Apply even to the second element of a pair:
>>>even <$> (2,2)(2,True)
maybe :: b -> (a -> b) -> Maybe a -> b Source #
The maybe function takes a default value, a function, and a Maybe
 value.  If the Maybe value is Nothing, the function returns the
 default value.  Otherwise, it applies the function to the value inside
 the Just and returns the result.
Examples
Basic usage:
>>>maybe False odd (Just 3)True
>>>maybe False odd NothingFalse
Read an integer from a string using readMaybe. If we succeed,
 return twice the integer; that is, apply (*2) to it. If instead
 we fail to parse an integer, return 0 by default:
>>>import Text.Read ( readMaybe )>>>maybe 0 (*2) (readMaybe "5")10>>>maybe 0 (*2) (readMaybe "")0
Apply show to a Maybe Int. If we have Just n, we want to show
 the underlying Int n. But if we have Nothing, we return the
 empty string instead of (for example) "Nothing":
>>>maybe "" show (Just 5)"5">>>maybe "" show Nothing""
either :: (a -> c) -> (b -> c) -> Either a b -> c Source #
Case analysis for the Either type.
 If the value is , apply the first function to Left aa;
 if it is , apply the second function to Right bb.
Examples
We create two values of type , one using the
 Either String IntLeft constructor and another using the Right constructor. Then
 we apply "either" the length function (if we have a String)
 or the "times-two" function (if we have an Int):
>>>let s = Left "foo" :: Either String Int>>>let n = Right 3 :: Either String Int>>>either length (*2) s3>>>either length (*2) n6
flip :: (a -> b -> c) -> b -> a -> c Source #
 takes its (first) two arguments in the reverse order of flip ff.
>>>flip (++) "hello" "world""worldhello"
const x is a unary function which evaluates to x for all inputs.
>>>const 42 "hello"42
>>>map (const 42) [0..3][42,42,42,42]
error :: forall (r :: RuntimeRep). forall (a :: TYPE r). HasCallStack => String -> a Source #
stop execution and displays an error message
and :: Foldable t => t Bool -> Bool Source #
and returns the conjunction of a container of Bools.  For the
 result to be True, the container must be finite; False, however,
 results from a False value finitely far from the left end.
Examples
Basic usage:
>>>and []True
>>>and [True]True
>>>and [False]False
>>>and [True, True, False]False
>>>and (False : repeat True) -- Infinite list [False,True,True,True,...False
>>>and (repeat True)* Hangs forever *
undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a Source #
seq :: forall {r :: RuntimeRep} a (b :: TYPE r). a -> b -> b infixr 0 Source #
The value of seq a b is bottom if a is bottom, and
      otherwise equal to b. In other words, it evaluates the first
      argument a to weak head normal form (WHNF). seq is usually
      introduced to improve performance by avoiding unneeded laziness.
A note on evaluation order: the expression seq a b does
      not guarantee that a will be evaluated before b.
      The only guarantee given by seq is that the both a
      and b will be evaluated before seq returns a value.
      In particular, this means that b may be evaluated before
      a. If you need to guarantee a specific order of evaluation,
      you must use the function pseq from the "parallel" package. 
Conversion of values to readable Strings.
Derived instances of Show have the following properties, which
 are compatible with derived instances of Read:
- The result of 
showis a syntactically correct Haskell expression containing only constants, given the fixity declarations in force at the point where the type is declared. It contains only the constructor names defined in the data type, parentheses, and spaces. When labelled constructor fields are used, braces, commas, field names, and equal signs are also used. - If the constructor is defined to be an infix operator, then
   
showsPrecwill produce infix applications of the constructor. - the representation will be enclosed in parentheses if the
   precedence of the top-level constructor in 
xis less thand(associativity is ignored). Thus, ifdis0then the result is never surrounded in parentheses; ifdis11it is always surrounded in parentheses, unless it is an atomic expression. - If the constructor is defined using record syntax, then 
showwill produce the record-syntax form, with the fields given in the same order as the original declaration. 
For example, given the declarations
infixr 5 :^: data Tree a = Leaf a | Tree a :^: Tree a
the derived instance of Show is equivalent to
instance (Show a) => Show (Tree a) where
       showsPrec d (Leaf m) = showParen (d > app_prec) $
            showString "Leaf " . showsPrec (app_prec+1) m
         where app_prec = 10
       showsPrec d (u :^: v) = showParen (d > up_prec) $
            showsPrec (up_prec+1) u .
            showString " :^: "      .
            showsPrec (up_prec+1) v
         where up_prec = 5Note that right-associativity of :^: is ignored.  For example,
produces the stringshow(Leaf 1 :^: Leaf 2 :^: Leaf 3)"Leaf 1 :^: (Leaf 2 :^: Leaf 3)".
Instances
| Show Constr | Since: base-4.0.0.0  | 
| Show ConstrRep | Since: base-4.0.0.0  | 
| Show DataRep | Since: base-4.0.0.0  | 
| Show DataType | Since: base-4.0.0.0  | 
| Show Fixity | Since: base-4.0.0.0  | 
| Show All | Since: base-2.1  | 
| Show Any | Since: base-2.1  | 
| Show SomeTypeRep | Since: base-4.10.0.0  | 
Defined in Data.Typeable.Internal  | |
| Show Version | Since: base-2.1  | 
| Show CBool | |
| Show CChar | |
| Show CClock | |
| Show CDouble | |
| Show CFloat | |
| Show CInt | |
| Show CIntMax | |
| Show CIntPtr | |
| Show CLLong | |
| Show CLong | |
| Show CPtrdiff | |
| Show CSChar | |
| Show CSUSeconds | |
Defined in Foreign.C.Types  | |
| Show CShort | |
| Show CSigAtomic | |
Defined in Foreign.C.Types  | |
| Show CSize | |
| Show CTime | |
| Show CUChar | |
| Show CUInt | |
| Show CUIntMax | |
| Show CUIntPtr | |
| Show CULLong | |
| Show CULong | |
| Show CUSeconds | |
| Show CUShort | |
| Show CWchar | |
| Show IntPtr | |
| Show WordPtr | |
| Show ErrorCall | Since: base-4.0.0.0  | 
| Show ArithException | Since: base-4.0.0.0  | 
Defined in GHC.Exception.Type  | |
| Show SomeException | Since: base-3.0  | 
Defined in GHC.Exception.Type  | |
| Show Associativity | Since: base-4.6.0.0  | 
Defined in GHC.Generics  | |
| Show DecidedStrictness | Since: base-4.9.0.0  | 
Defined in GHC.Generics  | |
| Show Fixity | Since: base-4.6.0.0  | 
| Show SourceStrictness | Since: base-4.9.0.0  | 
Defined in GHC.Generics  | |
| Show SourceUnpackedness | Since: base-4.9.0.0  | 
Defined in GHC.Generics  | |
| Show MaskingState | Since: base-4.3.0.0  | 
| Show AllocationLimitExceeded | Since: base-4.7.1.0  | 
Defined in GHC.IO.Exception  | |
| Show ArrayException | Since: base-4.1.0.0  | 
Defined in GHC.IO.Exception  | |
| Show AssertionFailed | Since: base-4.1.0.0  | 
Defined in GHC.IO.Exception  | |
| Show AsyncException | Since: base-4.1.0.0  | 
Defined in GHC.IO.Exception  | |
| Show BlockedIndefinitelyOnMVar | Since: base-4.1.0.0  | 
Defined in GHC.IO.Exception  | |
| Show BlockedIndefinitelyOnSTM | Since: base-4.1.0.0  | 
Defined in GHC.IO.Exception  | |
| Show CompactionFailed | Since: base-4.10.0.0  | 
Defined in GHC.IO.Exception  | |
| Show Deadlock | Since: base-4.1.0.0  | 
| Show ExitCode | |
| Show FixIOException | Since: base-4.11.0.0  | 
Defined in GHC.IO.Exception  | |
| Show IOErrorType | Since: base-4.1.0.0  | 
Defined in GHC.IO.Exception  | |
| Show IOException | Since: base-4.1.0.0  | 
Defined in GHC.IO.Exception  | |
| Show SomeAsyncException | Since: base-4.7.0.0  | 
Defined in GHC.IO.Exception  | |
| Show Int16 | Since: base-2.1  | 
| Show Int32 | Since: base-2.1  | 
| Show Int64 | Since: base-2.1  | 
| Show Int8 | Since: base-2.1  | 
| Show CCFlags | Since: base-4.8.0.0  | 
| Show ConcFlags | Since: base-4.8.0.0  | 
| Show DebugFlags | Since: base-4.8.0.0  | 
Defined in GHC.RTS.Flags  | |
| Show DoCostCentres | Since: base-4.8.0.0  | 
Defined in GHC.RTS.Flags  | |
| Show DoHeapProfile | Since: base-4.8.0.0  | 
Defined in GHC.RTS.Flags  | |
| Show DoTrace | Since: base-4.8.0.0  | 
| Show GCFlags | Since: base-4.8.0.0  | 
| Show GiveGCStats | Since: base-4.8.0.0  | 
Defined in GHC.RTS.Flags  | |
| Show IoSubSystem | |
Defined in GHC.RTS.Flags  | |
| Show MiscFlags | Since: base-4.8.0.0  | 
| Show ParFlags | Since: base-4.8.0.0  | 
| Show ProfFlags | Since: base-4.8.0.0  | 
| Show RTSFlags | Since: base-4.8.0.0  | 
| Show TickyFlags | Since: base-4.8.0.0  | 
Defined in GHC.RTS.Flags  | |
| Show TraceFlags | Since: base-4.8.0.0  | 
Defined in GHC.RTS.Flags  | |
| Show FractionalExponentBase | |
| Show CallStack | Since: base-4.9.0.0  | 
| Show SrcLoc | Since: base-4.9.0.0  | 
| Show SomeChar | |
| Show SomeSymbol | Since: base-4.7.0.0  | 
Defined in GHC.TypeLits  | |
| Show SomeNat | Since: base-4.7.0.0  | 
| Show GeneralCategory | Since: base-2.1  | 
Defined in GHC.Unicode  | |
| Show Word16 | Since: base-2.1  | 
| Show Word32 | Since: base-2.1  | 
| Show Word64 | Since: base-2.1  | 
| Show Word8 | Since: base-2.1  | 
| Show CBlkCnt | |
| Show CBlkSize | |
| Show CCc | |
| Show CClockId | |
| Show CDev | |
| Show CFsBlkCnt | |
| Show CFsFilCnt | |
| Show CGid | |
| Show CId | |
| Show CIno | |
| Show CKey | |
| Show CMode | |
| Show CNfds | |
| Show CNlink | |
| Show COff | |
| Show CPid | |
| Show CRLim | |
| Show CSocklen | |
| Show CSpeed | |
| Show CSsize | |
| Show CTcflag | |
| Show CTimer | |
| Show CUid | |
| Show Fd | |
| Show Endianness Source # | |
Defined in Basement.Endianness  | |
| Show InvalidRecast Source # | |
Defined in Basement.Exception  | |
| Show NonEmptyCollectionIsEmpty Source # | |
Defined in Basement.Exception  | |
| Show OutOfBound Source # | |
Defined in Basement.Exception  | |
| Show OutOfBoundOperation Source # | |
Defined in Basement.Exception  | |
| Show RecastDestinationSize Source # | |
Defined in Basement.Exception  | |
| Show RecastSourceSize Source # | |
Defined in Basement.Exception  | |
| Show Encoding Source # | |
| Show AsciiString Source # | |
Defined in Basement.Types.AsciiString  | |
| Show Char7 Source # | |
| Show FileSize Source # | |
| Show Word128 Source # | |
| Show Word256 Source # | |
| Show String Source # | |
| Show ValidationFailure Source # | |
Defined in Basement.UTF8.Types  | |
| Show KindRep | |
| Show Module | Since: base-4.9.0.0  | 
| Show Ordering | Since: base-2.1  | 
| Show TrName | Since: base-4.9.0.0  | 
| Show TyCon | Since: base-2.1  | 
| Show TypeLitSort | Since: base-4.11.0.0  | 
| Show Integer | Since: base-2.1  | 
| Show Natural | Since: base-4.8.0.0  | 
| Show () | Since: base-2.1  | 
| Show Bool | Since: base-2.1  | 
| Show Char | Since: base-2.1  | 
| Show Int | Since: base-2.1  | 
| Show Levity | Since: base-4.15.0.0  | 
| Show RuntimeRep | Since: base-4.11.0.0  | 
| Show VecCount | Since: base-4.11.0.0  | 
| Show VecElem | Since: base-4.11.0.0  | 
| Show Word | Since: base-2.1  | 
| Show a => Show (ZipList a) | Since: base-4.7.0.0  | 
| Show a => Show (And a) | Since: base-4.16  | 
| Show a => Show (Iff a) | Since: base-4.16  | 
| Show a => Show (Ior a) | Since: base-4.16  | 
| Show a => Show (Xor a) | Since: base-4.16  | 
| Show a => Show (Identity a) | This instance would be equivalent to the derived instances of the
  Since: base-4.8.0.0  | 
| Show a => Show (First a) | Since: base-2.1  | 
| Show a => Show (Last a) | Since: base-2.1  | 
| Show a => Show (Down a) | This instance would be equivalent to the derived instances of the
  Since: base-4.7.0.0  | 
| Show a => Show (First a) | Since: base-4.9.0.0  | 
| Show a => Show (Last a) | Since: base-4.9.0.0  | 
| Show a => Show (Max a) | Since: base-4.9.0.0  | 
| Show a => Show (Min a) | Since: base-4.9.0.0  | 
| Show m => Show (WrappedMonoid m) | Since: base-4.9.0.0  | 
Defined in Data.Semigroup  | |
| Show a => Show (Dual a) | Since: base-2.1  | 
| Show a => Show (Product a) | Since: base-2.1  | 
| Show a => Show (Sum a) | Since: base-2.1  | 
| Show (ForeignPtr a) | Since: base-2.1  | 
Defined in GHC.ForeignPtr  | |
| Show p => Show (Par1 p) | Since: base-4.7.0.0  | 
| Show (FunPtr a) | Since: base-2.1  | 
| Show (Ptr a) | Since: base-2.1  | 
| Show a => Show (Ratio a) | Since: base-2.0.1  | 
| Show (Bits n) Source # | |
| (PrimType ty, Show ty) => Show (Block ty) Source # | |
| Show (Zn n) Source # | |
| Show (Zn64 n) Source # | |
| Show a => Show (Array a) Source # | |
| Show a => Show (BE a) Source # | |
| Show a => Show (LE a) Source # | |
| Show (FinalPtr a) Source # | |
| Show a => Show (NonEmpty a) Source # | |
| Show (CountOf ty) Source # | |
| Show (Offset ty) Source # | |
| (PrimType ty, Show ty) => Show (UArray ty) Source # | |
| Show a => Show (NonEmpty a) | Since: base-4.11.0.0  | 
| Show a => Show (Maybe a) | Since: base-2.1  | 
| Show a => Show (a) | Since: base-4.15  | 
| Show a => Show [a] | Since: base-2.1  | 
| (Show a, Show b) => Show (Either a b) | Since: base-3.0  | 
| Show (Proxy s) | Since: base-4.7.0.0  | 
| (Show a, Show b) => Show (Arg a b) | Since: base-4.9.0.0  | 
| Show (TypeRep a) | |
| (Ix a, Show a, Show b) => Show (Array a b) | Since: base-2.1  | 
| Show (U1 p) | Since: base-4.9.0.0  | 
| Show (V1 p) | Since: base-4.9.0.0  | 
| Show (ST s a) | Since: base-2.1  | 
| (PrimType a, Show a) => Show (BlockN n a) Source # | |
| Show a => Show (ListN n a) Source # | |
| (PrimType a, Show a) => Show (UVect n a) Source # | |
| Show a => Show (Vect n a) Source # | |
| (Show a, Show b) => Show (These a b) Source # | |
| (Show a, Show b) => Show (a, b) | Since: base-2.1  | 
| Show a => Show (Const a b) | This instance would be equivalent to the derived instances of the
  Since: base-4.8.0.0  | 
| Show (f a) => Show (Ap f a) | Since: base-4.12.0.0  | 
| Show (f a) => Show (Alt f a) | Since: base-4.8.0.0  | 
| Show (Coercion a b) | Since: base-4.7.0.0  | 
| Show (a :~: b) | Since: base-4.7.0.0  | 
| Show (OrderingI a b) | |
| Show (f p) => Show (Rec1 f p) | Since: base-4.7.0.0  | 
| Show (URec Char p) | Since: base-4.9.0.0  | 
| Show (URec Double p) | Since: base-4.9.0.0  | 
| Show (URec Float p) | |
| Show (URec Int p) | Since: base-4.9.0.0  | 
| Show (URec Word p) | Since: base-4.9.0.0  | 
| (Show a, Show b, Show c) => Show (a, b, c) | Since: base-2.1  | 
| Show (a :~~: b) | Since: base-4.10.0.0  | 
| (Show (f p), Show (g p)) => Show ((f :*: g) p) | Since: base-4.7.0.0  | 
| (Show (f p), Show (g p)) => Show ((f :+: g) p) | Since: base-4.7.0.0  | 
| Show c => Show (K1 i c p) | Since: base-4.7.0.0  | 
| (Show a, Show b, Show c, Show d) => Show (a, b, c, d) | Since: base-2.1  | 
| Show (f (g p)) => Show ((f :.: g) p) | Since: base-4.7.0.0  | 
| Show (f p) => Show (M1 i c f p) | Since: base-4.7.0.0  | 
| (Show a, Show b, Show c, Show d, Show e) => Show (a, b, c, d, e) | Since: base-2.1  | 
| (Show a, Show b, Show c, Show d, Show e, Show f) => Show (a, b, c, d, e, f) | Since: base-2.1  | 
| (Show a, Show b, Show c, Show d, Show e, Show f, Show g) => Show (a, b, c, d, e, f, g) | Since: base-2.1  | 
| (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) | Since: base-2.1  | 
| (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) | Since: base-2.1  | 
| (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) | Since: base-2.1  | 
| (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) | Since: base-2.1  | 
| (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) | Since: base-2.1  | 
| (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) | Since: base-2.1  | 
| (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) | Since: base-2.1  | 
| (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) | Since: base-2.1  | 
show :: Show a => a -> String Source #
Use the Show class to create a String.
Note that this is not efficient, since an intermediate [Char] is going to be created before turning into a real String.
class Eq a => Ord a where Source #
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.
Ord, as defined by the Haskell report, implements a total order and has the
 following properties:
- Comparability
 x <= y || y <= x=True- Transitivity
 - if 
x <= y && y <= z=True, thenx <= z=True - Reflexivity
 x <= x=True- Antisymmetry
 - if 
x <= y && y <= x=True, thenx == y=True 
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.
Methods
compare :: a -> a -> Ordering Source #
(<) :: a -> a -> Bool infix 4 Source #
(<=) :: a -> a -> Bool infix 4 Source #
(>) :: a -> a -> Bool infix 4 Source #
Instances
| Ord All | Since: base-2.1  | 
| Ord Any | Since: base-2.1  | 
| Ord SomeTypeRep | |
Defined in Data.Typeable.Internal Methods compare :: SomeTypeRep -> SomeTypeRep -> Ordering Source # (<) :: SomeTypeRep -> SomeTypeRep -> Bool Source # (<=) :: SomeTypeRep -> SomeTypeRep -> Bool Source # (>) :: SomeTypeRep -> SomeTypeRep -> Bool Source # (>=) :: SomeTypeRep -> SomeTypeRep -> Bool Source # max :: SomeTypeRep -> SomeTypeRep -> SomeTypeRep Source # min :: SomeTypeRep -> SomeTypeRep -> SomeTypeRep Source #  | |
| Ord Version | Since: base-2.1  | 
| Ord CBool | |
Defined in Foreign.C.Types  | |
| Ord CChar | |
Defined in Foreign.C.Types  | |
| Ord CClock | |
| Ord CDouble | |
| Ord CFloat | |
| Ord CInt | |
| Ord CIntMax | |
| Ord CIntPtr | |
| Ord CLLong | |
| Ord CLong | |
Defined in Foreign.C.Types  | |
| Ord CPtrdiff | |
Defined in Foreign.C.Types  | |
| Ord CSChar | |
| Ord CSUSeconds | |
Defined in Foreign.C.Types Methods compare :: CSUSeconds -> CSUSeconds -> Ordering Source # (<) :: CSUSeconds -> CSUSeconds -> Bool Source # (<=) :: CSUSeconds -> CSUSeconds -> Bool Source # (>) :: CSUSeconds -> CSUSeconds -> Bool Source # (>=) :: CSUSeconds -> CSUSeconds -> Bool Source # max :: CSUSeconds -> CSUSeconds -> CSUSeconds Source # min :: CSUSeconds -> CSUSeconds -> CSUSeconds Source #  | |
| Ord CShort | |
| Ord CSigAtomic | |
Defined in Foreign.C.Types Methods compare :: CSigAtomic -> CSigAtomic -> Ordering Source # (<) :: CSigAtomic -> CSigAtomic -> Bool Source # (<=) :: CSigAtomic -> CSigAtomic -> Bool Source # (>) :: CSigAtomic -> CSigAtomic -> Bool Source # (>=) :: CSigAtomic -> CSigAtomic -> Bool Source # max :: CSigAtomic -> CSigAtomic -> CSigAtomic Source # min :: CSigAtomic -> CSigAtomic -> CSigAtomic Source #  | |
| Ord CSize | |
Defined in Foreign.C.Types  | |
| Ord CTime | |
Defined in Foreign.C.Types  | |
| Ord CUChar | |
| Ord CUInt | |
Defined in Foreign.C.Types  | |
| Ord CUIntMax | |
Defined in Foreign.C.Types  | |
| Ord CUIntPtr | |
Defined in Foreign.C.Types  | |
| Ord CULLong | |
| Ord CULong | |
| Ord CUSeconds | |
Defined in Foreign.C.Types  | |
| Ord CUShort | |
| Ord CWchar | |
| Ord IntPtr | |
| Ord WordPtr | |
| Ord ErrorCall | Since: base-4.7.0.0  | 
Defined in GHC.Exception  | |
| Ord ArithException | Since: base-3.0  | 
Defined in GHC.Exception.Type Methods compare :: ArithException -> ArithException -> Ordering Source # (<) :: ArithException -> ArithException -> Bool Source # (<=) :: ArithException -> ArithException -> Bool Source # (>) :: ArithException -> ArithException -> Bool Source # (>=) :: ArithException -> ArithException -> Bool Source # max :: ArithException -> ArithException -> ArithException Source # min :: ArithException -> ArithException -> ArithException Source #  | |
| Ord Associativity | Since: base-4.6.0.0  | 
Defined in GHC.Generics Methods compare :: Associativity -> Associativity -> Ordering Source # (<) :: Associativity -> Associativity -> Bool Source # (<=) :: Associativity -> Associativity -> Bool Source # (>) :: Associativity -> Associativity -> Bool Source # (>=) :: Associativity -> Associativity -> Bool Source # max :: Associativity -> Associativity -> Associativity Source # min :: Associativity -> Associativity -> Associativity Source #  | |
| Ord DecidedStrictness | Since: base-4.9.0.0  | 
Defined in GHC.Generics Methods compare :: DecidedStrictness -> DecidedStrictness -> Ordering Source # (<) :: DecidedStrictness -> DecidedStrictness -> Bool Source # (<=) :: DecidedStrictness -> DecidedStrictness -> Bool Source # (>) :: DecidedStrictness -> DecidedStrictness -> Bool Source # (>=) :: DecidedStrictness -> DecidedStrictness -> Bool Source # max :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness Source # min :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness Source #  | |
| Ord Fixity | Since: base-4.6.0.0  | 
| Ord SourceStrictness | Since: base-4.9.0.0  | 
Defined in GHC.Generics Methods compare :: SourceStrictness -> SourceStrictness -> Ordering Source # (<) :: SourceStrictness -> SourceStrictness -> Bool Source # (<=) :: SourceStrictness -> SourceStrictness -> Bool Source # (>) :: SourceStrictness -> SourceStrictness -> Bool Source # (>=) :: SourceStrictness -> SourceStrictness -> Bool Source # max :: SourceStrictness -> SourceStrictness -> SourceStrictness Source # min :: SourceStrictness -> SourceStrictness -> SourceStrictness Source #  | |
| Ord SourceUnpackedness | Since: base-4.9.0.0  | 
Defined in GHC.Generics Methods compare :: SourceUnpackedness -> SourceUnpackedness -> Ordering Source # (<) :: SourceUnpackedness -> SourceUnpackedness -> Bool Source # (<=) :: SourceUnpackedness -> SourceUnpackedness -> Bool Source # (>) :: SourceUnpackedness -> SourceUnpackedness -> Bool Source # (>=) :: SourceUnpackedness -> SourceUnpackedness -> Bool Source # max :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness Source # min :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness Source #  | |
| Ord ArrayException | Since: base-4.2.0.0  | 
Defined in GHC.IO.Exception Methods compare :: ArrayException -> ArrayException -> Ordering Source # (<) :: ArrayException -> ArrayException -> Bool Source # (<=) :: ArrayException -> ArrayException -> Bool Source # (>) :: ArrayException -> ArrayException -> Bool Source # (>=) :: ArrayException -> ArrayException -> Bool Source # max :: ArrayException -> ArrayException -> ArrayException Source # min :: ArrayException -> ArrayException -> ArrayException Source #  | |
| Ord AsyncException | Since: base-4.2.0.0  | 
Defined in GHC.IO.Exception Methods compare :: AsyncException -> AsyncException -> Ordering Source # (<) :: AsyncException -> AsyncException -> Bool Source # (<=) :: AsyncException -> AsyncException -> Bool Source # (>) :: AsyncException -> AsyncException -> Bool Source # (>=) :: AsyncException -> AsyncException -> Bool Source # max :: AsyncException -> AsyncException -> AsyncException Source # min :: AsyncException -> AsyncException -> AsyncException Source #  | |
| Ord ExitCode | |
Defined in GHC.IO.Exception  | |
| Ord Int16 | Since: base-2.1  | 
Defined in GHC.Int  | |
| Ord Int32 | Since: base-2.1  | 
Defined in GHC.Int  | |
| Ord Int64 | Since: base-2.1  | 
Defined in GHC.Int  | |
| Ord Int8 | Since: base-2.1  | 
| Ord SomeChar | |
Defined in GHC.TypeLits  | |
| Ord SomeSymbol | Since: base-4.7.0.0  | 
Defined in GHC.TypeLits Methods compare :: SomeSymbol -> SomeSymbol -> Ordering Source # (<) :: SomeSymbol -> SomeSymbol -> Bool Source # (<=) :: SomeSymbol -> SomeSymbol -> Bool Source # (>) :: SomeSymbol -> SomeSymbol -> Bool Source # (>=) :: SomeSymbol -> SomeSymbol -> Bool Source # max :: SomeSymbol -> SomeSymbol -> SomeSymbol Source # min :: SomeSymbol -> SomeSymbol -> SomeSymbol Source #  | |
| Ord SomeNat | Since: base-4.7.0.0  | 
| Ord GeneralCategory | Since: base-2.1  | 
Defined in GHC.Unicode Methods compare :: GeneralCategory -> GeneralCategory -> Ordering Source # (<) :: GeneralCategory -> GeneralCategory -> Bool Source # (<=) :: GeneralCategory -> GeneralCategory -> Bool Source # (>) :: GeneralCategory -> GeneralCategory -> Bool Source # (>=) :: GeneralCategory -> GeneralCategory -> Bool Source # max :: GeneralCategory -> GeneralCategory -> GeneralCategory Source # min :: GeneralCategory -> GeneralCategory -> GeneralCategory Source #  | |
| Ord Word16 | Since: base-2.1  | 
| Ord Word32 | Since: base-2.1  | 
| Ord Word64 | Since: base-2.1  | 
| Ord Word8 | Since: base-2.1  | 
Defined in GHC.Word  | |
| Ord CBlkCnt | |
Defined in System.Posix.Types  | |
| Ord CBlkSize | |
Defined in System.Posix.Types  | |
| Ord CCc | |
| Ord CClockId | |
Defined in System.Posix.Types  | |
| Ord CDev | |
| Ord CFsBlkCnt | |
Defined in System.Posix.Types  | |
| Ord CFsFilCnt | |
Defined in System.Posix.Types  | |
| Ord CGid | |
| Ord CId | |
| Ord CIno | |
| Ord CKey | |
| Ord CMode | |
Defined in System.Posix.Types  | |
| Ord CNfds | |
Defined in System.Posix.Types  | |
| Ord CNlink | |
| Ord COff | |
| Ord CPid | |
| Ord CRLim | |
Defined in System.Posix.Types  | |
| Ord CSocklen | |
Defined in System.Posix.Types  | |
| Ord CSpeed | |
| Ord CSsize | |
| Ord CTcflag | |
Defined in System.Posix.Types  | |
| Ord CTimer | |
| Ord CUid | |
| Ord Fd | |
| Ord Encoding Source # | |
Defined in Basement.String  | |
| Ord AsciiString Source # | |
Defined in Basement.Types.AsciiString Methods compare :: AsciiString -> AsciiString -> Ordering Source # (<) :: AsciiString -> AsciiString -> Bool Source # (<=) :: AsciiString -> AsciiString -> Bool Source # (>) :: AsciiString -> AsciiString -> Bool Source # (>=) :: AsciiString -> AsciiString -> Bool Source # max :: AsciiString -> AsciiString -> AsciiString Source # min :: AsciiString -> AsciiString -> AsciiString Source #  | |
| Ord Char7 Source # | |
Defined in Basement.Types.Char7  | |
| Ord FileSize Source # | |
Defined in Basement.Types.OffsetSize  | |
| Ord Addr Source # | |
| Ord Word128 Source # | |
Defined in Basement.Types.Word128  | |
| Ord Word256 Source # | |
Defined in Basement.Types.Word256  | |
| Ord String Source # | |
| Ord Ordering | |
Defined in GHC.Classes  | |
| Ord TyCon | |
Defined in GHC.Classes  | |
| Ord Integer | |
| Ord Natural | |
| Ord () | |
| 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,  
  | 
Defined in GHC.Classes  | |
| Ord Int | |
| Ord Word | |
| Ord a => Ord (ZipList a) | Since: base-4.7.0.0  | 
Defined in Control.Applicative  | |
| Ord a => Ord (Identity a) | Since: base-4.8.0.0  | 
Defined in Data.Functor.Identity Methods compare :: Identity a -> Identity a -> Ordering Source # (<) :: Identity a -> Identity a -> Bool Source # (<=) :: Identity a -> Identity a -> Bool Source # (>) :: Identity a -> Identity a -> Bool Source # (>=) :: Identity a -> Identity a -> Bool Source #  | |
| Ord a => Ord (First a) | Since: base-2.1  | 
| Ord a => Ord (Last a) | Since: base-2.1  | 
| Ord a => Ord (Down a) | Since: base-4.6.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 a => Ord (Max a) | Since: base-4.9.0.0  | 
Defined in Data.Semigroup  | |
| Ord a => Ord (Min a) | Since: base-4.9.0.0  | 
Defined in Data.Semigroup  | |
| Ord m => Ord (WrappedMonoid m) | Since: base-4.9.0.0  | 
Defined in Data.Semigroup Methods compare :: WrappedMonoid m -> WrappedMonoid m -> Ordering Source # (<) :: WrappedMonoid m -> WrappedMonoid m -> Bool Source # (<=) :: WrappedMonoid m -> WrappedMonoid m -> Bool Source # (>) :: WrappedMonoid m -> WrappedMonoid m -> Bool Source # (>=) :: WrappedMonoid m -> WrappedMonoid m -> Bool Source # max :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m Source # min :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m Source #  | |
| Ord a => Ord (Dual a) | Since: base-2.1  | 
| Ord a => Ord (Product a) | Since: base-2.1  | 
Defined in Data.Semigroup.Internal  | |
| Ord a => Ord (Sum a) | Since: base-2.1  | 
Defined in Data.Semigroup.Internal  | |
| Ord (ForeignPtr a) | Since: base-2.1  | 
Defined in GHC.ForeignPtr Methods compare :: ForeignPtr a -> ForeignPtr a -> Ordering Source # (<) :: ForeignPtr a -> ForeignPtr a -> Bool Source # (<=) :: ForeignPtr a -> ForeignPtr a -> Bool Source # (>) :: ForeignPtr a -> ForeignPtr a -> Bool Source # (>=) :: ForeignPtr a -> ForeignPtr a -> Bool Source # max :: ForeignPtr a -> ForeignPtr a -> ForeignPtr a Source # min :: ForeignPtr a -> ForeignPtr a -> ForeignPtr a Source #  | |
| Ord p => Ord (Par1 p) | Since: base-4.7.0.0  | 
| Ord (FunPtr a) | |
Defined in GHC.Ptr  | |
| Ord (Ptr a) | Since: base-2.1  | 
Defined in GHC.Ptr  | |
| Integral a => Ord (Ratio a) | Since: base-2.0.1  | 
| Ord (Bits n) Source # | |
| (PrimType ty, Ord ty) => Ord (Block ty) Source # | |
Defined in Basement.Block.Base  | |
| Ord (Zn n) Source # | |
| Ord (Zn64 n) Source # | |
| Ord a => Ord (Array a) Source # | |
Defined in Basement.BoxedArray  | |
| (ByteSwap a, Ord a) => Ord (BE a) Source # | |
Defined in Basement.Endianness  | |
| (ByteSwap a, Ord a) => Ord (LE a) Source # | |
Defined in Basement.Endianness  | |
| Ord (FinalPtr a) Source # | |
Defined in Basement.FinalPtr Methods compare :: FinalPtr a -> FinalPtr a -> Ordering Source # (<) :: FinalPtr a -> FinalPtr a -> Bool Source # (<=) :: FinalPtr a -> FinalPtr a -> Bool Source # (>) :: FinalPtr a -> FinalPtr a -> Bool Source # (>=) :: FinalPtr a -> FinalPtr a -> Bool Source #  | |
| Ord (CountOf ty) Source # | |
Defined in Basement.Types.OffsetSize Methods compare :: CountOf ty -> CountOf ty -> Ordering Source # (<) :: CountOf ty -> CountOf ty -> Bool Source # (<=) :: CountOf ty -> CountOf ty -> Bool Source # (>) :: CountOf ty -> CountOf ty -> Bool Source # (>=) :: CountOf ty -> CountOf ty -> Bool Source #  | |
| Ord (Offset ty) Source # | |
Defined in Basement.Types.OffsetSize  | |
| (PrimType ty, Ord ty) => Ord (UArray ty) Source # | |
Defined in Basement.UArray.Base  | |
| Ord a => Ord (NonEmpty a) | Since: base-4.9.0.0  | 
Defined in GHC.Base Methods compare :: NonEmpty a -> NonEmpty a -> Ordering Source # (<) :: NonEmpty a -> NonEmpty a -> Bool Source # (<=) :: NonEmpty a -> NonEmpty a -> Bool Source # (>) :: NonEmpty a -> NonEmpty a -> Bool Source # (>=) :: NonEmpty a -> NonEmpty a -> Bool Source #  | |
| Ord a => Ord (Maybe a) | Since: base-2.1  | 
| Ord a => Ord (a) | |
| Ord a => Ord [a] | |
| (Ord a, Ord b) => Ord (Either a b) | Since: base-2.1  | 
Defined in Data.Either Methods compare :: Either a b -> Either a b -> Ordering Source # (<) :: Either a b -> Either a b -> Bool Source # (<=) :: Either a b -> Either a b -> Bool Source # (>) :: Either a b -> Either a b -> Bool Source # (>=) :: Either a b -> Either a b -> Bool Source #  | |
| Ord (Proxy s) | Since: base-4.7.0.0  | 
| Ord a => Ord (Arg a b) | Since: base-4.9.0.0  | 
| Ord (TypeRep a) | Since: base-4.4.0.0  | 
Defined in Data.Typeable.Internal  | |
| (Ix i, Ord e) => Ord (Array i e) | Since: base-2.1  | 
Defined in GHC.Arr  | |
| Ord (U1 p) | Since: base-4.7.0.0  | 
| Ord (V1 p) | Since: base-4.9.0.0  | 
| (PrimType a, Ord a) => Ord (BlockN n a) Source # | |
Defined in Basement.Sized.Block Methods compare :: BlockN n a -> BlockN n a -> Ordering Source # (<) :: BlockN n a -> BlockN n a -> Bool Source # (<=) :: BlockN n a -> BlockN n a -> Bool Source # (>) :: BlockN n a -> BlockN n a -> Bool Source # (>=) :: BlockN n a -> BlockN n a -> Bool Source #  | |
| Ord a => Ord (ListN n a) Source # | |
Defined in Basement.Sized.List  | |
| (Ord a, Ord b) => Ord (These a b) Source # | |
Defined in Basement.These  | |
| (Ord a, Ord b) => Ord (a, b) | |
| Ord a => Ord (Const a b) | Since: base-4.9.0.0  | 
Defined in Data.Functor.Const  | |
| 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 (Coercion a b) | Since: base-4.7.0.0  | 
Defined in Data.Type.Coercion Methods compare :: Coercion a b -> Coercion a b -> Ordering Source # (<) :: Coercion a b -> Coercion a b -> Bool Source # (<=) :: Coercion a b -> Coercion a b -> Bool Source # (>) :: Coercion a b -> Coercion a b -> Bool Source # (>=) :: Coercion a b -> Coercion a b -> Bool Source # max :: Coercion a b -> Coercion a b -> Coercion a b Source # min :: Coercion a b -> Coercion a b -> Coercion a b Source #  | |
| Ord (a :~: b) | Since: base-4.7.0.0  | 
Defined in Data.Type.Equality  | |
| 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 Source # (<) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source # (<=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source # (>) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source # (>=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source # max :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p Source # min :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p Source #  | |
| Ord (URec Char p) | Since: base-4.9.0.0  | 
Defined in GHC.Generics Methods compare :: URec Char p -> URec Char p -> Ordering Source # (<) :: URec Char p -> URec Char p -> Bool Source # (<=) :: URec Char p -> URec Char p -> Bool Source # (>) :: URec Char p -> URec Char p -> Bool Source # (>=) :: URec Char p -> URec Char p -> Bool Source #  | |
| Ord (URec Double p) | Since: base-4.9.0.0  | 
Defined in GHC.Generics Methods compare :: URec Double p -> URec Double p -> Ordering Source # (<) :: URec Double p -> URec Double p -> Bool Source # (<=) :: URec Double p -> URec Double p -> Bool Source # (>) :: URec Double p -> URec Double p -> Bool Source # (>=) :: URec Double p -> URec Double p -> Bool Source # max :: URec Double p -> URec Double p -> URec Double p Source # min :: URec Double p -> URec Double p -> URec Double p Source #  | |
| Ord (URec Float p) | |
Defined in GHC.Generics Methods compare :: URec Float p -> URec Float p -> Ordering Source # (<) :: URec Float p -> URec Float p -> Bool Source # (<=) :: URec Float p -> URec Float p -> Bool Source # (>) :: URec Float p -> URec Float p -> Bool Source # (>=) :: URec Float p -> URec Float p -> Bool Source # max :: URec Float p -> URec Float p -> URec Float p Source # min :: URec Float p -> URec Float p -> URec Float p Source #  | |
| Ord (URec Int p) | Since: base-4.9.0.0  | 
Defined in GHC.Generics Methods compare :: URec Int p -> URec Int p -> Ordering Source # (<) :: URec Int p -> URec Int p -> Bool Source # (<=) :: URec Int p -> URec Int p -> Bool Source # (>) :: URec Int p -> URec Int p -> Bool Source # (>=) :: URec Int p -> URec Int p -> Bool Source #  | |
| Ord (URec Word p) | Since: base-4.9.0.0  | 
Defined in GHC.Generics Methods compare :: URec Word p -> URec Word p -> Ordering Source # (<) :: URec Word p -> URec Word p -> Bool Source # (<=) :: URec Word p -> URec Word p -> Bool Source # (>) :: URec Word p -> URec Word p -> Bool Source # (>=) :: URec Word p -> URec Word p -> Bool Source #  | |
| (Ord a, Ord b, Ord c) => Ord (a, b, c) | |
Defined in GHC.Classes  | |
| Ord (a :~~: b) | Since: base-4.10.0.0  | 
Defined in Data.Type.Equality Methods compare :: (a :~~: b) -> (a :~~: b) -> Ordering Source # (<) :: (a :~~: b) -> (a :~~: b) -> Bool Source # (<=) :: (a :~~: b) -> (a :~~: b) -> Bool Source # (>) :: (a :~~: b) -> (a :~~: b) -> Bool Source # (>=) :: (a :~~: b) -> (a :~~: b) -> Bool Source #  | |
| (Ord (f p), Ord (g p)) => Ord ((f :*: g) p) | Since: base-4.7.0.0  | 
Defined in GHC.Generics Methods compare :: (f :*: g) p -> (f :*: g) p -> Ordering Source # (<) :: (f :*: g) p -> (f :*: g) p -> Bool Source # (<=) :: (f :*: g) p -> (f :*: g) p -> Bool Source # (>) :: (f :*: g) p -> (f :*: g) p -> Bool Source # (>=) :: (f :*: g) p -> (f :*: g) p -> Bool Source #  | |
| (Ord (f p), Ord (g p)) => Ord ((f :+: g) p) | Since: base-4.7.0.0  | 
Defined in GHC.Generics Methods compare :: (f :+: g) p -> (f :+: g) p -> Ordering Source # (<) :: (f :+: g) p -> (f :+: g) p -> Bool Source # (<=) :: (f :+: g) p -> (f :+: g) p -> Bool Source # (>) :: (f :+: g) p -> (f :+: g) p -> Bool Source # (>=) :: (f :+: g) p -> (f :+: g) p -> Bool Source #  | |
| Ord c => Ord (K1 i c 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 Methods compare :: (a, b, c, d) -> (a, b, c, d) -> Ordering Source # (<) :: (a, b, c, d) -> (a, b, c, d) -> Bool Source # (<=) :: (a, b, c, d) -> (a, b, c, d) -> Bool Source # (>) :: (a, b, c, d) -> (a, b, c, d) -> Bool Source # (>=) :: (a, b, c, d) -> (a, b, c, d) -> Bool Source # max :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) Source # min :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) Source #  | |
| Ord (f (g p)) => Ord ((f :.: g) p) | Since: base-4.7.0.0  | 
Defined in GHC.Generics Methods compare :: (f :.: g) p -> (f :.: g) p -> Ordering Source # (<) :: (f :.: g) p -> (f :.: g) p -> Bool Source # (<=) :: (f :.: g) p -> (f :.: g) p -> Bool Source # (>) :: (f :.: g) p -> (f :.: g) p -> Bool Source # (>=) :: (f :.: g) p -> (f :.: g) p -> Bool Source #  | |
| Ord (f p) => Ord (M1 i c f p) | Since: base-4.7.0.0  | 
Defined in GHC.Generics Methods compare :: M1 i c f p -> M1 i c f p -> Ordering Source # (<) :: M1 i c f p -> M1 i c f p -> Bool Source # (<=) :: M1 i c f p -> M1 i c f p -> Bool Source # (>) :: M1 i c f p -> M1 i c f p -> Bool Source # (>=) :: M1 i c f p -> M1 i c f p -> Bool Source #  | |
| (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 Source # (<) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool Source # (<=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool Source # (>) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool Source # (>=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool Source # max :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) Source # min :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) Source #  | |
| (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 Source # (<) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool Source # (<=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool Source # (>) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool Source # (>=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool Source # max :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) Source # min :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) Source #  | |
| (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 Source # (<) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool Source # (<=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool Source # (>) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool Source # (>=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool Source # max :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) Source # min :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) Source #  | |
| (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 Source # (<) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool Source # (<=) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool Source # (>) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool Source # (>=) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool Source # 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) Source # 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) Source #  | |
| (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 Source # (<) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool Source # (<=) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool Source # (>) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool Source # (>=) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool Source # 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) Source # 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) Source #  | |
| (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 Source # (<) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool Source # (<=) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool Source # (>) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool Source # (>=) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool Source # 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) Source # 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) Source #  | |
| (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 Source # (<) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool Source # (<=) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool Source # (>) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool Source # (>=) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool Source # 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) Source # 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) Source #  | |
| (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 Source # (<) :: (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 Source # (<=) :: (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 Source # (>) :: (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 Source # (>=) :: (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 Source # 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) Source # 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) Source #  | |
| (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 Source # (<) :: (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 Source # (<=) :: (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 Source # (>) :: (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 Source # (>=) :: (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 Source # 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) Source # 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) Source #  | |
| (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 Source # (<) :: (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 Source # (<=) :: (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 Source # (>) :: (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 Source # (>=) :: (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 Source # 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) Source # 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) Source #  | |
| (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 Source # (<) :: (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 Source # (<=) :: (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 Source # (>) :: (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 Source # (>=) :: (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 Source # 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) Source # 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) Source #  | |
The Eq class defines equality (==) and inequality (/=).
 All the basic datatypes exported by the Prelude are instances of Eq,
 and Eq may be derived for any datatype whose constituents are also
 instances of Eq.
The Haskell Report defines no laws for Eq. However, instances are
 encouraged to follow these properties:
Instances
| Eq Constr | Equality of constructors Since: base-4.0.0.0  | 
| Eq ConstrRep | Since: base-4.0.0.0  | 
| Eq DataRep | Since: base-4.0.0.0  | 
| Eq Fixity | Since: base-4.0.0.0  | 
| Eq All | Since: base-2.1  | 
| Eq Any | Since: base-2.1  | 
| Eq SomeTypeRep | |
Defined in Data.Typeable.Internal Methods (==) :: SomeTypeRep -> SomeTypeRep -> Bool Source # (/=) :: SomeTypeRep -> SomeTypeRep -> Bool Source #  | |
| Eq Version | Since: base-2.1  | 
| Eq Errno | Since: base-2.1  | 
| Eq CBool | |
| Eq CChar | |
| Eq CClock | |
| Eq CDouble | |
| Eq CFloat | |
| Eq CInt | |
| Eq CIntMax | |
| Eq CIntPtr | |
| Eq CLLong | |
| Eq CLong | |
| Eq CPtrdiff | |
| Eq CSChar | |
| Eq CSUSeconds | |
Defined in Foreign.C.Types Methods (==) :: CSUSeconds -> CSUSeconds -> Bool Source # (/=) :: CSUSeconds -> CSUSeconds -> Bool Source #  | |
| Eq CShort | |
| Eq CSigAtomic | |
Defined in Foreign.C.Types Methods (==) :: CSigAtomic -> CSigAtomic -> Bool Source # (/=) :: CSigAtomic -> CSigAtomic -> Bool Source #  | |
| Eq CSize | |
| Eq CTime | |
| Eq CUChar | |
| Eq CUInt | |
| Eq CUIntMax | |
| Eq CUIntPtr | |
| Eq CULLong | |
| Eq CULong | |
| Eq CUSeconds | |
| Eq CUShort | |
| Eq CWchar | |
| Eq IntPtr | |
| Eq WordPtr | |
| Eq ErrorCall | Since: base-4.7.0.0  | 
| Eq ArithException | Since: base-3.0  | 
Defined in GHC.Exception.Type Methods (==) :: ArithException -> ArithException -> Bool Source # (/=) :: ArithException -> ArithException -> Bool Source #  | |
| Eq SpecConstrAnnotation | Since: base-4.3.0.0  | 
Defined in GHC.Exts Methods (==) :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool Source # (/=) :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool Source #  | |
| Eq Associativity | Since: base-4.6.0.0  | 
Defined in GHC.Generics Methods (==) :: Associativity -> Associativity -> Bool Source # (/=) :: Associativity -> Associativity -> Bool Source #  | |
| Eq DecidedStrictness | Since: base-4.9.0.0  | 
Defined in GHC.Generics Methods (==) :: DecidedStrictness -> DecidedStrictness -> Bool Source # (/=) :: DecidedStrictness -> DecidedStrictness -> Bool Source #  | |
| Eq Fixity | Since: base-4.6.0.0  | 
| Eq SourceStrictness | Since: base-4.9.0.0  | 
Defined in GHC.Generics Methods (==) :: SourceStrictness -> SourceStrictness -> Bool Source # (/=) :: SourceStrictness -> SourceStrictness -> Bool Source #  | |
| Eq SourceUnpackedness | Since: base-4.9.0.0  | 
Defined in GHC.Generics Methods (==) :: SourceUnpackedness -> SourceUnpackedness -> Bool Source # (/=) :: SourceUnpackedness -> SourceUnpackedness -> Bool Source #  | |
| Eq MaskingState | Since: base-4.3.0.0  | 
Defined in GHC.IO Methods (==) :: MaskingState -> MaskingState -> Bool Source # (/=) :: MaskingState -> MaskingState -> Bool Source #  | |
| Eq ArrayException | Since: base-4.2.0.0  | 
Defined in GHC.IO.Exception Methods (==) :: ArrayException -> ArrayException -> Bool Source # (/=) :: ArrayException -> ArrayException -> Bool Source #  | |
| Eq AsyncException | Since: base-4.2.0.0  | 
Defined in GHC.IO.Exception Methods (==) :: AsyncException -> AsyncException -> Bool Source # (/=) :: AsyncException -> AsyncException -> Bool Source #  | |
| Eq ExitCode | |
| Eq IOErrorType | Since: base-4.1.0.0  | 
Defined in GHC.IO.Exception Methods (==) :: IOErrorType -> IOErrorType -> Bool Source # (/=) :: IOErrorType -> IOErrorType -> Bool Source #  | |
| Eq IOException | Since: base-4.1.0.0  | 
Defined in GHC.IO.Exception Methods (==) :: IOException -> IOException -> Bool Source # (/=) :: IOException -> IOException -> Bool Source #  | |
| Eq Int16 | Since: base-2.1  | 
| Eq Int32 | Since: base-2.1  | 
| Eq Int64 | Since: base-2.1  | 
| Eq Int8 | Since: base-2.1  | 
| Eq IoSubSystem | |
Defined in GHC.RTS.Flags Methods (==) :: IoSubSystem -> IoSubSystem -> Bool Source # (/=) :: IoSubSystem -> IoSubSystem -> Bool Source #  | |
| Eq SrcLoc | Since: base-4.9.0.0  | 
| Eq SomeChar | |
| Eq SomeSymbol | Since: base-4.7.0.0  | 
Defined in GHC.TypeLits Methods (==) :: SomeSymbol -> SomeSymbol -> Bool Source # (/=) :: SomeSymbol -> SomeSymbol -> Bool Source #  | |
| Eq SomeNat | Since: base-4.7.0.0  | 
| Eq GeneralCategory | Since: base-2.1  | 
Defined in GHC.Unicode Methods (==) :: GeneralCategory -> GeneralCategory -> Bool Source # (/=) :: GeneralCategory -> GeneralCategory -> Bool Source #  | |
| Eq Word16 | Since: base-2.1  | 
| Eq Word32 | Since: base-2.1  | 
| Eq Word64 | Since: base-2.1  | 
| Eq Word8 | Since: base-2.1  | 
| Eq CBlkCnt | |
| Eq CBlkSize | |
| Eq CCc | |
| Eq CClockId | |
| Eq CDev | |
| Eq CFsBlkCnt | |
| Eq CFsFilCnt | |
| Eq CGid | |
| Eq CId | |
| Eq CIno | |
| Eq CKey | |
| Eq CMode | |
| Eq CNfds | |
| Eq CNlink | |
| Eq COff | |
| Eq CPid | |
| Eq CRLim | |
| Eq CSocklen | |
| Eq CSpeed | |
| Eq CSsize | |
| Eq CTcflag | |
| Eq CTimer | |
| Eq CUid | |
| Eq Fd | |
| Eq PinnedStatus Source # | |
Defined in Basement.Compat.Primitive Methods (==) :: PinnedStatus -> PinnedStatus -> Bool Source # (/=) :: PinnedStatus -> PinnedStatus -> Bool Source #  | |
| Eq Endianness Source # | |
Defined in Basement.Endianness Methods (==) :: Endianness -> Endianness -> Bool Source # (/=) :: Endianness -> Endianness -> Bool Source #  | |
| Eq OutOfBoundOperation Source # | |
Defined in Basement.Exception Methods (==) :: OutOfBoundOperation -> OutOfBoundOperation -> Bool Source # (/=) :: OutOfBoundOperation -> OutOfBoundOperation -> Bool Source #  | |
| Eq RecastDestinationSize Source # | |
Defined in Basement.Exception Methods (==) :: RecastDestinationSize -> RecastDestinationSize -> Bool Source # (/=) :: RecastDestinationSize -> RecastDestinationSize -> Bool Source #  | |
| Eq RecastSourceSize Source # | |
Defined in Basement.Exception Methods (==) :: RecastSourceSize -> RecastSourceSize -> Bool Source # (/=) :: RecastSourceSize -> RecastSourceSize -> Bool Source #  | |
| Eq Encoding Source # | |
| Eq AsciiString Source # | |
Defined in Basement.Types.AsciiString Methods (==) :: AsciiString -> AsciiString -> Bool Source # (/=) :: AsciiString -> AsciiString -> Bool Source #  | |
| Eq Char7 Source # | |
| Eq FileSize Source # | |
| Eq Addr Source # | |
| Eq Word128 Source # | |
| Eq Word256 Source # | |
| Eq String Source # | |
| Eq ValidationFailure Source # | |
Defined in Basement.UTF8.Types Methods (==) :: ValidationFailure -> ValidationFailure -> Bool Source # (/=) :: ValidationFailure -> ValidationFailure -> Bool Source #  | |
| Eq Module | |
| Eq Ordering | |
| Eq TrName | |
| Eq TyCon | |
| Eq Integer | |
| Eq Natural | |
| Eq () | |
| 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 Word | |
| Eq a => Eq (ZipList a) | Since: base-4.7.0.0  | 
| Eq a => Eq (And a) | Since: base-4.16  | 
| Eq a => Eq (Iff a) | Since: base-4.16  | 
| Eq a => Eq (Ior a) | Since: base-4.16  | 
| Eq a => Eq (Xor a) | Since: base-4.16  | 
| Eq a => Eq (Identity a) | Since: base-4.8.0.0  | 
| Eq a => Eq (First a) | Since: base-2.1  | 
| Eq a => Eq (Last a) | Since: base-2.1  | 
| Eq a => Eq (Down a) | Since: base-4.6.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 a => Eq (Max a) | Since: base-4.9.0.0  | 
| Eq a => Eq (Min 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 Source # (/=) :: WrappedMonoid m -> WrappedMonoid m -> Bool Source #  | |
| Eq a => Eq (Dual a) | Since: base-2.1  | 
| Eq a => Eq (Product a) | Since: base-2.1  | 
| Eq a => Eq (Sum a) | Since: base-2.1  | 
| Eq (ForeignPtr a) | Since: base-2.1  | 
Defined in GHC.ForeignPtr Methods (==) :: ForeignPtr a -> ForeignPtr a -> Bool Source # (/=) :: ForeignPtr a -> ForeignPtr a -> Bool Source #  | |
| Eq p => Eq (Par1 p) | Since: base-4.7.0.0  | 
| Eq (IORef a) | Pointer equality. Since: base-4.0.0.0  | 
| Eq (FunPtr a) | |
| Eq (Ptr a) | Since: base-2.1  | 
| Eq a => Eq (Ratio a) | Since: base-2.1  | 
| Eq (StablePtr a) | Since: base-2.1  | 
| Eq (Bits n) Source # | |
| (PrimType ty, Eq ty) => Eq (Block ty) Source # | |
| Eq (Zn n) Source # | |
| Eq (Zn64 n) Source # | |
| Eq a => Eq (Array a) Source # | |
| Eq a => Eq (BE a) Source # | |
| Eq a => Eq (LE a) Source # | |
| Eq (FinalPtr a) Source # | |
| Eq a => Eq (NonEmpty a) Source # | |
| Eq (CountOf ty) Source # | |
| Eq (Offset ty) Source # | |
| (PrimType ty, Eq ty) => Eq (UArray ty) Source # | |
| Eq a => Eq (NonEmpty a) | Since: base-4.9.0.0  | 
| Eq a => Eq (Maybe a) | Since: base-2.1  | 
| Eq a => Eq (a) | |
| Eq a => Eq [a] | |
| (Eq a, Eq b) => Eq (Either a b) | Since: base-2.1  | 
| Eq (Proxy s) | Since: base-4.7.0.0  | 
| Eq a => Eq (Arg a b) | Since: base-4.9.0.0  | 
| Eq (TypeRep a) | Since: base-2.1  | 
| (Ix i, Eq e) => Eq (Array i e) | Since: base-2.1  | 
| Eq (U1 p) | Since: base-4.9.0.0  | 
| Eq (V1 p) | Since: base-4.9.0.0  | 
| Eq (STRef s a) | Pointer equality. Since: base-2.1  | 
| PrimType a => Eq (BlockN n a) Source # | |
| Eq a => Eq (ListN n a) Source # | |
| PrimType a => Eq (UVect n a) Source # | |
| Eq a => Eq (Vect n a) Source # | |
| (Eq a, Eq b) => Eq (These a b) Source # | |
| (Eq a, Eq b) => Eq (a, b) | |
| 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 (Coercion a b) | Since: base-4.7.0.0  | 
| Eq (a :~: b) | Since: base-4.7.0.0  | 
| Eq (OrderingI a b) | |
| Eq (STArray s i e) | Since: base-2.1  | 
| 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 :~~: b) | Since: base-4.10.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 c => Eq (K1 i c p) | Since: base-4.7.0.0  | 
| (Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d) | |
| Eq (f (g p)) => Eq ((f :.: g) p) | Since: base-4.7.0.0  | 
| Eq (f p) => Eq (M1 i c f p) | Since: base-4.7.0.0  | 
| (Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e) | |
| (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) => Eq (a, b, c, d, e, f) | |
| (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) => Eq (a, b, c, d, e, f, g) | |
| (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h) => Eq (a, b, c, d, e, f, g, h) | |
| (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i) => Eq (a, b, c, d, e, f, g, h, i) | |
| (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j) => Eq (a, b, c, d, e, f, g, h, i, j) | |
| (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k) => Eq (a, b, c, d, e, f, g, h, i, j, k) | |
| (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l) => Eq (a, b, c, d, e, f, g, h, i, j, k, l) | |
| (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m) | |
| (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n) | |
| (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n, Eq o) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) | |
class Bounded a where Source #
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
| Bounded All | Since: base-2.1  | 
| Bounded Any | Since: base-2.1  | 
| Bounded CBool | |
| Bounded CChar | |
| Bounded CInt | |
| Bounded CIntMax | |
| Bounded CIntPtr | |
| Bounded CLLong | |
| Bounded CLong | |
| Bounded CPtrdiff | |
| Bounded CSChar | |
| Bounded CShort | |
| Bounded CSigAtomic | |
Defined in Foreign.C.Types  | |
| Bounded CSize | |
| Bounded CUChar | |
| Bounded CUInt | |
| Bounded CUIntMax | |
| Bounded CUIntPtr | |
| Bounded CULLong | |
| Bounded CULong | |
| Bounded CUShort | |
| Bounded CWchar | |
| Bounded IntPtr | |
| Bounded WordPtr | |
| Bounded Associativity | Since: base-4.9.0.0  | 
Defined in GHC.Generics  | |
| Bounded DecidedStrictness | Since: base-4.9.0.0  | 
Defined in GHC.Generics  | |
| Bounded SourceStrictness | Since: base-4.9.0.0  | 
Defined in GHC.Generics  | |
| Bounded SourceUnpackedness | Since: base-4.9.0.0  | 
Defined in GHC.Generics  | |
| Bounded Int16 | Since: base-2.1  | 
| Bounded Int32 | Since: base-2.1  | 
| Bounded Int64 | Since: base-2.1  | 
| Bounded Int8 | Since: base-2.1  | 
| Bounded GeneralCategory | Since: base-2.1  | 
Defined in GHC.Unicode  | |
| Bounded Word16 | Since: base-2.1  | 
| Bounded Word32 | Since: base-2.1  | 
| Bounded Word64 | Since: base-2.1  | 
| Bounded Word8 | Since: base-2.1  | 
| Bounded CBlkCnt | |
| Bounded CBlkSize | |
| Bounded CClockId | |
| Bounded CDev | |
| Bounded CFsBlkCnt | |
| Bounded CFsFilCnt | |
| Bounded CGid | |
| Bounded CId | |
| Bounded CIno | |
| Bounded CKey | |
| Bounded CMode | |
| Bounded CNfds | |
| Bounded CNlink | |
| Bounded COff | |
| Bounded CPid | |
| Bounded CRLim | |
| Bounded CSocklen | |
| Bounded CSsize | |
| Bounded CTcflag | |
| Bounded CUid | |
| Bounded Fd | |
| Bounded Encoding Source # | |
| Bounded Word128 Source # | |
| Bounded Word256 Source # | |
| Bounded Ordering | Since: base-2.1  | 
| Bounded () | Since: base-2.1  | 
| Bounded Bool | Since: base-2.1  | 
| Bounded Char | Since: base-2.1  | 
| Bounded Int | Since: base-2.1  | 
| Bounded Levity | Since: base-4.16.0.0  | 
| Bounded VecCount | Since: base-4.10.0.0  | 
| Bounded VecElem | Since: base-4.10.0.0  | 
| Bounded Word | Since: base-2.1  | 
| Bounded a => Bounded (And a) | Since: base-4.16  | 
| Bounded a => Bounded (Iff a) | Since: base-4.16  | 
| Bounded a => Bounded (Ior a) | Since: base-4.16  | 
| Bounded a => Bounded (Xor a) | Since: base-4.16  | 
| Bounded a => Bounded (Identity a) | Since: base-4.9.0.0  | 
| Bounded a => Bounded (Down a) | Swaps  Since: base-4.14.0.0  | 
| Bounded a => Bounded (First a) | Since: base-4.9.0.0  | 
| Bounded a => Bounded (Last a) | Since: base-4.9.0.0  | 
| Bounded a => Bounded (Max a) | Since: base-4.9.0.0  | 
| Bounded a => Bounded (Min a) | Since: base-4.9.0.0  | 
| Bounded m => Bounded (WrappedMonoid m) | Since: base-4.9.0.0  | 
Defined in Data.Semigroup  | |
| Bounded a => Bounded (Dual a) | Since: base-2.1  | 
| Bounded a => Bounded (Product a) | Since: base-2.1  | 
| Bounded a => Bounded (Sum a) | Since: base-2.1  | 
| SizeValid n => Bounded (Bits n) Source # | |
| Bounded a => Bounded (a) | |
| Bounded (Proxy t) | Since: base-4.7.0.0  | 
| (Bounded a, Bounded b) => Bounded (a, b) | Since: base-2.1  | 
| Bounded a => Bounded (Const a b) | Since: base-4.9.0.0  | 
| (Applicative f, Bounded a) => Bounded (Ap f a) | Since: base-4.12.0.0  | 
| Coercible a b => Bounded (Coercion a b) | Since: base-4.7.0.0  | 
| a ~ b => Bounded (a :~: b) | Since: base-4.7.0.0  | 
| (Bounded a, Bounded b, Bounded c) => Bounded (a, b, c) | Since: base-2.1  | 
| a ~~ b => Bounded (a :~~: b) | Since: base-4.10.0.0  | 
| (Bounded a, Bounded b, Bounded c, Bounded d) => Bounded (a, b, c, d) | Since: base-2.1  | 
| (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e) => Bounded (a, b, c, d, e) | Since: base-2.1  | 
| (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f) => Bounded (a, b, c, d, e, f) | Since: base-2.1  | 
| (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g) => Bounded (a, b, c, d, e, f, g) | Since: base-2.1  | 
| (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h) => Bounded (a, b, c, d, e, f, g, h) | Since: base-2.1  | 
| (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i) => Bounded (a, b, c, d, e, f, g, h, i) | Since: base-2.1  | 
| (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j) => Bounded (a, b, c, d, e, f, g, h, i, j) | Since: base-2.1  | 
| (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k) => Bounded (a, b, c, d, e, f, g, h, i, j, k) | Since: base-2.1  | 
| (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l) | Since: base-2.1  | 
| (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m) | Since: base-2.1  | 
| (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m, Bounded n) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m, n) | Since: base-2.1  | 
| (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m, Bounded n, Bounded o) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) | Since: base-2.1  | 
Class Enum defines operations on sequentially ordered types.
The enumFrom... methods are used in Haskell's translation of
 arithmetic sequences.
Instances of Enum may be derived for any enumeration type (types
 whose constructors have no fields).  The nullary constructors are
 assumed to be numbered left-to-right by fromEnum from 0 through n-1.
 See Chapter 10 of the Haskell Report for more details.
For any type that is an instance of class Bounded as well as Enum,
 the following should hold:
- The calls 
andsuccmaxBoundshould result in a runtime error.predminBound fromEnumandtoEnumshould give a runtime error if the result value is not representable in the result type. For example,is an error.toEnum7 ::BoolenumFromandenumFromThenshould be defined with an implicit bound, thus:
   enumFrom     x   = enumFromTo     x maxBound
   enumFromThen x y = enumFromThenTo x y bound
     where
       bound | fromEnum y >= fromEnum x = maxBound
             | otherwise                = minBoundMethods
the successor of a value.  For numeric types, succ adds 1.
the predecessor of a value.  For numeric types, pred subtracts 1.
Convert from an Int.
Convert to an Int.
 It is implementation-dependent what fromEnum returns when
 applied to a value that is too large to fit in an Int.
Used in Haskell's translation of [n..] with [n..] = enumFrom n,
   a possible implementation being enumFrom n = n : enumFrom (succ n).
   For example:
enumFrom 4 :: [Integer] = [4,5,6,7,...]
enumFrom 6 :: [Int] = [6,7,8,9,...,maxBound :: Int]
enumFromThen :: a -> a -> [a] Source #
Used in Haskell's translation of [n,n'..]
   with [n,n'..] = enumFromThen n n', a possible implementation being
   enumFromThen n n' = n : n' : worker (f x) (f x n'),
   worker s v = v : worker s (s v), x = fromEnum n' - fromEnum n and
   f n y
     | n > 0 = f (n - 1) (succ y)
     | n < 0 = f (n + 1) (pred y)
     | otherwise = y
   For example:
enumFromThen 4 6 :: [Integer] = [4,6,8,10...]
enumFromThen 6 2 :: [Int] = [6,2,-2,-6,...,minBound :: Int]
enumFromTo :: a -> a -> [a] Source #
Used in Haskell's translation of [n..m] with
   [n..m] = enumFromTo n m, a possible implementation being
   enumFromTo n m
      | n <= m = n : enumFromTo (succ n) m
      | otherwise = [].
   For example:
enumFromTo 6 10 :: [Int] = [6,7,8,9,10]
enumFromTo 42 1 :: [Integer] = []
enumFromThenTo :: a -> a -> a -> [a] Source #
Used in Haskell's translation of [n,n'..m] with
   [n,n'..m] = enumFromThenTo n n' m, a possible implementation
   being enumFromThenTo n n' m = worker (f x) (c x) n m,
   x = fromEnum n' - fromEnum n, c x = bool (>=) ((x 0)
   f n y
      | n > 0 = f (n - 1) (succ y)
      | n < 0 = f (n + 1) (pred y)
      | otherwise = y and
   worker s c v m
      | c v m = v : worker s c (s v) m
      | otherwise = []
   For example:
enumFromThenTo 4 2 -6 :: [Integer] = [4,2,0,-2,-4,-6]
enumFromThenTo 6 8 2 :: [Int] = []
Instances
class Functor (f :: Type -> Type) where Source #
A type f is a Functor if it provides a function fmap which, given any types a and b
lets you apply any function from (a -> b) to turn an f a into an f b, preserving the
structure of f. Furthermore f needs to adhere to the following:
Note, that the second law follows from the free theorem of the type fmap and
the first law, so you need only check that the former condition holds.
Minimal complete definition
Methods
fmap :: (a -> b) -> f a -> f b Source #
fmap is used to apply a function of type (a -> b) to a value of type f a,
 where f is a functor, to produce a value of type f b.
 Note that for any type constructor with more than one parameter (e.g., Either),
 only the last type parameter can be modified with fmap (e.g., b in `Either a b`).
Some type constructors with two parameters or more have a  instance that allows
 both the last and the penultimate parameters to be mapped over.Bifunctor
Examples
Convert from a  to a Maybe IntMaybe String
 using show:
>>>fmap show NothingNothing>>>fmap show (Just 3)Just "3"
Convert from an  to an
 Either Int IntEither Int String using show:
>>>fmap show (Left 17)Left 17>>>fmap show (Right 17)Right "17"
Double each element of a list:
>>>fmap (*2) [1,2,3][2,4,6]
Apply even to the second element of a pair:
>>>fmap even (2,2)(2,True)
It may seem surprising that the function is only applied to the last element of the tuple
 compared to the list example above which applies it to every element in the list.
 To understand, remember that tuples are type constructors with multiple type parameters:
 a tuple of 3 elements (a,b,c) can also be written (,,) a b c and its Functor instance
 is defined for Functor ((,,) a b) (i.e., only the third parameter is free to be mapped over
 with fmap).
It explains why fmap can be used with tuples containing values of different types as in the
 following example:
>>>fmap even ("hello", 1.0, 4)("hello",1.0,True)
Instances
| Functor ZipList | Since: base-2.1  | 
| Functor Handler | Since: base-4.6.0.0  | 
| Functor Identity | Since: base-4.8.0.0  | 
| Functor First | Since: base-4.8.0.0  | 
| Functor Last | Since: base-4.8.0.0  | 
| Functor Down | Since: base-4.11.0.0  | 
| Functor First | Since: base-4.9.0.0  | 
| Functor Last | Since: base-4.9.0.0  | 
| Functor Max | Since: base-4.9.0.0  | 
| Functor Min | Since: base-4.9.0.0  | 
| Functor Dual | Since: base-4.8.0.0  | 
| Functor Product | Since: base-4.8.0.0  | 
| Functor Sum | Since: base-4.8.0.0  | 
| Functor Par1 | Since: base-4.9.0.0  | 
| Functor Array Source # | |
| Functor IO | Since: base-2.1  | 
| Functor NonEmpty | Since: base-4.9.0.0  | 
| Functor Maybe | Since: base-2.1  | 
| Functor Solo | Since: base-4.15  | 
| Functor [] | Since: base-2.1  | 
| Monad m => Functor (WrappedMonad m) | Since: base-2.1  | 
Defined in Control.Applicative Methods fmap :: (a -> b) -> WrappedMonad m a -> WrappedMonad m b Source # (<$) :: a -> WrappedMonad m b -> WrappedMonad m a Source #  | |
| Arrow a => Functor (ArrowMonad a) | Since: base-4.6.0.0  | 
Defined in Control.Arrow Methods fmap :: (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b Source # (<$) :: a0 -> ArrowMonad a b -> ArrowMonad a a0 Source #  | |
| Functor (Either a) | Since: base-3.0  | 
| Functor (Proxy :: Type -> Type) | Since: base-4.7.0.0  | 
| Functor (Arg a) | Since: base-4.9.0.0  | 
| Functor (Array i) | Since: base-2.1  | 
| Functor (U1 :: Type -> Type) | Since: base-4.9.0.0  | 
| Functor (V1 :: TYPE LiftedRep -> Type) | Since: base-4.9.0.0  | 
| Functor (ST s) | Since: base-2.1  | 
| Functor (Vect n) Source # | |
| Functor (These a) Source # | |
| Functor ((,) a) | Since: base-2.1  | 
| Arrow a => Functor (WrappedArrow a b) | Since: base-2.1  | 
Defined in Control.Applicative Methods fmap :: (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 Source # (<$) :: a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 Source #  | |
| Functor m => Functor (Kleisli m a) | Since: base-4.14.0.0  | 
| Functor (Const m :: Type -> Type) | Since: base-2.1  | 
| Functor f => Functor (Ap f) | Since: base-4.12.0.0  | 
| Functor f => Functor (Alt f) | Since: base-4.8.0.0  | 
| Functor f => Functor (Rec1 f) | Since: base-4.9.0.0  | 
| Functor (URec (Ptr ()) :: TYPE LiftedRep -> Type) | Since: base-4.9.0.0  | 
| Functor (URec Char :: TYPE LiftedRep -> Type) | Since: base-4.9.0.0  | 
| Functor (URec Double :: TYPE LiftedRep -> Type) | Since: base-4.9.0.0  | 
| Functor (URec Float :: TYPE LiftedRep -> Type) | Since: base-4.9.0.0  | 
| Functor (URec Int :: TYPE LiftedRep -> Type) | Since: base-4.9.0.0  | 
| Functor (URec Word :: TYPE LiftedRep -> Type) | Since: base-4.9.0.0  | 
| Monad m => Functor (Reader r m) Source # | |
| Monad m => Functor (State s m) Source # | |
| Functor ((,,) a b) | Since: base-4.14.0.0  | 
| (Functor f, Functor g) => Functor (f :*: g) | Since: base-4.9.0.0  | 
| (Functor f, Functor g) => Functor (f :+: g) | Since: base-4.9.0.0  | 
| Functor (K1 i c :: TYPE LiftedRep -> Type) | Since: base-4.9.0.0  | 
| Functor ((,,,) a b c) | Since: base-4.14.0.0  | 
| Functor ((->) r) | Since: base-2.1  | 
| (Functor f, Functor g) => Functor (f :.: g) | Since: base-4.9.0.0  | 
| Functor f => Functor (M1 i c f) | Since: base-4.9.0.0  | 
| Monad state => Functor (Builder collection mutCollection step state err) Source # | |
class Functor f => Applicative (f :: Type -> Type) where Source #
A functor with application, providing operations to
A minimal complete definition must include implementations of pure
 and of either <*> or liftA2. If it defines both, then they must behave
 the same as their default definitions:
(<*>) =liftA2id
liftA2f x y = f<$>x<*>y
Further, any definition must satisfy the following:
- Identity
 pureid<*>v = v- Composition
 pure(.)<*>u<*>v<*>w = u<*>(v<*>w)- Homomorphism
 puref<*>purex =pure(f x)- Interchange
 u
<*>purey =pure($y)<*>u
The other methods have the following default definitions, which may be overridden with equivalent specialized implementations:
As a consequence of these laws, the Functor instance for f will satisfy
It may be useful to note that supposing
forall x y. p (q x y) = f x . g y
it follows from the above that
liftA2p (liftA2q u v) =liftA2f u .liftA2g v
If f is also a Monad, it should satisfy
(which implies that pure and <*> satisfy the applicative functor laws).
Methods
Lift a value.
(<*>) :: f (a -> b) -> f a -> f b infixl 4 Source #
Sequential application.
A few functors support an implementation of <*> that is more
 efficient than the default one.
Example
Used in combination with (, <$>)( can be used to build a record.<*>)
>>>data MyState = MyState {arg1 :: Foo, arg2 :: Bar, arg3 :: Baz}
>>>produceFoo :: Applicative f => f Foo
>>>produceBar :: Applicative f => f Bar>>>produceBaz :: Applicative f => f Baz
>>>mkState :: Applicative f => f MyState>>>mkState = MyState <$> produceFoo <*> produceBar <*> produceBaz
liftA2 :: (a -> b -> c) -> f a -> f b -> f c Source #
Lift a binary function to actions.
Some functors support an implementation of liftA2 that is more
 efficient than the default one. In particular, if fmap is an
 expensive operation, it is likely better to use liftA2 than to
 fmap over the structure and then use <*>.
This became a typeclass method in 4.10.0.0. Prior to that, it was
 a function defined in terms of <*> and fmap.
Example
>>>liftA2 (,) (Just 3) (Just 5)Just (3,5)
(*>) :: f a -> f b -> f b infixl 4 Source #
Sequence actions, discarding the value of the first argument.
Examples
If used in conjunction with the Applicative instance for Maybe,
 you can chain Maybe computations, with a possible "early return"
 in case of Nothing.
>>>Just 2 *> Just 3Just 3
>>>Nothing *> Just 3Nothing
Of course a more interesting use case would be to have effectful computations instead of just returning pure values.
>>>import Data.Char>>>import Text.ParserCombinators.ReadP>>>let p = string "my name is " *> munch1 isAlpha <* eof>>>readP_to_S p "my name is Simon"[("Simon","")]
(<*) :: f a -> f b -> f a infixl 4 Source #
Sequence actions, discarding the value of the second argument.
Instances
| Applicative ZipList | f <$> ZipList xs1 <*> ... <*> ZipList xsN
    = ZipList (zipWithN f xs1 ... xsN)where  (\a b c -> stimes c [a, b]) <$> ZipList "abcd" <*> ZipList "567" <*> ZipList [1..]
    = ZipList (zipWith3 (\a b c -> stimes c [a, b]) "abcd" "567" [1..])
    = ZipList {getZipList = ["a5","b6b6","c7c7c7"]}Since: base-2.1  | 
Defined in Control.Applicative  | |
| Applicative Identity | Since: base-4.8.0.0  | 
Defined in Data.Functor.Identity  | |
| Applicative First | Since: base-4.8.0.0  | 
| Applicative Last | Since: base-4.8.0.0  | 
| Applicative Down | Since: base-4.11.0.0  | 
| Applicative First | Since: base-4.9.0.0  | 
| Applicative Last | Since: base-4.9.0.0  | 
| Applicative Max | Since: base-4.9.0.0  | 
| Applicative Min | Since: base-4.9.0.0  | 
| Applicative Dual | Since: base-4.8.0.0  | 
| Applicative Product | Since: base-4.8.0.0  | 
Defined in Data.Semigroup.Internal  | |
| Applicative Sum | Since: base-4.8.0.0  | 
| Applicative Par1 | Since: base-4.9.0.0  | 
| Applicative IO | Since: base-2.1  | 
| Applicative NonEmpty | Since: base-4.9.0.0  | 
Defined in GHC.Base  | |
| Applicative Maybe | Since: base-2.1  | 
| Applicative Solo | Since: base-4.15  | 
| Applicative [] | Since: base-2.1  | 
| Monad m => Applicative (WrappedMonad m) | Since: base-2.1  | 
Defined in Control.Applicative Methods pure :: a -> WrappedMonad m a Source # (<*>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b Source # liftA2 :: (a -> b -> c) -> WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m c Source # (*>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b Source # (<*) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a Source #  | |
| Arrow a => Applicative (ArrowMonad a) | Since: base-4.6.0.0  | 
Defined in Control.Arrow Methods pure :: a0 -> ArrowMonad a a0 Source # (<*>) :: ArrowMonad a (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b Source # liftA2 :: (a0 -> b -> c) -> ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a c Source # (*>) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a b Source # (<*) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a a0 Source #  | |
| Applicative (Either e) | Since: base-3.0  | 
Defined in Data.Either  | |
| Applicative (Proxy :: Type -> Type) | Since: base-4.7.0.0  | 
| Applicative (U1 :: Type -> Type) | Since: base-4.9.0.0  | 
| Applicative (ST s) | Since: base-4.4.0.0  | 
| Monoid a => Applicative ((,) a) | For tuples, the  ("hello ", (+15)) <*> ("world!", 2002)
("hello world!",2017)Since: base-2.1  | 
| Arrow a => Applicative (WrappedArrow a b) | Since: base-2.1  | 
Defined in Control.Applicative Methods pure :: a0 -> WrappedArrow a b a0 Source # (<*>) :: WrappedArrow a b (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 Source # liftA2 :: (a0 -> b0 -> c) -> WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b c Source # (*>) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b b0 Source # (<*) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 Source #  | |
| Applicative m => Applicative (Kleisli m a) | Since: base-4.14.0.0  | 
Defined in Control.Arrow Methods pure :: a0 -> Kleisli m a a0 Source # (<*>) :: Kleisli m a (a0 -> b) -> Kleisli m a a0 -> Kleisli m a b Source # liftA2 :: (a0 -> b -> c) -> Kleisli m a a0 -> Kleisli m a b -> Kleisli m a c Source # (*>) :: Kleisli m a a0 -> Kleisli m a b -> Kleisli m a b Source # (<*) :: Kleisli m a a0 -> Kleisli m a b -> Kleisli m a a0 Source #  | |
| Monoid m => Applicative (Const m :: Type -> Type) | Since: base-2.0.1  | 
Defined in Data.Functor.Const  | |
| Applicative f => Applicative (Ap f) | Since: base-4.12.0.0  | 
| Applicative f => Applicative (Alt f) | Since: base-4.8.0.0  | 
| Applicative f => Applicative (Rec1 f) | Since: base-4.9.0.0  | 
| Monad m => Applicative (Reader r m) Source # | |
Defined in Basement.Compat.MonadTrans Methods pure :: a -> Reader r m a Source # (<*>) :: Reader r m (a -> b) -> Reader r m a -> Reader r m b Source # liftA2 :: (a -> b -> c) -> Reader r m a -> Reader r m b -> Reader r m c Source # (*>) :: Reader r m a -> Reader r m b -> Reader r m b Source # (<*) :: Reader r m a -> Reader r m b -> Reader r m a Source #  | |
| Monad m => Applicative (State s m) Source # | |
Defined in Basement.Compat.MonadTrans  | |
| (Monoid a, Monoid b) => Applicative ((,,) a b) | Since: base-4.14.0.0  | 
Defined in GHC.Base  | |
| (Applicative f, Applicative g) => Applicative (f :*: g) | Since: base-4.9.0.0  | 
Defined in GHC.Generics  | |
| Monoid c => Applicative (K1 i c :: Type -> Type) | Since: base-4.12.0.0  | 
| (Monoid a, Monoid b, Monoid c) => Applicative ((,,,) a b c) | Since: base-4.14.0.0  | 
Defined in GHC.Base Methods pure :: a0 -> (a, b, c, a0) Source # (<*>) :: (a, b, c, a0 -> b0) -> (a, b, c, a0) -> (a, b, c, b0) Source # liftA2 :: (a0 -> b0 -> c0) -> (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, c0) Source # (*>) :: (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, b0) Source # (<*) :: (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, a0) Source #  | |
| Applicative ((->) r) | Since: base-2.1  | 
| (Applicative f, Applicative g) => Applicative (f :.: g) | Since: base-4.9.0.0  | 
Defined in GHC.Generics  | |
| Applicative f => Applicative (M1 i c f) | Since: base-4.9.0.0  | 
Defined in GHC.Generics  | |
| Monad state => Applicative (Builder collection mutCollection step state err) Source # | |
Defined in Basement.MutableBuilder Methods pure :: a -> Builder collection mutCollection step state err a Source # (<*>) :: Builder collection mutCollection step state err (a -> b) -> Builder collection mutCollection step state err a -> Builder collection mutCollection step state err b Source # liftA2 :: (a -> b -> c) -> Builder collection mutCollection step state err a -> Builder collection mutCollection step state err b -> Builder collection mutCollection step state err c Source # (*>) :: Builder collection mutCollection step state err a -> Builder collection mutCollection step state err b -> Builder collection mutCollection step state err b Source # (<*) :: Builder collection mutCollection step state err a -> Builder collection mutCollection step state err b -> Builder collection mutCollection step state err a Source #  | |
class Applicative m => Monad (m :: Type -> Type) where Source #
The Monad class defines the basic operations over a monad,
a concept from a branch of mathematics known as category theory.
From the perspective of a Haskell programmer, however, it is best to
think of a monad as an abstract datatype of actions.
Haskell's do expressions provide a convenient syntax for writing
monadic expressions.
Instances of Monad should satisfy the following:
- Left identity
 returna>>=k = k a- Right identity
 m>>=return= m- Associativity
 m>>=(\x -> k x>>=h) = (m>>=k)>>=h
Furthermore, the Monad and Applicative operations should relate as follows:
The above laws imply:
and that pure and (<*>) satisfy the applicative functor laws.
The instances of Monad for lists, Maybe and IO
defined in the Prelude satisfy these laws.
Minimal complete definition
Methods
(>>=) :: m a -> (a -> m b) -> m b infixl 1 Source #
Sequentially compose two actions, passing any value produced by the first as an argument to the second.
'as ' can be understood as the >>= bsdo expression
do a <- as bs a
(>>) :: m a -> m b -> m b infixl 1 Source #
Sequentially compose two actions, discarding any value produced by the first, like sequencing operators (such as the semicolon) in imperative languages.
'as ' can be understood as the >> bsdo expression
do as bs
Inject a value into the monadic type.
Instances
| Monad Identity | Since: base-4.8.0.0  | 
| Monad First | Since: base-4.8.0.0  | 
| Monad Last | Since: base-4.8.0.0  | 
| Monad Down | Since: base-4.11.0.0  | 
| Monad First | Since: base-4.9.0.0  | 
| Monad Last | Since: base-4.9.0.0  | 
| Monad Max | Since: base-4.9.0.0  | 
| Monad Min | Since: base-4.9.0.0  | 
| Monad Dual | Since: base-4.8.0.0  | 
| Monad Product | Since: base-4.8.0.0  | 
| Monad Sum | Since: base-4.8.0.0  | 
| Monad Par1 | Since: base-4.9.0.0  | 
| Monad IO | Since: base-2.1  | 
| Monad NonEmpty | Since: base-4.9.0.0  | 
| Monad Maybe | Since: base-2.1  | 
| Monad Solo | Since: base-4.15  | 
| Monad [] | Since: base-2.1  | 
| Monad m => Monad (WrappedMonad m) | Since: base-4.7.0.0  | 
Defined in Control.Applicative Methods (>>=) :: WrappedMonad m a -> (a -> WrappedMonad m b) -> WrappedMonad m b Source # (>>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b Source # return :: a -> WrappedMonad m a Source #  | |
| ArrowApply a => Monad (ArrowMonad a) | Since: base-2.1  | 
Defined in Control.Arrow Methods (>>=) :: ArrowMonad a a0 -> (a0 -> ArrowMonad a b) -> ArrowMonad a b Source # (>>) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a b Source # return :: a0 -> ArrowMonad a a0 Source #  | |
| Monad (Either e) | Since: base-4.4.0.0  | 
| Monad (Proxy :: Type -> Type) | Since: base-4.7.0.0  | 
| Monad (U1 :: Type -> Type) | Since: base-4.9.0.0  | 
| Monad (ST s) | Since: base-2.1  | 
| Monoid a => Monad ((,) a) | Since: base-4.9.0.0  | 
| Monad m => Monad (Kleisli m a) | Since: base-4.14.0.0  | 
| Monad f => Monad (Ap f) | Since: base-4.12.0.0  | 
| Monad f => Monad (Alt f) | Since: base-4.8.0.0  | 
| Monad f => Monad (Rec1 f) | Since: base-4.9.0.0  | 
| Monad m => Monad (Reader r m) Source # | |
| Monad m => Monad (State r m) Source # | |
| (Monoid a, Monoid b) => Monad ((,,) a b) | Since: base-4.14.0.0  | 
| (Monad f, Monad g) => Monad (f :*: g) | Since: base-4.9.0.0  | 
| (Monoid a, Monoid b, Monoid c) => Monad ((,,,) a b c) | Since: base-4.14.0.0  | 
| Monad ((->) r) | Since: base-2.1  | 
| Monad f => Monad (M1 i c f) | Since: base-4.9.0.0  | 
| Monad state => Monad (Builder collection mutCollection step state err) Source # | |
Defined in Basement.MutableBuilder Methods (>>=) :: Builder collection mutCollection step state err a -> (a -> Builder collection mutCollection step state err b) -> Builder collection mutCollection step state err b Source # (>>) :: Builder collection mutCollection step state err a -> Builder collection mutCollection step state err b -> Builder collection mutCollection step state err b Source # return :: a -> Builder collection mutCollection step state err a Source #  | |
when :: Applicative f => Bool -> f () -> f () Source #
Conditional execution of Applicative expressions. For example,
when debug (putStrLn "Debugging")
will output the string Debugging if the Boolean value debug
 is True, and otherwise do nothing.
The Maybe type encapsulates an optional value.  A value of type
  either contains a value of type Maybe aa (represented as ),
 or it is empty (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
| Foldable Maybe | Since: base-2.1  | 
Defined in Data.Foldable Methods fold :: Monoid m => Maybe m -> m Source # foldMap :: Monoid m => (a -> m) -> Maybe a -> m Source # foldMap' :: Monoid m => (a -> m) -> Maybe a -> m Source # foldr :: (a -> b -> b) -> b -> Maybe a -> b Source # foldr' :: (a -> b -> b) -> b -> Maybe a -> b Source # foldl :: (b -> a -> b) -> b -> Maybe a -> b Source # foldl' :: (b -> a -> b) -> b -> Maybe a -> b Source # foldr1 :: (a -> a -> a) -> Maybe a -> a Source # foldl1 :: (a -> a -> a) -> Maybe a -> a Source # toList :: Maybe a -> [a] Source # null :: Maybe a -> Bool Source # length :: Maybe a -> Int Source # elem :: Eq a => a -> Maybe a -> Bool Source # maximum :: Ord a => Maybe a -> a Source # minimum :: Ord a => Maybe a -> a Source #  | |
| Traversable Maybe | Since: base-2.1  | 
| Alternative Maybe | Since: base-2.1  | 
| Applicative Maybe | Since: base-2.1  | 
| Functor Maybe | Since: base-2.1  | 
| Monad Maybe | Since: base-2.1  | 
| MonadPlus Maybe | Since: base-2.1  | 
| MonadFailure Maybe Source # | |
| Generic1 Maybe | |
| Data a => Data (Maybe a) | Since: base-4.0.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Maybe a -> c (Maybe a) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Maybe a) Source # toConstr :: Maybe a -> Constr Source # dataTypeOf :: Maybe a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Maybe a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Maybe a)) Source # gmapT :: (forall b. Data b => b -> b) -> Maybe a -> Maybe a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Maybe a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Maybe a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) Source #  | |
| Semigroup a => Monoid (Maybe a) | Lift a semigroup into  Since 4.11.0: constraint on inner  Since: base-2.1  | 
| Semigroup a => Semigroup (Maybe a) | Since: base-4.9.0.0  | 
| Generic (Maybe a) | |
| SingKind a => SingKind (Maybe a) | Since: base-4.9.0.0  | 
Defined in GHC.Generics Associated Types type DemoteRep (Maybe a)  | |
| Read a => Read (Maybe a) | Since: base-2.1  | 
| Show a => Show (Maybe a) | Since: base-2.1  | 
| NormalForm a => NormalForm (Maybe a) Source # | |
Defined in Basement.NormalForm Methods toNormalForm :: Maybe a -> () Source #  | |
| Eq a => Eq (Maybe a) | Since: base-2.1  | 
| Ord a => Ord (Maybe a) | Since: base-2.1  | 
| SingI ('Nothing :: Maybe a) | Since: base-4.9.0.0  | 
Defined in GHC.Generics  | |
| SingI a2 => SingI ('Just a2 :: Maybe a1) | Since: base-4.9.0.0  | 
Defined in GHC.Generics  | |
| From (Maybe a) (Either () a) Source # | |
| type Failure Maybe Source # | |
Defined in Basement.Monad  | |
| type Rep1 Maybe | Since: base-4.6.0.0  | 
| type DemoteRep (Maybe a) | |
Defined in GHC.Generics  | |
| type Rep (Maybe a) | Since: base-4.6.0.0  | 
Defined in GHC.Generics  | |
| data Sing (b :: Maybe a) | |
Instances
| Data Ordering | Since: base-4.0.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ordering -> c Ordering Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Ordering Source # toConstr :: Ordering -> Constr Source # dataTypeOf :: Ordering -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Ordering) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ordering) Source # gmapT :: (forall b. Data b => b -> b) -> Ordering -> Ordering Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ordering -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ordering -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Ordering -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Ordering -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering Source #  | |
| Monoid Ordering | Since: base-2.1  | 
| Semigroup Ordering | Since: base-4.9.0.0  | 
| Bounded Ordering | Since: base-2.1  | 
| Enum Ordering | Since: base-2.1  | 
Defined in GHC.Enum Methods succ :: Ordering -> Ordering Source # pred :: Ordering -> Ordering Source # toEnum :: Int -> Ordering Source # fromEnum :: Ordering -> Int Source # enumFrom :: Ordering -> [Ordering] Source # enumFromThen :: Ordering -> Ordering -> [Ordering] Source # enumFromTo :: Ordering -> Ordering -> [Ordering] Source # enumFromThenTo :: Ordering -> Ordering -> Ordering -> [Ordering] Source #  | |
| Generic Ordering | |
| Ix Ordering | Since: base-2.1  | 
Defined in GHC.Ix  | |
| Read Ordering | Since: base-2.1  | 
| Show Ordering | Since: base-2.1  | 
| Eq Ordering | |
| Ord Ordering | |
Defined in GHC.Classes  | |
| type Rep Ordering | Since: base-4.6.0.0  | 
Instances
| Data Bool | Since: base-4.0.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bool -> c Bool Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Bool Source # toConstr :: Bool -> Constr Source # dataTypeOf :: Bool -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Bool) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bool) Source # gmapT :: (forall b. Data b => b -> b) -> Bool -> Bool Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bool -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bool -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Bool -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Bool -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bool -> m Bool Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bool -> m Bool Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bool -> m Bool Source #  | |
| Storable Bool | Since: base-2.1  | 
Defined in Foreign.Storable Methods sizeOf :: Bool -> Int Source # alignment :: Bool -> Int Source # peekElemOff :: Ptr Bool -> Int -> IO Bool Source # pokeElemOff :: Ptr Bool -> Int -> Bool -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Bool Source # pokeByteOff :: Ptr b -> Int -> Bool -> IO () Source #  | |
| Bits Bool | Interpret  Since: base-4.7.0.0  | 
Defined in GHC.Bits Methods (.&.) :: Bool -> Bool -> Bool Source # (.|.) :: Bool -> Bool -> Bool Source # xor :: Bool -> Bool -> Bool Source # complement :: Bool -> Bool Source # shift :: Bool -> Int -> Bool Source # rotate :: Bool -> Int -> Bool Source # setBit :: Bool -> Int -> Bool Source # clearBit :: Bool -> Int -> Bool Source # complementBit :: Bool -> Int -> Bool Source # testBit :: Bool -> Int -> Bool Source # bitSizeMaybe :: Bool -> Maybe Int Source # bitSize :: Bool -> Int Source # isSigned :: Bool -> Bool Source # shiftL :: Bool -> Int -> Bool Source # unsafeShiftL :: Bool -> Int -> Bool Source # shiftR :: Bool -> Int -> Bool Source # unsafeShiftR :: Bool -> Int -> Bool Source # rotateL :: Bool -> Int -> Bool Source #  | |
| FiniteBits Bool | Since: base-4.7.0.0  | 
| Bounded Bool | Since: base-2.1  | 
| Enum Bool | Since: base-2.1  | 
| Generic Bool | |
| SingKind Bool | Since: base-4.9.0.0  | 
Defined in GHC.Generics Associated Types type DemoteRep Bool  | |
| Ix Bool | Since: base-2.1  | 
| Read Bool | Since: base-2.1  | 
| Show Bool | Since: base-2.1  | 
| BitOps Bool Source # | |
Defined in Basement.Bits Methods (.&.) :: Bool -> Bool -> Bool Source # (.|.) :: Bool -> Bool -> Bool Source # (.^.) :: Bool -> Bool -> Bool Source # (.<<.) :: Bool -> CountOf Bool -> Bool Source # (.>>.) :: Bool -> CountOf Bool -> Bool Source # bit :: Offset Bool -> Bool Source # isBitSet :: Bool -> Offset Bool -> Bool Source #  | |
| FiniteBitsOps Bool Source # | |
| NormalForm Bool Source # | |
Defined in Basement.NormalForm Methods toNormalForm :: Bool -> () Source #  | |
| Eq Bool | |
| Ord Bool | |
| SingI 'False | Since: base-4.9.0.0  | 
Defined in GHC.Generics  | |
| SingI 'True | Since: base-4.9.0.0  | 
Defined in GHC.Generics  | |
| type DemoteRep Bool | |
Defined in GHC.Generics  | |
| type Rep Bool | Since: base-4.6.0.0  | 
| data Sing (a :: Bool) | |
A fixed-precision integer type with at least the range [-2^29 .. 2^29-1].
 The exact range for a given implementation can be determined by using
 minBound and maxBound from the Bounded class.
Instances
Arbitrary precision integers. In contrast with fixed-size integral types
 such as Int, the Integer type represents the entire infinite range of
 integers.
Integers are stored in a kind of sign-magnitude form, hence do not expect two's complement form when using bit operations.
If the value is small (fit into an Int), IS constructor is used.
 Otherwise Integer and IN constructors are used to store a BigNat
 representing respectively the positive or the negative value magnitude.
Invariant: Integer and IN are used iff value doesn't fit in IS
Instances
Natural number
Invariant: numbers <= 0xffffffffffffffff use the NS constructor
Instances
Offset in a data structure consisting of elements of type ty.
Int is a terrible backing type which is hard to get away from, considering that GHC/Haskell are mostly using this for offset. Trying to bring some sanity by a lightweight wrapping.
Instances
CountOf of a data structure.
More specifically, it represents the number of elements of type ty that fit
 into the data structure.
>>>length (fromList ['a', 'b', 'c', '🌟']) :: CountOf CharCountOf 4
Same caveats as Offset apply here.
Instances
The character type Char is an enumeration whose values represent
Unicode (or equivalently ISO/IEC 10646) code points (i.e. characters, see
http://www.unicode.org/ for details).  This set extends the ISO 8859-1
(Latin-1) character set (the first 256 characters), which is itself an extension
of the ASCII character set (the first 128 characters).  A character literal in
Haskell has type Char.
To convert a Char to or from the corresponding Int value defined
by Unicode, use toEnum and fromEnum from the
Enum class respectively (or equivalently ord and
chr).
Instances
| Data Char | Since: base-4.0.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Char -> c Char Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Char Source # toConstr :: Char -> Constr Source # dataTypeOf :: Char -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Char) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Char) Source # gmapT :: (forall b. Data b => b -> b) -> Char -> Char Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Char -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Char -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Char -> m Char Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char Source #  | |
| Storable Char | Since: base-2.1  | 
Defined in Foreign.Storable Methods sizeOf :: Char -> Int Source # alignment :: Char -> Int Source # peekElemOff :: Ptr Char -> Int -> IO Char Source # pokeElemOff :: Ptr Char -> Int -> Char -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Char Source # pokeByteOff :: Ptr b -> Int -> Char -> IO () Source #  | |
| Bounded Char | Since: base-2.1  | 
| Enum Char | Since: base-2.1  | 
| Ix Char | Since: base-2.1  | 
| Read Char | Since: base-2.1  | 
| Show Char | Since: base-2.1  | 
| NormalForm Char Source # | |
Defined in Basement.NormalForm Methods toNormalForm :: Char -> () Source #  | |
| Subtractive Char Source # | |
Defined in Basement.Numerical.Subtractive Associated Types type Difference Char Source #  | |
| PrimMemoryComparable Char Source # | |
Defined in Basement.PrimType  | |
| PrimType Char Source # | |
Defined in Basement.PrimType Methods primSizeInBytes :: Proxy Char -> CountOf Word8 Source # primShiftToBytes :: Proxy Char -> Int Source # primBaUIndex :: ByteArray# -> Offset Char -> Char Source # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Char -> prim Char Source # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Char -> Char -> prim () Source # primAddrIndex :: Addr# -> Offset Char -> Char Source # primAddrRead :: PrimMonad prim => Addr# -> Offset Char -> prim Char Source # primAddrWrite :: PrimMonad prim => Addr# -> Offset Char -> Char -> prim () Source #  | |
| Eq Char | |
| Ord Char | |
| Generic1 (URec Char :: k -> Type) | |
| Foldable (UChar :: TYPE LiftedRep -> Type) | Since: base-4.9.0.0  | 
Defined in Data.Foldable Methods fold :: Monoid m => UChar m -> m Source # foldMap :: Monoid m => (a -> m) -> UChar a -> m Source # foldMap' :: Monoid m => (a -> m) -> UChar a -> m Source # foldr :: (a -> b -> b) -> b -> UChar a -> b Source # foldr' :: (a -> b -> b) -> b -> UChar a -> b Source # foldl :: (b -> a -> b) -> b -> UChar a -> b Source # foldl' :: (b -> a -> b) -> b -> UChar a -> b Source # foldr1 :: (a -> a -> a) -> UChar a -> a Source # foldl1 :: (a -> a -> a) -> UChar a -> a Source # toList :: UChar a -> [a] Source # null :: UChar a -> Bool Source # length :: UChar a -> Int Source # elem :: Eq a => a -> UChar a -> Bool Source # maximum :: Ord a => UChar a -> a Source # minimum :: Ord a => UChar a -> a Source #  | |
| Traversable (UChar :: Type -> Type) | Since: base-4.9.0.0  | 
| Functor (URec Char :: TYPE LiftedRep -> Type) | Since: base-4.9.0.0  | 
| Generic (URec Char p) | |
| Show (URec Char p) | Since: base-4.9.0.0  | 
| Eq (URec Char p) | Since: base-4.9.0.0  | 
| Ord (URec Char p) | Since: base-4.9.0.0  | 
Defined in GHC.Generics Methods compare :: URec Char p -> URec Char p -> Ordering Source # (<) :: URec Char p -> URec Char p -> Bool Source # (<=) :: URec Char p -> URec Char p -> Bool Source # (>) :: URec Char p -> URec Char p -> Bool Source # (>=) :: URec Char p -> URec Char p -> Bool Source #  | |
| type NatNumMaxBound Char Source # | |
Defined in Basement.Nat  | |
| type Difference Char Source # | |
Defined in Basement.Numerical.Subtractive  | |
| type PrimSize Char Source # | |
Defined in Basement.PrimType  | |
| data URec Char (p :: k) | Used for marking occurrences of  Since: base-4.9.0.0  | 
| type Compare (a :: Char) (b :: Char) | |
Defined in Data.Type.Ord  | |
| type Rep1 (URec Char :: k -> Type) | Since: base-4.9.0.0  | 
Defined in GHC.Generics  | |
| type Rep (URec Char p) | Since: base-4.9.0.0  | 
Defined in GHC.Generics  | |
class Eq ty => PrimType ty Source #
Represent the accessor for types that can be stored in the UArray and MUArray.
Types need to be a instance of storable and have fixed sized.
Minimal complete definition
primSizeInBytes, primShiftToBytes, primBaUIndex, primMbaURead, primMbaUWrite, primAddrIndex, primAddrRead, primAddrWrite
Instances
ASCII value between 0x0 and 0x7f
Instances
| Show Char7 Source # | |
| NormalForm Char7 Source # | |
Defined in Basement.NormalForm Methods toNormalForm :: Char7 -> () Source #  | |
| PrimType Char7 Source # | |
Defined in Basement.PrimType Methods primSizeInBytes :: Proxy Char7 -> CountOf Word8 Source # primShiftToBytes :: Proxy Char7 -> Int Source # primBaUIndex :: ByteArray# -> Offset Char7 -> Char7 Source # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Char7 -> prim Char7 Source # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Char7 -> Char7 -> prim () Source # primAddrIndex :: Addr# -> Offset Char7 -> Char7 Source # primAddrRead :: PrimMonad prim => Addr# -> Offset Char7 -> prim Char7 Source # primAddrWrite :: PrimMonad prim => Addr# -> Offset Char7 -> Char7 -> prim () Source #  | |
| Eq Char7 Source # | |
| Ord Char7 Source # | |
Defined in Basement.Types.Char7  | |
| type NatNumMaxBound Char7 Source # | |
Defined in Basement.Nat  | |
| type PrimSize Char7 Source # | |
Defined in Basement.PrimType  | |
data AsciiString Source #
Opaque packed array of characters in the ASCII encoding
Instances
Opaque packed array of characters in the UTF8 encoding
Instances
| Data String Source # | |
Defined in Basement.UTF8.Base Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> String -> c String Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c String Source # toConstr :: String -> Constr Source # dataTypeOf :: String -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c String) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c String) Source # gmapT :: (forall b. Data b => b -> b) -> String -> String Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> String -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> String -> r Source # gmapQ :: (forall d. Data d => d -> u) -> String -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> String -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> String -> m String Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> String -> m String Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> String -> m String Source #  | |
| IsString String Source # | |
Defined in Basement.UTF8.Base Methods fromString :: String0 -> String Source #  | |
| Monoid String Source # | |
| Semigroup String Source # | |
| IsList String Source # | |
| Show String Source # | |
| NormalForm String Source # | |
Defined in Basement.UTF8.Base Methods toNormalForm :: String -> () Source #  | |
| Eq String Source # | |
| Ord String Source # | |
| From AsciiString String Source # | |
Defined in Basement.From Methods from :: AsciiString -> String Source #  | |
| From String (UArray Word8) Source # | |
| TryFrom (UArray Word8) String Source # | |
| type Item String Source # | |
Defined in Basement.UTF8.Base  | |
An array of type built on top of GHC primitive.
The elements need to have fixed sized and the representation is a packed contiguous array in memory that can easily be passed to foreign interface
Instances
| From AsciiString (UArray Word8) Source # | |
Defined in Basement.From  | |
| From String (UArray Word8) Source # | |
| Data ty => Data (UArray ty) Source # | |
Defined in Basement.UArray.Base Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UArray ty -> c (UArray ty) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UArray ty) Source # toConstr :: UArray ty -> Constr Source # dataTypeOf :: UArray ty -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UArray ty)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UArray ty)) Source # gmapT :: (forall b. Data b => b -> b) -> UArray ty -> UArray ty Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UArray ty -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UArray ty -> r Source # gmapQ :: (forall d. Data d => d -> u) -> UArray ty -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> UArray ty -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> UArray ty -> m (UArray ty) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UArray ty -> m (UArray ty) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UArray ty -> m (UArray ty) Source #  | |
| PrimType ty => Monoid (UArray ty) Source # | |
| PrimType ty => Semigroup (UArray ty) Source # | |
| PrimType ty => IsList (UArray ty) Source # | |
| (PrimType ty, Show ty) => Show (UArray ty) Source # | |
| NormalForm (UArray ty) Source # | |
Defined in Basement.UArray.Base Methods toNormalForm :: UArray ty -> () Source #  | |
| (PrimType ty, Eq ty) => Eq (UArray ty) Source # | |
| (PrimType ty, Ord ty) => Ord (UArray ty) Source # | |
Defined in Basement.UArray.Base  | |
| TryFrom (UArray Word8) String Source # | |
| PrimType ty => From (Block ty) (UArray ty) Source # | |
| PrimType ty => From (Array ty) (UArray ty) Source # | |
| PrimType ty => From (UArray ty) (Block ty) Source # | |
| PrimType ty => From (UArray ty) (Array ty) Source # | |
| (NatWithinBound (CountOf ty) n, KnownNat n, PrimType ty) => TryFrom (UArray ty) (BlockN n ty) Source # | |
| (NatWithinBound Int n, PrimType ty) => From (BlockN n ty) (UArray ty) Source # | |
| type Item (UArray ty) Source # | |
Defined in Basement.UArray.Base  | |
Array of a
Instances
| Functor Array Source # | |
| Data ty => Data (Array ty) Source # | |
Defined in Basement.BoxedArray Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Array ty -> c (Array ty) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Array ty) Source # toConstr :: Array ty -> Constr Source # dataTypeOf :: Array ty -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Array ty)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Array ty)) Source # gmapT :: (forall b. Data b => b -> b) -> Array ty -> Array ty Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Array ty -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Array ty -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Array ty -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Array ty -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Array ty -> m (Array ty) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Array ty -> m (Array ty) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Array ty -> m (Array ty) Source #  | |
| Monoid (Array a) Source # | |
| Semigroup (Array a) Source # | |
| IsList (Array ty) Source # | |
| Show a => Show (Array a) Source # | |
| NormalForm a => NormalForm (Array a) Source # | |
Defined in Basement.BoxedArray Methods toNormalForm :: Array a -> () Source #  | |
| Eq a => Eq (Array a) Source # | |
| Ord a => Ord (Array a) Source # | |
Defined in Basement.BoxedArray  | |
| PrimType ty => From (Array ty) (Block ty) Source # | |
| PrimType ty => From (Array ty) (UArray ty) Source # | |
| PrimType ty => From (UArray ty) (Array ty) Source # | |
| (NatWithinBound (CountOf ty) n, KnownNat n, PrimType ty) => TryFrom (Array ty) (BlockN n ty) Source # | |
| (NatWithinBound Int n, PrimType ty) => From (BlockN n ty) (Array ty) Source # | |
| type Item (Array ty) Source # | |
Defined in Basement.BoxedArray  | |
class Integral a where Source #
Integral Literal support
e.g. 123 :: Integer 123 :: Word8
Methods
fromInteger :: Integer -> a Source #
Instances
class Fractional a where Source #
Fractional Literal support
e.g. 1.2 :: Double 0.03 :: Float
Methods
fromRational :: Rational -> a Source #
Instances
| Fractional CDouble Source # | |
Defined in Basement.Compat.NumLiteral Methods fromRational :: Rational -> CDouble Source #  | |
| Fractional CFloat Source # | |
Defined in Basement.Compat.NumLiteral Methods fromRational :: Rational -> CFloat Source #  | |
| Fractional Rational Source # | |
Defined in Basement.Compat.NumLiteral Methods fromRational :: Rational -> Rational Source #  | |
| Fractional Double Source # | |
Defined in Basement.Compat.NumLiteral Methods fromRational :: Rational -> Double Source #  | |
| Fractional Float Source # | |
Defined in Basement.Compat.NumLiteral Methods fromRational :: Rational -> Float Source #  | |
class HasNegation a where Source #
Negation support
e.g. -(f x)
Instances
8-bit signed integer type
Instances
16-bit signed integer type
Instances
32-bit signed integer type
Instances
64-bit signed integer type
Instances
8-bit unsigned integer type
Instances
16-bit unsigned integer type
Instances
32-bit unsigned integer type
Instances
64-bit unsigned integer type
Instances
Instances
Double-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE double-precision type.
Instances
Single-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE single-precision type.
Instances
A value of type  is a computation which, when performed,
does some I/O before returning a value of type IO aa.
There is really only one way to "perform" an I/O action: bind it to
Main.main in your program.  When your program is run, the I/O will
be performed.  It isn't possible to perform I/O from an arbitrary
function, unless that function is itself in the IO monad and called
at some point, directly or indirectly, from Main.main.
IO is a monad, so IO actions can be combined using either the do-notation
or the >> and >>= operations from the Monad
class.
Instances
| Alternative IO | Since: base-4.9.0.0  | 
| Applicative IO | Since: base-2.1  | 
| Functor IO | Since: base-2.1  | 
| Monad IO | Since: base-2.1  | 
| MonadPlus IO | Since: base-4.9.0.0  | 
| PrimMonad IO Source # | |
Defined in Basement.Monad Methods primitive :: (State# (PrimState IO) -> (# State# (PrimState IO), a #)) -> IO a Source # primThrow :: Exception e => e -> IO a Source # unPrimMonad :: IO a -> State# (PrimState IO) -> (# State# (PrimState IO), a #) Source # primVarNew :: a -> IO (PrimVar IO a) Source #  | |
| Monoid a => Monoid (IO a) | Since: base-4.9.0.0  | 
| Semigroup a => Semigroup (IO a) | Since: base-4.10.0.0  | 
| type PrimState IO Source # | |
Defined in Basement.Monad  | |
| type PrimVar IO Source # | |
Defined in Basement.Monad  | |
The IsList class and its methods are intended to be used in
   conjunction with the OverloadedLists extension.
Since: base-4.7.0.0
Associated Types
The Item type function returns the type of items of the structure
   l.
Methods
fromList :: [Item l] -> l Source #
The fromList function constructs the structure l from the given
   list of Item l
fromListN :: Int -> [Item l] -> l Source #
The fromListN function takes the input list's length and potentially
   uses it to construct the structure l more efficiently compared to
   fromList. If the given number does not equal to the input list's length
   the behaviour of fromListN is not specified.
fromListN (length xs) xs == fromList xs
toList :: l -> [Item l] Source #
The toList function extracts a list of Item l from the structure l.
   It should satisfy fromList . toList = id.
Instances
| IsList Version | Since: base-4.8.0.0  | 
| IsList CallStack | Be aware that 'fromList . toList = id' only for unfrozen  Since: base-4.9.0.0  | 
| IsList AsciiString Source # | |
Defined in Basement.Types.AsciiString Associated Types type Item AsciiString Source # Methods fromList :: [Item AsciiString] -> AsciiString Source # fromListN :: Int -> [Item AsciiString] -> AsciiString Source # toList :: AsciiString -> [Item AsciiString] Source #  | |
| IsList String Source # | |
| IsList (ZipList a) | Since: base-4.15.0.0  | 
| PrimType ty => IsList (Block ty) Source # | |
| IsList (Array ty) Source # | |
| IsList c => IsList (NonEmpty c) Source # | |
| PrimType ty => IsList (UArray ty) Source # | |
| IsList (NonEmpty a) | Since: base-4.9.0.0  | 
| IsList [a] | Since: base-4.7.0.0  | 
class IsString a where Source #
Class for string-like datastructures; used by the overloaded string extension (-XOverloadedStrings in GHC).
Methods
fromString :: String -> a Source #
Instances
| IsString AsciiString Source # | |
Defined in Basement.Types.AsciiString Methods fromString :: String -> AsciiString Source #  | |
| IsString String Source # | |
Defined in Basement.UTF8.Base Methods fromString :: String0 -> String Source #  | |
| IsString a => IsString (Identity a) | Since: base-4.9.0.0  | 
Defined in Data.String Methods fromString :: String -> Identity a Source #  | |
| a ~ Char => IsString [a] | 
 Since: base-2.1  | 
Defined in Data.String Methods fromString :: String -> [a] Source #  | |
| IsString a => IsString (Const a b) | Since: base-4.9.0.0  | 
Defined in Data.String Methods fromString :: String -> Const a b Source #  | |
class Generic a where Source #
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
Methods
Convert from the datatype to its representation
Convert from the representation to the datatype
Instances
The Either type represents values with two possibilities: a value of
type  is either Either a b or Left a.Right 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  is the type of values which can be either
a 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
| Bifunctor Either | Since: base-4.8.0.0  | 
| Generic1 (Either a :: Type -> Type) | |
| Foldable (Either a) | Since: base-4.7.0.0  | 
Defined in Data.Foldable Methods fold :: Monoid m => Either a m -> m Source # foldMap :: Monoid m => (a0 -> m) -> Either a a0 -> m Source # foldMap' :: Monoid m => (a0 -> m) -> Either a a0 -> m Source # foldr :: (a0 -> b -> b) -> b -> Either a a0 -> b Source # foldr' :: (a0 -> b -> b) -> b -> Either a a0 -> b Source # foldl :: (b -> a0 -> b) -> b -> Either a a0 -> b Source # foldl' :: (b -> a0 -> b) -> b -> Either a a0 -> b Source # foldr1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 Source # foldl1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 Source # toList :: Either a a0 -> [a0] Source # null :: Either a a0 -> Bool Source # length :: Either a a0 -> Int Source # elem :: Eq a0 => a0 -> Either a a0 -> Bool Source # maximum :: Ord a0 => Either a a0 -> a0 Source # minimum :: Ord a0 => Either a a0 -> a0 Source #  | |
| Traversable (Either a) | Since: base-4.7.0.0  | 
Defined in Data.Traversable Methods traverse :: Applicative f => (a0 -> f b) -> Either a a0 -> f (Either a b) Source # sequenceA :: Applicative f => Either a (f a0) -> f (Either a a0) Source # mapM :: Monad m => (a0 -> m b) -> Either a a0 -> m (Either a b) Source # sequence :: Monad m => Either a (m a0) -> m (Either a a0) Source #  | |
| Applicative (Either e) | Since: base-3.0  | 
Defined in Data.Either  | |
| Functor (Either a) | Since: base-3.0  | 
| Monad (Either e) | Since: base-4.4.0.0  | 
| MonadFailure (Either a) Source # | |
| From (Maybe a) (Either () a) Source # | |
| (Data a, Data b) => Data (Either a b) | Since: base-4.0.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Either a b -> c (Either a b) Source # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Either a b) Source # toConstr :: Either a b -> Constr Source # dataTypeOf :: Either a b -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Either a b)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Either a b)) Source # gmapT :: (forall b0. Data b0 => b0 -> b0) -> Either a b -> Either a b Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Either a b -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Either a b -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Either a b -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Either a b -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) Source #  | |
| Semigroup (Either a b) | Since: base-4.9.0.0  | 
| Generic (Either a b) | |
| (Read a, Read b) => Read (Either a b) | Since: base-3.0  | 
| (Show a, Show b) => Show (Either a b) | Since: base-3.0  | 
| (NormalForm l, NormalForm r) => NormalForm (Either l r) Source # | |
Defined in Basement.NormalForm Methods toNormalForm :: Either l r -> () 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  | 
Defined in Data.Either Methods compare :: Either a b -> Either a b -> Ordering Source # (<) :: Either a b -> Either a b -> Bool Source # (<=) :: Either a b -> Either a b -> Bool Source # (>) :: Either a b -> Either a b -> Bool Source # (>=) :: Either a b -> Either a b -> Bool Source #  | |
| From (Either a b) (These a b) Source # | |
| type Rep1 (Either a :: Type -> Type) | Since: base-4.6.0.0  | 
Defined in GHC.Generics type Rep1 (Either a :: Type -> Type) = D1 ('MetaData "Either" "Data.Either" "base" 'False) (C1 ('MetaCons "Left" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)) :+: C1 ('MetaCons "Right" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1))  | |
| type Failure (Either a) Source # | |
Defined in Basement.Monad  | |
| type Rep (Either a b) | Since: base-4.6.0.0  | 
Defined in GHC.Generics type Rep (Either a b) = D1 ('MetaData "Either" "Data.Either" "base" 'False) (C1 ('MetaCons "Left" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)) :+: C1 ('MetaCons "Right" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 b)))  | |
class Typeable a => Data a where Source #
The Data class comprehends a fundamental primitive gfoldl for
folding over constructor applications, say terms. This primitive can
be instantiated in several ways to map over the immediate subterms
of a term; see the gmap combinators later in this class.  Indeed, a
generic programmer does not necessarily need to use the ingenious gfoldl
primitive but rather the intuitive gmap combinators.  The gfoldl
primitive is completed by means to query top-level constructors, to
turn constructor representations into proper terms, and to list all
possible datatype constructors.  This completion allows us to serve
generic programming scenarios like read, show, equality, term generation.
The combinators gmapT, gmapQ, gmapM, etc are all provided with
default definitions in terms of gfoldl, leaving open the opportunity
to provide datatype-specific definitions.
(The inclusion of the gmap combinators as members of class Data
allows the programmer or the compiler to derive specialised, and maybe
more efficient code per datatype.  Note: gfoldl is more higher-order
than the gmap combinators.  This is subject to ongoing benchmarking
experiments.  It might turn out that the gmap combinators will be
moved out of the class Data.)
Conceptually, the definition of the gmap combinators in terms of the
primitive gfoldl requires the identification of the gfoldl function
arguments.  Technically, we also need to identify the type constructor
c for the construction of the result type from the folded term type.
In the definition of gmapQx combinators, we use phantom type
constructors for the c in the type of gfoldl because the result type
of a query does not involve the (polymorphic) type of the term argument.
In the definition of gmapQl we simply use the plain constant type
constructor because gfoldl is left-associative anyway and so it is
readily suited to fold a left-associative binary operation over the
immediate subterms.  In the definition of gmapQr, extra effort is
needed. We use a higher-order accumulation trick to mediate between
left-associative constructor application vs. right-associative binary
operation (e.g., (:)).  When the query is meant to compute a value
of type r, then the result type within generic folding is r -> r.
So the result of folding is a function to which we finally pass the
right unit.
With the -XDeriveDataTypeable option, GHC can generate instances of the
Data class automatically.  For example, given the declaration
data T a b = C1 a b | C2 deriving (Typeable, Data)
GHC will generate an instance that is equivalent to
instance (Data a, Data b) => Data (T a b) where
    gfoldl k z (C1 a b) = z C1 `k` a `k` b
    gfoldl k z C2       = z C2
    gunfold k z c = case constrIndex c of
                        1 -> k (k (z C1))
                        2 -> z C2
    toConstr (C1 _ _) = con_C1
    toConstr C2       = con_C2
    dataTypeOf _ = ty_T
con_C1 = mkConstr ty_T "C1" [] Prefix
con_C2 = mkConstr ty_T "C2" [] Prefix
ty_T   = mkDataType "Module.T" [con_C1, con_C2]This is suitable for datatypes that are exported transparently.
Minimal complete definition
Methods
Arguments
| :: (forall d b. Data d => c (d -> b) -> d -> c b) | defines how nonempty constructor applications are folded. It takes the folded tail of the constructor application and its head, i.e., an immediate subterm, and combines them in some way.  | 
| -> (forall g. g -> c g) | defines how the empty constructor application is folded, like the neutral / start element for list folding.  | 
| -> a | structure to be folded.  | 
| -> c a | result, with a type defined in terms of   | 
Left-associative fold operation for constructor applications.
The type of gfoldl is a headache, but operationally it is a simple
 generalisation of a list fold.
The default definition for gfoldl is , which is
 suitable for abstract datatypes with no substructures.const id
gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c a Source #
Unfolding constructor applications
toConstr :: a -> Constr Source #
Obtaining the constructor from a given datum. For proper terms, this is meant to be the top-level constructor. Primitive datatypes are here viewed as potentially infinite sets of values (i.e., constructors).
dataTypeOf :: a -> DataType Source #
The outer type constructor of the type
dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c a) Source #
Mediate types and unary type constructors.
In Data instances of the form
instance (Data a, ...) => Data (T a)
dataCast1 should be defined as gcast1.
The default definition is , which is appropriate
 for instances of other forms.const Nothing
dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a) Source #
Mediate types and binary type constructors.
In Data instances of the form
instance (Data a, Data b, ...) => Data (T a b)
dataCast2 should be defined as gcast2.
The default definition is , which is appropriate
 for instances of other forms.const Nothing
gmapT :: (forall b. Data b => b -> b) -> a -> a Source #
A generic transformation that maps over the immediate subterms
The default definition instantiates the type constructor c in the
 type of gfoldl to an identity datatype constructor, using the
 isomorphism pair as injection and projection.
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r Source #
A generic query with a left-associative binary operator
gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r Source #
A generic query with a right-associative binary operator
gmapQ :: (forall d. Data d => d -> u) -> a -> [u] Source #
A generic query that processes the immediate subterms and returns a list of results. The list is given in the same order as originally specified in the declaration of the data constructors.
gmapQi :: Int -> (forall d. Data d => d -> u) -> a -> u Source #
A generic query that processes one child by index (zero-based)
gmapM :: Monad m => (forall d. Data d => d -> m d) -> a -> m a Source #
A generic monadic transformation that maps over the immediate subterms
The default definition instantiates the type constructor c in
 the type of gfoldl to the monad datatype constructor, defining
 injection and projection using return and >>=.
gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> a -> m a Source #
Transformation of at least one immediate subterm does not fail
gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> a -> m a Source #
Transformation of one immediate subterm with success
Instances
| Data All | Since: base-4.8.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> All -> c All Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c All Source # toConstr :: All -> Constr Source # dataTypeOf :: All -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c All) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c All) Source # gmapT :: (forall b. Data b => b -> b) -> All -> All Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> All -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> All -> r Source # gmapQ :: (forall d. Data d => d -> u) -> All -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> All -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> All -> m All Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> All -> m All Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> All -> m All Source #  | |
| Data Any | Since: base-4.8.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Any -> c Any Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Any Source # toConstr :: Any -> Constr Source # dataTypeOf :: Any -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Any) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Any) Source # gmapT :: (forall b. Data b => b -> b) -> Any -> Any Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Any -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Any -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Any -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Any -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Any -> m Any Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Any -> m Any Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Any -> m Any Source #  | |
| Data Version | Since: base-4.7.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Version -> c Version Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Version Source # toConstr :: Version -> Constr Source # dataTypeOf :: Version -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Version) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Version) Source # gmapT :: (forall b. Data b => b -> b) -> Version -> Version Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Version -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Version -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Version -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Version -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Version -> m Version Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Version -> m Version Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Version -> m Version Source #  | |
| Data IntPtr | Since: base-4.11.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IntPtr -> c IntPtr Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IntPtr Source # toConstr :: IntPtr -> Constr Source # dataTypeOf :: IntPtr -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c IntPtr) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IntPtr) Source # gmapT :: (forall b. Data b => b -> b) -> IntPtr -> IntPtr Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IntPtr -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IntPtr -> r Source # gmapQ :: (forall d. Data d => d -> u) -> IntPtr -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> IntPtr -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> IntPtr -> m IntPtr Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IntPtr -> m IntPtr Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IntPtr -> m IntPtr Source #  | |
| Data WordPtr | Since: base-4.11.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WordPtr -> c WordPtr Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c WordPtr Source # toConstr :: WordPtr -> Constr Source # dataTypeOf :: WordPtr -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c WordPtr) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WordPtr) Source # gmapT :: (forall b. Data b => b -> b) -> WordPtr -> WordPtr Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WordPtr -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WordPtr -> r Source # gmapQ :: (forall d. Data d => d -> u) -> WordPtr -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> WordPtr -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> WordPtr -> m WordPtr Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WordPtr -> m WordPtr Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WordPtr -> m WordPtr Source #  | |
| Data SpecConstrAnnotation | Since: base-4.3.0.0  | 
Defined in GHC.Exts Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SpecConstrAnnotation -> c SpecConstrAnnotation Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SpecConstrAnnotation Source # toConstr :: SpecConstrAnnotation -> Constr Source # dataTypeOf :: SpecConstrAnnotation -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SpecConstrAnnotation) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SpecConstrAnnotation) Source # gmapT :: (forall b. Data b => b -> b) -> SpecConstrAnnotation -> SpecConstrAnnotation Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SpecConstrAnnotation -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SpecConstrAnnotation -> r Source # gmapQ :: (forall d. Data d => d -> u) -> SpecConstrAnnotation -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> SpecConstrAnnotation -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SpecConstrAnnotation -> m SpecConstrAnnotation Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SpecConstrAnnotation -> m SpecConstrAnnotation Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SpecConstrAnnotation -> m SpecConstrAnnotation Source #  | |
| Data Associativity | Since: base-4.9.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Associativity -> c Associativity Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Associativity Source # toConstr :: Associativity -> Constr Source # dataTypeOf :: Associativity -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Associativity) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Associativity) Source # gmapT :: (forall b. Data b => b -> b) -> Associativity -> Associativity Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Associativity -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Associativity -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Associativity -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Associativity -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Associativity -> m Associativity Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Associativity -> m Associativity Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Associativity -> m Associativity Source #  | |
| Data DecidedStrictness | Since: base-4.9.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DecidedStrictness -> c DecidedStrictness Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DecidedStrictness Source # toConstr :: DecidedStrictness -> Constr Source # dataTypeOf :: DecidedStrictness -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DecidedStrictness) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DecidedStrictness) Source # gmapT :: (forall b. Data b => b -> b) -> DecidedStrictness -> DecidedStrictness Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r Source # gmapQ :: (forall d. Data d => d -> u) -> DecidedStrictness -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> DecidedStrictness -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DecidedStrictness -> m DecidedStrictness Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DecidedStrictness -> m DecidedStrictness Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DecidedStrictness -> m DecidedStrictness Source #  | |
| Data Fixity | Since: base-4.9.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Fixity -> c Fixity Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Fixity Source # toConstr :: Fixity -> Constr Source # dataTypeOf :: Fixity -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Fixity) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Fixity) Source # gmapT :: (forall b. Data b => b -> b) -> Fixity -> Fixity Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Fixity -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Fixity -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity Source #  | |
| Data SourceStrictness | Since: base-4.9.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SourceStrictness -> c SourceStrictness Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SourceStrictness Source # toConstr :: SourceStrictness -> Constr Source # dataTypeOf :: SourceStrictness -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SourceStrictness) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SourceStrictness) Source # gmapT :: (forall b. Data b => b -> b) -> SourceStrictness -> SourceStrictness Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r Source # gmapQ :: (forall d. Data d => d -> u) -> SourceStrictness -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> SourceStrictness -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SourceStrictness -> m SourceStrictness Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceStrictness -> m SourceStrictness Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceStrictness -> m SourceStrictness Source #  | |
| Data SourceUnpackedness | Since: base-4.9.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SourceUnpackedness -> c SourceUnpackedness Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SourceUnpackedness Source # toConstr :: SourceUnpackedness -> Constr Source # dataTypeOf :: SourceUnpackedness -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SourceUnpackedness) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SourceUnpackedness) Source # gmapT :: (forall b. Data b => b -> b) -> SourceUnpackedness -> SourceUnpackedness Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r Source # gmapQ :: (forall d. Data d => d -> u) -> SourceUnpackedness -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> SourceUnpackedness -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SourceUnpackedness -> m SourceUnpackedness Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceUnpackedness -> m SourceUnpackedness Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceUnpackedness -> m SourceUnpackedness Source #  | |
| Data Int16 | Since: base-4.0.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int16 -> c Int16 Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int16 Source # toConstr :: Int16 -> Constr Source # dataTypeOf :: Int16 -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int16) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int16) Source # gmapT :: (forall b. Data b => b -> b) -> Int16 -> Int16 Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int16 -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int16 -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Int16 -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int16 -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int16 -> m Int16 Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int16 -> m Int16 Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int16 -> m Int16 Source #  | |
| Data Int32 | Since: base-4.0.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int32 -> c Int32 Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int32 Source # toConstr :: Int32 -> Constr Source # dataTypeOf :: Int32 -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int32) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int32) Source # gmapT :: (forall b. Data b => b -> b) -> Int32 -> Int32 Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int32 -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int32 -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Int32 -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int32 -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int32 -> m Int32 Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int32 -> m Int32 Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int32 -> m Int32 Source #  | |
| Data Int64 | Since: base-4.0.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int64 -> c Int64 Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int64 Source # toConstr :: Int64 -> Constr Source # dataTypeOf :: Int64 -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int64) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int64) Source # gmapT :: (forall b. Data b => b -> b) -> Int64 -> Int64 Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int64 -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int64 -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Int64 -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int64 -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int64 -> m Int64 Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int64 -> m Int64 Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int64 -> m Int64 Source #  | |
| Data Int8 | Since: base-4.0.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int8 -> c Int8 Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int8 Source # toConstr :: Int8 -> Constr Source # dataTypeOf :: Int8 -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int8) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int8) Source # gmapT :: (forall b. Data b => b -> b) -> Int8 -> Int8 Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int8 -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int8 -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Int8 -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int8 -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int8 -> m Int8 Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int8 -> m Int8 Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int8 -> m Int8 Source #  | |
| Data Word16 | Since: base-4.0.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word16 -> c Word16 Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word16 Source # toConstr :: Word16 -> Constr Source # dataTypeOf :: Word16 -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word16) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word16) Source # gmapT :: (forall b. Data b => b -> b) -> Word16 -> Word16 Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word16 -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word16 -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Word16 -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word16 -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word16 -> m Word16 Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word16 -> m Word16 Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word16 -> m Word16 Source #  | |
| Data Word32 | Since: base-4.0.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word32 -> c Word32 Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word32 Source # toConstr :: Word32 -> Constr Source # dataTypeOf :: Word32 -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word32) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word32) Source # gmapT :: (forall b. Data b => b -> b) -> Word32 -> Word32 Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word32 -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word32 -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Word32 -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word32 -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word32 -> m Word32 Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word32 -> m Word32 Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word32 -> m Word32 Source #  | |
| Data Word64 | Since: base-4.0.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word64 -> c Word64 Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word64 Source # toConstr :: Word64 -> Constr Source # dataTypeOf :: Word64 -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word64) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word64) Source # gmapT :: (forall b. Data b => b -> b) -> Word64 -> Word64 Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word64 -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word64 -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Word64 -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word64 -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word64 -> m Word64 Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word64 -> m Word64 Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word64 -> m Word64 Source #  | |
| Data Word8 | Since: base-4.0.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word8 -> c Word8 Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word8 Source # toConstr :: Word8 -> Constr Source # dataTypeOf :: Word8 -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word8) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word8) Source # gmapT :: (forall b. Data b => b -> b) -> Word8 -> Word8 Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word8 -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word8 -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Word8 -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word8 -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word8 -> m Word8 Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word8 -> m Word8 Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word8 -> m Word8 Source #  | |
| Data Encoding Source # | |
Defined in Basement.String Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Encoding -> c Encoding Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Encoding Source # toConstr :: Encoding -> Constr Source # dataTypeOf :: Encoding -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Encoding) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Encoding) Source # gmapT :: (forall b. Data b => b -> b) -> Encoding -> Encoding Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Encoding -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Encoding -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Encoding -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Encoding -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Encoding -> m Encoding Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Encoding -> m Encoding Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Encoding -> m Encoding Source #  | |
| Data String Source # | |
Defined in Basement.UTF8.Base Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> String -> c String Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c String Source # toConstr :: String -> Constr Source # dataTypeOf :: String -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c String) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c String) Source # gmapT :: (forall b. Data b => b -> b) -> String -> String Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> String -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> String -> r Source # gmapQ :: (forall d. Data d => d -> u) -> String -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> String -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> String -> m String Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> String -> m String Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> String -> m String Source #  | |
| Data Ordering | Since: base-4.0.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ordering -> c Ordering Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Ordering Source # toConstr :: Ordering -> Constr Source # dataTypeOf :: Ordering -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Ordering) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ordering) Source # gmapT :: (forall b. Data b => b -> b) -> Ordering -> Ordering Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ordering -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ordering -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Ordering -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Ordering -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering Source #  | |
| Data Integer | Since: base-4.0.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Integer -> c Integer Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Integer Source # toConstr :: Integer -> Constr Source # dataTypeOf :: Integer -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Integer) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Integer) Source # gmapT :: (forall b. Data b => b -> b) -> Integer -> Integer Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Integer -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Integer -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Integer -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Integer -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Integer -> m Integer Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Integer -> m Integer Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Integer -> m Integer Source #  | |
| Data Natural | Since: base-4.8.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Natural -> c Natural Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Natural Source # toConstr :: Natural -> Constr Source # dataTypeOf :: Natural -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Natural) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Natural) Source # gmapT :: (forall b. Data b => b -> b) -> Natural -> Natural Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Natural -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Natural -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Natural -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Natural -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Natural -> m Natural Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Natural -> m Natural Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Natural -> m Natural Source #  | |
| Data () | Since: base-4.0.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> () -> c () Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c () Source # toConstr :: () -> Constr Source # dataTypeOf :: () -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ()) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ()) Source # gmapT :: (forall b. Data b => b -> b) -> () -> () Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> () -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> () -> r Source # gmapQ :: (forall d. Data d => d -> u) -> () -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> () -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> () -> m () Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> () -> m () Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> () -> m () Source #  | |
| Data Bool | Since: base-4.0.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bool -> c Bool Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Bool Source # toConstr :: Bool -> Constr Source # dataTypeOf :: Bool -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Bool) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bool) Source # gmapT :: (forall b. Data b => b -> b) -> Bool -> Bool Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bool -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bool -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Bool -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Bool -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bool -> m Bool Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bool -> m Bool Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bool -> m Bool Source #  | |
| Data Char | Since: base-4.0.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Char -> c Char Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Char Source # toConstr :: Char -> Constr Source # dataTypeOf :: Char -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Char) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Char) Source # gmapT :: (forall b. Data b => b -> b) -> Char -> Char Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Char -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Char -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Char -> m Char Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char Source #  | |
| Data Double | Since: base-4.0.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Double -> c Double Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Double Source # toConstr :: Double -> Constr Source # dataTypeOf :: Double -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Double) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Double) Source # gmapT :: (forall b. Data b => b -> b) -> Double -> Double Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Double -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Double -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Double -> m Double Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double Source #  | |
| Data Float | Since: base-4.0.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Float -> c Float Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Float Source # toConstr :: Float -> Constr Source # dataTypeOf :: Float -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Float) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Float) Source # gmapT :: (forall b. Data b => b -> b) -> Float -> Float Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Float -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Float -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Float -> m Float Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float Source #  | |
| Data Int | Since: base-4.0.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int -> c Int Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int Source # toConstr :: Int -> Constr Source # dataTypeOf :: Int -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int) Source # gmapT :: (forall b. Data b => b -> b) -> Int -> Int Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Int -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int -> m Int Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int Source #  | |
| Data Word | Since: base-4.0.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word -> c Word Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word Source # toConstr :: Word -> Constr Source # dataTypeOf :: Word -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word) Source # gmapT :: (forall b. Data b => b -> b) -> Word -> Word Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Word -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word -> m Word Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word Source #  | |
| Data a => Data (ZipList a) | Since: base-4.14.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ZipList a -> c (ZipList a) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ZipList a) Source # toConstr :: ZipList a -> Constr Source # dataTypeOf :: ZipList a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ZipList a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ZipList a)) Source # gmapT :: (forall b. Data b => b -> b) -> ZipList a -> ZipList a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ZipList a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ZipList a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> ZipList a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> ZipList a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ZipList a -> m (ZipList a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ZipList a -> m (ZipList a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ZipList a -> m (ZipList a) Source #  | |
| Data a => Data (Identity a) | Since: base-4.9.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Identity a -> c (Identity a) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Identity a) Source # toConstr :: Identity a -> Constr Source # dataTypeOf :: Identity a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Identity a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Identity a)) Source # gmapT :: (forall b. Data b => b -> b) -> Identity a -> Identity a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Identity a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Identity a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Identity a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Identity a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Identity a -> m (Identity a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Identity a -> m (Identity a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Identity a -> m (Identity a) Source #  | |
| Data a => Data (First a) | Since: base-4.8.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> First a -> c (First a) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (First a) Source # toConstr :: First a -> Constr Source # dataTypeOf :: First a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (First a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (First a)) Source # gmapT :: (forall b. Data b => b -> b) -> First a -> First a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> First a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> First a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> First a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> First a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> First a -> m (First a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> First a -> m (First a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> First a -> m (First a) Source #  | |
| Data a => Data (Last a) | Since: base-4.8.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Last a -> c (Last a) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Last a) Source # toConstr :: Last a -> Constr Source # dataTypeOf :: Last a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Last a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Last a)) Source # gmapT :: (forall b. Data b => b -> b) -> Last a -> Last a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Last a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Last a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Last a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Last a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) Source #  | |
| Data a => Data (Down a) | Since: base-4.12.0.0  | 
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) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Down a) Source # toConstr :: Down a -> Constr Source # dataTypeOf :: Down a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Down a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Down a)) Source # gmapT :: (forall b. Data b => b -> b) -> Down a -> Down a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Down a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Down a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Down a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Down a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Down a -> m (Down a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Down a -> m (Down a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Down a -> m (Down a) Source #  | |
| Data a => Data (First a) | Since: base-4.9.0.0  | 
Defined in Data.Semigroup Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> First a -> c (First a) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (First a) Source # toConstr :: First a -> Constr Source # dataTypeOf :: First a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (First a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (First a)) Source # gmapT :: (forall b. Data b => b -> b) -> First a -> First a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> First a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> First a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> First a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> First a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> First a -> m (First a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> First a -> m (First a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> First a -> m (First a) Source #  | |
| Data a => Data (Last a) | Since: base-4.9.0.0  | 
Defined in Data.Semigroup Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Last a -> c (Last a) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Last a) Source # toConstr :: Last a -> Constr Source # dataTypeOf :: Last a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Last a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Last a)) Source # gmapT :: (forall b. Data b => b -> b) -> Last a -> Last a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Last a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Last a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Last a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Last a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) Source #  | |
| Data a => Data (Max a) | Since: base-4.9.0.0  | 
Defined in Data.Semigroup Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Max a -> c (Max a) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Max a) Source # toConstr :: Max a -> Constr Source # dataTypeOf :: Max a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Max a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Max a)) Source # gmapT :: (forall b. Data b => b -> b) -> Max a -> Max a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Max a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Max a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Max a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Max a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Max a -> m (Max a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Max a -> m (Max a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Max a -> m (Max a) Source #  | |
| Data a => Data (Min a) | Since: base-4.9.0.0  | 
Defined in Data.Semigroup Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Min a -> c (Min a) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Min a) Source # toConstr :: Min a -> Constr Source # dataTypeOf :: Min a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Min a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Min a)) Source # gmapT :: (forall b. Data b => b -> b) -> Min a -> Min a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Min a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Min a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Min a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Min a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Min a -> m (Min a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Min a -> m (Min a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Min a -> m (Min a) Source #  | |
| Data m => Data (WrappedMonoid m) | Since: base-4.9.0.0  | 
Defined in Data.Semigroup Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WrappedMonoid m -> c (WrappedMonoid m) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WrappedMonoid m) Source # toConstr :: WrappedMonoid m -> Constr Source # dataTypeOf :: WrappedMonoid m -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (WrappedMonoid m)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (WrappedMonoid m)) Source # gmapT :: (forall b. Data b => b -> b) -> WrappedMonoid m -> WrappedMonoid m Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WrappedMonoid m -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WrappedMonoid m -> r Source # gmapQ :: (forall d. Data d => d -> u) -> WrappedMonoid m -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> WrappedMonoid m -> u Source # gmapM :: Monad m0 => (forall d. Data d => d -> m0 d) -> WrappedMonoid m -> m0 (WrappedMonoid m) Source # gmapMp :: MonadPlus m0 => (forall d. Data d => d -> m0 d) -> WrappedMonoid m -> m0 (WrappedMonoid m) Source # gmapMo :: MonadPlus m0 => (forall d. Data d => d -> m0 d) -> WrappedMonoid m -> m0 (WrappedMonoid m) Source #  | |
| Data a => Data (Dual a) | Since: base-4.8.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Dual a -> c (Dual a) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Dual a) Source # toConstr :: Dual a -> Constr Source # dataTypeOf :: Dual a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Dual a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Dual a)) Source # gmapT :: (forall b. Data b => b -> b) -> Dual a -> Dual a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dual a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dual a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Dual a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Dual a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Dual a -> m (Dual a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Dual a -> m (Dual a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Dual a -> m (Dual a) Source #  | |
| Data a => Data (Product a) | Since: base-4.8.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Product a -> c (Product a) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Product a) Source # toConstr :: Product a -> Constr Source # dataTypeOf :: Product a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Product a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Product a)) Source # gmapT :: (forall b. Data b => b -> b) -> Product a -> Product a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Product a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Product a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Product a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Product a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Product a -> m (Product a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Product a -> m (Product a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Product a -> m (Product a) Source #  | |
| Data a => Data (Sum a) | Since: base-4.8.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Sum a -> c (Sum a) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Sum a) Source # toConstr :: Sum a -> Constr Source # dataTypeOf :: Sum a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Sum a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sum a)) Source # gmapT :: (forall b. Data b => b -> b) -> Sum a -> Sum a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sum a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sum a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Sum a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Sum a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Sum a -> m (Sum a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Sum a -> m (Sum a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Sum a -> m (Sum a) Source #  | |
| Data a => Data (ForeignPtr a) | Since: base-4.8.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ForeignPtr a -> c (ForeignPtr a) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ForeignPtr a) Source # toConstr :: ForeignPtr a -> Constr Source # dataTypeOf :: ForeignPtr a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ForeignPtr a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ForeignPtr a)) Source # gmapT :: (forall b. Data b => b -> b) -> ForeignPtr a -> ForeignPtr a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ForeignPtr a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ForeignPtr a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> ForeignPtr a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> ForeignPtr a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ForeignPtr a -> m (ForeignPtr a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignPtr a -> m (ForeignPtr a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignPtr a -> m (ForeignPtr a) Source #  | |
| Data p => Data (Par1 p) | Since: base-4.9.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Par1 p -> c (Par1 p) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Par1 p) Source # toConstr :: Par1 p -> Constr Source # dataTypeOf :: Par1 p -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Par1 p)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Par1 p)) Source # gmapT :: (forall b. Data b => b -> b) -> Par1 p -> Par1 p Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Par1 p -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Par1 p -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Par1 p -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Par1 p -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Par1 p -> m (Par1 p) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Par1 p -> m (Par1 p) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Par1 p -> m (Par1 p) Source #  | |
| Data a => Data (Ptr a) | Since: base-4.8.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ptr a -> c (Ptr a) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Ptr a) Source # toConstr :: Ptr a -> Constr Source # dataTypeOf :: Ptr a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Ptr a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ptr a)) Source # gmapT :: (forall b. Data b => b -> b) -> Ptr a -> Ptr a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ptr a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ptr a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Ptr a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Ptr a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a) Source #  | |
| (Data a, Integral a) => Data (Ratio a) | Since: base-4.0.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ratio a -> c (Ratio a) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Ratio a) Source # toConstr :: Ratio a -> Constr Source # dataTypeOf :: Ratio a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Ratio a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ratio a)) Source # gmapT :: (forall b. Data b => b -> b) -> Ratio a -> Ratio a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ratio a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ratio a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Ratio a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Ratio a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ratio a -> m (Ratio a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ratio a -> m (Ratio a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ratio a -> m (Ratio a) Source #  | |
| Data ty => Data (Block ty) Source # | |
Defined in Basement.Block.Base Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Block ty -> c (Block ty) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Block ty) Source # toConstr :: Block ty -> Constr Source # dataTypeOf :: Block ty -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Block ty)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Block ty)) Source # gmapT :: (forall b. Data b => b -> b) -> Block ty -> Block ty Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Block ty -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Block ty -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Block ty -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Block ty -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Block ty -> m (Block ty) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Block ty -> m (Block ty) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Block ty -> m (Block ty) Source #  | |
| Data ty => Data (Array ty) Source # | |
Defined in Basement.BoxedArray Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Array ty -> c (Array ty) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Array ty) Source # toConstr :: Array ty -> Constr Source # dataTypeOf :: Array ty -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Array ty)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Array ty)) Source # gmapT :: (forall b. Data b => b -> b) -> Array ty -> Array ty Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Array ty -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Array ty -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Array ty -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Array ty -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Array ty -> m (Array ty) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Array ty -> m (Array ty) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Array ty -> m (Array ty) Source #  | |
| Data ty => Data (UArray ty) Source # | |
Defined in Basement.UArray.Base Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UArray ty -> c (UArray ty) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UArray ty) Source # toConstr :: UArray ty -> Constr Source # dataTypeOf :: UArray ty -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UArray ty)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UArray ty)) Source # gmapT :: (forall b. Data b => b -> b) -> UArray ty -> UArray ty Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UArray ty -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UArray ty -> r Source # gmapQ :: (forall d. Data d => d -> u) -> UArray ty -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> UArray ty -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> UArray ty -> m (UArray ty) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UArray ty -> m (UArray ty) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UArray ty -> m (UArray ty) Source #  | |
| Data a => Data (NonEmpty a) | Since: base-4.9.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NonEmpty a -> c (NonEmpty a) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (NonEmpty a) Source # toConstr :: NonEmpty a -> Constr Source # dataTypeOf :: NonEmpty a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (NonEmpty a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (NonEmpty a)) Source # gmapT :: (forall b. Data b => b -> b) -> NonEmpty a -> NonEmpty a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NonEmpty a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NonEmpty a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> NonEmpty a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> NonEmpty a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a) Source #  | |
| Data a => Data (Maybe a) | Since: base-4.0.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Maybe a -> c (Maybe a) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Maybe a) Source # toConstr :: Maybe a -> Constr Source # dataTypeOf :: Maybe a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Maybe a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Maybe a)) Source # gmapT :: (forall b. Data b => b -> b) -> Maybe a -> Maybe a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Maybe a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Maybe a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) Source #  | |
| Data a => Data (a) | Since: base-4.15  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> (a) -> c (a) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (a) Source # toConstr :: (a) -> Constr Source # dataTypeOf :: (a) -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (a)) Source # gmapT :: (forall b. Data b => b -> b) -> (a) -> (a) Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (a) -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (a) -> r Source # gmapQ :: (forall d. Data d => d -> u) -> (a) -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> (a) -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> (a) -> m (a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (a) -> m (a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (a) -> m (a) Source #  | |
| Data a => Data [a] | Since: base-4.0.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> [a] -> c [a] Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c [a] Source # toConstr :: [a] -> Constr Source # dataTypeOf :: [a] -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c [a]) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c [a]) Source # gmapT :: (forall b. Data b => b -> b) -> [a] -> [a] Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> [a] -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> [a] -> r Source # gmapQ :: (forall d. Data d => d -> u) -> [a] -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> [a] -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> [a] -> m [a] Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> [a] -> m [a] Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> [a] -> m [a] Source #  | |
| (Typeable m, Typeable a, Data (m a)) => Data (WrappedMonad m a) | Since: base-4.14.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WrappedMonad m a -> c (WrappedMonad m a) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WrappedMonad m a) Source # toConstr :: WrappedMonad m a -> Constr Source # dataTypeOf :: WrappedMonad m a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (WrappedMonad m a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (WrappedMonad m a)) Source # gmapT :: (forall b. Data b => b -> b) -> WrappedMonad m a -> WrappedMonad m a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WrappedMonad m a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WrappedMonad m a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> WrappedMonad m a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> WrappedMonad m a -> u Source # gmapM :: Monad m0 => (forall d. Data d => d -> m0 d) -> WrappedMonad m a -> m0 (WrappedMonad m a) Source # gmapMp :: MonadPlus m0 => (forall d. Data d => d -> m0 d) -> WrappedMonad m a -> m0 (WrappedMonad m a) Source # gmapMo :: MonadPlus m0 => (forall d. Data d => d -> m0 d) -> WrappedMonad m a -> m0 (WrappedMonad m a) Source #  | |
| (Data a, Data b) => Data (Either a b) | Since: base-4.0.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Either a b -> c (Either a b) Source # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Either a b) Source # toConstr :: Either a b -> Constr Source # dataTypeOf :: Either a b -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Either a b)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Either a b)) Source # gmapT :: (forall b0. Data b0 => b0 -> b0) -> Either a b -> Either a b Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Either a b -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Either a b -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Either a b -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Either a b -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) Source #  | |
| Data t => Data (Proxy t) | Since: base-4.7.0.0  | 
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) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Proxy t) Source # toConstr :: Proxy t -> Constr Source # dataTypeOf :: Proxy t -> DataType Source # dataCast1 :: Typeable t0 => (forall d. Data d => c (t0 d)) -> Maybe (c (Proxy t)) Source # dataCast2 :: Typeable t0 => (forall d e. (Data d, Data e) => c (t0 d e)) -> Maybe (c (Proxy t)) Source # gmapT :: (forall b. Data b => b -> b) -> Proxy t -> Proxy t Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Proxy t -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Proxy t -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Proxy t -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Proxy t -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Proxy t -> m (Proxy t) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Proxy t -> m (Proxy t) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Proxy t -> m (Proxy t) Source #  | |
| (Data a, Data b) => Data (Arg a b) | Since: base-4.9.0.0  | 
Defined in Data.Semigroup Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Arg a b -> c (Arg a b) Source # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Arg a b) Source # toConstr :: Arg a b -> Constr Source # dataTypeOf :: Arg a b -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Arg a b)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Arg a b)) Source # gmapT :: (forall b0. Data b0 => b0 -> b0) -> Arg a b -> Arg a b Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Arg a b -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Arg a b -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Arg a b -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Arg a b -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Arg a b -> m (Arg a b) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Arg a b -> m (Arg a b) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Arg a b -> m (Arg a b) Source #  | |
| (Data a, Data b, Ix a) => Data (Array a b) | Since: base-4.8.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Array a b -> c (Array a b) Source # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Array a b) Source # toConstr :: Array a b -> Constr Source # dataTypeOf :: Array a b -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Array a b)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Array a b)) Source # gmapT :: (forall b0. Data b0 => b0 -> b0) -> Array a b -> Array a b Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Array a b -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Array a b -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Array a b -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Array a b -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Array a b -> m (Array a b) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Array a b -> m (Array a b) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Array a b -> m (Array a b) Source #  | |
| Data p => Data (U1 p) | Since: base-4.9.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> U1 p -> c (U1 p) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (U1 p) Source # toConstr :: U1 p -> Constr Source # dataTypeOf :: U1 p -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (U1 p)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (U1 p)) Source # gmapT :: (forall b. Data b => b -> b) -> U1 p -> U1 p Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> U1 p -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> U1 p -> r Source # gmapQ :: (forall d. Data d => d -> u) -> U1 p -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> U1 p -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> U1 p -> m (U1 p) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> U1 p -> m (U1 p) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> U1 p -> m (U1 p) Source #  | |
| Data p => Data (V1 p) | Since: base-4.9.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> V1 p -> c (V1 p) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (V1 p) Source # toConstr :: V1 p -> Constr Source # dataTypeOf :: V1 p -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (V1 p)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (V1 p)) Source # gmapT :: (forall b. Data b => b -> b) -> V1 p -> V1 p Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> V1 p -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> V1 p -> r Source # gmapQ :: (forall d. Data d => d -> u) -> V1 p -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> V1 p -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> V1 p -> m (V1 p) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> V1 p -> m (V1 p) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> V1 p -> m (V1 p) Source #  | |
| (KnownNat n, Data a) => Data (BlockN n a) Source # | |
Defined in Basement.Sized.Block Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BlockN n a -> c (BlockN n a) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (BlockN n a) Source # toConstr :: BlockN n a -> Constr Source # dataTypeOf :: BlockN n a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (BlockN n a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (BlockN n a)) Source # gmapT :: (forall b. Data b => b -> b) -> BlockN n a -> BlockN n a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BlockN n a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BlockN n a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> BlockN n a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> BlockN n a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> BlockN n a -> m (BlockN n a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BlockN n a -> m (BlockN n a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BlockN n a -> m (BlockN n a) Source #  | |
| (Data a, Data b) => Data (a, b) | Since: base-4.0.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> (a, b) -> c (a, b) Source # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (a, b) Source # toConstr :: (a, b) -> Constr Source # dataTypeOf :: (a, b) -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (a, b)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (a, b)) Source # gmapT :: (forall b0. Data b0 => b0 -> b0) -> (a, b) -> (a, b) Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (a, b) -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (a, b) -> r Source # gmapQ :: (forall d. Data d => d -> u) -> (a, b) -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> (a, b) -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> (a, b) -> m (a, b) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (a, b) -> m (a, b) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (a, b) -> m (a, b) Source #  | |
| (Typeable a, Typeable b, Typeable c, Data (a b c)) => Data (WrappedArrow a b c) | Since: base-4.14.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b0. Data d => c0 (d -> b0) -> d -> c0 b0) -> (forall g. g -> c0 g) -> WrappedArrow a b c -> c0 (WrappedArrow a b c) Source # gunfold :: (forall b0 r. Data b0 => c0 (b0 -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (WrappedArrow a b c) Source # toConstr :: WrappedArrow a b c -> Constr Source # dataTypeOf :: WrappedArrow a b c -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c0 (t d)) -> Maybe (c0 (WrappedArrow a b c)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c0 (t d e)) -> Maybe (c0 (WrappedArrow a b c)) Source # gmapT :: (forall b0. Data b0 => b0 -> b0) -> WrappedArrow a b c -> WrappedArrow a b c Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WrappedArrow a b c -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WrappedArrow a b c -> r Source # gmapQ :: (forall d. Data d => d -> u) -> WrappedArrow a b c -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> WrappedArrow a b c -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> WrappedArrow a b c -> m (WrappedArrow a b c) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WrappedArrow a b c -> m (WrappedArrow a b c) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WrappedArrow a b c -> m (WrappedArrow a b c) Source #  | |
| (Typeable k, Data a, Typeable b) => Data (Const a b) | Since: base-4.10.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Const a b -> c (Const a b) Source # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Const a b) Source # toConstr :: Const a b -> Constr Source # dataTypeOf :: Const a b -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Const a b)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Const a b)) Source # gmapT :: (forall b0. Data b0 => b0 -> b0) -> Const a b -> Const a b Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Const a b -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Const a b -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Const a b -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Const a b -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Const a b -> m (Const a b) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Const a b -> m (Const a b) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Const a b -> m (Const a b) Source #  | |
| (Data (f a), Data a, Typeable f) => Data (Ap f a) | Since: base-4.12.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ap f a -> c (Ap f a) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Ap f a) Source # toConstr :: Ap f a -> Constr Source # dataTypeOf :: Ap f a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Ap f a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ap f a)) Source # gmapT :: (forall b. Data b => b -> b) -> Ap f a -> Ap f a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ap f a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ap f a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Ap f a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Ap f a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ap f a -> m (Ap f a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ap f a -> m (Ap f a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ap f a -> m (Ap f a) Source #  | |
| (Data (f a), Data a, Typeable f) => Data (Alt f a) | Since: base-4.8.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Alt f a -> c (Alt f a) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Alt f a) Source # toConstr :: Alt f a -> Constr Source # dataTypeOf :: Alt f a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Alt f a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Alt f a)) Source # gmapT :: (forall b. Data b => b -> b) -> Alt f a -> Alt f a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alt f a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alt f a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Alt f a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Alt f a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Alt f a -> m (Alt f a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt f a -> m (Alt f a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt f a -> m (Alt f a) Source #  | |
| (Coercible a b, Data a, Data b) => Data (Coercion a b) | Since: base-4.7.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Coercion a b -> c (Coercion a b) Source # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Coercion a b) Source # toConstr :: Coercion a b -> Constr Source # dataTypeOf :: Coercion a b -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Coercion a b)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Coercion a b)) Source # gmapT :: (forall b0. Data b0 => b0 -> b0) -> Coercion a b -> Coercion a b Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Coercion a b -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Coercion a b -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Coercion a b -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Coercion a b -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Coercion a b -> m (Coercion a b) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Coercion a b -> m (Coercion a b) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Coercion a b -> m (Coercion a b) Source #  | |
| (a ~ b, Data a) => Data (a :~: b) | Since: base-4.7.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> (a :~: b) -> c (a :~: b) Source # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (a :~: b) Source # toConstr :: (a :~: b) -> Constr Source # dataTypeOf :: (a :~: b) -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (a :~: b)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (a :~: b)) Source # gmapT :: (forall b0. Data b0 => b0 -> b0) -> (a :~: b) -> a :~: b Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (a :~: b) -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (a :~: b) -> r Source # gmapQ :: (forall d. Data d => d -> u) -> (a :~: b) -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> (a :~: b) -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> (a :~: b) -> m (a :~: b) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (a :~: b) -> m (a :~: b) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (a :~: b) -> m (a :~: b) Source #  | |
| (Data (f p), Typeable f, Data p) => Data (Rec1 f p) | Since: base-4.9.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Rec1 f p -> c (Rec1 f p) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Rec1 f p) Source # toConstr :: Rec1 f p -> Constr Source # dataTypeOf :: Rec1 f p -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Rec1 f p)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rec1 f p)) Source # gmapT :: (forall b. Data b => b -> b) -> Rec1 f p -> Rec1 f p Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rec1 f p -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rec1 f p -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Rec1 f p -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Rec1 f p -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Rec1 f p -> m (Rec1 f p) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Rec1 f p -> m (Rec1 f p) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Rec1 f p -> m (Rec1 f p) Source #  | |
| (Data a, Data b, Data c) => Data (a, b, c) | Since: base-4.0.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b0. Data d => c0 (d -> b0) -> d -> c0 b0) -> (forall g. g -> c0 g) -> (a, b, c) -> c0 (a, b, c) Source # gunfold :: (forall b0 r. Data b0 => c0 (b0 -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (a, b, c) Source # toConstr :: (a, b, c) -> Constr Source # dataTypeOf :: (a, b, c) -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c0 (t d)) -> Maybe (c0 (a, b, c)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c0 (t d e)) -> Maybe (c0 (a, b, c)) Source # gmapT :: (forall b0. Data b0 => b0 -> b0) -> (a, b, c) -> (a, b, c) Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (a, b, c) -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (a, b, c) -> r Source # gmapQ :: (forall d. Data d => d -> u) -> (a, b, c) -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> (a, b, c) -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> (a, b, c) -> m (a, b, c) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (a, b, c) -> m (a, b, c) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (a, b, c) -> m (a, b, c) Source #  | |
| (Typeable i, Typeable j, Typeable a, Typeable b, a ~~ b) => Data (a :~~: b) | Since: base-4.10.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> (a :~~: b) -> c (a :~~: b) Source # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (a :~~: b) Source # toConstr :: (a :~~: b) -> Constr Source # dataTypeOf :: (a :~~: b) -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (a :~~: b)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (a :~~: b)) Source # gmapT :: (forall b0. Data b0 => b0 -> b0) -> (a :~~: b) -> a :~~: b Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (a :~~: b) -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (a :~~: b) -> r Source # gmapQ :: (forall d. Data d => d -> u) -> (a :~~: b) -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> (a :~~: b) -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> (a :~~: b) -> m (a :~~: b) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (a :~~: b) -> m (a :~~: b) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (a :~~: b) -> m (a :~~: b) Source #  | |
| (Typeable f, Typeable g, Data p, Data (f p), Data (g p)) => Data ((f :*: g) p) | Since: base-4.9.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g0. g0 -> c g0) -> (f :*: g) p -> c ((f :*: g) p) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ((f :*: g) p) Source # toConstr :: (f :*: g) p -> Constr Source # dataTypeOf :: (f :*: g) p -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ((f :*: g) p)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ((f :*: g) p)) Source # gmapT :: (forall b. Data b => b -> b) -> (f :*: g) p -> (f :*: g) p Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (f :*: g) p -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (f :*: g) p -> r Source # gmapQ :: (forall d. Data d => d -> u) -> (f :*: g) p -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> (f :*: g) p -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> (f :*: g) p -> m ((f :*: g) p) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (f :*: g) p -> m ((f :*: g) p) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (f :*: g) p -> m ((f :*: g) p) Source #  | |
| (Typeable f, Typeable g, Data p, Data (f p), Data (g p)) => Data ((f :+: g) p) | Since: base-4.9.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g0. g0 -> c g0) -> (f :+: g) p -> c ((f :+: g) p) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ((f :+: g) p) Source # toConstr :: (f :+: g) p -> Constr Source # dataTypeOf :: (f :+: g) p -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ((f :+: g) p)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ((f :+: g) p)) Source # gmapT :: (forall b. Data b => b -> b) -> (f :+: g) p -> (f :+: g) p Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (f :+: g) p -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (f :+: g) p -> r Source # gmapQ :: (forall d. Data d => d -> u) -> (f :+: g) p -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> (f :+: g) p -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> (f :+: g) p -> m ((f :+: g) p) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (f :+: g) p -> m ((f :+: g) p) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (f :+: g) p -> m ((f :+: g) p) Source #  | |
| (Typeable i, Data p, Data c) => Data (K1 i c p) | Since: base-4.9.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c0 (d -> b) -> d -> c0 b) -> (forall g. g -> c0 g) -> K1 i c p -> c0 (K1 i c p) Source # gunfold :: (forall b r. Data b => c0 (b -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (K1 i c p) Source # toConstr :: K1 i c p -> Constr Source # dataTypeOf :: K1 i c p -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c0 (t d)) -> Maybe (c0 (K1 i c p)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c0 (t d e)) -> Maybe (c0 (K1 i c p)) Source # gmapT :: (forall b. Data b => b -> b) -> K1 i c p -> K1 i c p Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> K1 i c p -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> K1 i c p -> r Source # gmapQ :: (forall d. Data d => d -> u) -> K1 i c p -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> K1 i c p -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> K1 i c p -> m (K1 i c p) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> K1 i c p -> m (K1 i c p) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> K1 i c p -> m (K1 i c p) Source #  | |
| (Data a, Data b, Data c, Data d) => Data (a, b, c, d) | Since: base-4.0.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d0 b0. Data d0 => c0 (d0 -> b0) -> d0 -> c0 b0) -> (forall g. g -> c0 g) -> (a, b, c, d) -> c0 (a, b, c, d) Source # gunfold :: (forall b0 r. Data b0 => c0 (b0 -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (a, b, c, d) Source # toConstr :: (a, b, c, d) -> Constr Source # dataTypeOf :: (a, b, c, d) -> DataType Source # dataCast1 :: Typeable t => (forall d0. Data d0 => c0 (t d0)) -> Maybe (c0 (a, b, c, d)) Source # dataCast2 :: Typeable t => (forall d0 e. (Data d0, Data e) => c0 (t d0 e)) -> Maybe (c0 (a, b, c, d)) Source # gmapT :: (forall b0. Data b0 => b0 -> b0) -> (a, b, c, d) -> (a, b, c, d) Source # gmapQl :: (r -> r' -> r) -> r -> (forall d0. Data d0 => d0 -> r') -> (a, b, c, d) -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d0. Data d0 => d0 -> r') -> (a, b, c, d) -> r Source # gmapQ :: (forall d0. Data d0 => d0 -> u) -> (a, b, c, d) -> [u] Source # gmapQi :: Int -> (forall d0. Data d0 => d0 -> u) -> (a, b, c, d) -> u Source # gmapM :: Monad m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d) -> m (a, b, c, d) Source # gmapMp :: MonadPlus m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d) -> m (a, b, c, d) Source # gmapMo :: MonadPlus m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d) -> m (a, b, c, d) Source #  | |
| (Typeable f, Typeable g, Data p, Data (f (g p))) => Data ((f :.: g) p) | Since: base-4.9.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g0. g0 -> c g0) -> (f :.: g) p -> c ((f :.: g) p) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ((f :.: g) p) Source # toConstr :: (f :.: g) p -> Constr Source # dataTypeOf :: (f :.: g) p -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ((f :.: g) p)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ((f :.: g) p)) Source # gmapT :: (forall b. Data b => b -> b) -> (f :.: g) p -> (f :.: g) p Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (f :.: g) p -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (f :.: g) p -> r Source # gmapQ :: (forall d. Data d => d -> u) -> (f :.: g) p -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> (f :.: g) p -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> (f :.: g) p -> m ((f :.: g) p) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (f :.: g) p -> m ((f :.: g) p) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (f :.: g) p -> m ((f :.: g) p) Source #  | |
| (Data p, Data (f p), Typeable c, Typeable i, Typeable f) => Data (M1 i c f p) | Since: base-4.9.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c0 (d -> b) -> d -> c0 b) -> (forall g. g -> c0 g) -> M1 i c f p -> c0 (M1 i c f p) Source # gunfold :: (forall b r. Data b => c0 (b -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (M1 i c f p) Source # toConstr :: M1 i c f p -> Constr Source # dataTypeOf :: M1 i c f p -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c0 (t d)) -> Maybe (c0 (M1 i c f p)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c0 (t d e)) -> Maybe (c0 (M1 i c f p)) Source # gmapT :: (forall b. Data b => b -> b) -> M1 i c f p -> M1 i c f p Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> M1 i c f p -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> M1 i c f p -> r Source # gmapQ :: (forall d. Data d => d -> u) -> M1 i c f p -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> M1 i c f p -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> M1 i c f p -> m (M1 i c f p) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> M1 i c f p -> m (M1 i c f p) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> M1 i c f p -> m (M1 i c f p) Source #  | |
| (Data a, Data b, Data c, Data d, Data e) => Data (a, b, c, d, e) | Since: base-4.0.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d0 b0. Data d0 => c0 (d0 -> b0) -> d0 -> c0 b0) -> (forall g. g -> c0 g) -> (a, b, c, d, e) -> c0 (a, b, c, d, e) Source # gunfold :: (forall b0 r. Data b0 => c0 (b0 -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (a, b, c, d, e) Source # toConstr :: (a, b, c, d, e) -> Constr Source # dataTypeOf :: (a, b, c, d, e) -> DataType Source # dataCast1 :: Typeable t => (forall d0. Data d0 => c0 (t d0)) -> Maybe (c0 (a, b, c, d, e)) Source # dataCast2 :: Typeable t => (forall d0 e0. (Data d0, Data e0) => c0 (t d0 e0)) -> Maybe (c0 (a, b, c, d, e)) Source # gmapT :: (forall b0. Data b0 => b0 -> b0) -> (a, b, c, d, e) -> (a, b, c, d, e) Source # gmapQl :: (r -> r' -> r) -> r -> (forall d0. Data d0 => d0 -> r') -> (a, b, c, d, e) -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d0. Data d0 => d0 -> r') -> (a, b, c, d, e) -> r Source # gmapQ :: (forall d0. Data d0 => d0 -> u) -> (a, b, c, d, e) -> [u] Source # gmapQi :: Int -> (forall d0. Data d0 => d0 -> u) -> (a, b, c, d, e) -> u Source # gmapM :: Monad m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d, e) -> m (a, b, c, d, e) Source # gmapMp :: MonadPlus m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d, e) -> m (a, b, c, d, e) Source # gmapMo :: MonadPlus m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d, e) -> m (a, b, c, d, e) Source #  | |
| (Data a, Data b, Data c, Data d, Data e, Data f) => Data (a, b, c, d, e, f) | Since: base-4.0.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d0 b0. Data d0 => c0 (d0 -> b0) -> d0 -> c0 b0) -> (forall g. g -> c0 g) -> (a, b, c, d, e, f) -> c0 (a, b, c, d, e, f) Source # gunfold :: (forall b0 r. Data b0 => c0 (b0 -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (a, b, c, d, e, f) Source # toConstr :: (a, b, c, d, e, f) -> Constr Source # dataTypeOf :: (a, b, c, d, e, f) -> DataType Source # dataCast1 :: Typeable t => (forall d0. Data d0 => c0 (t d0)) -> Maybe (c0 (a, b, c, d, e, f)) Source # dataCast2 :: Typeable t => (forall d0 e0. (Data d0, Data e0) => c0 (t d0 e0)) -> Maybe (c0 (a, b, c, d, e, f)) Source # gmapT :: (forall b0. Data b0 => b0 -> b0) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) Source # gmapQl :: (r -> r' -> r) -> r -> (forall d0. Data d0 => d0 -> r') -> (a, b, c, d, e, f) -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d0. Data d0 => d0 -> r') -> (a, b, c, d, e, f) -> r Source # gmapQ :: (forall d0. Data d0 => d0 -> u) -> (a, b, c, d, e, f) -> [u] Source # gmapQi :: Int -> (forall d0. Data d0 => d0 -> u) -> (a, b, c, d, e, f) -> u Source # gmapM :: Monad m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d, e, f) -> m (a, b, c, d, e, f) Source # gmapMp :: MonadPlus m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d, e, f) -> m (a, b, c, d, e, f) Source # gmapMo :: MonadPlus m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d, e, f) -> m (a, b, c, d, e, f) Source #  | |
| (Data a, Data b, Data c, Data d, Data e, Data f, Data g) => Data (a, b, c, d, e, f, g) | Since: base-4.0.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d0 b0. Data d0 => c0 (d0 -> b0) -> d0 -> c0 b0) -> (forall g0. g0 -> c0 g0) -> (a, b, c, d, e, f, g) -> c0 (a, b, c, d, e, f, g) Source # gunfold :: (forall b0 r. Data b0 => c0 (b0 -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (a, b, c, d, e, f, g) Source # toConstr :: (a, b, c, d, e, f, g) -> Constr Source # dataTypeOf :: (a, b, c, d, e, f, g) -> DataType Source # dataCast1 :: Typeable t => (forall d0. Data d0 => c0 (t d0)) -> Maybe (c0 (a, b, c, d, e, f, g)) Source # dataCast2 :: Typeable t => (forall d0 e0. (Data d0, Data e0) => c0 (t d0 e0)) -> Maybe (c0 (a, b, c, d, e, f, g)) Source # gmapT :: (forall b0. Data b0 => b0 -> b0) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) Source # gmapQl :: (r -> r' -> r) -> r -> (forall d0. Data d0 => d0 -> r') -> (a, b, c, d, e, f, g) -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d0. Data d0 => d0 -> r') -> (a, b, c, d, e, f, g) -> r Source # gmapQ :: (forall d0. Data d0 => d0 -> u) -> (a, b, c, d, e, f, g) -> [u] Source # gmapQi :: Int -> (forall d0. Data d0 => d0 -> u) -> (a, b, c, d, e, f, g) -> u Source # gmapM :: Monad m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d, e, f, g) -> m (a, b, c, d, e, f, g) Source # gmapMp :: MonadPlus m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d, e, f, g) -> m (a, b, c, d, e, f, g) Source # gmapMo :: MonadPlus m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d, e, f, g) -> m (a, b, c, d, e, f, g) Source #  | |
mkNoRepType :: String -> DataType Source #
Constructs a non-representation for a non-representable type
Representation of datatypes. A package of constructor representations with names of type and module.
class Typeable (a :: k) Source #
The class Typeable allows a concrete representation of a type to
 be calculated.
Minimal complete definition
typeRep#
class Semigroup a => Monoid a where Source #
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"
mappend :: a -> a -> a Source #
An associative operation
NOTE: This method is redundant and has the default
 implementation  since base-4.11.0.0.
 Should it be implemented manually, since 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 All | Since: base-2.1  | 
| Monoid Any | Since: base-2.1  | 
| Monoid Builder Source # | |
| Monoid Builder Source # | |
| Monoid AsciiString Source # | |
Defined in Basement.Types.AsciiString Methods mempty :: AsciiString Source # mappend :: AsciiString -> AsciiString -> AsciiString Source # mconcat :: [AsciiString] -> AsciiString Source #  | |
| Monoid String Source # | |
| Monoid Ordering | Since: base-2.1  | 
| Monoid () | Since: base-2.1  | 
| FiniteBits a => Monoid (And a) | This constraint is arguably too strong. However,
 as some types (such as  Since: base-4.16  | 
| FiniteBits a => Monoid (Iff a) | This constraint is arguably
 too strong. However, as some types (such as  Since: base-4.16  | 
| Bits a => Monoid (Ior a) | Since: base-4.16  | 
| Bits a => Monoid (Xor a) | Since: base-4.16  | 
| 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 (Down a) | Since: base-4.11.0.0  | 
| (Ord a, Bounded a) => Monoid (Max a) | Since: base-4.9.0.0  | 
| (Ord a, Bounded a) => Monoid (Min 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 Source # mappend :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m Source # mconcat :: [WrappedMonoid m] -> WrappedMonoid m Source #  | |
| Monoid a => Monoid (Dual a) | Since: base-2.1  | 
| Monoid (Endo a) | Since: base-2.1  | 
| Num a => Monoid (Product a) | Since: base-2.1  | 
| Num a => Monoid (Sum a) | Since: base-2.1  | 
| Monoid p => Monoid (Par1 p) | Since: base-4.12.0.0  | 
| PrimType ty => Monoid (Block ty) Source # | |
| Monoid (Array a) Source # | |
| Monoid (CountOf ty) Source # | |
| PrimType ty => Monoid (UArray ty) Source # | |
| Monoid a => Monoid (IO 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  | 
| Monoid a => Monoid (a) | Since: base-4.15  | 
| Monoid [a] | Since: base-2.1  | 
| Monoid (Proxy s) | Since: base-4.7.0.0  | 
| Monoid (U1 p) | Since: base-4.12.0.0  | 
| Monoid a => Monoid (ST s a) | Since: base-4.11.0.0  | 
| Monoid b => Monoid (a -> b) | Since: base-2.1  | 
| (Monoid a, Monoid b) => Monoid (a, b) | 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  | 
| 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 (f p), Monoid (g p)) => Monoid ((f :*: g) p) | Since: base-4.12.0.0  | 
| Monoid c => Monoid (K1 i c 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 (g p)) => Monoid ((f :.: g) p) | Since: base-4.12.0.0  | 
| Monoid (f p) => Monoid (M1 i c f 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  | 
class Semigroup a where Source #
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 Source #
An associative operation.
>>>[1,2,3] <> [4,5,6][1,2,3,4,5,6]
sconcat :: NonEmpty a -> a Source #
Reduce a non-empty list with <>
The default definition should be sufficient, but this can be overridden for efficiency.
>>>import Data.List.NonEmpty (NonEmpty (..))>>>sconcat $ "Hello" :| [" ", "Haskell", "!"]"Hello Haskell!"
stimes :: Integral b => b -> a -> a Source #
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
| Semigroup All | Since: base-4.9.0.0  | 
| Semigroup Any | Since: base-4.9.0.0  | 
| Semigroup Builder Source # | |
| Semigroup Builder Source # | |
| Semigroup AsciiString Source # | |
Defined in Basement.Types.AsciiString Methods (<>) :: AsciiString -> AsciiString -> AsciiString Source # sconcat :: NonEmpty AsciiString -> AsciiString Source # stimes :: Integral b => b -> AsciiString -> AsciiString Source #  | |
| Semigroup String Source # | |
| Semigroup Ordering | Since: base-4.9.0.0  | 
| Semigroup () | Since: base-4.9.0.0  | 
| Bits a => Semigroup (And a) | Since: base-4.16  | 
| FiniteBits a => Semigroup (Iff a) | This constraint is arguably
 too strong. However, as some types (such as  Since: base-4.16  | 
| Bits a => Semigroup (Ior a) | Since: base-4.16  | 
| Bits a => Semigroup (Xor a) | Since: base-4.16  | 
| Semigroup a => Semigroup (Identity a) | Since: base-4.9.0.0  | 
| Semigroup (First a) | Since: base-4.9.0.0  | 
| Semigroup (Last a) | Since: base-4.9.0.0  | 
| Semigroup a => Semigroup (Down a) | Since: base-4.11.0.0  | 
| Semigroup (First a) | Since: base-4.9.0.0  | 
| Semigroup (Last a) | Since: base-4.9.0.0  | 
| Ord a => Semigroup (Max a) | Since: base-4.9.0.0  | 
| Ord a => Semigroup (Min a) | Since: base-4.9.0.0  | 
| Monoid m => Semigroup (WrappedMonoid m) | Since: base-4.9.0.0  | 
Defined in Data.Semigroup Methods (<>) :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m Source # sconcat :: NonEmpty (WrappedMonoid m) -> WrappedMonoid m Source # stimes :: Integral b => b -> WrappedMonoid m -> WrappedMonoid m Source #  | |
| Semigroup a => Semigroup (Dual a) | Since: base-4.9.0.0  | 
| Semigroup (Endo a) | Since: base-4.9.0.0  | 
| Num a => Semigroup (Product a) | Since: base-4.9.0.0  | 
| Num a => Semigroup (Sum a) | Since: base-4.9.0.0  | 
| Semigroup p => Semigroup (Par1 p) | Since: base-4.12.0.0  | 
| PrimType ty => Semigroup (Block ty) Source # | |
| Semigroup (Array a) Source # | |
| Semigroup (CountOf ty) Source # | |
| PrimType ty => Semigroup (UArray ty) Source # | |
| Semigroup a => Semigroup (IO a) | Since: base-4.10.0.0  | 
| Semigroup (NonEmpty a) | Since: base-4.9.0.0  | 
| Semigroup a => Semigroup (Maybe a) | Since: base-4.9.0.0  | 
| Semigroup a => Semigroup (a) | Since: base-4.15  | 
| Semigroup [a] | Since: base-4.9.0.0  | 
| Semigroup (Either a b) | Since: base-4.9.0.0  | 
| Semigroup (Proxy s) | Since: base-4.9.0.0  | 
| Semigroup (U1 p) | Since: base-4.12.0.0  | 
| Semigroup (V1 p) | Since: base-4.12.0.0  | 
| Semigroup a => Semigroup (ST s a) | Since: base-4.11.0.0  | 
| Semigroup b => Semigroup (a -> b) | Since: base-4.9.0.0  | 
| (Semigroup a, Semigroup b) => Semigroup (a, b) | Since: base-4.9.0.0  | 
| Semigroup a => Semigroup (Const a b) | Since: base-4.9.0.0  | 
| (Applicative f, Semigroup a) => Semigroup (Ap f a) | Since: base-4.12.0.0  | 
| Alternative f => Semigroup (Alt f a) | Since: base-4.9.0.0  | 
| Semigroup (f p) => Semigroup (Rec1 f p) | Since: base-4.12.0.0  | 
| (Semigroup a, Semigroup b, Semigroup c) => Semigroup (a, b, c) | Since: base-4.9.0.0  | 
| (Semigroup (f p), Semigroup (g p)) => Semigroup ((f :*: g) p) | Since: base-4.12.0.0  | 
| Semigroup c => Semigroup (K1 i c p) | Since: base-4.12.0.0  | 
| (Semigroup a, Semigroup b, Semigroup c, Semigroup d) => Semigroup (a, b, c, d) | Since: base-4.9.0.0  | 
| Semigroup (f (g p)) => Semigroup ((f :.: g) p) | Since: base-4.12.0.0  | 
| Semigroup (f p) => Semigroup (M1 i c f p) | Since: base-4.12.0.0  | 
| (Semigroup a, Semigroup b, Semigroup c, Semigroup d, Semigroup e) => Semigroup (a, b, c, d, e) | Since: base-4.9.0.0  | 
class (Typeable e, Show e) => Exception e Source #
Any type that you wish to throw or catch as an exception must be an
instance of the Exception class. The simplest case is a new exception
type directly below the root:
data MyException = ThisException | ThatException
    deriving Show
instance Exception MyExceptionThe default method definitions in the Exception class do what we need
in this case. You can now throw and catch ThisException and
ThatException as exceptions:
*Main> throw ThisException `catch` \e -> putStrLn ("Caught " ++ show (e :: MyException))
Caught ThisException
In more complicated examples, you may wish to define a whole hierarchy of exceptions:
---------------------------------------------------------------------
-- Make the root exception type for all the exceptions in a compiler
data SomeCompilerException = forall e . Exception e => SomeCompilerException e
instance Show SomeCompilerException where
    show (SomeCompilerException e) = show e
instance Exception SomeCompilerException
compilerExceptionToException :: Exception e => e -> SomeException
compilerExceptionToException = toException . SomeCompilerException
compilerExceptionFromException :: Exception e => SomeException -> Maybe e
compilerExceptionFromException x = do
    SomeCompilerException a <- fromException x
    cast a
---------------------------------------------------------------------
-- Make a subhierarchy for exceptions in the frontend of the compiler
data SomeFrontendException = forall e . Exception e => SomeFrontendException e
instance Show SomeFrontendException where
    show (SomeFrontendException e) = show e
instance Exception SomeFrontendException where
    toException = compilerExceptionToException
    fromException = compilerExceptionFromException
frontendExceptionToException :: Exception e => e -> SomeException
frontendExceptionToException = toException . SomeFrontendException
frontendExceptionFromException :: Exception e => SomeException -> Maybe e
frontendExceptionFromException x = do
    SomeFrontendException a <- fromException x
    cast a
---------------------------------------------------------------------
-- Make an exception type for a particular frontend compiler exception
data MismatchedParentheses = MismatchedParentheses
    deriving Show
instance Exception MismatchedParentheses where
    toException   = frontendExceptionToException
    fromException = frontendExceptionFromExceptionWe can now catch a MismatchedParentheses exception as
MismatchedParentheses, SomeFrontendException or
SomeCompilerException, but not other types, e.g. IOException:
*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: MismatchedParentheses))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: SomeFrontendException))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: SomeCompilerException))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: IOException))
*** Exception: MismatchedParentheses
Instances
throw :: forall (r :: RuntimeRep) (a :: TYPE r) e. Exception e => e -> a Source #
Throw an exception.  Exceptions may be thrown from purely
 functional code, but may only be caught within the IO monad.
throwIO :: Exception e => e -> IO a Source #
A variant of throw that can only be used within the IO monad.
Although throwIO has a type that is an instance of the type of throw, the
 two functions are subtly different:
throw e `seq` x ===> throw e throwIO e `seq` x ===> x
The first example will cause the exception e to be raised,
 whereas the second one won't.  In fact, throwIO will only cause
 an exception to be raised when it is used within the IO monad.
 The throwIO variant should be used in preference to throw to
 raise an exception within the IO monad because it guarantees
 ordering with respect to other IO operations, whereas throw
 does not.
A value of type  represents a pointer to an object, or an
 array of objects, which may be marshalled to or from Haskell values
 of type Ptr aa.
The type a will often be an instance of class
 Storable which provides the marshalling operations.
 However this is not essential, and you can provide your own operations
 to access the pointer.  For example you might write small foreign
 functions to get or set the fields of a C struct.
Instances
| Generic1 (URec (Ptr ()) :: k -> Type) | |
| Data a => Data (Ptr a) | Since: base-4.8.0.0  | 
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ptr a -> c (Ptr a) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Ptr a) Source # toConstr :: Ptr a -> Constr Source # dataTypeOf :: Ptr a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Ptr a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ptr a)) Source # gmapT :: (forall b. Data b => b -> b) -> Ptr a -> Ptr a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ptr a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ptr a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Ptr a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Ptr a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a) Source #  | |
| Foldable (UAddr :: TYPE LiftedRep -> Type) | Since: base-4.9.0.0  | 
Defined in Data.Foldable Methods fold :: Monoid m => UAddr m -> m Source # foldMap :: Monoid m => (a -> m) -> UAddr a -> m Source # foldMap' :: Monoid m => (a -> m) -> UAddr a -> m Source # foldr :: (a -> b -> b) -> b -> UAddr a -> b Source # foldr' :: (a -> b -> b) -> b -> UAddr a -> b Source # foldl :: (b -> a -> b) -> b -> UAddr a -> b Source # foldl' :: (b -> a -> b) -> b -> UAddr a -> b Source # foldr1 :: (a -> a -> a) -> UAddr a -> a Source # foldl1 :: (a -> a -> a) -> UAddr a -> a Source # toList :: UAddr a -> [a] Source # null :: UAddr a -> Bool Source # length :: UAddr a -> Int Source # elem :: Eq a => a -> UAddr a -> Bool Source # maximum :: Ord a => UAddr a -> a Source # minimum :: Ord a => UAddr a -> a Source #  | |
| Traversable (UAddr :: Type -> Type) | Since: base-4.9.0.0  | 
| Storable (Ptr a) | Since: base-2.1  | 
Defined in Foreign.Storable Methods sizeOf :: Ptr a -> Int Source # alignment :: Ptr a -> Int Source # peekElemOff :: Ptr (Ptr a) -> Int -> IO (Ptr a) Source # pokeElemOff :: Ptr (Ptr a) -> Int -> Ptr a -> IO () Source # peekByteOff :: Ptr b -> Int -> IO (Ptr a) Source # pokeByteOff :: Ptr b -> Int -> Ptr a -> IO () Source #  | |
| Show (Ptr a) | Since: base-2.1  | 
| NormalForm (Ptr a) Source # | |
Defined in Basement.NormalForm Methods toNormalForm :: Ptr a -> () Source #  | |
| Eq (Ptr a) | Since: base-2.1  | 
| Ord (Ptr a) | Since: base-2.1  | 
Defined in GHC.Ptr  | |
| Functor (URec (Ptr ()) :: TYPE LiftedRep -> Type) | Since: base-4.9.0.0  | 
| Generic (URec (Ptr ()) p) | |
| Eq (URec (Ptr ()) p) | Since: base-4.9.0.0  | 
| Ord (URec (Ptr ()) p) | Since: base-4.9.0.0  | 
Defined in GHC.Generics Methods compare :: URec (Ptr ()) p -> URec (Ptr ()) p -> Ordering Source # (<) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source # (<=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source # (>) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source # (>=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source # max :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p Source # min :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p Source #  | |
| data URec (Ptr ()) (p :: k) | Used for marking occurrences of  Since: base-4.9.0.0  | 
| type Rep1 (URec (Ptr ()) :: k -> Type) | Since: base-4.9.0.0  | 
Defined in GHC.Generics  | |
| type Rep (URec (Ptr ()) p) | Since: base-4.9.0.0  | 
Defined in GHC.Generics  | |
ifThenElse :: Bool -> a -> a -> a Source #
for support of if .. then .. else