Safe Haskell | None |
---|---|
Language | Haskell98 |
- newtype Fun a b = Fun (RefExp -> R a -> R b)
- data Int :: *
- data Char :: *
- data Integer :: *
- data Float :: *
- data Double :: *
- data Bool :: *
- type IOError = IOException
- aTrue :: RefAtom
- aFalse :: RefAtom
- type String = List Char
- toFun :: (RefExp -> c -> R a) -> (RefExp -> R b -> d) -> RefExp -> R (Fun a b) -> c -> d
- fromFun :: (RefExp -> R a -> b) -> (RefExp -> c -> R d) -> RefExp -> (b -> c) -> R (Fun a d)
- toBool :: RefExp -> R Bool -> Bool
- fromBool :: RefExp -> Bool -> R Bool
- toList :: (RefExp -> R a -> b) -> RefExp -> R (List a) -> [b]
- fromList :: (RefExp -> a -> R b) -> RefExp -> [a] -> R (List b)
- toString :: RefExp -> R String -> String
- fromString :: RefExp -> String -> R String
- toIOError :: RefExp -> R IOError -> IOError
- fromIOError :: RefExp -> IOError -> R IOError
- aIOError :: RefAtom
- gerror :: RefSrcPos -> RefExp -> R (Fun String z)
- herror :: R String -> RefExp -> a
- aerror :: RefAtom
- gundefined :: RefSrcPos -> RefExp -> R a
- hundefined :: RefExp -> a
- aundefined :: RefAtom
Documentation
A fixed-precision integer type with at least the range [-2^29 .. 2^29-1]
.
The exact range for a given implementation can be determined by using
minBound
and maxBound
from the Bounded
class.
The character type Char
is an enumeration whose values represent
Unicode (or equivalently ISO/IEC 10646) characters (see
http://www.unicode.org/ for details). This set extends the ISO 8859-1
(Latin-1) character set (the first 256 characters), which is itself an extension
of the ASCII character set (the first 128 characters). A character literal in
Haskell has type Char
.
To convert a Char
to or from the corresponding Int
value defined
by Unicode, use toEnum
and fromEnum
from the
Enum
class respectively (or equivalently ord
and chr
).
Invariant: Jn#
and Jp#
are used iff value doesn't fit in S#
Useful properties resulting from the invariants:
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.
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.
type IOError = IOException #
fromFun :: (RefExp -> R a -> b) -> (RefExp -> c -> R d) -> RefExp -> (b -> c) -> R (Fun a d) Source #
hundefined :: RefExp -> a Source #
aundefined :: RefAtom Source #