| Safe Haskell | None |
|---|---|
| Language | Haskell98 |
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, which we reexport explicitly here.
- module Data.Char
- module Data.Int
- module Data.Word
- module Data.ByteString.Char8
- module Foreign.C
- module Foreign.Ptr
- module Foreign.ForeignPtr
- module Foreign.ForeignPtr.Unsafe
- module Foreign.Storable
- module Control.Applicative
- module Control.Exception
- module Control.Monad.IO.Class
- module Data.GI.Base.Attributes
- module Data.GI.Base.BasicTypes
- module Data.GI.Base.BasicConversions
- module Data.GI.Base.Closure
- module Data.GI.Base.GError
- module Data.GI.Base.GHashTable
- module Data.GI.Base.GParamSpec
- module Data.GI.Base.GVariant
- module Data.GI.Base.GValue
- module Data.GI.Base.ManagedPtr
- module Data.GI.Base.Overloading
- module Data.GI.Base.Properties
- module Data.GI.Base.Signals
- module Data.GI.Base.Utils
- module GHC.TypeLits
- module GHC.OverloadedLabels
- class Enum a where
- class Show a where
- class Eq a where
- data IO a :: TYPE Lifted -> TYPE Lifted
- class Applicative m => Monad m where
- data Maybe a :: TYPE Lifted -> TYPE Lifted
- (.) :: (b -> c) -> (a -> b) -> a -> c
- ($) :: (a -> b) -> a -> b
- (++) :: [a] -> [a] -> [a]
- (=<<) :: Monad m => (a -> m b) -> m a -> m b
- data Bool :: TYPE Lifted
- data Float :: TYPE Lifted
- data Double :: TYPE Lifted
- undefined :: HasCallStack => a
- error :: HasCallStack => [Char] -> a
- map :: (a -> b) -> [a] -> [b]
- length :: Foldable t => forall a. t a -> Int
- mapM :: Traversable t => forall m a b. 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
Documentation
module Data.Char
module Data.Int
module Data.Word
module Data.ByteString.Char8
module Foreign.C
module Foreign.Ptr
module Foreign.ForeignPtr
module Foreign.ForeignPtr.Unsafe
module Foreign.Storable
module Control.Applicative
module Control.Exception
module Control.Monad.IO.Class
module Data.GI.Base.Attributes
module Data.GI.Base.BasicTypes
module Data.GI.Base.Closure
module Data.GI.Base.GError
module Data.GI.Base.GHashTable
module Data.GI.Base.GParamSpec
module Data.GI.Base.GVariant
module Data.GI.Base.GValue
module Data.GI.Base.ManagedPtr
module Data.GI.Base.Overloading
module Data.GI.Base.Properties
module Data.GI.Base.Signals
module Data.GI.Base.Utils
module GHC.TypeLits
module GHC.OverloadedLabels
class Enum a where
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 = minBoundInstances
| Enum Bool | |
| Enum Char | |
| Enum Int | |
| Enum Int8 | |
| Enum Int16 | |
| Enum Int32 | |
| Enum Int64 | |
| Enum Integer | |
| Enum Ordering | |
| Enum Word | |
| Enum Word8 | |
| Enum Word16 | |
| Enum Word32 | |
| Enum Word64 | |
| Enum () | |
| Enum WordPtr | |
| Enum IntPtr | |
| Enum CChar | |
| Enum CSChar | |
| Enum CUChar | |
| Enum CShort | |
| Enum CUShort | |
| Enum CInt | |
| Enum CUInt | |
| Enum CLong | |
| Enum CULong | |
| Enum CLLong | |
| Enum CULLong | |
| Enum CFloat | |
| Enum CDouble | |
| Enum CPtrdiff | |
| Enum CSize | |
| Enum CWchar | |
| Enum CSigAtomic | |
| Enum CClock | |
| Enum CTime | |
| Enum CUSeconds | |
| Enum CSUSeconds | |
| Enum CIntPtr | |
| Enum CUIntPtr | |
| Enum CIntMax | |
| Enum CUIntMax | |
| Enum I16 | |
| Integral a => Enum (Ratio a) | |
| Enum a => Enum (Identity a) | |
| Enum a => Enum (Min a) | |
| Enum a => Enum (Max a) | |
| Enum a => Enum (First a) | |
| Enum a => Enum (Last a) | |
| Enum a => Enum (WrappedMonoid a) | |
| Enum (Proxy k s) | |
| Enum a => Enum (Const k a b) | |
| Enum (f a) => Enum (Alt k f a) | |
| (~) k a b => Enum ((:~:) k a b) | |
class Show a where
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)".
Instances
class Eq a where
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.
Instances
| Eq Bool | |
| Eq Char | |
| Eq Double | |
| Eq Float | |
| Eq Int | |
| Eq Int8 | |
| Eq Int16 | |
| Eq Int32 | |
| Eq Int64 | |
| Eq Integer | |
| Eq Ordering | |
| Eq Word | |
| Eq Word8 | |
| Eq Word16 | |
| Eq Word32 | |
| Eq Word64 | |
| Eq TypeRep | |
| Eq () | |
| Eq TyCon | |
| Eq BigNat | |
| Eq Void | |
| Eq SpecConstrAnnotation | |
| Eq Version | |
| Eq AsyncException | |
| Eq ArrayException | |
| Eq ExitCode | |
| Eq IOErrorType | |
| Eq WordPtr | |
| Eq IntPtr | |
| Eq CChar | |
| Eq CSChar | |
| Eq CUChar | |
| Eq CShort | |
| Eq CUShort | |
| Eq CInt | |
| Eq CUInt | |
| Eq CLong | |
| Eq CULong | |
| Eq CLLong | |
| Eq CULLong | |
| Eq CFloat | |
| Eq CDouble | |
| Eq CPtrdiff | |
| Eq CSize | |
| Eq CWchar | |
| Eq CSigAtomic | |
| Eq CClock | |
| Eq CTime | |
| Eq CUSeconds | |
| Eq CSUSeconds | |
| Eq CIntPtr | |
| Eq CUIntPtr | |
| Eq CIntMax | |
| Eq CUIntMax | |
| Eq MaskingState | |
| Eq IOException | |
| Eq ErrorCall | |
| Eq ArithException | |
| Eq Fingerprint | |
| Eq All | |
| Eq Any | |
| Eq Fixity | |
| Eq Associativity | |
| Eq SourceUnpackedness | |
| Eq SourceStrictness | |
| Eq DecidedStrictness | |
| Eq SomeNat | |
| Eq SomeSymbol | |
| Eq ByteString | |
| Eq IntSet | |
| Eq I16 | |
| Eq GVariantSignature | |
| Eq GVariantObjectPath | |
| Eq GVariantHandle | |
| Eq a => Eq [a] | |
| Eq a => Eq (Maybe a) | |
| Eq a => Eq (Ratio a) | |
| Eq (StablePtr a) | |
| Eq (Ptr a) | |
| Eq (FunPtr a) | |
| Eq (U1 p) | |
| Eq p => Eq (Par1 p) | |
| Eq (ForeignPtr a) | |
| Eq a => Eq (Identity a) | |
| Eq a => Eq (Min a) | |
| Eq a => Eq (Max a) | |
| Eq a => Eq (First a) | |
| Eq a => Eq (Last a) | |
| Eq m => Eq (WrappedMonoid m) | |
| Eq a => Eq (Option a) | |
| Eq a => Eq (NonEmpty a) | |
| Eq a => Eq (Complex a) | |
| Eq a => Eq (ZipList a) | |
| Eq a => Eq (Dual a) | |
| Eq a => Eq (Sum a) | |
| Eq a => Eq (Product a) | |
| Eq a => Eq (First a) | |
| Eq a => Eq (Last a) | |
| Eq a => Eq (IntMap a) | |
| Eq a => Eq (Set a) | |
| Eq a => Eq (Seq a) | |
| Eq a => Eq (ViewL a) | |
| Eq a => Eq (ViewR a) | |
| Eq a => Eq (GVariantSinglet a) | |
| (Eq a, Eq b) => Eq (Either a b) | |
| Eq (f p) => Eq (Rec1 f p) | |
| Eq (URec Char p) | |
| Eq (URec Double p) | |
| Eq (URec Float p) | |
| Eq (URec Int p) | |
| Eq (URec Word p) | |
| Eq (URec (Ptr ()) p) | |
| (Eq a, Eq b) => Eq (a, b) | |
| (Ix i, Eq e) => Eq (Array i e) | |
| Eq a => Eq (Arg a b) | |
| Eq (Proxy k s) | |
| (Eq k, Eq a) => Eq (Map k a) | |
| (Eq key, Eq value) => Eq (GVariantDictEntry key value) | |
| Eq c => Eq (K1 i c p) | |
| (Eq (f p), Eq (g p)) => Eq ((:+:) f g p) | |
| (Eq (f p), Eq (g p)) => Eq ((:*:) f g p) | |
| Eq (f (g p)) => Eq ((:.:) f g p) | |
| (Eq a, Eq b, Eq c) => Eq (a, b, c) | |
| Eq (STArray s i e) | |
| Eq a => Eq (Const k a b) | |
| Eq (f a) => Eq (Alt k f a) | |
| Eq ((:~:) k a b) | |
| Eq (f p) => Eq (M1 i c f p) | |
| (Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d) | |
| (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) | |
data IO a :: TYPE Lifted -> TYPE Lifted
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.
class Applicative m => Monad m 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 laws:
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
Instances
| Monad [] | |
| Monad Maybe | |
| Monad IO | |
| Monad Identity | |
| Monad Min | |
| Monad Max | |
| Monad First | |
| Monad Last | |
| Monad Option | |
| Monad NonEmpty | |
| Monad Complex | |
| Monad Dual | |
| Monad Sum | |
| Monad Product | |
| Monad First | |
| Monad Last | |
| Monad Put | |
| Monad Seq | |
| Monad ((->) r) | |
| Monad (Either e) | |
| Monoid a => Monad ((,) a) | |
| Monad m => Monad (WrappedMonad m) | |
| ArrowApply a => Monad (ArrowMonad a) | |
| Monad (Proxy (TYPE Lifted)) | |
| Monad (State s) | |
| Monad f => Monad (Alt (TYPE Lifted) f) | |
data Maybe a :: TYPE Lifted -> TYPE Lifted
The Maybe type encapsulates an optional value. A value of type
Maybe aa (represented as Just aNothing). Using Maybe is a good way to
deal with errors or exceptional cases without resorting to drastic
measures such as error.
The Maybe type is also a monad. It is a simple kind of error
monad, where all errors are represented by Nothing. A richer
error monad can be built using the Either type.
Instances
| Monad Maybe | |
| Functor Maybe | |
| Applicative Maybe | |
| Foldable Maybe | |
| Traversable Maybe | |
| Generic1 Maybe | |
| Alternative Maybe | |
| MonadPlus Maybe | |
| Eq a => Eq (Maybe a) | |
| Ord a => Ord (Maybe a) | |
| Show a => Show (Maybe a) | |
| Generic (Maybe a) | |
| Semigroup a => Semigroup (Maybe a) | |
| Monoid a => Monoid (Maybe a) | Lift a semigroup into |
| IsGVariant a => IsGVariant (Maybe a) Source | |
| SingI (Maybe a) (Nothing a) | |
| SingKind a (KProxy a) => SingKind (Maybe a) (KProxy (Maybe a)) | |
| SingI a a1 => SingI (Maybe a) (Just a a1) | |
| type Rep1 Maybe = D1 (MetaData "Maybe" "GHC.Base" "base" False) ((:+:) (C1 (MetaCons "Nothing" PrefixI False) U1) (C1 (MetaCons "Just" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))) | |
| type Rep (Maybe a) = D1 (MetaData "Maybe" "GHC.Base" "base" False) ((:+:) (C1 (MetaCons "Nothing" PrefixI False) U1) (C1 (MetaCons "Just" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))) | |
| data Sing (Maybe a) where | |
| type (==) (Maybe k) a b = EqMaybe k a b | |
| type DemoteRep (Maybe a) (KProxy (Maybe a)) = Maybe (DemoteRep a (KProxy a)) | |
(.) :: (b -> c) -> (a -> b) -> a -> c infixr 9
Function composition.
($) :: (a -> b) -> a -> b infixr 0
Application operator. This operator is redundant, since ordinary
application (f x) means the same as (f . However, $ x)$ has
low, right-associative binding precedence, so it sometimes allows
parentheses to be omitted; for example:
f $ g $ h x = f (g (h x))
It is also useful in higher-order situations, such as map ($ 0) xszipWith ($) fs xs
(++) :: [a] -> [a] -> [a] infixr 5
Append 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.
(=<<) :: Monad m => (a -> m b) -> m a -> m b infixr 1
Same as >>=, but with the arguments interchanged.
Instances
| Bounded Bool | |
| Enum Bool | |
| Eq Bool | |
| Ord Bool | |
| Show Bool | |
| Ix Bool | |
| Generic Bool | |
| Storable Bool | |
| Bits Bool | |
| FiniteBits Bool | |
| IsGValue Bool Source | |
| IsGVariantBasicType Bool Source | |
| IsGVariant Bool Source | |
| SingI Bool False | |
| SingI Bool True | |
| SingKind Bool (KProxy Bool) | |
| type Rep Bool = D1 (MetaData "Bool" "GHC.Types" "ghc-prim" False) ((:+:) (C1 (MetaCons "False" PrefixI False) U1) (C1 (MetaCons "True" PrefixI False) U1)) | |
| data Sing Bool where | |
| type (==) Bool a b = EqBool a b | |
| type DemoteRep Bool (KProxy Bool) = Bool | |
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
| Eq Float | |
| Floating Float | |
| Ord Float | |
| RealFloat Float | |
| Storable Float | |
| IsGValue Float Source | |
| Eq (URec Float p) | |
| Ord (URec Float p) | |
| Show (URec Float p) | |
| Generic (URec Float p) | |
| data URec Float = UFloat {} | Used for marking occurrences of |
| type Rep (URec Float p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UFloat" PrefixI True) (S1 (MetaSel (Just Symbol "uFloat#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UFloat)) | |
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
| Eq Double | |
| Floating Double | |
| Ord Double | |
| RealFloat Double | |
| Storable Double | |
| IsGValue Double Source | |
| IsGVariantBasicType Double Source | |
| IsGVariant Double Source | |
| Eq (URec Double p) | |
| Ord (URec Double p) | |
| Show (URec Double p) | |
| Generic (URec Double p) | |
| data URec Double = UDouble {} | Used for marking occurrences of |
| type Rep (URec Double p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UDouble" PrefixI True) (S1 (MetaSel (Just Symbol "uDouble#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UDouble)) | |
undefined :: HasCallStack => a
error :: HasCallStack => [Char] -> a
error stops execution and displays an error message.
map :: (a -> b) -> [a] -> [b]
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, ...]
length :: Foldable t => forall a. t a -> Int
Returns the size/length of a finite structure as an Int. The
default implementation is optimized for structures that are similar to
cons-lists, because there is no general way to do better.
mapM :: Traversable t => forall m a b. 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_.
when :: Applicative f => Bool -> f () -> f ()
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.
fromIntegral :: (Integral a, Num b) => a -> b
general coercion from integral types
realToFrac :: (Real a, Fractional b) => a -> b
general coercion to fractional types