| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Data.GI.Base.ShortPrelude
Description
The Haskell Prelude exports a number of symbols that can easily collide with functions appearing in bindings. The generated code requires just a small subset of the functions in the Prelude, together with some of the functionality in Data.GI.Base, we reexport this explicitly here.
Synopsis
- data Char
- ord :: Char -> Int
- chr :: Int -> Char
- module Data.Int
- data Word8
- data Word64
- data Word32
- data Word16
- data ByteString
- newtype CUIntPtr = CUIntPtr Word64
- newtype CIntPtr = CIntPtr Int64
- newtype CDouble = CDouble Double
- newtype CFloat = CFloat Float
- newtype CULong = CULong Word64
- newtype CLong = CLong Int64
- newtype CUInt = CUInt Word32
- newtype CInt = CInt Int32
- type CString = Ptr CChar
- data Ptr a
- data FunPtr a
- nullPtr :: Ptr a
- plusPtr :: Ptr a -> Int -> Ptr b
- castFunPtrToPtr :: FunPtr a -> Ptr b
- castPtrToFunPtr :: Ptr a -> FunPtr b
- data ForeignPtr a
- module Foreign.ForeignPtr.Unsafe
- sizeOf :: Storable a => a -> Int
- peek :: Storable a => Ptr a -> IO a
- poke :: Storable a => Ptr a -> a -> IO ()
- (<$>) :: Functor f => (a -> b) -> f a -> f b
- onException :: IO a -> IO b -> IO a
- module Control.Monad.IO.Class
- clear :: forall info (attr :: Symbol) obj m. (AttrClearC info obj attr, MonadIO m) => obj -> AttrLabelProxy attr -> m ()
- data AttrOp obj (tag :: AttrOpTag) where
- (:=) :: forall obj info (attr :: Symbol) (tag :: AttrOpTag) b. (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed tag info obj, AttrSetTypeConstraint info b) => AttrLabelProxy attr -> b -> AttrOp obj tag
- (:=>) :: forall obj info (attr :: Symbol) (tag :: AttrOpTag) b. (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed tag info obj, AttrSetTypeConstraint info b) => AttrLabelProxy attr -> IO b -> AttrOp obj tag
- (:~) :: forall obj info (attr :: Symbol) (tag :: AttrOpTag) b a. (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, tag ~ 'AttrSet, AttrOpAllowed 'AttrSet info obj, AttrOpAllowed 'AttrGet info obj, AttrSetTypeConstraint info b, a ~ AttrGetType info) => AttrLabelProxy attr -> (a -> b) -> AttrOp obj tag
- (:~>) :: forall obj info (attr :: Symbol) (tag :: AttrOpTag) b a. (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, tag ~ 'AttrSet, AttrOpAllowed 'AttrSet info obj, AttrOpAllowed 'AttrGet info obj, AttrSetTypeConstraint info b, a ~ AttrGetType info) => AttrLabelProxy attr -> (a -> IO b) -> AttrOp obj tag
- (:&=) :: forall obj info (attr :: Symbol) (tag :: AttrOpTag) b. (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed tag info obj, AttrTransferTypeConstraint info b, AttrSetTypeConstraint info (AttrTransferType info)) => AttrLabelProxy attr -> b -> AttrOp obj tag
- On :: forall obj info (tag :: AttrOpTag). (GObject obj, SignalInfo info) => SignalProxy obj info -> ((?self :: obj) => HaskellCallbackType info) -> AttrOp obj tag
- After :: forall obj info (tag :: AttrOpTag). (GObject obj, SignalInfo info) => SignalProxy obj info -> ((?self :: obj) => HaskellCallbackType info) -> AttrOp obj tag
- class AttrInfo info where
- type AttrAllowedOps info :: [AttrOpTag]
- type AttrBaseTypeConstraint info :: Type -> Constraint
- type AttrGetType info
- type AttrSetTypeConstraint info :: Type -> Constraint
- type AttrTransferTypeConstraint info :: Type -> Constraint
- type AttrTransferType info
- type AttrLabel info :: Symbol
- type AttrOrigin info
- attrGet :: AttrBaseTypeConstraint info o => o -> IO (AttrGetType info)
- attrSet :: (AttrBaseTypeConstraint info o, AttrSetTypeConstraint info b) => o -> b -> IO ()
- attrClear :: AttrBaseTypeConstraint info o => o -> IO ()
- attrConstruct :: (AttrBaseTypeConstraint info o, AttrSetTypeConstraint info b) => b -> IO (GValueConstruct o)
- attrTransfer :: (AttrBaseTypeConstraint info o, AttrTransferTypeConstraint info b) => Proxy o -> b -> IO (AttrTransferType info)
- dbgAttrInfo :: Maybe ResolvedSymbolInfo
- data AttrOpTag
- type family AttrOpAllowed (tag :: AttrOpTag) info useType where ...
- type AttrGetC info obj (attr :: Symbol) result = (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed 'AttrGet info obj, result ~ AttrGetType info)
- type AttrSetC info obj (attr :: Symbol) value = (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed 'AttrSet info obj, AttrSetTypeConstraint info value)
- type AttrConstructC info obj (attr :: Symbol) value = (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed 'AttrConstruct info obj, AttrSetTypeConstraint info value)
- type AttrClearC info obj (attr :: Symbol) = (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed 'AttrClear info obj)
- data AttrLabelProxy (a :: Symbol) = AttrLabelProxy
- resolveAttr :: forall info (attr :: Symbol) obj. (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info) => obj -> AttrLabelProxy attr -> Maybe ResolvedSymbolInfo
- type family AttrLabel info :: Symbol
- type family AttrAllowedOps info :: [AttrOpTag]
- type family AttrBaseTypeConstraint info :: Type -> Constraint
- type family AttrGetType info
- type family AttrSetTypeConstraint info :: Type -> Constraint
- type family AttrTransferTypeConstraint info :: Type -> Constraint
- type family AttrTransferType info
- type family AttrOrigin info
- module Data.GI.Base.BasicTypes
- module Data.GI.Base.BasicConversions
- data GClosure a
- module Data.GI.Base.Constructible
- module Data.GI.Base.GError
- module Data.GI.Base.GHashTable
- module Data.GI.Base.GParamSpec
- module Data.GI.Base.GObject
- module Data.GI.Base.GVariant
- module Data.GI.Base.GValue
- module Data.GI.Base.ManagedPtr
- class SignalInfo info where
- type HaskellCallbackType info
- connectSignal :: GObject o => o -> (o -> HaskellCallbackType info) -> SignalConnectMode -> Maybe Text -> IO SignalHandlerId
- dbgSignalInfo :: Maybe ResolvedSymbolInfo
- data SignalConnectMode
- connectSignalFunPtr :: GObject o => o -> Text -> FunPtr a -> SignalConnectMode -> Maybe Text -> IO SignalHandlerId
- type SignalHandlerId = CULong
- data GObjectNotifySignalInfo
- type family HaskellCallbackType info
- module Data.GI.Base.Utils
- data Symbol
- class Enum a where
- class Show a where
- class Eq a where
- data IO a
- class Applicative m => Monad (m :: Type -> Type) where
- data Maybe a
- (.) :: (b -> c) -> (a -> b) -> a -> c
- ($) :: (a -> b) -> a -> b
- (++) :: [a] -> [a] -> [a]
- (=<<) :: Monad m => (a -> m b) -> m a -> m b
- (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
- data Bool
- data Float
- data Double
- undefined :: HasCallStack => a
- error :: HasCallStack => [Char] -> a
- map :: (a -> b) -> [a] -> [b]
- length :: Foldable t => t a -> Int
- mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)
- mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
- when :: Applicative f => Bool -> f () -> f ()
- fromIntegral :: (Integral a, Num b) => a -> b
- realToFrac :: (Real a, Fractional b) => a -> b
- class a ~# b => (a :: k) ~ (b :: k)
Documentation
The character type Char represents Unicode codespace
and its elements are code points as in definitions
D9 and D10 of the Unicode Standard.
Character literals in Haskell are single-quoted: 'Q', 'Я' or 'Ω'.
To represent a single quote itself use '\'', and to represent a backslash
use '\\'. The full grammar can be found in the section 2.6 of the
Haskell 2010 Language Report.
To specify a character by its code point one can use decimal, hexadecimal
or octal notation: '\65', '\x41' and '\o101' are all alternative forms
of 'A'. The largest code point is '\x10ffff'.
There is a special escape syntax for ASCII control characters:
| Escape | Alternatives | Meaning |
|---|---|---|
'\NUL' | '\0' | null character |
'\SOH' | '\1' | start of heading |
'\STX' | '\2' | start of text |
'\ETX' | '\3' | end of text |
'\EOT' | '\4' | end of transmission |
'\ENQ' | '\5' | enquiry |
'\ACK' | '\6' | acknowledge |
'\BEL' | '\7', '\a' | bell (alert) |
'\BS' | '\8', '\b' | backspace |
'\HT' | '\9', '\t' | horizontal tab |
'\LF' | '\10', '\n' | line feed (new line) |
'\VT' | '\11', '\v' | vertical tab |
'\FF' | '\12', '\f' | form feed |
'\CR' | '\13', '\r' | carriage return |
'\SO' | '\14' | shift out |
'\SI' | '\15' | shift in |
'\DLE' | '\16' | data link escape |
'\DC1' | '\17' | device control 1 |
'\DC2' | '\18' | device control 2 |
'\DC3' | '\19' | device control 3 |
'\DC4' | '\20' | device control 4 |
'\NAK' | '\21' | negative acknowledge |
'\SYN' | '\22' | synchronous idle |
'\ETB' | '\23' | end of transmission block |
'\CAN' | '\24' | cancel |
'\EM' | '\25' | end of medium |
'\SUB' | '\26' | substitute |
'\ESC' | '\27' | escape |
'\FS' | '\28' | file separator |
'\GS' | '\29' | group separator |
'\RS' | '\30' | record separator |
'\US' | '\31' | unit separator |
'\SP' | '\32', ' ' | space |
'\DEL' | '\127' | delete |
Instances
| IsChar Char | Since: base-2.1 |
| PrintfArg Char | Since: base-2.1 |
Defined in Text.Printf | |
| Bounded Char | @since base-2.01 |
| Enum Char | @since base-2.01 |
| Storable Char | @since base-2.01 |
Defined in GHC.Internal.Foreign.Storable | |
| Show Char | @since base-2.01 |
| Eq Char | |
| Ord Char | |
| TestCoercion SChar | @since base-4.18.0.0 |
Defined in GHC.Internal.TypeLits | |
| TestEquality SChar | @since base-4.18.0.0 |
Defined in GHC.Internal.TypeLits | |
| Foldable (UChar :: Type -> Type) | @since base-4.9.0.0 |
Defined in GHC.Internal.Data.Foldable Methods fold :: Monoid m => UChar m -> m # foldMap :: Monoid m => (a -> m) -> UChar a -> m # foldMap' :: Monoid m => (a -> m) -> UChar a -> m # foldr :: (a -> b -> b) -> b -> UChar a -> b # foldr' :: (a -> b -> b) -> b -> UChar a -> b # foldl :: (b -> a -> b) -> b -> UChar a -> b # foldl' :: (b -> a -> b) -> b -> UChar a -> b # foldr1 :: (a -> a -> a) -> UChar a -> a # foldl1 :: (a -> a -> a) -> UChar a -> a # elem :: Eq a => a -> UChar a -> Bool # maximum :: Ord a => UChar a -> a # minimum :: Ord a => UChar a -> a # | |
| Traversable (UChar :: Type -> Type) | @since base-4.9.0.0 |
| IsGValue (Maybe String) Source # | |
module Data.Int
8-bit unsigned integer type
Instances
64-bit unsigned integer type
Instances
32-bit unsigned integer type
Instances
16-bit unsigned integer type
Instances
data ByteString #
A space-efficient representation of a Word8 vector, supporting many
efficient operations.
A ByteString contains 8-bit bytes, or by using the operations from
Data.ByteString.Char8 it can be interpreted as containing 8-bit
characters.
Instances
Instances
| Bits CUIntPtr | |
Defined in GHC.Internal.Foreign.C.Types Methods (.&.) :: CUIntPtr -> CUIntPtr -> CUIntPtr # (.|.) :: CUIntPtr -> CUIntPtr -> CUIntPtr # xor :: CUIntPtr -> CUIntPtr -> CUIntPtr # complement :: CUIntPtr -> CUIntPtr # shift :: CUIntPtr -> Int -> CUIntPtr # rotate :: CUIntPtr -> Int -> CUIntPtr # setBit :: CUIntPtr -> Int -> CUIntPtr # clearBit :: CUIntPtr -> Int -> CUIntPtr # complementBit :: CUIntPtr -> Int -> CUIntPtr # testBit :: CUIntPtr -> Int -> Bool # bitSizeMaybe :: CUIntPtr -> Maybe Int # isSigned :: CUIntPtr -> Bool # shiftL :: CUIntPtr -> Int -> CUIntPtr # unsafeShiftL :: CUIntPtr -> Int -> CUIntPtr # shiftR :: CUIntPtr -> Int -> CUIntPtr # unsafeShiftR :: CUIntPtr -> Int -> CUIntPtr # rotateL :: CUIntPtr -> Int -> CUIntPtr # | |
| FiniteBits CUIntPtr | |
Defined in GHC.Internal.Foreign.C.Types Methods finiteBitSize :: CUIntPtr -> Int # countLeadingZeros :: CUIntPtr -> Int # countTrailingZeros :: CUIntPtr -> Int # | |
| Bounded CUIntPtr | |
| Enum CUIntPtr | |
Defined in GHC.Internal.Foreign.C.Types | |
| Storable CUIntPtr | |
Defined in GHC.Internal.Foreign.C.Types | |
| Ix CUIntPtr | |
Defined in GHC.Internal.Foreign.C.Types Methods range :: (CUIntPtr, CUIntPtr) -> [CUIntPtr] # index :: (CUIntPtr, CUIntPtr) -> CUIntPtr -> Int # unsafeIndex :: (CUIntPtr, CUIntPtr) -> CUIntPtr -> Int # inRange :: (CUIntPtr, CUIntPtr) -> CUIntPtr -> Bool # rangeSize :: (CUIntPtr, CUIntPtr) -> Int # unsafeRangeSize :: (CUIntPtr, CUIntPtr) -> Int # | |
| Num CUIntPtr | |
| Read CUIntPtr | |
| Integral CUIntPtr | |
Defined in GHC.Internal.Foreign.C.Types | |
| Real CUIntPtr | |
Defined in GHC.Internal.Foreign.C.Types Methods toRational :: CUIntPtr -> Rational # | |
| Show CUIntPtr | |
| Eq CUIntPtr | |
| Ord CUIntPtr | |
Defined in GHC.Internal.Foreign.C.Types | |
Instances
| Bits CIntPtr | |
Defined in GHC.Internal.Foreign.C.Types Methods (.&.) :: CIntPtr -> CIntPtr -> CIntPtr # (.|.) :: CIntPtr -> CIntPtr -> CIntPtr # xor :: CIntPtr -> CIntPtr -> CIntPtr # complement :: CIntPtr -> CIntPtr # shift :: CIntPtr -> Int -> CIntPtr # rotate :: CIntPtr -> Int -> CIntPtr # setBit :: CIntPtr -> Int -> CIntPtr # clearBit :: CIntPtr -> Int -> CIntPtr # complementBit :: CIntPtr -> Int -> CIntPtr # testBit :: CIntPtr -> Int -> Bool # bitSizeMaybe :: CIntPtr -> Maybe Int # shiftL :: CIntPtr -> Int -> CIntPtr # unsafeShiftL :: CIntPtr -> Int -> CIntPtr # shiftR :: CIntPtr -> Int -> CIntPtr # unsafeShiftR :: CIntPtr -> Int -> CIntPtr # rotateL :: CIntPtr -> Int -> CIntPtr # | |
| FiniteBits CIntPtr | |
Defined in GHC.Internal.Foreign.C.Types Methods finiteBitSize :: CIntPtr -> Int # countLeadingZeros :: CIntPtr -> Int # countTrailingZeros :: CIntPtr -> Int # | |
| Bounded CIntPtr | |
| Enum CIntPtr | |
| Storable CIntPtr | |
| Ix CIntPtr | |
Defined in GHC.Internal.Foreign.C.Types | |
| Num CIntPtr | |
| Read CIntPtr | |
| Integral CIntPtr | |
Defined in GHC.Internal.Foreign.C.Types | |
| Real CIntPtr | |
Defined in GHC.Internal.Foreign.C.Types Methods toRational :: CIntPtr -> Rational # | |
| Show CIntPtr | |
| Eq CIntPtr | |
| Ord CIntPtr | |
Defined in GHC.Internal.Foreign.C.Types | |
Haskell type representing the C double type.
(The concrete types of Foreign.C.Types are platform-specific.)
Instances
| Enum CDouble | |
| Floating CDouble | |
| RealFloat CDouble | |
Defined in GHC.Internal.Foreign.C.Types Methods floatRadix :: CDouble -> Integer # floatDigits :: CDouble -> Int # floatRange :: CDouble -> (Int, Int) # decodeFloat :: CDouble -> (Integer, Int) # encodeFloat :: Integer -> Int -> CDouble # significand :: CDouble -> CDouble # scaleFloat :: Int -> CDouble -> CDouble # isInfinite :: CDouble -> Bool # isDenormalized :: CDouble -> Bool # isNegativeZero :: CDouble -> Bool # | |
| Storable CDouble | |
| Num CDouble | |
| Read CDouble | |
| Fractional CDouble | |
| Real CDouble | |
Defined in GHC.Internal.Foreign.C.Types Methods toRational :: CDouble -> Rational # | |
| RealFrac CDouble | |
| Show CDouble | |
| Eq CDouble | |
| Ord CDouble | |
Defined in GHC.Internal.Foreign.C.Types | |
Haskell type representing the C float type.
(The concrete types of Foreign.C.Types are platform-specific.)
Instances
| Enum CFloat | |
Defined in GHC.Internal.Foreign.C.Types | |
| Floating CFloat | |
| RealFloat CFloat | |
Defined in GHC.Internal.Foreign.C.Types Methods floatRadix :: CFloat -> Integer # floatDigits :: CFloat -> Int # floatRange :: CFloat -> (Int, Int) # decodeFloat :: CFloat -> (Integer, Int) # encodeFloat :: Integer -> Int -> CFloat # significand :: CFloat -> CFloat # scaleFloat :: Int -> CFloat -> CFloat # isInfinite :: CFloat -> Bool # isDenormalized :: CFloat -> Bool # isNegativeZero :: CFloat -> Bool # | |
| Storable CFloat | |
| Num CFloat | |
| Read CFloat | |
| Fractional CFloat | |
| Real CFloat | |
Defined in GHC.Internal.Foreign.C.Types Methods toRational :: CFloat -> Rational # | |
| RealFrac CFloat | |
| Show CFloat | |
| Eq CFloat | |
| Ord CFloat | |
Haskell type representing the C unsigned long type.
(The concrete types of Foreign.C.Types are platform-specific.)
Instances
| Bits CULong | |
Defined in GHC.Internal.Foreign.C.Types Methods (.&.) :: CULong -> CULong -> CULong # (.|.) :: CULong -> CULong -> CULong # xor :: CULong -> CULong -> CULong # complement :: CULong -> CULong # shift :: CULong -> Int -> CULong # rotate :: CULong -> Int -> CULong # setBit :: CULong -> Int -> CULong # clearBit :: CULong -> Int -> CULong # complementBit :: CULong -> Int -> CULong # testBit :: CULong -> Int -> Bool # bitSizeMaybe :: CULong -> Maybe Int # shiftL :: CULong -> Int -> CULong # unsafeShiftL :: CULong -> Int -> CULong # shiftR :: CULong -> Int -> CULong # unsafeShiftR :: CULong -> Int -> CULong # rotateL :: CULong -> Int -> CULong # | |
| FiniteBits CULong | |
Defined in GHC.Internal.Foreign.C.Types Methods finiteBitSize :: CULong -> Int # countLeadingZeros :: CULong -> Int # countTrailingZeros :: CULong -> Int # | |
| Bounded CULong | |
| Enum CULong | |
Defined in GHC.Internal.Foreign.C.Types | |
| Storable CULong | |
| Ix CULong | |
Defined in GHC.Internal.Foreign.C.Types | |
| Num CULong | |
| Read CULong | |
| Integral CULong | |
Defined in GHC.Internal.Foreign.C.Types | |
| Real CULong | |
Defined in GHC.Internal.Foreign.C.Types Methods toRational :: CULong -> Rational # | |
| Show CULong | |
| Eq CULong | |
| Ord CULong | |
| IsGValue CULong Source # | |
Defined in Data.GI.Base.GValue | |
Haskell type representing the C long type.
(The concrete types of Foreign.C.Types are platform-specific.)
Instances
| Bits CLong | |
Defined in GHC.Internal.Foreign.C.Types Methods (.&.) :: CLong -> CLong -> CLong # (.|.) :: CLong -> CLong -> CLong # xor :: CLong -> CLong -> CLong # complement :: CLong -> CLong # shift :: CLong -> Int -> CLong # rotate :: CLong -> Int -> CLong # setBit :: CLong -> Int -> CLong # clearBit :: CLong -> Int -> CLong # complementBit :: CLong -> Int -> CLong # testBit :: CLong -> Int -> Bool # bitSizeMaybe :: CLong -> Maybe Int # shiftL :: CLong -> Int -> CLong # unsafeShiftL :: CLong -> Int -> CLong # shiftR :: CLong -> Int -> CLong # unsafeShiftR :: CLong -> Int -> CLong # rotateL :: CLong -> Int -> CLong # | |
| FiniteBits CLong | |
Defined in GHC.Internal.Foreign.C.Types Methods finiteBitSize :: CLong -> Int # countLeadingZeros :: CLong -> Int # countTrailingZeros :: CLong -> Int # | |
| Bounded CLong | |
| Enum CLong | |
Defined in GHC.Internal.Foreign.C.Types | |
| Storable CLong | |
| Ix CLong | |
| Num CLong | |
| Read CLong | |
| Integral CLong | |
| Real CLong | |
Defined in GHC.Internal.Foreign.C.Types Methods toRational :: CLong -> Rational # | |
| Show CLong | |
| Eq CLong | |
| Ord CLong | |
| IsGValue CLong Source # | |
Defined in Data.GI.Base.GValue | |
Haskell type representing the C unsigned int type.
(The concrete types of Foreign.C.Types are platform-specific.)
Instances
| Bits CUInt | |
Defined in GHC.Internal.Foreign.C.Types Methods (.&.) :: CUInt -> CUInt -> CUInt # (.|.) :: CUInt -> CUInt -> CUInt # xor :: CUInt -> CUInt -> CUInt # complement :: CUInt -> CUInt # shift :: CUInt -> Int -> CUInt # rotate :: CUInt -> Int -> CUInt # setBit :: CUInt -> Int -> CUInt # clearBit :: CUInt -> Int -> CUInt # complementBit :: CUInt -> Int -> CUInt # testBit :: CUInt -> Int -> Bool # bitSizeMaybe :: CUInt -> Maybe Int # shiftL :: CUInt -> Int -> CUInt # unsafeShiftL :: CUInt -> Int -> CUInt # shiftR :: CUInt -> Int -> CUInt # unsafeShiftR :: CUInt -> Int -> CUInt # rotateL :: CUInt -> Int -> CUInt # | |
| FiniteBits CUInt | |
Defined in GHC.Internal.Foreign.C.Types Methods finiteBitSize :: CUInt -> Int # countLeadingZeros :: CUInt -> Int # countTrailingZeros :: CUInt -> Int # | |
| Bounded CUInt | |
| Enum CUInt | |
Defined in GHC.Internal.Foreign.C.Types | |
| Storable CUInt | |
| Ix CUInt | |
| Num CUInt | |
| Read CUInt | |
| Integral CUInt | |
| Real CUInt | |
Defined in GHC.Internal.Foreign.C.Types Methods toRational :: CUInt -> Rational # | |
| Show CUInt | |
| Eq CUInt | |
| Ord CUInt | |
| IsGValue CUInt Source # | |
Defined in Data.GI.Base.GValue | |
Haskell type representing the C int type.
(The concrete types of Foreign.C.Types are platform-specific.)
Instances
| Bits CInt | |
Defined in GHC.Internal.Foreign.C.Types Methods (.&.) :: CInt -> CInt -> CInt # (.|.) :: CInt -> CInt -> CInt # complement :: CInt -> CInt # shift :: CInt -> Int -> CInt # rotate :: CInt -> Int -> CInt # setBit :: CInt -> Int -> CInt # clearBit :: CInt -> Int -> CInt # complementBit :: CInt -> Int -> CInt # testBit :: CInt -> Int -> Bool # bitSizeMaybe :: CInt -> Maybe Int # shiftL :: CInt -> Int -> CInt # unsafeShiftL :: CInt -> Int -> CInt # shiftR :: CInt -> Int -> CInt # unsafeShiftR :: CInt -> Int -> CInt # rotateL :: CInt -> Int -> CInt # | |
| FiniteBits CInt | |
Defined in GHC.Internal.Foreign.C.Types Methods finiteBitSize :: CInt -> Int # countLeadingZeros :: CInt -> Int # countTrailingZeros :: CInt -> Int # | |
| Bounded CInt | |
| Enum CInt | |
| Storable CInt | |
Defined in GHC.Internal.Foreign.C.Types | |
| Ix CInt | |
| Num CInt | |
| Read CInt | |
| Integral CInt | |
| Real CInt | |
Defined in GHC.Internal.Foreign.C.Types Methods toRational :: CInt -> Rational # | |
| Show CInt | |
| Eq CInt | |
| Ord CInt | |
| IsGValue CInt Source # | |
Defined in Data.GI.Base.GValue | |
A value 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
| Foldable (UAddr :: Type -> Type) | @since base-4.9.0.0 |
Defined in GHC.Internal.Data.Foldable Methods fold :: Monoid m => UAddr m -> m # foldMap :: Monoid m => (a -> m) -> UAddr a -> m # foldMap' :: Monoid m => (a -> m) -> UAddr a -> m # foldr :: (a -> b -> b) -> b -> UAddr a -> b # foldr' :: (a -> b -> b) -> b -> UAddr a -> b # foldl :: (b -> a -> b) -> b -> UAddr a -> b # foldl' :: (b -> a -> b) -> b -> UAddr a -> b # foldr1 :: (a -> a -> a) -> UAddr a -> a # foldl1 :: (a -> a -> a) -> UAddr a -> a # elem :: Eq a => a -> UAddr a -> Bool # maximum :: Ord a => UAddr a -> a # minimum :: Ord a => UAddr a -> a # | |
| Traversable (UAddr :: Type -> Type) | @since base-4.9.0.0 |
| Storable (Ptr a) | @since base-2.01 |
| Show (Ptr a) | @since base-2.01 |
| Eq (Ptr a) | @since base-2.01 |
| Ord (Ptr a) | @since base-2.01 |
| IsGValue (Ptr a) Source # | |
Defined in Data.GI.Base.GValue | |
A value of type FunPtr aa will normally be a foreign type,
a function type with zero or more arguments where
- the argument types are marshallable foreign types,
i.e.
Char,Int,Double,Float,Bool,Int8,Int16,Int32,Int64,Word8,Word16,Word32,Word64,PtraFunPtraStablePtranewtype. - the return type is either a marshallable foreign type or has the form
IOttis a marshallable foreign type or().
A value of type FunPtr a
foreign import ccall "stdlib.h &free" p_free :: FunPtr (Ptr a -> IO ())
or a pointer to a Haskell function created using a wrapper stub
declared to produce a FunPtr of the correct type. For example:
type Compare = Int -> Int -> Bool foreign import ccall "wrapper" mkCompare :: Compare -> IO (FunPtr Compare)
Calls to wrapper stubs like mkCompare allocate storage, which
should be released with freeHaskellFunPtr when no
longer required.
To convert FunPtr values to corresponding Haskell functions, one
can define a dynamic stub for the specific foreign type, e.g.
type IntFunction = CInt -> IO () foreign import ccall "dynamic" mkFun :: FunPtr IntFunction -> IntFunction
Instances
| Storable (FunPtr a) | @since base-2.01 |
Defined in GHC.Internal.Foreign.Storable | |
| Show (FunPtr a) | @since base-2.01 |
| Eq (FunPtr a) | |
| Ord (FunPtr a) | |
Defined in GHC.Internal.Ptr | |
castFunPtrToPtr :: FunPtr a -> Ptr b #
castPtrToFunPtr :: Ptr a -> FunPtr b #
data ForeignPtr a #
The type ForeignPtr represents references to objects that are
maintained in a foreign language, i.e., that are not part of the
data structures usually managed by the Haskell storage manager.
The essential difference between ForeignPtrs and vanilla memory
references of type Ptr a is that the former may be associated
with finalizers. A finalizer is a routine that is invoked when
the Haskell storage manager detects that - within the Haskell heap
and stack - there are no more references left that are pointing to
the ForeignPtr. Typically, the finalizer will, then, invoke
routines in the foreign language that free the resources bound by
the foreign object.
The ForeignPtr is parameterised in the same way as Ptr. The
type argument of ForeignPtr should normally be an instance of
class Storable.
Instances
| Show (ForeignPtr a) | @since base-2.01 |
Defined in GHC.Internal.ForeignPtr Methods showsPrec :: Int -> ForeignPtr a -> ShowS # show :: ForeignPtr a -> String # showList :: [ForeignPtr a] -> ShowS # | |
| Eq (ForeignPtr a) | @since base-2.01 |
Defined in GHC.Internal.ForeignPtr | |
| Ord (ForeignPtr a) | @since base-2.01 |
Defined in GHC.Internal.ForeignPtr Methods compare :: ForeignPtr a -> ForeignPtr a -> Ordering # (<) :: ForeignPtr a -> ForeignPtr a -> Bool # (<=) :: ForeignPtr a -> ForeignPtr a -> Bool # (>) :: ForeignPtr a -> ForeignPtr a -> Bool # (>=) :: ForeignPtr a -> ForeignPtr a -> Bool # max :: ForeignPtr a -> ForeignPtr a -> ForeignPtr a # min :: ForeignPtr a -> ForeignPtr a -> ForeignPtr a # | |
module Foreign.ForeignPtr.Unsafe
sizeOf :: Storable a => a -> Int #
Computes the storage requirements (in bytes) of the argument. The value of the argument is not used.
peek :: Storable a => Ptr a -> IO a #
Read a value from the given memory location.
Note that the peek and poke functions might require properly
aligned addresses to function correctly. This is architecture
dependent; thus, portable code should ensure that when peeking or
poking values of some type a, the alignment
constraint for a, as given by the function
alignment is fulfilled.
poke :: Storable a => Ptr a -> a -> IO () #
Write the given value to the given memory location. Alignment
restrictions might apply; see peek.
(<$>) :: Functor f => (a -> b) -> f a -> f b infixl 4 #
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 Maybe IntMaybe
Stringshow:
>>>show <$> NothingNothing
>>>show <$> Just 3Just "3"
Convert from 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)
onException :: IO a -> IO b -> IO a #
Like finally, but only performs the final action if there was an
exception raised by the computation.
module Control.Monad.IO.Class
clear :: forall info (attr :: Symbol) obj m. (AttrClearC info obj attr, MonadIO m) => obj -> AttrLabelProxy attr -> m () Source #
Set a nullable attribute to NULL.
data AttrOp obj (tag :: AttrOpTag) where Source #
Constructors for the different operations allowed on an attribute.
Constructors
| (:=) :: forall obj info (attr :: Symbol) (tag :: AttrOpTag) b. (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed tag info obj, AttrSetTypeConstraint info b) => AttrLabelProxy attr -> b -> AttrOp obj tag infixr 0 | Assign a value to an attribute |
| (:=>) :: forall obj info (attr :: Symbol) (tag :: AttrOpTag) b. (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed tag info obj, AttrSetTypeConstraint info b) => AttrLabelProxy attr -> IO b -> AttrOp obj tag infixr 0 | Assign the result of an IO action to an attribute |
| (:~) :: forall obj info (attr :: Symbol) (tag :: AttrOpTag) b a. (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, tag ~ 'AttrSet, AttrOpAllowed 'AttrSet info obj, AttrOpAllowed 'AttrGet info obj, AttrSetTypeConstraint info b, a ~ AttrGetType info) => AttrLabelProxy attr -> (a -> b) -> AttrOp obj tag infixr 0 | Apply an update function to an attribute |
| (:~>) :: forall obj info (attr :: Symbol) (tag :: AttrOpTag) b a. (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, tag ~ 'AttrSet, AttrOpAllowed 'AttrSet info obj, AttrOpAllowed 'AttrGet info obj, AttrSetTypeConstraint info b, a ~ AttrGetType info) => AttrLabelProxy attr -> (a -> IO b) -> AttrOp obj tag infixr 0 | Apply an IO update function to an attribute |
| (:&=) :: forall obj info (attr :: Symbol) (tag :: AttrOpTag) b. (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed tag info obj, AttrTransferTypeConstraint info b, AttrSetTypeConstraint info (AttrTransferType info)) => AttrLabelProxy attr -> b -> AttrOp obj tag | Assign a value to an attribute, allocating any necessary
memory for representing the Haskell value as a C value. Note
that it is the responsibility of the caller to make sure that
the memory is freed when no longer used, otherwise there will
be a memory leak. In the majority of cases you probably want to
use |
| On :: forall obj info (tag :: AttrOpTag). (GObject obj, SignalInfo info) => SignalProxy obj info -> ((?self :: obj) => HaskellCallbackType info) -> AttrOp obj tag | Connect the given signal to a signal handler. |
| After :: forall obj info (tag :: AttrOpTag). (GObject obj, SignalInfo info) => SignalProxy obj info -> ((?self :: obj) => HaskellCallbackType info) -> AttrOp obj tag | Like |
class AttrInfo info where Source #
Info describing an attribute.
Minimal complete definition
Nothing
Associated Types
type AttrAllowedOps info :: [AttrOpTag] Source #
The operations that are allowed on the attribute.
type AttrBaseTypeConstraint info :: Type -> Constraint Source #
Constraint on the type for which we are allowed to create/set/get the attribute.
type AttrGetType info Source #
Type returned by attrGet.
type AttrSetTypeConstraint info :: Type -> Constraint Source #
Constraint on the value being set.
type AttrSetTypeConstraint info = Type ~ AttrGetType info
type AttrTransferTypeConstraint info :: Type -> Constraint Source #
Constraint on the value being set, with allocation allowed
(see :&= below).
type AttrTransferTypeConstraint info = Type ~ AttrTransferType info
type AttrTransferType info Source #
Type resulting from the allocation.
type AttrTransferType info = AttrGetType info
type AttrLabel info :: Symbol Source #
Name of the attribute.
type AttrOrigin info Source #
Type which introduces the attribute.
Methods
attrGet :: AttrBaseTypeConstraint info o => o -> IO (AttrGetType info) Source #
Get the value of the given attribute.
default attrGet :: CheckNotElem 'AttrGet (AttrAllowedOps info) (GetNotProvidedError info) => o -> IO (AttrGetType info) Source #
attrSet :: (AttrBaseTypeConstraint info o, AttrSetTypeConstraint info b) => o -> b -> IO () Source #
Set the value of the given attribute, after the object having the attribute has already been created.
default attrSet :: CheckNotElem 'AttrSet (AttrAllowedOps info) (SetNotProvidedError info) => o -> b -> IO () Source #
attrClear :: AttrBaseTypeConstraint info o => o -> IO () Source #
Set the value of the given attribute to NULL (for nullable
attributes).
default attrClear :: CheckNotElem 'AttrClear (AttrAllowedOps info) (ClearNotProvidedError info) => o -> IO () Source #
attrConstruct :: (AttrBaseTypeConstraint info o, AttrSetTypeConstraint info b) => b -> IO (GValueConstruct o) Source #
Build a GValue representing the attribute.
default attrConstruct :: CheckNotElem 'AttrConstruct (AttrAllowedOps info) (ConstructNotProvidedError info) => b -> IO (GValueConstruct o) Source #
attrTransfer :: (AttrBaseTypeConstraint info o, AttrTransferTypeConstraint info b) => Proxy o -> b -> IO (AttrTransferType info) Source #
Allocate memory as necessary to generate a settable type from the transfer type. This is useful for types which needs allocations for marshalling from Haskell to C, this makes the allocation explicit.
default attrTransfer :: (AttrBaseTypeConstraint info o, AttrTransferTypeConstraint info b, b ~ AttrGetType info, b ~ AttrTransferType info) => Proxy o -> b -> IO (AttrTransferType info) Source #
dbgAttrInfo :: Maybe ResolvedSymbolInfo Source #
Return some information about the overloaded attribute,
useful for debugging. See resolveAttr for how to access this
conveniently.
Possible operations on an attribute.
Constructors
| AttrGet | It is possible to read the value of the attribute
with |
| AttrSet | It is possible to write the value of the attribute
with |
| AttrConstruct | It is possible to set the value of the attribute
in |
| AttrClear | It is possible to clear the value of the
(nullable) attribute with |
Instances
| Bounded AttrOpTag Source # | |
| Enum AttrOpTag Source # | |
Defined in Data.GI.Base.Attributes Methods succ :: AttrOpTag -> AttrOpTag # pred :: AttrOpTag -> AttrOpTag # fromEnum :: AttrOpTag -> Int # enumFrom :: AttrOpTag -> [AttrOpTag] # enumFromThen :: AttrOpTag -> AttrOpTag -> [AttrOpTag] # enumFromTo :: AttrOpTag -> AttrOpTag -> [AttrOpTag] # enumFromThenTo :: AttrOpTag -> AttrOpTag -> AttrOpTag -> [AttrOpTag] # | |
| Show AttrOpTag Source # | |
| Eq AttrOpTag Source # | |
| Ord AttrOpTag Source # | |
type family AttrOpAllowed (tag :: AttrOpTag) info useType where ... Source #
Whether a given AttrOpTag is allowed on an attribute, given the
info type.
Equations
| AttrOpAllowed tag info useType = AttrOpIsAllowed tag (AttrAllowedOps info) (AttrLabel info) (AttrOrigin info) useType |
type AttrGetC info obj (attr :: Symbol) result = (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed 'AttrGet info obj, result ~ AttrGetType info) Source #
Constraints on a obj/attr pair so get is possible,
producing a value of type result.
type AttrSetC info obj (attr :: Symbol) value = (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed 'AttrSet info obj, AttrSetTypeConstraint info value) Source #
Constraint on a obj/attr pair so that set works on values
of type value.
type AttrConstructC info obj (attr :: Symbol) value = (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed 'AttrConstruct info obj, AttrSetTypeConstraint info value) Source #
Constraint on a obj/value pair so that
new works on values of type value.
type AttrClearC info obj (attr :: Symbol) = (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed 'AttrClear info obj) Source #
Constraint on a obj/attr pair so that clear is allowed.
data AttrLabelProxy (a :: Symbol) Source #
A proxy for attribute labels.
Constructors
| AttrLabelProxy |
Instances
| a ~ x => IsLabel x (AttrLabelProxy a) Source # | |
Defined in Data.GI.Base.Attributes Methods fromLabel :: AttrLabelProxy a # | |
resolveAttr :: forall info (attr :: Symbol) obj. (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info) => obj -> AttrLabelProxy attr -> Maybe ResolvedSymbolInfo Source #
Return the fully qualified attribute name that a given overloaded attribute resolves to (mostly useful for debugging).
resolveAttr #sensitive button
type family AttrAllowedOps info :: [AttrOpTag] Source #
The operations that are allowed on the attribute.
type family AttrBaseTypeConstraint info :: Type -> Constraint Source #
Constraint on the type for which we are allowed to create/set/get the attribute.
type family AttrGetType info Source #
Type returned by attrGet.
type family AttrSetTypeConstraint info :: Type -> Constraint Source #
Constraint on the value being set.
type family AttrTransferTypeConstraint info :: Type -> Constraint Source #
Constraint on the value being set, with allocation allowed
(see :&= below).
type family AttrTransferType info Source #
Type resulting from the allocation.
type family AttrOrigin info Source #
Type which introduces the attribute.
module Data.GI.Base.BasicTypes
The basic type. This corresponds to a wrapped GClosure on the C
side, which is a boxed object.
Instances
| GBoxed (GClosure a) Source # |
|
Defined in Data.GI.Base.GClosure | |
| TypedObject (GClosure a) Source # | Find the associated |
| HasParentTypes (GClosure a) Source # | |
Defined in Data.GI.Base.GClosure | |
| type ParentTypes (GClosure a) Source # | There are no types in the bindings that a closure can be safely cast to. |
Defined in Data.GI.Base.GClosure | |
module Data.GI.Base.Constructible
module Data.GI.Base.GError
module Data.GI.Base.GHashTable
module Data.GI.Base.GParamSpec
module Data.GI.Base.GObject
module Data.GI.Base.GVariant
module Data.GI.Base.GValue
module Data.GI.Base.ManagedPtr
class SignalInfo info where Source #
Information about an overloaded signal.
Minimal complete definition
Methods
connectSignal :: GObject o => o -> (o -> HaskellCallbackType info) -> SignalConnectMode -> Maybe Text -> IO SignalHandlerId Source #
Connect a Haskell function to a signal of the given GObject,
specifying whether the handler will be called before or after the
default handler. Note that the callback being passed here admits
an extra initial parameter with respect to the usual Haskell
callback type. This will be passed as an implicit ?self
argument to the Haskell callback.
dbgSignalInfo :: Maybe ResolvedSymbolInfo Source #
Optional extra debug information, for resolveSignal below.
Instances
| SignalInfo GObjectNotifySignalInfo Source # | |||||
Defined in Data.GI.Base.Signals Associated Types
Methods connectSignal :: GObject o => o -> (o -> HaskellCallbackType GObjectNotifySignalInfo) -> SignalConnectMode -> Maybe Text -> IO SignalHandlerId Source # | |||||
data SignalConnectMode Source #
Whether to connect a handler to a signal with connectSignal so
that it runs before/after the default handler for the given signal.
Constructors
| SignalConnectBefore | Run before the default handler. |
| SignalConnectAfter | Run after the default handler. |
connectSignalFunPtr :: GObject o => o -> Text -> FunPtr a -> SignalConnectMode -> Maybe Text -> IO SignalHandlerId Source #
Connect a signal to a handler, given as a FunPtr.
type SignalHandlerId = CULong Source #
Type of a GObject signal handler id.
data GObjectNotifySignalInfo Source #
Connection information for a "notify" signal indicating that a
specific property changed (see PropertyNotify for the relevant
constructor).
Instances
| SignalInfo GObjectNotifySignalInfo Source # | |||||
Defined in Data.GI.Base.Signals Associated Types
Methods connectSignal :: GObject o => o -> (o -> HaskellCallbackType GObjectNotifySignalInfo) -> SignalConnectMode -> Maybe Text -> IO SignalHandlerId Source # | |||||
| type HaskellCallbackType GObjectNotifySignalInfo Source # | |||||
Defined in Data.GI.Base.Signals | |||||
module Data.GI.Base.Utils
(Kind) This is the kind of type-level symbols.
Instances
| TestCoercion SSymbol | @since base-4.18.0.0 |
Defined in GHC.Internal.TypeLits | |
| TestEquality SSymbol | @since base-4.18.0.0 |
Defined in GHC.Internal.TypeLits | |
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
succmaxBoundpredminBound fromEnumandtoEnumshould give a runtime error if the result value is not representable in the result type. For example,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
Convert from an Int.
Instances
| Enum CBool | |
Defined in GHC.Internal.Foreign.C.Types | |
| Enum CChar | |
Defined in GHC.Internal.Foreign.C.Types | |
| Enum CClock | |
Defined in GHC.Internal.Foreign.C.Types | |
| Enum CDouble | |
| Enum CFloat | |
Defined in GHC.Internal.Foreign.C.Types | |
| Enum CInt | |
| Enum CIntMax | |
| Enum CIntPtr | |
| Enum CLLong | |
Defined in GHC.Internal.Foreign.C.Types | |
| Enum CLong | |
Defined in GHC.Internal.Foreign.C.Types | |
| Enum CPtrdiff | |
Defined in GHC.Internal.Foreign.C.Types | |
| Enum CSChar | |
Defined in GHC.Internal.Foreign.C.Types | |
| Enum CSUSeconds | |
Defined in GHC.Internal.Foreign.C.Types Methods succ :: CSUSeconds -> CSUSeconds # pred :: CSUSeconds -> CSUSeconds # toEnum :: Int -> CSUSeconds # fromEnum :: CSUSeconds -> Int # enumFrom :: CSUSeconds -> [CSUSeconds] # enumFromThen :: CSUSeconds -> CSUSeconds -> [CSUSeconds] # enumFromTo :: CSUSeconds -> CSUSeconds -> [CSUSeconds] # enumFromThenTo :: CSUSeconds -> CSUSeconds -> CSUSeconds -> [CSUSeconds] # | |
| Enum CShort | |
Defined in GHC.Internal.Foreign.C.Types | |
| Enum CSigAtomic | |
Defined in GHC.Internal.Foreign.C.Types Methods succ :: CSigAtomic -> CSigAtomic # pred :: CSigAtomic -> CSigAtomic # toEnum :: Int -> CSigAtomic # fromEnum :: CSigAtomic -> Int # enumFrom :: CSigAtomic -> [CSigAtomic] # enumFromThen :: CSigAtomic -> CSigAtomic -> [CSigAtomic] # enumFromTo :: CSigAtomic -> CSigAtomic -> [CSigAtomic] # enumFromThenTo :: CSigAtomic -> CSigAtomic -> CSigAtomic -> [CSigAtomic] # | |
| Enum CSize | |
Defined in GHC.Internal.Foreign.C.Types | |
| Enum CTime | |
Defined in GHC.Internal.Foreign.C.Types | |
| Enum CUChar | |
Defined in GHC.Internal.Foreign.C.Types | |
| Enum CUInt | |
Defined in GHC.Internal.Foreign.C.Types | |
| Enum CUIntMax | |
Defined in GHC.Internal.Foreign.C.Types | |
| Enum CUIntPtr | |
Defined in GHC.Internal.Foreign.C.Types | |
| Enum CULLong | |
| Enum CULong | |
Defined in GHC.Internal.Foreign.C.Types | |
| Enum CUSeconds | |
Defined in GHC.Internal.Foreign.C.Types Methods succ :: CUSeconds -> CUSeconds # pred :: CUSeconds -> CUSeconds # fromEnum :: CUSeconds -> Int # enumFrom :: CUSeconds -> [CUSeconds] # enumFromThen :: CUSeconds -> CUSeconds -> [CUSeconds] # enumFromTo :: CUSeconds -> CUSeconds -> [CUSeconds] # enumFromThenTo :: CUSeconds -> CUSeconds -> CUSeconds -> [CUSeconds] # | |
| Enum CUShort | |
| Enum CWchar | |
Defined in GHC.Internal.Foreign.C.Types | |
| Enum IntPtr | |
Defined in GHC.Internal.Foreign.Ptr | |
| Enum WordPtr | |
| Enum Int16 | @since base-2.01 |
Defined in GHC.Internal.Int | |
| Enum Int32 | @since base-2.01 |
Defined in GHC.Internal.Int | |
| Enum Int64 | @since base-2.01 |
Defined in GHC.Internal.Int | |
| Enum Int8 | @since base-2.01 |
| Enum Word16 | @since base-2.01 |
Defined in GHC.Internal.Word | |
| Enum Word32 | @since base-2.01 |
Defined in GHC.Internal.Word | |
| Enum Word64 | @since base-2.01 |
Defined in GHC.Internal.Word | |
| Enum Word8 | @since base-2.01 |
Defined in GHC.Internal.Word | |
| Enum Ordering | @since base-2.01 |
Defined in GHC.Internal.Enum | |
| Enum AttrOpTag Source # | |
Defined in Data.GI.Base.Attributes Methods succ :: AttrOpTag -> AttrOpTag # pred :: AttrOpTag -> AttrOpTag # fromEnum :: AttrOpTag -> Int # enumFrom :: AttrOpTag -> [AttrOpTag] # enumFromThen :: AttrOpTag -> AttrOpTag -> [AttrOpTag] # enumFromTo :: AttrOpTag -> AttrOpTag -> [AttrOpTag] # enumFromThenTo :: AttrOpTag -> AttrOpTag -> AttrOpTag -> [AttrOpTag] # | |
| Enum GParamFlag Source # | |
Defined in Data.GI.Base.GParamSpec Methods succ :: GParamFlag -> GParamFlag # pred :: GParamFlag -> GParamFlag # toEnum :: Int -> GParamFlag # fromEnum :: GParamFlag -> Int # enumFrom :: GParamFlag -> [GParamFlag] # enumFromThen :: GParamFlag -> GParamFlag -> [GParamFlag] # enumFromTo :: GParamFlag -> GParamFlag -> [GParamFlag] # enumFromThenTo :: GParamFlag -> GParamFlag -> GParamFlag -> [GParamFlag] # | |
| Enum I8 | |
| Enum FPFormat | |
Defined in Data.Text.Lazy.Builder.RealFloat | |
| Enum Integer | @since base-2.01 |
| Enum Natural | @since base-4.8.0.0 |
| Enum () | @since base-2.01 |
Defined in GHC.Internal.Enum | |
| Enum Bool | @since base-2.01 |
| Enum Char | @since base-2.01 |
| Enum Int | @since base-2.01 |
| Enum Levity | @since base-4.16.0.0 |
Defined in GHC.Internal.Enum | |
| Enum VecCount | @since base-4.10.0.0 |
Defined in GHC.Internal.Enum | |
| Enum VecElem | @since base-4.10.0.0 |
| Enum Word | @since base-2.01 |
| Enum a => Enum (First a) | Since: base-4.9.0.0 |
| Enum a => Enum (Last a) | Since: base-4.9.0.0 |
Defined in Data.Semigroup | |
| Enum a => Enum (Max a) | Since: base-4.9.0.0 |
| Enum a => Enum (Min a) | Since: base-4.9.0.0 |
| Enum a => Enum (WrappedMonoid a) | Since: base-4.9.0.0 |
Defined in Data.Semigroup Methods succ :: WrappedMonoid a -> WrappedMonoid a # pred :: WrappedMonoid a -> WrappedMonoid a # toEnum :: Int -> WrappedMonoid a # fromEnum :: WrappedMonoid a -> Int # enumFrom :: WrappedMonoid a -> [WrappedMonoid a] # enumFromThen :: WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] # enumFromTo :: WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] # enumFromThenTo :: WrappedMonoid a -> WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] # | |
| Integral a => Enum (Ratio a) | @since base-2.0.1 |
| Enum a => Enum (Solo a) | |
Defined in GHC.Internal.Enum | |
| Enum (Fixed a) | Recall that, for numeric types,
and likewise
In other words,
and similarly
This is worth bearing in mind when defining [1..10] :: [Pico] evaluates to However, this is not true. On the contrary, similarly to the above
implementations of [1.000000000000, 1.00000000001, 1.00000000002, ..., 10.000000000000] and contains Since: base-2.1 |
| Enum (Proxy s) | @since base-4.7.0.0 |
| Enum (f (g a)) => Enum (Compose f g a) | Since: base-4.19.0.0 |
Defined in Data.Functor.Compose Methods succ :: Compose f g a -> Compose f g a # pred :: Compose f g a -> Compose f g a # toEnum :: Int -> Compose f g a # fromEnum :: Compose f g a -> Int # enumFrom :: Compose f g a -> [Compose f g a] # enumFromThen :: Compose f g a -> Compose f g a -> [Compose f g a] # enumFromTo :: Compose f g a -> Compose f g a -> [Compose f g a] # enumFromThenTo :: Compose f g a -> Compose f g a -> Compose f g a -> [Compose f g a] # | |
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,
show(Leaf 1 :^: Leaf 2 :^: Leaf 3)"Leaf 1 :^: (Leaf 2 :^: Leaf 3)".
Methods
Arguments
| :: Int | the operator precedence of the enclosing
context (a number from |
| -> a | the value to be converted to a |
| -> ShowS |
Convert a value to a readable String.
showsPrec should satisfy the law
showsPrec d x r ++ s == showsPrec d x (r ++ s)
Derived instances of Read and Show satisfy the following:
That is, readsPrec parses the string produced by
showsPrec, and delivers the value that showsPrec started with.
Instances
| Show ByteArray | Since: base-4.17.0.0 |
| Show Timeout | Since: base-4.0 |
| Show FormatMode | |
| Show ByteString | |
Defined in Data.ByteString.Internal.Type Methods showsPrec :: Int -> ByteString -> ShowS # show :: ByteString -> String # showList :: [ByteString] -> ShowS # | |
| Show ByteString | |
Defined in Data.ByteString.Lazy.Internal Methods showsPrec :: Int -> ByteString -> ShowS # show :: ByteString -> String # showList :: [ByteString] -> ShowS # | |
| Show ShortByteString | |
Defined in Data.ByteString.Short.Internal Methods showsPrec :: Int -> ShortByteString -> ShowS # show :: ShortByteString -> String # showList :: [ShortByteString] -> ShowS # | |
| Show IntSet | |
| Show BitQueue | |
| Show BitQueueB | |
| Show Void | @since base-4.8.0.0 |
| Show NestedAtomically | @since base-4.0 |
Defined in GHC.Internal.Control.Exception.Base Methods showsPrec :: Int -> NestedAtomically -> ShowS # show :: NestedAtomically -> String # showList :: [NestedAtomically] -> ShowS # | |
| Show NoMatchingContinuationPrompt | @since base-4.18 |
Defined in GHC.Internal.Control.Exception.Base Methods showsPrec :: Int -> NoMatchingContinuationPrompt -> ShowS # show :: NoMatchingContinuationPrompt -> String # showList :: [NoMatchingContinuationPrompt] -> ShowS # | |
| Show NoMethodError | @since base-4.0 |
Defined in GHC.Internal.Control.Exception.Base Methods showsPrec :: Int -> NoMethodError -> ShowS # show :: NoMethodError -> String # showList :: [NoMethodError] -> ShowS # | |
| Show NonTermination | @since base-4.0 |
Defined in GHC.Internal.Control.Exception.Base Methods showsPrec :: Int -> NonTermination -> ShowS # show :: NonTermination -> String # showList :: [NonTermination] -> ShowS # | |
| Show PatternMatchFail | @since base-4.0 |
Defined in GHC.Internal.Control.Exception.Base Methods showsPrec :: Int -> PatternMatchFail -> ShowS # show :: PatternMatchFail -> String # showList :: [PatternMatchFail] -> ShowS # | |
| Show RecConError | @since base-4.0 |
Defined in GHC.Internal.Control.Exception.Base Methods showsPrec :: Int -> RecConError -> ShowS # show :: RecConError -> String # showList :: [RecConError] -> ShowS # | |
| Show RecSelError | @since base-4.0 |
Defined in GHC.Internal.Control.Exception.Base Methods showsPrec :: Int -> RecSelError -> ShowS # show :: RecSelError -> String # showList :: [RecSelError] -> ShowS # | |
| Show RecUpdError | @since base-4.0 |
Defined in GHC.Internal.Control.Exception.Base Methods showsPrec :: Int -> RecUpdError -> ShowS # show :: RecUpdError -> String # showList :: [RecUpdError] -> ShowS # | |
| Show TypeError | @since base-4.9.0.0 |
| Show Dynamic | @since base-2.01 |
| Show SomeTypeRep | @since base-4.10.0.0 |
Defined in GHC.Internal.Data.Typeable.Internal Methods showsPrec :: Int -> SomeTypeRep -> ShowS # show :: SomeTypeRep -> String # showList :: [SomeTypeRep] -> ShowS # | |
| Show ErrorCall | @since base-4.0.0.0 |
| Show ArithException | @since base-4.0.0.0 |
Defined in GHC.Internal.Exception.Type Methods showsPrec :: Int -> ArithException -> ShowS # show :: ArithException -> String # showList :: [ArithException] -> ShowS # | |
| Show SomeException | Since: ghc-internal-3.0 |
Defined in GHC.Internal.Exception.Type Methods showsPrec :: Int -> SomeException -> ShowS # show :: SomeException -> String # showList :: [SomeException] -> ShowS # | |
| 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 GHC.Internal.Foreign.C.Types Methods showsPrec :: Int -> CSUSeconds -> ShowS # show :: CSUSeconds -> String # showList :: [CSUSeconds] -> ShowS # | |
| Show CShort | |
| Show CSigAtomic | |
Defined in GHC.Internal.Foreign.C.Types Methods showsPrec :: Int -> CSigAtomic -> ShowS # show :: CSigAtomic -> String # showList :: [CSigAtomic] -> ShowS # | |
| 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 MaskingState | @since base-4.3.0.0 |
Defined in GHC.Internal.IO Methods showsPrec :: Int -> MaskingState -> ShowS # show :: MaskingState -> String # showList :: [MaskingState] -> ShowS # | |
| Show BufferMode | @since base-4.2.0.0 |
Defined in GHC.Internal.IO.Handle.Types Methods showsPrec :: Int -> BufferMode -> ShowS # show :: BufferMode -> String # showList :: [BufferMode] -> ShowS # | |
| Show Handle | @since base-4.1.0.0 |
| Show HandleType | @since base-4.1.0.0 |
Defined in GHC.Internal.IO.Handle.Types Methods showsPrec :: Int -> HandleType -> ShowS # show :: HandleType -> String # showList :: [HandleType] -> ShowS # | |
| Show Newline | @since base-4.3.0.0 |
| Show NewlineMode | @since base-4.3.0.0 |
Defined in GHC.Internal.IO.Handle.Types Methods showsPrec :: Int -> NewlineMode -> ShowS # show :: NewlineMode -> String # showList :: [NewlineMode] -> ShowS # | |
| Show Int16 | @since base-2.01 |
| Show Int32 | @since base-2.01 |
| Show Int64 | @since base-2.01 |
| Show Int8 | @since base-2.01 |
| Show FractionalExponentBase | |
Defined in GHC.Internal.Real Methods showsPrec :: Int -> FractionalExponentBase -> ShowS # show :: FractionalExponentBase -> String # showList :: [FractionalExponentBase] -> ShowS # | |
| 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.Internal.TypeLits Methods showsPrec :: Int -> SomeSymbol -> ShowS # show :: SomeSymbol -> String # showList :: [SomeSymbol] -> ShowS # | |
| Show Word16 | @since base-2.01 |
| Show Word32 | @since base-2.01 |
| Show Word64 | @since base-2.01 |
| Show Word8 | @since base-2.01 |
| Show KindRep | |
| Show Module | @since base-4.9.0.0 |
| Show Ordering | @since base-2.01 |
| Show TrName | @since base-4.9.0.0 |
| Show TyCon | @since base-2.01 |
| Show TypeLitSort | @since base-4.11.0.0 |
Defined in GHC.Internal.Show Methods showsPrec :: Int -> TypeLitSort -> ShowS # show :: TypeLitSort -> String # showList :: [TypeLitSort] -> ShowS # | |
| Show AttrOpTag Source # | |
| Show GType Source # | |
| Show UnexpectedNullPointerReturn Source # | |
Defined in Data.GI.Base.BasicTypes Methods showsPrec :: Int -> UnexpectedNullPointerReturn -> ShowS # show :: UnexpectedNullPointerReturn -> String # showList :: [UnexpectedNullPointerReturn] -> ShowS # | |
| Show GError Source # | |
| Show GParamFlag Source # | |
Defined in Data.GI.Base.GParamSpec Methods showsPrec :: Int -> GParamFlag -> ShowS # show :: GParamFlag -> String # showList :: [GParamFlag] -> ShowS # | |
| Show GVariantHandle Source # | |
Defined in Data.GI.Base.GVariant Methods showsPrec :: Int -> GVariantHandle -> ShowS # show :: GVariantHandle -> String # showList :: [GVariantHandle] -> ShowS # | |
| Show GVariantObjectPath Source # | |
Defined in Data.GI.Base.GVariant Methods showsPrec :: Int -> GVariantObjectPath -> ShowS # show :: GVariantObjectPath -> String # showList :: [GVariantObjectPath] -> ShowS # | |
| Show GVariantSignature Source # | |
Defined in Data.GI.Base.GVariant Methods showsPrec :: Int -> GVariantSignature -> ShowS # show :: GVariantSignature -> String # showList :: [GVariantSignature] -> ShowS # | |
| Show ResolvedSymbolInfo Source # | |
Defined in Data.GI.Base.Overloading Methods showsPrec :: Int -> ResolvedSymbolInfo -> ShowS # show :: ResolvedSymbolInfo -> String # showList :: [ResolvedSymbolInfo] -> ShowS # | |
| Show Mode | |
| Show Style | |
| Show TextDetails | |
Defined in Text.PrettyPrint.Annotated.HughesPJ Methods showsPrec :: Int -> TextDetails -> ShowS # show :: TextDetails -> String # showList :: [TextDetails] -> ShowS # | |
| Show Doc | |
| Show Decoding | |
| Show UnicodeException | |
Defined in Data.Text.Encoding.Error Methods showsPrec :: Int -> UnicodeException -> ShowS # show :: UnicodeException -> String # showList :: [UnicodeException] -> ShowS # | |
| Show I8 | |
| Show Builder | |
| Show PartialUtf8CodePoint | |
| Show Utf8State | |
| Show DecoderState | |
Defined in Data.Text.Internal.Encoding.Utf8 Methods showsPrec :: Int -> DecoderState -> ShowS # show :: DecoderState -> String # showList :: [DecoderState] -> ShowS # | |
| Show Size | |
| Show FPFormat | |
| Show Iter | |
| Show Integer | @since base-2.01 |
| Show Natural | @since base-4.8.0.0 |
| Show () | @since base-2.01 |
| Show Bool | @since base-2.01 |
| Show Char | @since base-2.01 |
| Show Int | @since base-2.01 |
| Show Levity | @since base-4.15.0.0 |
| Show RuntimeRep | @since base-4.11.0.0 |
Defined in GHC.Internal.Show Methods showsPrec :: Int -> RuntimeRep -> ShowS # show :: RuntimeRep -> String # showList :: [RuntimeRep] -> ShowS # | |
| Show VecCount | @since base-4.11.0.0 |
| Show VecElem | @since base-4.11.0.0 |
| Show Word | @since base-2.01 |
| Show a => Show (Complex a) | Since: base-2.1 |
| 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 Methods showsPrec :: Int -> WrappedMonoid m -> ShowS # show :: WrappedMonoid m -> String # showList :: [WrappedMonoid m] -> ShowS # | |
| Show vertex => Show (SCC vertex) | Since: containers-0.5.9 |
| Show a => Show (IntMap a) | |
| Show a => Show (Seq a) | |
| Show a => Show (ViewL a) | |
| Show a => Show (ViewR a) | |
| Show a => Show (Intersection a) | |
Defined in Data.Set.Internal Methods showsPrec :: Int -> Intersection a -> ShowS # show :: Intersection a -> String # showList :: [Intersection a] -> ShowS # | |
| Show a => Show (Set a) | |
| Show a => Show (Tree a) | |
| Show a => Show (NonEmpty a) | @since base-4.11.0.0 |
| Show a => Show (ExceptionWithContext a) | |
Defined in GHC.Internal.Exception.Type Methods showsPrec :: Int -> ExceptionWithContext a -> ShowS # show :: ExceptionWithContext a -> String # showList :: [ExceptionWithContext a] -> ShowS # | |
| Show e => Show (NoBacktrace e) | |
Defined in GHC.Internal.Exception.Type Methods showsPrec :: Int -> NoBacktrace e -> ShowS # show :: NoBacktrace e -> String # showList :: [NoBacktrace e] -> ShowS # | |
| Show (ForeignPtr a) | @since base-2.01 |
Defined in GHC.Internal.ForeignPtr Methods showsPrec :: Int -> ForeignPtr a -> ShowS # show :: ForeignPtr a -> String # showList :: [ForeignPtr a] -> ShowS # | |
| Show (FunPtr a) | @since base-2.01 |
| Show (Ptr a) | @since base-2.01 |
| Show a => Show (Ratio a) | @since base-2.0.1 |
| Show (SChar c) | @since base-4.18.0.0 |
| Show (SSymbol s) | @since base-4.18.0.0 |
| Show a => Show (HValue a) Source # | |
| Show a => Show (GVariantSinglet a) Source # | |
Defined in Data.GI.Base.GVariant Methods showsPrec :: Int -> GVariantSinglet a -> ShowS # show :: GVariantSinglet a -> String # showList :: [GVariantSinglet a] -> ShowS # | |
| Show a => Show (AnnotDetails a) | |
Defined in Text.PrettyPrint.Annotated.HughesPJ Methods showsPrec :: Int -> AnnotDetails a -> ShowS # show :: AnnotDetails a -> String # showList :: [AnnotDetails a] -> ShowS # | |
| Show (Doc a) | |
| Show a => Show (Span a) | |
| Show a => Show (Maybe a) | @since base-2.01 |
| Show a => Show (Solo a) | @since base-4.15 |
| Show a => Show [a] | @since base-2.01 |
| HasResolution a => Show (Fixed a) | Since: base-2.1 |
| (Show a, Show b) => Show (Arg a b) | Since: base-4.9.0.0 |
| (Show k, Show a) => Show (Map k a) | |
| Show (Proxy s) | @since base-4.7.0.0 |
| Show (TypeRep a) | |
| (Show key, Show value) => Show (GVariantDictEntry key value) Source # | |
Defined in Data.GI.Base.GVariant Methods showsPrec :: Int -> GVariantDictEntry key value -> ShowS # show :: GVariantDictEntry key value -> String # showList :: [GVariantDictEntry key value] -> ShowS # | |
| (Show a, Show b) => Show (a, b) | @since base-2.01 |
| (Show a, Show b, Show c) => Show (a, b, c) | @since base-2.01 |
| (Show (f a), Show (g a)) => Show (Product f g a) | Since: base-4.18.0.0 |
| (Show (f a), Show (g a)) => Show (Sum f g a) | Since: base-4.18.0.0 |
| (Show a, Show b, Show c, Show d) => Show (a, b, c, d) | @since base-2.01 |
| Show (f (g a)) => Show (Compose f g a) | Since: base-4.18.0.0 |
| (Show a, Show b, Show c, Show d, Show e) => Show (a, b, c, d, e) | @since base-2.01 |
| (Show a, Show b, Show c, Show d, Show e, Show f) => Show (a, b, c, d, e, f) | @since base-2.01 |
| (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.01 |
| (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.01 |
| (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.01 |
| (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.01 |
| (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.01 |
| (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.01 |
| (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.01 |
| (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.01 |
| (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.01 |
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 ByteArray | Since: base-4.17.0.0 |
| Eq Timeout | |
| Eq ByteString | |
Defined in Data.ByteString.Internal.Type | |
| Eq ByteString | |
Defined in Data.ByteString.Lazy.Internal | |
| Eq ShortByteString | |
Defined in Data.ByteString.Short.Internal Methods (==) :: ShortByteString -> ShortByteString -> Bool # (/=) :: ShortByteString -> ShortByteString -> Bool # | |
| Eq IntSet | |
| Eq BigNat | |
| Eq Void | @since base-4.8.0.0 |
| Eq SomeTypeRep | |
Defined in GHC.Internal.Data.Typeable.Internal | |
| Eq ErrorCall | @since base-4.7.0.0 |
| Eq ArithException | @since base-3.0 |
Defined in GHC.Internal.Exception.Type Methods (==) :: ArithException -> ArithException -> Bool # (/=) :: ArithException -> ArithException -> Bool # | |
| 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 GHC.Internal.Foreign.C.Types | |
| Eq CShort | |
| Eq CSigAtomic | |
Defined in GHC.Internal.Foreign.C.Types | |
| 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 MaskingState | @since base-4.3.0.0 |
Defined in GHC.Internal.IO | |
| Eq BufferMode | @since base-4.2.0.0 |
Defined in GHC.Internal.IO.Handle.Types | |
| Eq Handle | @since base-4.1.0.0 |
| Eq Newline | @since base-4.2.0.0 |
| Eq NewlineMode | @since base-4.2.0.0 |
Defined in GHC.Internal.IO.Handle.Types | |
| Eq Int16 | @since base-2.01 |
| Eq Int32 | @since base-2.01 |
| Eq Int64 | @since base-2.01 |
| Eq Int8 | @since base-2.01 |
| Eq SrcLoc | @since base-4.9.0.0 |
| Eq SomeChar | |
| Eq SomeSymbol | @since base-4.7.0.0 |
Defined in GHC.Internal.TypeLits | |
| Eq Word16 | @since base-2.01 |
| Eq Word32 | @since base-2.01 |
| Eq Word64 | @since base-2.01 |
| Eq Word8 | @since base-2.01 |
| Eq Module | |
| Eq Ordering | |
| Eq TrName | |
| Eq TyCon | |
| Eq AttrOpTag Source # | |
| Eq GType Source # | |
| Eq GParamFlag Source # | |
Defined in Data.GI.Base.GParamSpec | |
| Eq GVariantHandle Source # | |
Defined in Data.GI.Base.GVariant Methods (==) :: GVariantHandle -> GVariantHandle -> Bool # (/=) :: GVariantHandle -> GVariantHandle -> Bool # | |
| Eq GVariantObjectPath Source # | |
Defined in Data.GI.Base.GVariant Methods (==) :: GVariantObjectPath -> GVariantObjectPath -> Bool # (/=) :: GVariantObjectPath -> GVariantObjectPath -> Bool # | |
| Eq GVariantSignature Source # | |
Defined in Data.GI.Base.GVariant Methods (==) :: GVariantSignature -> GVariantSignature -> Bool # (/=) :: GVariantSignature -> GVariantSignature -> Bool # | |
| Eq Mode | |
| Eq Style | |
| Eq TextDetails | |
Defined in Text.PrettyPrint.Annotated.HughesPJ | |
| Eq Doc | |
| Eq UnicodeException | |
Defined in Data.Text.Encoding.Error Methods (==) :: UnicodeException -> UnicodeException -> Bool # (/=) :: UnicodeException -> UnicodeException -> Bool # | |
| Eq I8 | |
| Eq Builder | |
| Eq PartialUtf8CodePoint | |
| Eq Utf8State | |
| Eq DecoderState | |
Defined in Data.Text.Internal.Encoding.Utf8 | |
| Eq Size | |
| 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 (Chan a) | Since: base-4.4.0.0 |
| Eq (MutableByteArray s) | Since: base-4.17.0.0 |
Defined in Data.Array.Byte Methods (==) :: MutableByteArray s -> MutableByteArray s -> Bool # (/=) :: MutableByteArray s -> MutableByteArray s -> Bool # | |
| Eq a => Eq (Complex a) | Since: base-2.1 |
| 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 # (/=) :: WrappedMonoid m -> WrappedMonoid m -> Bool # | |
| Eq vertex => Eq (SCC vertex) | Since: containers-0.5.9 |
| Eq a => Eq (IntMap a) | |
| Eq a => Eq (Seq a) | |
| Eq a => Eq (ViewL a) | |
| Eq a => Eq (ViewR a) | |
| Eq a => Eq (Intersection a) | |
Defined in Data.Set.Internal Methods (==) :: Intersection a -> Intersection a -> Bool # (/=) :: Intersection a -> Intersection a -> Bool # | |
| Eq a => Eq (Set a) | |
| Eq a => Eq (Tree a) | |
| Eq a => Eq (NonEmpty a) | @since base-4.9.0.0 |
| Eq (ForeignPtr a) | @since base-2.01 |
Defined in GHC.Internal.ForeignPtr | |
| Eq (IORef a) | Pointer equality. @since base-4.0.0.0 |
| Eq (FunPtr a) | |
| Eq (Ptr a) | @since base-2.01 |
| Eq a => Eq (Ratio a) | @since base-2.01 |
| Eq (StablePtr a) | @since base-2.01 |
| Eq (SChar c) | @since base-4.19.0.0 |
| Eq (SSymbol s) | @since base-4.19.0.0 |
| Eq (ManagedPtr a) Source # | Two |
Defined in Data.GI.Base.BasicTypes | |
| Eq a => Eq (HValue a) Source # | |
| Eq a => Eq (GVariantSinglet a) Source # | |
Defined in Data.GI.Base.GVariant Methods (==) :: GVariantSinglet a -> GVariantSinglet a -> Bool # (/=) :: GVariantSinglet a -> GVariantSinglet a -> Bool # | |
| Eq a => Eq (AnnotDetails a) | |
Defined in Text.PrettyPrint.Annotated.HughesPJ Methods (==) :: AnnotDetails a -> AnnotDetails a -> Bool # (/=) :: AnnotDetails a -> AnnotDetails a -> Bool # | |
| Eq (Doc a) | |
| Eq a => Eq (Span a) | |
| Eq a => Eq (Stream a) | |
| Eq a => Eq (Maybe a) | @since base-2.01 |
| Eq a => Eq (Solo a) | |
| Eq a => Eq [a] | |
| Eq (Fixed a) | Since: base-2.1 |
| Eq a => Eq (Arg a b) | Since: base-4.9.0.0 |
| (Eq k, Eq a) => Eq (Map k a) | |
| Eq (Proxy s) | @since base-4.7.0.0 |
| Eq (TypeRep a) | @since base-2.01 |
| (Eq key, Eq value) => Eq (GVariantDictEntry key value) Source # | |
Defined in Data.GI.Base.GVariant Methods (==) :: GVariantDictEntry key value -> GVariantDictEntry key value -> Bool # (/=) :: GVariantDictEntry key value -> GVariantDictEntry key value -> Bool # | |
| (Eq a, Eq b) => Eq (a, b) | |
| (Eq a, Eq b, Eq c) => Eq (a, b, c) | |
| (Eq (f a), Eq (g a)) => Eq (Product f g a) | Since: base-4.18.0.0 |
| (Eq (f a), Eq (g a)) => Eq (Sum f g a) | Since: base-4.18.0.0 |
| (Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d) | |
| Eq (f (g a)) => Eq (Compose f g a) | Since: base-4.18.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) | |
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
| MonadIO IO | Since: base-4.9.0.0 |
Defined in Control.Monad.IO.Class | |
| Alternative IO | Takes the first non-throwing @since base-4.9.0.0 |
| Applicative IO | @since base-2.01 |
| Functor IO | @since base-2.01 |
| Monad IO | @since base-2.01 |
| MonadPlus IO | Takes the first non-throwing @since base-4.9.0.0 |
| MonadFail IO | @since base-4.9.0.0 |
Defined in GHC.Internal.Control.Monad.Fail | |
| MonadFix IO | @since base-2.01 |
Defined in GHC.Internal.Control.Monad.Fix | |
| a ~ () => HPrintfType (IO a) | Since: base-4.7.0.0 |
Defined in Text.Printf | |
| a ~ () => PrintfType (IO a) | Since: base-4.7.0.0 |
Defined in Text.Printf | |
| Monoid a => Monoid (IO a) | @since base-4.9.0.0 |
| Semigroup a => Semigroup (IO a) | @since base-4.10.0.0 |
class Applicative m => Monad (m :: Type -> Type) where #
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 List, Maybe and IO
defined in the Prelude satisfy these laws.
Minimal complete definition
Methods
(>>=) :: m a -> (a -> m b) -> m b infixl 1 #
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
An alternative name for this function is 'bind', but some people may refer to it as 'flatMap', which results from it being equivialent to
\x f ->join(fmapf x) :: Monad m => m a -> (a -> m b) -> m b
which can be seen as mapping a value with
Monad m => m a -> m (m b) and then 'flattening' m (m b) to m b using join.
(>>) :: m a -> m b -> m b infixl 1 #
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
or in terms of (>>=)
as >>= const bs
Inject a value into the monadic type.
This function should not be different from its default implementation
as pure. The justification for the existence of this function is
merely historic.
Instances
| Monad Complex | Since: base-4.9.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 Put | |
| Monad Seq | |
| Monad Tree | |
| Monad NonEmpty | @since base-4.9.0.0 |
| Monad IO | @since base-2.01 |
| Monad Maybe | @since base-2.01 |
| Monad Solo | @since base-4.15 |
| Monad [] | @since base-2.01 |
| 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 # (>>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b # return :: a -> WrappedMonad m a # | |
| Monad (SetM s) | |
| Monad (Proxy :: Type -> Type) | @since base-4.7.0.0 |
| Monad (IParser t) | |
| Monoid a => Monad ((,) a) | @since base-4.9.0.0 |
| (Applicative f, Monad f) => Monad (WhenMissing f x) | Equivalent to Since: containers-0.5.9 |
Defined in Data.IntMap.Internal Methods (>>=) :: WhenMissing f x a -> (a -> WhenMissing f x b) -> WhenMissing f x b # (>>) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x b # return :: a -> WhenMissing f x a # | |
| (Monoid a, Monoid b) => Monad ((,,) a b) | @since base-4.14.0.0 |
| (Monad f, Monad g) => Monad (Product f g) | Since: base-4.9.0.0 |
| (Monad f, Applicative f) => Monad (WhenMatched f x y) | Equivalent to Since: containers-0.5.9 |
Defined in Data.IntMap.Internal Methods (>>=) :: WhenMatched f x y a -> (a -> WhenMatched f x y b) -> WhenMatched f x y b # (>>) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y b # return :: a -> WhenMatched f x y a # | |
| (Applicative f, Monad f) => Monad (WhenMissing f k x) | Equivalent to Since: containers-0.5.9 |
Defined in Data.Map.Internal Methods (>>=) :: WhenMissing f k x a -> (a -> WhenMissing f k x b) -> WhenMissing f k x b # (>>) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x b # return :: a -> WhenMissing f k x a # | |
| (Monoid a, Monoid b, Monoid c) => Monad ((,,,) a b c) | @since base-4.14.0.0 |
| Monad ((->) r) | @since base-2.01 |
| (Monad f, Applicative f) => Monad (WhenMatched f k x y) | Equivalent to Since: containers-0.5.9 |
Defined in Data.Map.Internal Methods (>>=) :: WhenMatched f k x y a -> (a -> WhenMatched f k x y b) -> WhenMatched f k x y b # (>>) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y b # return :: a -> WhenMatched f k x y a # | |
The Maybe type encapsulates an optional value. A value of type
Maybe aa (represented as Just aNothing). Using Maybe is a good way to
deal with errors or exceptional cases without resorting to drastic
measures such as error.
The Maybe type is also a monad. It is a simple kind of error
monad, where all errors are represented by Nothing. A richer
error monad can be built using the Either type.
Instances
| MonadZip Maybe | Since: base-4.8.0.0 |
| Eq1 Maybe | Since: base-4.9.0.0 |
| Ord1 Maybe | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
| Read1 Maybe | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
| Show1 Maybe | Since: base-4.9.0.0 |
| Alternative Maybe | Picks the leftmost @since base-2.01 |
| Applicative Maybe | @since base-2.01 |
| Functor Maybe | @since base-2.01 |
| Monad Maybe | @since base-2.01 |
| MonadPlus Maybe | Picks the leftmost @since base-2.01 |
| MonadFail Maybe | @since base-4.9.0.0 |
Defined in GHC.Internal.Control.Monad.Fail | |
| MonadFix Maybe | @since base-2.01 |
Defined in GHC.Internal.Control.Monad.Fix | |
| Foldable Maybe | @since base-2.01 |
Defined in GHC.Internal.Data.Foldable Methods fold :: Monoid m => Maybe m -> m # foldMap :: Monoid m => (a -> m) -> Maybe a -> m # foldMap' :: Monoid m => (a -> m) -> Maybe a -> m # foldr :: (a -> b -> b) -> b -> Maybe a -> b # foldr' :: (a -> b -> b) -> b -> Maybe a -> b # foldl :: (b -> a -> b) -> b -> Maybe a -> b # foldl' :: (b -> a -> b) -> b -> Maybe a -> b # foldr1 :: (a -> a -> a) -> Maybe a -> a # foldl1 :: (a -> a -> a) -> Maybe a -> a # elem :: Eq a => a -> Maybe a -> Bool # maximum :: Ord a => Maybe a -> a # minimum :: Ord a => Maybe a -> a # | |
| Traversable Maybe | @since base-2.01 |
| Semigroup a => Monoid (Maybe a) | Lift a semigroup into Since 4.11.0: constraint on inner @since base-2.01 |
| Semigroup a => Semigroup (Maybe a) | @since base-4.9.0.0 |
| Show a => Show (Maybe a) | @since base-2.01 |
| Eq a => Eq (Maybe a) | @since base-2.01 |
| Ord a => Ord (Maybe a) | @since base-2.01 |
| IsGValue (Maybe GParamSpec) Source # | |
Defined in Data.GI.Base.GValue Methods gvalueGType_ :: IO GType Source # gvalueSet_ :: Ptr GValue -> Maybe GParamSpec -> IO () Source # gvalueGet_ :: Ptr GValue -> IO (Maybe GParamSpec) Source # | |
| IsGValue (Maybe Text) Source # | |
| IsGValue (Maybe String) Source # | |
| IsGVariant a => IsGVariant (Maybe a) Source # | |
Defined in Data.GI.Base.GVariant | |
(.) :: (b -> c) -> (a -> b) -> a -> c infixr 9 #
Right to left function composition.
(f . g) x = f (g x)
f . id = f = id . f
Examples
>>>map ((*2) . length) [[], [0, 1, 2], [0]][0,6,2]
>>>foldr (.) id [(+1), (*3), (^3)] 225
>>>let (...) = (.).(.) in ((*2)...(+)) 5 1030
($) :: (a -> b) -> a -> b infixr 0 #
($)
Applying ($)f and an argument x gives the same result as applying f to x directly. The definition is akin to this:
($) :: (a -> b) -> a -> b ($) f x = f x
This is ida -> a to (a -> b) -> (a -> b) which by the associativity of (->)
is the same as (a -> b) -> a -> b.
On the face of it, this may appear pointless! But it's actually one of the most useful and important operators in Haskell.
The order of operations is very different between ($) and normal function application. Normal function application has precedence 10 - higher than any operator - and associates to the left. So these two definitions are equivalent:
expr = min 5 1 + 5 expr = ((min 5) 1) + 5
($) has precedence 0 (the lowest) and associates to the right, so these are equivalent:
expr = min 5 $ 1 + 5 expr = (min 5) (1 + 5)
Examples
A common use cases of ($) is to avoid parentheses in complex expressions.
For example, instead of using nested parentheses in the following Haskell function:
-- | Sum numbers in a string: strSum "100 5 -7" == 98 strSum ::String->IntstrSum s =sum(mapMaybereadMaybe(wordss))
we can deploy the function application operator:
-- | Sum numbers in a string: strSum "100 5 -7" == 98 strSum ::String->IntstrSum s =sum$mapMaybereadMaybe$wordss
($) is also used as a section (a partially applied operator), in order to indicate that we wish to apply some yet-unspecified function to a given value. For example, to apply the argument 5 to a list of functions:
applyFive :: [Int] applyFive = map ($ 5) [(+1), (2^)] >>> [6, 32]
Technical Remark (Representation Polymorphism)
($) is fully representation-polymorphic. This allows it to also be used with arguments of unlifted and even unboxed kinds, such as unboxed integers:
fastMod :: Int -> Int -> Int fastMod (I# x) (I# m) = I# $ remInt# x m
(++) :: [a] -> [a] -> [a] infixr 5 #
(++) appends two lists, i.e.,
[x1, ..., xm] ++ [y1, ..., yn] == [x1, ..., xm, y1, ..., yn] [x1, ..., xm] ++ [y1, ...] == [x1, ..., xm, y1, ...]
If the first list is not finite, the result is the first list.
Performance considerations
This function takes linear time in the number of elements of the
first list. Thus it is better to associate repeated
applications of (++) to the right (which is the default behaviour):
xs ++ (ys ++ zs) or simply xs ++ ys ++ zs, but not (xs ++ ys) ++ zs.
For the same reason concat = foldr (++) []
has linear performance, while foldl (++) [] is prone
to quadratic slowdown
Examples
>>>[1, 2, 3] ++ [4, 5, 6][1,2,3,4,5,6]
>>>[] ++ [1, 2, 3][1,2,3]
>>>[3, 2, 1] ++ [][3,2,1]
(=<<) :: Monad m => (a -> m b) -> m a -> m b infixr 1 #
Same as >>=, but with the arguments interchanged.
as >>= f == f =<< as
Instances
| Bits Bool | Interpret @since base-4.7.0.0 |
Defined in GHC.Internal.Bits Methods (.&.) :: Bool -> Bool -> Bool # (.|.) :: Bool -> Bool -> Bool # complement :: Bool -> Bool # shift :: Bool -> Int -> Bool # rotate :: Bool -> Int -> Bool # setBit :: Bool -> Int -> Bool # clearBit :: Bool -> Int -> Bool # complementBit :: Bool -> Int -> Bool # testBit :: Bool -> Int -> Bool # bitSizeMaybe :: Bool -> Maybe Int # shiftL :: Bool -> Int -> Bool # unsafeShiftL :: Bool -> Int -> Bool # shiftR :: Bool -> Int -> Bool # unsafeShiftR :: Bool -> Int -> Bool # rotateL :: Bool -> Int -> Bool # | |
| FiniteBits Bool | @since base-4.7.0.0 |
Defined in GHC.Internal.Bits Methods finiteBitSize :: Bool -> Int # countLeadingZeros :: Bool -> Int # countTrailingZeros :: Bool -> Int # | |
| Bounded Bool | @since base-2.01 |
| Enum Bool | @since base-2.01 |
| Storable Bool | @since base-2.01 |
Defined in GHC.Internal.Foreign.Storable | |
| Show Bool | @since base-2.01 |
| Eq Bool | |
| Ord Bool | |
| IsGValue Bool Source # | |
Defined in Data.GI.Base.GValue | |
| IsGVariant Bool Source # | |
Defined in Data.GI.Base.GVariant | |
| IsGVariantBasicType Bool Source # | |
Defined in Data.GI.Base.GVariant | |
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
| PrintfArg Float | Since: base-2.1 |
Defined in Text.Printf | |
| Floating Float | @since base-2.01 |
| RealFloat Float | @since base-2.01 |
Defined in GHC.Internal.Float Methods floatRadix :: Float -> Integer # floatDigits :: Float -> Int # floatRange :: Float -> (Int, Int) # decodeFloat :: Float -> (Integer, Int) # encodeFloat :: Integer -> Int -> Float # significand :: Float -> Float # scaleFloat :: Int -> Float -> Float # isInfinite :: Float -> Bool # isDenormalized :: Float -> Bool # isNegativeZero :: Float -> Bool # | |
| Storable Float | @since base-2.01 |
| Eq Float | Note that due to the presence of
Also note that
|
| Ord Float | See |
| IsGValue Float Source # | |
Defined in Data.GI.Base.GValue | |
| Foldable (UFloat :: Type -> Type) | @since base-4.9.0.0 |
Defined in GHC.Internal.Data.Foldable Methods fold :: Monoid m => UFloat m -> m # foldMap :: Monoid m => (a -> m) -> UFloat a -> m # foldMap' :: Monoid m => (a -> m) -> UFloat a -> m # foldr :: (a -> b -> b) -> b -> UFloat a -> b # foldr' :: (a -> b -> b) -> b -> UFloat a -> b # foldl :: (b -> a -> b) -> b -> UFloat a -> b # foldl' :: (b -> a -> b) -> b -> UFloat a -> b # foldr1 :: (a -> a -> a) -> UFloat a -> a # foldl1 :: (a -> a -> a) -> UFloat a -> a # elem :: Eq a => a -> UFloat a -> Bool # maximum :: Ord a => UFloat a -> a # minimum :: Ord a => UFloat a -> a # | |
| Traversable (UFloat :: Type -> Type) | @since base-4.9.0.0 |
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
| PrintfArg Double | Since: base-2.1 |
Defined in Text.Printf | |
| Floating Double | @since base-2.01 |
| RealFloat Double | @since base-2.01 |
Defined in GHC.Internal.Float Methods floatRadix :: Double -> Integer # floatDigits :: Double -> Int # floatRange :: Double -> (Int, Int) # decodeFloat :: Double -> (Integer, Int) # encodeFloat :: Integer -> Int -> Double # significand :: Double -> Double # scaleFloat :: Int -> Double -> Double # isInfinite :: Double -> Bool # isDenormalized :: Double -> Bool # isNegativeZero :: Double -> Bool # | |
| Storable Double | @since base-2.01 |
| Eq Double | Note that due to the presence of
Also note that
|
| Ord Double | IEEE 754 IEEE 754-2008, section 5.11 requires that if at least one of arguments of
IEEE 754-2008, section 5.10 defines Thus, users must be extremely cautious when using Moving further, the behaviour of IEEE 754-2008 compliant |
| IsGValue Double Source # | |
Defined in Data.GI.Base.GValue | |
| IsGVariant Double Source # | |
Defined in Data.GI.Base.GVariant | |
| IsGVariantBasicType Double Source # | |
Defined in Data.GI.Base.GVariant | |
| Foldable (UDouble :: Type -> Type) | @since base-4.9.0.0 |
Defined in GHC.Internal.Data.Foldable Methods fold :: Monoid m => UDouble m -> m # foldMap :: Monoid m => (a -> m) -> UDouble a -> m # foldMap' :: Monoid m => (a -> m) -> UDouble a -> m # foldr :: (a -> b -> b) -> b -> UDouble a -> b # foldr' :: (a -> b -> b) -> b -> UDouble a -> b # foldl :: (b -> a -> b) -> b -> UDouble a -> b # foldl' :: (b -> a -> b) -> b -> UDouble a -> b # foldr1 :: (a -> a -> a) -> UDouble a -> a # foldl1 :: (a -> a -> a) -> UDouble a -> a # elem :: Eq a => a -> UDouble a -> Bool # maximum :: Ord a => UDouble a -> a # minimum :: Ord a => UDouble a -> a # | |
| Traversable (UDouble :: Type -> Type) | @since base-4.9.0.0 |
undefined :: HasCallStack => a #
error :: HasCallStack => [Char] -> a #
error stops execution and displays an error message.
map :: (a -> b) -> [a] -> [b] #
\(\mathcal{O}(n)\). map f xs is the list obtained by applying f to
each element of xs, i.e.,
map f [x1, x2, ..., xn] == [f x1, f x2, ..., f xn] map f [x1, x2, ...] == [f x1, f x2, ...]
this means that map id == id
Examples
>>>map (+1) [1, 2, 3][2,3,4]
>>>map id [1, 2, 3][1,2,3]
>>>map (\n -> 3 * n + 1) [1, 2, 3][4,7,10]
length :: Foldable t => t a -> Int #
Returns the size/length of a finite structure as an Int. The
default implementation just counts elements starting with the leftmost.
Instances for structures that can compute the element count faster
than via element-by-element counting, should provide a specialised
implementation.
Examples
Basic usage:
>>>length []0
>>>length ['a', 'b', 'c']3>>>length [1..]* Hangs forever *
@since base-4.8.0.0
mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b) #
Map each element of a structure to a monadic action, evaluate
these actions from left to right, and collect the results. For
a version that ignores the results see mapM_.
Examples
when :: Applicative f => Bool -> f () -> f () #
Conditional execution of Applicative expressions. For example,
Examples
when debug (putStrLn "Debugging")
will output the string Debugging if the Boolean value debug
is True, and otherwise do nothing.
>>>putStr "pi:" >> when False (print 3.14159)pi:
fromIntegral :: (Integral a, Num b) => a -> b #
General coercion from Integral types.
WARNING: This function performs silent truncation if the result type is not at least as big as the argument's type.
realToFrac :: (Real a, Fractional b) => a -> b #
General coercion to Fractional types.
WARNING: This function goes through the Rational type, which does not have values for NaN for example.
This means it does not round-trip.
For Double it also behaves differently with or without -O0:
Prelude> realToFrac nan -- With -O0 -Infinity Prelude> realToFrac nan NaN