Hat.PreludeBuiltinTypes

Documentation

newtype Fun a b

Constructors

Fun (RefExp -> R a -> R b)

data Int :: *

A fixed-precision integer type with at least the range [-2^29 .. 2^29-1]. The exact range for a given implementation can be determined by using minBound and maxBound from the Bounded class.

Instances

Bounded Int

Methods

minBound :: Int

maxBound :: Int

Enum Int

Methods

succ :: Int -> Int

pred :: Int -> Int

toEnum :: Int -> Int

fromEnum :: Int -> Int

enumFrom :: Int -> [Int]

enumFromThen :: Int -> Int -> [Int]

enumFromTo :: Int -> Int -> [Int]

enumFromThenTo :: Int -> Int -> Int -> [Int]

Eq Int

Methods

(==) :: Int -> Int -> Bool

(/=) :: Int -> Int -> Bool

Integral Int

Methods

quot :: Int -> Int -> Int

rem :: Int -> Int -> Int

div :: Int -> Int -> Int

mod :: Int -> Int -> Int

quotRem :: Int -> Int -> (Int, Int)

divMod :: Int -> Int -> (Int, Int)

toInteger :: Int -> Integer

Num Int

Methods

(+) :: Int -> Int -> Int

(-) :: Int -> Int -> Int

(*) :: Int -> Int -> Int

negate :: Int -> Int

abs :: Int -> Int

signum :: Int -> Int

fromInteger :: Integer -> Int

Ord Int

Methods

compare :: Int -> Int -> Ordering

(<) :: Int -> Int -> Bool

(<=) :: Int -> Int -> Bool

(>) :: Int -> Int -> Bool

(>=) :: Int -> Int -> Bool

max :: Int -> Int -> Int

min :: Int -> Int -> Int

Read Int

Methods

readsPrec :: Int -> ReadS Int

readList :: ReadS [Int]

readPrec :: ReadPrec Int

readListPrec :: ReadPrec [Int]

Real Int

Methods

toRational :: Int -> Rational

Show Int

Methods

showsPrec :: Int -> Int -> ShowS

show :: Int -> String

showList :: [Int] -> ShowS

Storable Int

Methods

sizeOf :: Int -> Int

alignment :: Int -> Int

peekElemOff :: Ptr Int -> Int -> IO Int

pokeElemOff :: Ptr Int -> Int -> Int -> IO ()

peekByteOff :: Ptr b -> Int -> IO Int

pokeByteOff :: Ptr b -> Int -> Int -> IO ()

peek :: Ptr Int -> IO Int

poke :: Ptr Int -> Int -> IO ()

Random Int

Methods

randomR :: RandomGen g => (Int, Int) -> g -> (Int, g)

random :: RandomGen g => g -> (Int, g)

randomRs :: RandomGen g => (Int, Int) -> g -> [Int]

randoms :: RandomGen g => g -> [Int]

randomRIO :: (Int, Int) -> IO Int

randomIO :: IO Int

Show Int

Methods

gshowsPrec :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int ShowS))

sshowsPrec :: R (Fun Int (Fun Int ShowS))

gshow :: RefSrcPos -> RefExp -> R (Fun Int String)

sshow :: R (Fun Int String)

gshowList :: RefSrcPos -> RefExp -> R (Fun (List Int) ShowS)

sshowList :: R (Fun (List Int) ShowS)

Read Int

Methods

greadsPrec :: RefSrcPos -> RefExp -> R (Fun Int (ReadS Int))

sreadsPrec :: R (Fun Int (ReadS Int))

greadList :: RefSrcPos -> RefExp -> R (ReadS (List Int))

sreadList :: R (ReadS (List Int))

Integral Int

Methods

gquot :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Int))

grem :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Int))

squot :: R (Fun Int (Fun Int Int))

srem :: R (Fun Int (Fun Int Int))

gdiv :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Int))

gmod :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Int))

sdiv :: R (Fun Int (Fun Int Int))

smod :: R (Fun Int (Fun Int Int))

gquotRem :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int (Tuple2 Int Int)))

gdivMod :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int (Tuple2 Int Int)))

squotRem :: R (Fun Int (Fun Int (Tuple2 Int Int)))

sdivMod :: R (Fun Int (Fun Int (Tuple2 Int Int)))

gtoInteger :: RefSrcPos -> RefExp -> R (Fun Int Integer)

stoInteger :: R (Fun Int Integer)

Real Int

Methods

gtoRational :: RefSrcPos -> RefExp -> R (Fun Int Rational)

stoRational :: R (Fun Int Rational)

Num Int

Methods

(!+) :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Int))

(!-) :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Int))

(!*) :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Int))

(|+) :: R (Fun Int (Fun Int Int))

(|-) :: R (Fun Int (Fun Int Int))

(|*) :: R (Fun Int (Fun Int Int))

gnegate :: RefSrcPos -> RefExp -> R (Fun Int Int)

snegate :: R (Fun Int Int)

gabs :: RefSrcPos -> RefExp -> R (Fun Int Int)

gsignum :: RefSrcPos -> RefExp -> R (Fun Int Int)

sabs :: R (Fun Int Int)

ssignum :: R (Fun Int Int)

gfromInteger :: RefSrcPos -> RefExp -> R (Fun Integer Int)

sfromInteger :: R (Fun Integer Int)

Bounded Int

Methods

gminBound :: RefSrcPos -> RefExp -> R Int

sminBound :: R Int

gmaxBound :: RefSrcPos -> RefExp -> R Int

smaxBound :: R Int

Enum Int

Methods

gsucc :: RefSrcPos -> RefExp -> R (Fun Int Int)

gpred :: RefSrcPos -> RefExp -> R (Fun Int Int)

ssucc :: R (Fun Int Int)

spred :: R (Fun Int Int)

gtoEnum :: RefSrcPos -> RefExp -> R (Fun Int Int)

stoEnum :: R (Fun Int Int)

gfromEnum :: RefSrcPos -> RefExp -> R (Fun Int Int)

sfromEnum :: R (Fun Int Int)

genumFrom :: RefSrcPos -> RefExp -> R (Fun Int (List Int))

senumFrom :: R (Fun Int (List Int))

genumFromThen :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int (List Int)))

senumFromThen :: R (Fun Int (Fun Int (List Int)))

genumFromTo :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int (List Int)))

senumFromTo :: R (Fun Int (Fun Int (List Int)))

genumFromThenTo :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int (Fun Int (List Int))))

senumFromThenTo :: R (Fun Int (Fun Int (Fun Int (List Int))))

Ord Int

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Ordering))

scompare :: R (Fun Int (Fun Int Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Bool))

(!<=) :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Bool))

(!>=) :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Bool))

(!>) :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Bool))

(|<) :: R (Fun Int (Fun Int Bool))

(|<=) :: R (Fun Int (Fun Int Bool))

(|>=) :: R (Fun Int (Fun Int Bool))

(|>) :: R (Fun Int (Fun Int Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Int))

gmin :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Int))

smax :: R (Fun Int (Fun Int Int))

smin :: R (Fun Int (Fun Int Int))

Eq Int

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Bool))

(!/=) :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Bool))

(|==) :: R (Fun Int (Fun Int Bool))

(|/=) :: R (Fun Int (Fun Int Bool))

Ix Int

Methods

grange :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Int Int) (List Int))

srange :: R (Fun (Tuple2 Int Int) (List Int))

gindex :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Int Int) (Fun Int Int))

sindex :: R (Fun (Tuple2 Int Int) (Fun Int Int))

ginRange :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Int Int) (Fun Int Bool))

sinRange :: R (Fun (Tuple2 Int Int) (Fun Int Bool))

grangeSize :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Int Int) Int)

srangeSize :: R (Fun (Tuple2 Int Int) Int)

Random Int

Methods

grandomR :: RandomGen g => RefSrcPos -> RefExp -> R (Fun (Tuple2 Int Int) (Fun g (Tuple2 Int g)))

srandomR :: RandomGen g => R (Fun (Tuple2 Int Int) (Fun g (Tuple2 Int g)))

grandom :: RandomGen g => RefSrcPos -> RefExp -> R (Fun g (Tuple2 Int g))

srandom :: RandomGen g => R (Fun g (Tuple2 Int g))

grandomRs :: RandomGen g => RefSrcPos -> RefExp -> R (Fun (Tuple2 Int Int) (Fun g (List Int)))

srandomRs :: RandomGen g => R (Fun (Tuple2 Int Int) (Fun g (List Int)))

grandoms :: RandomGen g => RefSrcPos -> RefExp -> R (Fun g (List Int))

srandoms :: RandomGen g => R (Fun g (List Int))

grandomRIO :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Int Int) (IO Int))

srandomRIO :: R (Fun (Tuple2 Int Int) (IO Int))

grandomIO :: RefSrcPos -> RefExp -> R (IO Int)

srandomIO :: R (IO Int)

Functor (URec Int)

Methods

fmap :: (a -> b) -> URec Int a -> URec Int b

(<$) :: a -> URec Int b -> URec Int a

Foldable (URec Int)

Methods

fold :: Monoid m => URec Int m -> m

foldMap :: Monoid m => (a -> m) -> URec Int a -> m

foldr :: (a -> b -> b) -> b -> URec Int a -> b

foldr' :: (a -> b -> b) -> b -> URec Int a -> b

foldl :: (b -> a -> b) -> b -> URec Int a -> b

foldl' :: (b -> a -> b) -> b -> URec Int a -> b

foldr1 :: (a -> a -> a) -> URec Int a -> a

foldl1 :: (a -> a -> a) -> URec Int a -> a

toList :: URec Int a -> [a]

null :: URec Int a -> Bool

length :: URec Int a -> Int

elem :: Eq a => a -> URec Int a -> Bool

maximum :: Ord a => URec Int a -> a

minimum :: Ord a => URec Int a -> a

sum :: Num a => URec Int a -> a

product :: Num a => URec Int a -> a

Generic1 (URec Int)

Associated Types

type Rep1 (URec Int :: * -> *) :: * -> *

Methods

from1 :: URec Int a -> Rep1 (URec Int) a

to1 :: Rep1 (URec Int) a -> URec Int a

Eq (URec Int p)

Methods

(==) :: URec Int p -> URec Int p -> Bool

(/=) :: URec Int p -> URec Int p -> Bool

Ord (URec Int p)

Methods

compare :: URec Int p -> URec Int p -> Ordering

(<) :: URec Int p -> URec Int p -> Bool

(<=) :: URec Int p -> URec Int p -> Bool

(>) :: URec Int p -> URec Int p -> Bool

(>=) :: URec Int p -> URec Int p -> Bool

max :: URec Int p -> URec Int p -> URec Int p

min :: URec Int p -> URec Int p -> URec Int p

Show (URec Int p)

Methods

showsPrec :: Int -> URec Int p -> ShowS

show :: URec Int p -> String

showList :: [URec Int p] -> ShowS

Generic (URec Int p)

Associated Types

type Rep (URec Int p) :: * -> *

Methods

from :: URec Int p -> Rep (URec Int p) x

to :: Rep (URec Int p) x -> URec Int p

data URec Int

Used for marking occurrences of Int#

data URec Int = UInt {

• uInt# :: Int#

}

type Rep1 (URec Int)

type Rep1 (URec Int) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UInt" PrefixI True) (S1 (MetaSel (Just Symbol "uInt#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UInt))

type Rep (URec Int p)

type Rep (URec Int p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UInt" PrefixI True) (S1 (MetaSel (Just Symbol "uInt#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UInt))

data Char :: *

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).

Instances

Bounded Char

Methods

minBound :: Char

maxBound :: Char

Enum Char

Methods

succ :: Char -> Char

pred :: Char -> Char

toEnum :: Int -> Char

fromEnum :: Char -> Int

enumFrom :: Char -> [Char]

enumFromThen :: Char -> Char -> [Char]

enumFromTo :: Char -> Char -> [Char]

enumFromThenTo :: Char -> Char -> Char -> [Char]

Eq Char

Methods

(==) :: Char -> Char -> Bool

(/=) :: Char -> Char -> Bool

Ord Char

Methods

compare :: Char -> Char -> Ordering

(<) :: Char -> Char -> Bool

(<=) :: Char -> Char -> Bool

(>) :: Char -> Char -> Bool

(>=) :: Char -> Char -> Bool

max :: Char -> Char -> Char

min :: Char -> Char -> Char

Read Char

Methods

readsPrec :: Int -> ReadS Char

readList :: ReadS [Char]

readPrec :: ReadPrec Char

readListPrec :: ReadPrec [Char]

Show Char

Methods

showsPrec :: Int -> Char -> ShowS

show :: Char -> String

showList :: [Char] -> ShowS

Storable Char

Methods

sizeOf :: Char -> Int

alignment :: Char -> Int

peekElemOff :: Ptr Char -> Int -> IO Char

pokeElemOff :: Ptr Char -> Int -> Char -> IO ()

peekByteOff :: Ptr b -> Int -> IO Char

pokeByteOff :: Ptr b -> Int -> Char -> IO ()

peek :: Ptr Char -> IO Char

poke :: Ptr Char -> Char -> IO ()

Random Char

Methods

randomR :: RandomGen g => (Char, Char) -> g -> (Char, g)

random :: RandomGen g => g -> (Char, g)

randomRs :: RandomGen g => (Char, Char) -> g -> [Char]

randoms :: RandomGen g => g -> [Char]

randomRIO :: (Char, Char) -> IO Char

randomIO :: IO Char

Show Char

Methods

gshowsPrec :: RefSrcPos -> RefExp -> R (Fun Int (Fun Char ShowS))

sshowsPrec :: R (Fun Int (Fun Char ShowS))

gshow :: RefSrcPos -> RefExp -> R (Fun Char String)

sshow :: R (Fun Char String)

gshowList :: RefSrcPos -> RefExp -> R (Fun (List Char) ShowS)

sshowList :: R (Fun (List Char) ShowS)

Read Char

Methods

greadsPrec :: RefSrcPos -> RefExp -> R (Fun Int (ReadS Char))

sreadsPrec :: R (Fun Int (ReadS Char))

greadList :: RefSrcPos -> RefExp -> R (ReadS (List Char))

sreadList :: R (ReadS (List Char))

Bounded Char

Methods

gminBound :: RefSrcPos -> RefExp -> R Char

sminBound :: R Char

gmaxBound :: RefSrcPos -> RefExp -> R Char

smaxBound :: R Char

Enum Char

Methods

gsucc :: RefSrcPos -> RefExp -> R (Fun Char Char)

gpred :: RefSrcPos -> RefExp -> R (Fun Char Char)

ssucc :: R (Fun Char Char)

spred :: R (Fun Char Char)

gtoEnum :: RefSrcPos -> RefExp -> R (Fun Int Char)

stoEnum :: R (Fun Int Char)

gfromEnum :: RefSrcPos -> RefExp -> R (Fun Char Int)

sfromEnum :: R (Fun Char Int)

genumFrom :: RefSrcPos -> RefExp -> R (Fun Char (List Char))

senumFrom :: R (Fun Char (List Char))

genumFromThen :: RefSrcPos -> RefExp -> R (Fun Char (Fun Char (List Char)))

senumFromThen :: R (Fun Char (Fun Char (List Char)))

genumFromTo :: RefSrcPos -> RefExp -> R (Fun Char (Fun Char (List Char)))

senumFromTo :: R (Fun Char (Fun Char (List Char)))

genumFromThenTo :: RefSrcPos -> RefExp -> R (Fun Char (Fun Char (Fun Char (List Char))))

senumFromThenTo :: R (Fun Char (Fun Char (Fun Char (List Char))))

Ord Char

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun Char (Fun Char Ordering))

scompare :: R (Fun Char (Fun Char Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun Char (Fun Char Bool))

(!<=) :: RefSrcPos -> RefExp -> R (Fun Char (Fun Char Bool))

(!>=) :: RefSrcPos -> RefExp -> R (Fun Char (Fun Char Bool))

(!>) :: RefSrcPos -> RefExp -> R (Fun Char (Fun Char Bool))

(|<) :: R (Fun Char (Fun Char Bool))

(|<=) :: R (Fun Char (Fun Char Bool))

(|>=) :: R (Fun Char (Fun Char Bool))

(|>) :: R (Fun Char (Fun Char Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun Char (Fun Char Char))

gmin :: RefSrcPos -> RefExp -> R (Fun Char (Fun Char Char))

smax :: R (Fun Char (Fun Char Char))

smin :: R (Fun Char (Fun Char Char))

Eq Char

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun Char (Fun Char Bool))

(!/=) :: RefSrcPos -> RefExp -> R (Fun Char (Fun Char Bool))

(|==) :: R (Fun Char (Fun Char Bool))

(|/=) :: R (Fun Char (Fun Char Bool))

Ix Char

Methods

grange :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Char Char) (List Char))

srange :: R (Fun (Tuple2 Char Char) (List Char))

gindex :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Char Char) (Fun Char Int))

sindex :: R (Fun (Tuple2 Char Char) (Fun Char Int))

ginRange :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Char Char) (Fun Char Bool))

sinRange :: R (Fun (Tuple2 Char Char) (Fun Char Bool))

grangeSize :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Char Char) Int)

srangeSize :: R (Fun (Tuple2 Char Char) Int)

Random Char

Methods

grandomR :: RandomGen g => RefSrcPos -> RefExp -> R (Fun (Tuple2 Char Char) (Fun g (Tuple2 Char g)))

srandomR :: RandomGen g => R (Fun (Tuple2 Char Char) (Fun g (Tuple2 Char g)))

grandom :: RandomGen g => RefSrcPos -> RefExp -> R (Fun g (Tuple2 Char g))

srandom :: RandomGen g => R (Fun g (Tuple2 Char g))

grandomRs :: RandomGen g => RefSrcPos -> RefExp -> R (Fun (Tuple2 Char Char) (Fun g (List Char)))

srandomRs :: RandomGen g => R (Fun (Tuple2 Char Char) (Fun g (List Char)))

grandoms :: RandomGen g => RefSrcPos -> RefExp -> R (Fun g (List Char))

srandoms :: RandomGen g => R (Fun g (List Char))

grandomRIO :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Char Char) (IO Char))

srandomRIO :: R (Fun (Tuple2 Char Char) (IO Char))

grandomIO :: RefSrcPos -> RefExp -> R (IO Char)

srandomIO :: R (IO Char)

Functor (URec Char)

Methods

fmap :: (a -> b) -> URec Char a -> URec Char b

(<$) :: a -> URec Char b -> URec Char a

Foldable (URec Char)

Methods

fold :: Monoid m => URec Char m -> m

foldMap :: Monoid m => (a -> m) -> URec Char a -> m

foldr :: (a -> b -> b) -> b -> URec Char a -> b

foldr' :: (a -> b -> b) -> b -> URec Char a -> b

foldl :: (b -> a -> b) -> b -> URec Char a -> b

foldl' :: (b -> a -> b) -> b -> URec Char a -> b

foldr1 :: (a -> a -> a) -> URec Char a -> a

foldl1 :: (a -> a -> a) -> URec Char a -> a

toList :: URec Char a -> [a]

null :: URec Char a -> Bool

length :: URec Char a -> Int

elem :: Eq a => a -> URec Char a -> Bool

maximum :: Ord a => URec Char a -> a

minimum :: Ord a => URec Char a -> a

sum :: Num a => URec Char a -> a

product :: Num a => URec Char a -> a

Generic1 (URec Char)

Associated Types

type Rep1 (URec Char :: * -> *) :: * -> *

Methods

from1 :: URec Char a -> Rep1 (URec Char) a

to1 :: Rep1 (URec Char) a -> URec Char a

Eq (URec Char p)

Methods

(==) :: URec Char p -> URec Char p -> Bool

(/=) :: URec Char p -> URec Char p -> Bool

Ord (URec Char p)

Methods

compare :: URec Char p -> URec Char p -> Ordering

(<) :: URec Char p -> URec Char p -> Bool

(<=) :: URec Char p -> URec Char p -> Bool

(>) :: URec Char p -> URec Char p -> Bool

(>=) :: URec Char p -> URec Char p -> Bool

max :: URec Char p -> URec Char p -> URec Char p

min :: URec Char p -> URec Char p -> URec Char p

Show (URec Char p)

Methods

showsPrec :: Int -> URec Char p -> ShowS

show :: URec Char p -> String

showList :: [URec Char p] -> ShowS

Generic (URec Char p)

Associated Types

type Rep (URec Char p) :: * -> *

Methods

from :: URec Char p -> Rep (URec Char p) x

to :: Rep (URec Char p) x -> URec Char p

data URec Char

Used for marking occurrences of Char#

data URec Char = UChar {

• uChar# :: Char#

}

type Rep1 (URec Char)

type Rep1 (URec Char) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UChar" PrefixI True) (S1 (MetaSel (Just Symbol "uChar#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UChar))

type Rep (URec Char p)

type Rep (URec Char p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UChar" PrefixI True) (S1 (MetaSel (Just Symbol "uChar#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UChar))

data Integer :: *

Invariant: Jn# and Jp# are used iff value doesn't fit in S#

Useful properties resulting from the invariants:

• abs (S# _) <= abs (Jp# _)

• abs (S# _) <  abs (Jn# _)

Instances

Enum Integer

Methods

succ :: Integer -> Integer

pred :: Integer -> Integer

toEnum :: Int -> Integer

fromEnum :: Integer -> Int

enumFrom :: Integer -> [Integer]

enumFromThen :: Integer -> Integer -> [Integer]

enumFromTo :: Integer -> Integer -> [Integer]

enumFromThenTo :: Integer -> Integer -> Integer -> [Integer]

Eq Integer

Methods

(==) :: Integer -> Integer -> Bool

(/=) :: Integer -> Integer -> Bool

Integral Integer

Methods

quot :: Integer -> Integer -> Integer

rem :: Integer -> Integer -> Integer

div :: Integer -> Integer -> Integer

mod :: Integer -> Integer -> Integer

quotRem :: Integer -> Integer -> (Integer, Integer)

divMod :: Integer -> Integer -> (Integer, Integer)

toInteger :: Integer -> Integer

Num Integer

Methods

(+) :: Integer -> Integer -> Integer

(-) :: Integer -> Integer -> Integer

(*) :: Integer -> Integer -> Integer

negate :: Integer -> Integer

abs :: Integer -> Integer

signum :: Integer -> Integer

fromInteger :: Integer -> Integer

Ord Integer

Methods

compare :: Integer -> Integer -> Ordering

(<) :: Integer -> Integer -> Bool

(<=) :: Integer -> Integer -> Bool

(>) :: Integer -> Integer -> Bool

(>=) :: Integer -> Integer -> Bool

max :: Integer -> Integer -> Integer

min :: Integer -> Integer -> Integer

Read Integer

Methods

readsPrec :: Int -> ReadS Integer

readList :: ReadS [Integer]

readPrec :: ReadPrec Integer

readListPrec :: ReadPrec [Integer]

Real Integer

Methods

toRational :: Integer -> Rational

Show Integer

Methods

showsPrec :: Int -> Integer -> ShowS

show :: Integer -> String

showList :: [Integer] -> ShowS

Random Integer

Methods

randomR :: RandomGen g => (Integer, Integer) -> g -> (Integer, g)

random :: RandomGen g => g -> (Integer, g)

randomRs :: RandomGen g => (Integer, Integer) -> g -> [Integer]

randoms :: RandomGen g => g -> [Integer]

randomRIO :: (Integer, Integer) -> IO Integer

randomIO :: IO Integer

Show Integer

Methods

gshowsPrec :: RefSrcPos -> RefExp -> R (Fun Int (Fun Integer ShowS))

sshowsPrec :: R (Fun Int (Fun Integer ShowS))

gshow :: RefSrcPos -> RefExp -> R (Fun Integer String)

sshow :: R (Fun Integer String)

gshowList :: RefSrcPos -> RefExp -> R (Fun (List Integer) ShowS)

sshowList :: R (Fun (List Integer) ShowS)

Read Integer

Methods

greadsPrec :: RefSrcPos -> RefExp -> R (Fun Int (ReadS Integer))

sreadsPrec :: R (Fun Int (ReadS Integer))

greadList :: RefSrcPos -> RefExp -> R (ReadS (List Integer))

sreadList :: R (ReadS (List Integer))

Integral Integer

Methods

gquot :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Integer))

grem :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Integer))

squot :: R (Fun Integer (Fun Integer Integer))

srem :: R (Fun Integer (Fun Integer Integer))

gdiv :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Integer))

gmod :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Integer))

sdiv :: R (Fun Integer (Fun Integer Integer))

smod :: R (Fun Integer (Fun Integer Integer))

gquotRem :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer (Tuple2 Integer Integer)))

gdivMod :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer (Tuple2 Integer Integer)))

squotRem :: R (Fun Integer (Fun Integer (Tuple2 Integer Integer)))

sdivMod :: R (Fun Integer (Fun Integer (Tuple2 Integer Integer)))

gtoInteger :: RefSrcPos -> RefExp -> R (Fun Integer Integer)

stoInteger :: R (Fun Integer Integer)

Real Integer

Methods

gtoRational :: RefSrcPos -> RefExp -> R (Fun Integer Rational)

stoRational :: R (Fun Integer Rational)

Num Integer

Methods

(!+) :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Integer))

(!-) :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Integer))

(!*) :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Integer))

(|+) :: R (Fun Integer (Fun Integer Integer))

(|-) :: R (Fun Integer (Fun Integer Integer))

(|*) :: R (Fun Integer (Fun Integer Integer))

gnegate :: RefSrcPos -> RefExp -> R (Fun Integer Integer)

snegate :: R (Fun Integer Integer)

gabs :: RefSrcPos -> RefExp -> R (Fun Integer Integer)

gsignum :: RefSrcPos -> RefExp -> R (Fun Integer Integer)

sabs :: R (Fun Integer Integer)

ssignum :: R (Fun Integer Integer)

gfromInteger :: RefSrcPos -> RefExp -> R (Fun Integer Integer)

sfromInteger :: R (Fun Integer Integer)

Enum Integer

Methods

gsucc :: RefSrcPos -> RefExp -> R (Fun Integer Integer)

gpred :: RefSrcPos -> RefExp -> R (Fun Integer Integer)

ssucc :: R (Fun Integer Integer)

spred :: R (Fun Integer Integer)

gtoEnum :: RefSrcPos -> RefExp -> R (Fun Int Integer)

stoEnum :: R (Fun Int Integer)

gfromEnum :: RefSrcPos -> RefExp -> R (Fun Integer Int)

sfromEnum :: R (Fun Integer Int)

genumFrom :: RefSrcPos -> RefExp -> R (Fun Integer (List Integer))

senumFrom :: R (Fun Integer (List Integer))

genumFromThen :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer (List Integer)))

senumFromThen :: R (Fun Integer (Fun Integer (List Integer)))

genumFromTo :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer (List Integer)))

senumFromTo :: R (Fun Integer (Fun Integer (List Integer)))

genumFromThenTo :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer (Fun Integer (List Integer))))

senumFromThenTo :: R (Fun Integer (Fun Integer (Fun Integer (List Integer))))

Ord Integer

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Ordering))

scompare :: R (Fun Integer (Fun Integer Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Bool))

(!<=) :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Bool))

(!>=) :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Bool))

(!>) :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Bool))

(|<) :: R (Fun Integer (Fun Integer Bool))

(|<=) :: R (Fun Integer (Fun Integer Bool))

(|>=) :: R (Fun Integer (Fun Integer Bool))

(|>) :: R (Fun Integer (Fun Integer Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Integer))

gmin :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Integer))

smax :: R (Fun Integer (Fun Integer Integer))

smin :: R (Fun Integer (Fun Integer Integer))

Eq Integer

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Bool))

(!/=) :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Bool))

(|==) :: R (Fun Integer (Fun Integer Bool))

(|/=) :: R (Fun Integer (Fun Integer Bool))

Ix Integer

Methods

grange :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Integer Integer) (List Integer))

srange :: R (Fun (Tuple2 Integer Integer) (List Integer))

gindex :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Integer Integer) (Fun Integer Int))

sindex :: R (Fun (Tuple2 Integer Integer) (Fun Integer Int))

ginRange :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Integer Integer) (Fun Integer Bool))

sinRange :: R (Fun (Tuple2 Integer Integer) (Fun Integer Bool))

grangeSize :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Integer Integer) Int)

srangeSize :: R (Fun (Tuple2 Integer Integer) Int)

Random Integer

Methods

grandomR :: RandomGen g => RefSrcPos -> RefExp -> R (Fun (Tuple2 Integer Integer) (Fun g (Tuple2 Integer g)))

srandomR :: RandomGen g => R (Fun (Tuple2 Integer Integer) (Fun g (Tuple2 Integer g)))

grandom :: RandomGen g => RefSrcPos -> RefExp -> R (Fun g (Tuple2 Integer g))

srandom :: RandomGen g => R (Fun g (Tuple2 Integer g))

grandomRs :: RandomGen g => RefSrcPos -> RefExp -> R (Fun (Tuple2 Integer Integer) (Fun g (List Integer)))

srandomRs :: RandomGen g => R (Fun (Tuple2 Integer Integer) (Fun g (List Integer)))

grandoms :: RandomGen g => RefSrcPos -> RefExp -> R (Fun g (List Integer))

srandoms :: RandomGen g => R (Fun g (List Integer))

grandomRIO :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Integer Integer) (IO Integer))

srandomRIO :: R (Fun (Tuple2 Integer Integer) (IO Integer))

grandomIO :: RefSrcPos -> RefExp -> R (IO Integer)

srandomIO :: R (IO Integer)

data Float :: *

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

Methods

(==) :: Float -> Float -> Bool

(/=) :: Float -> Float -> Bool

Floating Float

Methods

pi :: Float

exp :: Float -> Float

log :: Float -> Float

sqrt :: Float -> Float

(**) :: Float -> Float -> Float

logBase :: Float -> Float -> Float

sin :: Float -> Float

cos :: Float -> Float

tan :: Float -> Float

asin :: Float -> Float

acos :: Float -> Float

atan :: Float -> Float

sinh :: Float -> Float

cosh :: Float -> Float

tanh :: Float -> Float

asinh :: Float -> Float

acosh :: Float -> Float

atanh :: Float -> Float

log1p :: Float -> Float

expm1 :: Float -> Float

log1pexp :: Float -> Float

log1mexp :: Float -> Float

Ord Float

Methods

compare :: Float -> Float -> Ordering

(<) :: Float -> Float -> Bool

(<=) :: Float -> Float -> Bool

(>) :: Float -> Float -> Bool

(>=) :: Float -> Float -> Bool

max :: Float -> Float -> Float

min :: Float -> Float -> Float

Read Float

Methods

readsPrec :: Int -> ReadS Float

readList :: ReadS [Float]

readPrec :: ReadPrec Float

readListPrec :: ReadPrec [Float]

RealFloat Float

Methods

floatRadix :: Float -> Integer

floatDigits :: Float -> Int

floatRange :: Float -> (Int, Int)

decodeFloat :: Float -> (Integer, Int)

encodeFloat :: Integer -> Int -> Float

exponent :: Float -> Int

significand :: Float -> Float

scaleFloat :: Int -> Float -> Float

isNaN :: Float -> Bool

isInfinite :: Float -> Bool

isDenormalized :: Float -> Bool

isNegativeZero :: Float -> Bool

isIEEE :: Float -> Bool

atan2 :: Float -> Float -> Float

Storable Float

Methods

sizeOf :: Float -> Int

alignment :: Float -> Int

peekElemOff :: Ptr Float -> Int -> IO Float

pokeElemOff :: Ptr Float -> Int -> Float -> IO ()

peekByteOff :: Ptr b -> Int -> IO Float

pokeByteOff :: Ptr b -> Int -> Float -> IO ()

peek :: Ptr Float -> IO Float

poke :: Ptr Float -> Float -> IO ()

Random Float

Methods

randomR :: RandomGen g => (Float, Float) -> g -> (Float, g)

random :: RandomGen g => g -> (Float, g)

randomRs :: RandomGen g => (Float, Float) -> g -> [Float]

randoms :: RandomGen g => g -> [Float]

randomRIO :: (Float, Float) -> IO Float

randomIO :: IO Float

Show Float

Methods

gshowsPrec :: RefSrcPos -> RefExp -> R (Fun Int (Fun Float ShowS))

sshowsPrec :: R (Fun Int (Fun Float ShowS))

gshow :: RefSrcPos -> RefExp -> R (Fun Float String)

sshow :: R (Fun Float String)

gshowList :: RefSrcPos -> RefExp -> R (Fun (List Float) ShowS)

sshowList :: R (Fun (List Float) ShowS)

Read Float

Methods

greadsPrec :: RefSrcPos -> RefExp -> R (Fun Int (ReadS Float))

sreadsPrec :: R (Fun Int (ReadS Float))

greadList :: RefSrcPos -> RefExp -> R (ReadS (List Float))

sreadList :: R (ReadS (List Float))

RealFloat Float

Methods

gfloatRadix :: RefSrcPos -> RefExp -> R (Fun Float Integer)

sfloatRadix :: R (Fun Float Integer)

gfloatDigits :: RefSrcPos -> RefExp -> R (Fun Float Int)

sfloatDigits :: R (Fun Float Int)

gfloatRange :: RefSrcPos -> RefExp -> R (Fun Float (Tuple2 Int Int))

sfloatRange :: R (Fun Float (Tuple2 Int Int))

gdecodeFloat :: RefSrcPos -> RefExp -> R (Fun Float (Tuple2 Integer Int))

sdecodeFloat :: R (Fun Float (Tuple2 Integer Int))

gencodeFloat :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Int Float))

sencodeFloat :: R (Fun Integer (Fun Int Float))

gexponent :: RefSrcPos -> RefExp -> R (Fun Float Int)

sexponent :: R (Fun Float Int)

gsignificand :: RefSrcPos -> RefExp -> R (Fun Float Float)

ssignificand :: R (Fun Float Float)

gscaleFloat :: RefSrcPos -> RefExp -> R (Fun Int (Fun Float Float))

sscaleFloat :: R (Fun Int (Fun Float Float))

gisNaN :: RefSrcPos -> RefExp -> R (Fun Float Bool)

gisInfinite :: RefSrcPos -> RefExp -> R (Fun Float Bool)

gisDenormalized :: RefSrcPos -> RefExp -> R (Fun Float Bool)

gisNegativeZero :: RefSrcPos -> RefExp -> R (Fun Float Bool)

gisIEEE :: RefSrcPos -> RefExp -> R (Fun Float Bool)

sisNaN :: R (Fun Float Bool)

sisInfinite :: R (Fun Float Bool)

sisDenormalized :: R (Fun Float Bool)

sisNegativeZero :: R (Fun Float Bool)

sisIEEE :: R (Fun Float Bool)

gatan2 :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Float))

satan2 :: R (Fun Float (Fun Float Float))

RealFrac Float

Methods

gproperFraction :: Integral b => RefSrcPos -> RefExp -> R (Fun Float (Tuple2 b Float))

sproperFraction :: Integral b => R (Fun Float (Tuple2 b Float))

gtruncate :: Integral b => RefSrcPos -> RefExp -> R (Fun Float b)

ground :: Integral b => RefSrcPos -> RefExp -> R (Fun Float b)

struncate :: Integral b => R (Fun Float b)

sround :: Integral b => R (Fun Float b)

gceiling :: Integral b => RefSrcPos -> RefExp -> R (Fun Float b)

gfloor :: Integral b => RefSrcPos -> RefExp -> R (Fun Float b)

sceiling :: Integral b => R (Fun Float b)

sfloor :: Integral b => R (Fun Float b)

Floating Float

Methods

gpi :: RefSrcPos -> RefExp -> R Float

spi :: R Float

gexp :: RefSrcPos -> RefExp -> R (Fun Float Float)

glog :: RefSrcPos -> RefExp -> R (Fun Float Float)

gsqrt :: RefSrcPos -> RefExp -> R (Fun Float Float)

sexp :: R (Fun Float Float)

slog :: R (Fun Float Float)

ssqrt :: R (Fun Float Float)

(!**) :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Float))

glogBase :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Float))

(|**) :: R (Fun Float (Fun Float Float))

slogBase :: R (Fun Float (Fun Float Float))

gsin :: RefSrcPos -> RefExp -> R (Fun Float Float)

gcos :: RefSrcPos -> RefExp -> R (Fun Float Float)

gtan :: RefSrcPos -> RefExp -> R (Fun Float Float)

ssin :: R (Fun Float Float)

scos :: R (Fun Float Float)

stan :: R (Fun Float Float)

gasin :: RefSrcPos -> RefExp -> R (Fun Float Float)

gacos :: RefSrcPos -> RefExp -> R (Fun Float Float)

gatan :: RefSrcPos -> RefExp -> R (Fun Float Float)

sasin :: R (Fun Float Float)

sacos :: R (Fun Float Float)

satan :: R (Fun Float Float)

gsinh :: RefSrcPos -> RefExp -> R (Fun Float Float)

gcosh :: RefSrcPos -> RefExp -> R (Fun Float Float)

gtanh :: RefSrcPos -> RefExp -> R (Fun Float Float)

ssinh :: R (Fun Float Float)

scosh :: R (Fun Float Float)

stanh :: R (Fun Float Float)

gasinh :: RefSrcPos -> RefExp -> R (Fun Float Float)

gacosh :: RefSrcPos -> RefExp -> R (Fun Float Float)

gatanh :: RefSrcPos -> RefExp -> R (Fun Float Float)

sasinh :: R (Fun Float Float)

sacosh :: R (Fun Float Float)

satanh :: R (Fun Float Float)

Fractional Float

Methods

(!/) :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Float))

(|/) :: R (Fun Float (Fun Float Float))

grecip :: RefSrcPos -> RefExp -> R (Fun Float Float)

srecip :: R (Fun Float Float)

gfromRational :: RefSrcPos -> RefExp -> R (Fun Rational Float)

sfromRational :: R (Fun Rational Float)

Real Float

Methods

gtoRational :: RefSrcPos -> RefExp -> R (Fun Float Rational)

stoRational :: R (Fun Float Rational)

Num Float

Methods

(!+) :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Float))

(!-) :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Float))

(!*) :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Float))

(|+) :: R (Fun Float (Fun Float Float))

(|-) :: R (Fun Float (Fun Float Float))

(|*) :: R (Fun Float (Fun Float Float))

gnegate :: RefSrcPos -> RefExp -> R (Fun Float Float)

snegate :: R (Fun Float Float)

gabs :: RefSrcPos -> RefExp -> R (Fun Float Float)

gsignum :: RefSrcPos -> RefExp -> R (Fun Float Float)

sabs :: R (Fun Float Float)

ssignum :: R (Fun Float Float)

gfromInteger :: RefSrcPos -> RefExp -> R (Fun Integer Float)

sfromInteger :: R (Fun Integer Float)

Enum Float

Methods

gsucc :: RefSrcPos -> RefExp -> R (Fun Float Float)

gpred :: RefSrcPos -> RefExp -> R (Fun Float Float)

ssucc :: R (Fun Float Float)

spred :: R (Fun Float Float)

gtoEnum :: RefSrcPos -> RefExp -> R (Fun Int Float)

stoEnum :: R (Fun Int Float)

gfromEnum :: RefSrcPos -> RefExp -> R (Fun Float Int)

sfromEnum :: R (Fun Float Int)

genumFrom :: RefSrcPos -> RefExp -> R (Fun Float (List Float))

senumFrom :: R (Fun Float (List Float))

genumFromThen :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float (List Float)))

senumFromThen :: R (Fun Float (Fun Float (List Float)))

genumFromTo :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float (List Float)))

senumFromTo :: R (Fun Float (Fun Float (List Float)))

genumFromThenTo :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float (Fun Float (List Float))))

senumFromThenTo :: R (Fun Float (Fun Float (Fun Float (List Float))))

Ord Float

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Ordering))

scompare :: R (Fun Float (Fun Float Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Bool))

(!<=) :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Bool))

(!>=) :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Bool))

(!>) :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Bool))

(|<) :: R (Fun Float (Fun Float Bool))

(|<=) :: R (Fun Float (Fun Float Bool))

(|>=) :: R (Fun Float (Fun Float Bool))

(|>) :: R (Fun Float (Fun Float Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Float))

gmin :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Float))

smax :: R (Fun Float (Fun Float Float))

smin :: R (Fun Float (Fun Float Float))

Eq Float

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Bool))

(!/=) :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Bool))

(|==) :: R (Fun Float (Fun Float Bool))

(|/=) :: R (Fun Float (Fun Float Bool))

Random Float

Methods

grandomR :: RandomGen g => RefSrcPos -> RefExp -> R (Fun (Tuple2 Float Float) (Fun g (Tuple2 Float g)))

srandomR :: RandomGen g => R (Fun (Tuple2 Float Float) (Fun g (Tuple2 Float g)))

grandom :: RandomGen g => RefSrcPos -> RefExp -> R (Fun g (Tuple2 Float g))

srandom :: RandomGen g => R (Fun g (Tuple2 Float g))

grandomRs :: RandomGen g => RefSrcPos -> RefExp -> R (Fun (Tuple2 Float Float) (Fun g (List Float)))

srandomRs :: RandomGen g => R (Fun (Tuple2 Float Float) (Fun g (List Float)))

grandoms :: RandomGen g => RefSrcPos -> RefExp -> R (Fun g (List Float))

srandoms :: RandomGen g => R (Fun g (List Float))

grandomRIO :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Float Float) (IO Float))

srandomRIO :: R (Fun (Tuple2 Float Float) (IO Float))

grandomIO :: RefSrcPos -> RefExp -> R (IO Float)

srandomIO :: R (IO Float)

Functor (URec Float)

Methods

fmap :: (a -> b) -> URec Float a -> URec Float b

(<$) :: a -> URec Float b -> URec Float a

Foldable (URec Float)

Methods

fold :: Monoid m => URec Float m -> m

foldMap :: Monoid m => (a -> m) -> URec Float a -> m

foldr :: (a -> b -> b) -> b -> URec Float a -> b

foldr' :: (a -> b -> b) -> b -> URec Float a -> b

foldl :: (b -> a -> b) -> b -> URec Float a -> b

foldl' :: (b -> a -> b) -> b -> URec Float a -> b

foldr1 :: (a -> a -> a) -> URec Float a -> a

foldl1 :: (a -> a -> a) -> URec Float a -> a

toList :: URec Float a -> [a]

null :: URec Float a -> Bool

length :: URec Float a -> Int

elem :: Eq a => a -> URec Float a -> Bool

maximum :: Ord a => URec Float a -> a

minimum :: Ord a => URec Float a -> a

sum :: Num a => URec Float a -> a

product :: Num a => URec Float a -> a

Generic1 (URec Float)

Associated Types

type Rep1 (URec Float :: * -> *) :: * -> *

Methods

from1 :: URec Float a -> Rep1 (URec Float) a

to1 :: Rep1 (URec Float) a -> URec Float a

Eq (URec Float p)

Methods

(==) :: URec Float p -> URec Float p -> Bool

(/=) :: URec Float p -> URec Float p -> Bool

Ord (URec Float p)

Methods

compare :: URec Float p -> URec Float p -> Ordering

(<) :: URec Float p -> URec Float p -> Bool

(<=) :: URec Float p -> URec Float p -> Bool

(>) :: URec Float p -> URec Float p -> Bool

(>=) :: URec Float p -> URec Float p -> Bool

max :: URec Float p -> URec Float p -> URec Float p

min :: URec Float p -> URec Float p -> URec Float p

Show (URec Float p)

Methods

showsPrec :: Int -> URec Float p -> ShowS

show :: URec Float p -> String

showList :: [URec Float p] -> ShowS

Generic (URec Float p)

Associated Types

type Rep (URec Float p) :: * -> *

Methods

from :: URec Float p -> Rep (URec Float p) x

to :: Rep (URec Float p) x -> URec Float p

data URec Float

Used for marking occurrences of Float#

data URec Float = UFloat {

• uFloat# :: Float#

}

type Rep1 (URec Float)

type Rep1 (URec Float) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UFloat" PrefixI True) (S1 (MetaSel (Just Symbol "uFloat#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UFloat))

type Rep (URec Float p)

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))

data Double :: *

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

Methods

(==) :: Double -> Double -> Bool

(/=) :: Double -> Double -> Bool

Floating Double

Methods

pi :: Double

exp :: Double -> Double

log :: Double -> Double

sqrt :: Double -> Double

(**) :: Double -> Double -> Double

logBase :: Double -> Double -> Double

sin :: Double -> Double

cos :: Double -> Double

tan :: Double -> Double

asin :: Double -> Double

acos :: Double -> Double

atan :: Double -> Double

sinh :: Double -> Double

cosh :: Double -> Double

tanh :: Double -> Double

asinh :: Double -> Double

acosh :: Double -> Double

atanh :: Double -> Double

log1p :: Double -> Double

expm1 :: Double -> Double

log1pexp :: Double -> Double

log1mexp :: Double -> Double

Ord Double

Methods

compare :: Double -> Double -> Ordering

(<) :: Double -> Double -> Bool

(<=) :: Double -> Double -> Bool

(>) :: Double -> Double -> Bool

(>=) :: Double -> Double -> Bool

max :: Double -> Double -> Double

min :: Double -> Double -> Double

Read Double

Methods

readsPrec :: Int -> ReadS Double

readList :: ReadS [Double]

readPrec :: ReadPrec Double

readListPrec :: ReadPrec [Double]

RealFloat Double

Methods

floatRadix :: Double -> Integer

floatDigits :: Double -> Int

floatRange :: Double -> (Int, Int)

decodeFloat :: Double -> (Integer, Int)

encodeFloat :: Integer -> Int -> Double

exponent :: Double -> Int

significand :: Double -> Double

scaleFloat :: Int -> Double -> Double

isNaN :: Double -> Bool

isInfinite :: Double -> Bool

isDenormalized :: Double -> Bool

isNegativeZero :: Double -> Bool

isIEEE :: Double -> Bool

atan2 :: Double -> Double -> Double

Storable Double

Methods

sizeOf :: Double -> Int

alignment :: Double -> Int

peekElemOff :: Ptr Double -> Int -> IO Double

pokeElemOff :: Ptr Double -> Int -> Double -> IO ()

peekByteOff :: Ptr b -> Int -> IO Double

pokeByteOff :: Ptr b -> Int -> Double -> IO ()

peek :: Ptr Double -> IO Double

poke :: Ptr Double -> Double -> IO ()

Random Double

Methods

randomR :: RandomGen g => (Double, Double) -> g -> (Double, g)

random :: RandomGen g => g -> (Double, g)

randomRs :: RandomGen g => (Double, Double) -> g -> [Double]

randoms :: RandomGen g => g -> [Double]

randomRIO :: (Double, Double) -> IO Double

randomIO :: IO Double

Show Double

Methods

gshowsPrec :: RefSrcPos -> RefExp -> R (Fun Int (Fun Double ShowS))

sshowsPrec :: R (Fun Int (Fun Double ShowS))

gshow :: RefSrcPos -> RefExp -> R (Fun Double String)

sshow :: R (Fun Double String)

gshowList :: RefSrcPos -> RefExp -> R (Fun (List Double) ShowS)

sshowList :: R (Fun (List Double) ShowS)

Read Double

Methods

greadsPrec :: RefSrcPos -> RefExp -> R (Fun Int (ReadS Double))

sreadsPrec :: R (Fun Int (ReadS Double))

greadList :: RefSrcPos -> RefExp -> R (ReadS (List Double))

sreadList :: R (ReadS (List Double))

RealFloat Double

Methods

gfloatRadix :: RefSrcPos -> RefExp -> R (Fun Double Integer)

sfloatRadix :: R (Fun Double Integer)

gfloatDigits :: RefSrcPos -> RefExp -> R (Fun Double Int)

sfloatDigits :: R (Fun Double Int)

gfloatRange :: RefSrcPos -> RefExp -> R (Fun Double (Tuple2 Int Int))

sfloatRange :: R (Fun Double (Tuple2 Int Int))

gdecodeFloat :: RefSrcPos -> RefExp -> R (Fun Double (Tuple2 Integer Int))

sdecodeFloat :: R (Fun Double (Tuple2 Integer Int))

gencodeFloat :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Int Double))

sencodeFloat :: R (Fun Integer (Fun Int Double))

gexponent :: RefSrcPos -> RefExp -> R (Fun Double Int)

sexponent :: R (Fun Double Int)

gsignificand :: RefSrcPos -> RefExp -> R (Fun Double Double)

ssignificand :: R (Fun Double Double)

gscaleFloat :: RefSrcPos -> RefExp -> R (Fun Int (Fun Double Double))

sscaleFloat :: R (Fun Int (Fun Double Double))

gisNaN :: RefSrcPos -> RefExp -> R (Fun Double Bool)

gisInfinite :: RefSrcPos -> RefExp -> R (Fun Double Bool)

gisDenormalized :: RefSrcPos -> RefExp -> R (Fun Double Bool)

gisNegativeZero :: RefSrcPos -> RefExp -> R (Fun Double Bool)

gisIEEE :: RefSrcPos -> RefExp -> R (Fun Double Bool)

sisNaN :: R (Fun Double Bool)

sisInfinite :: R (Fun Double Bool)

sisDenormalized :: R (Fun Double Bool)

sisNegativeZero :: R (Fun Double Bool)

sisIEEE :: R (Fun Double Bool)

gatan2 :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Double))

satan2 :: R (Fun Double (Fun Double Double))

RealFrac Double

Methods

gproperFraction :: Integral b => RefSrcPos -> RefExp -> R (Fun Double (Tuple2 b Double))

sproperFraction :: Integral b => R (Fun Double (Tuple2 b Double))

gtruncate :: Integral b => RefSrcPos -> RefExp -> R (Fun Double b)

ground :: Integral b => RefSrcPos -> RefExp -> R (Fun Double b)

struncate :: Integral b => R (Fun Double b)

sround :: Integral b => R (Fun Double b)

gceiling :: Integral b => RefSrcPos -> RefExp -> R (Fun Double b)

gfloor :: Integral b => RefSrcPos -> RefExp -> R (Fun Double b)

sceiling :: Integral b => R (Fun Double b)

sfloor :: Integral b => R (Fun Double b)

Floating Double

Methods

gpi :: RefSrcPos -> RefExp -> R Double

spi :: R Double

gexp :: RefSrcPos -> RefExp -> R (Fun Double Double)

glog :: RefSrcPos -> RefExp -> R (Fun Double Double)

gsqrt :: RefSrcPos -> RefExp -> R (Fun Double Double)

sexp :: R (Fun Double Double)

slog :: R (Fun Double Double)

ssqrt :: R (Fun Double Double)

(!**) :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Double))

glogBase :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Double))

(|**) :: R (Fun Double (Fun Double Double))

slogBase :: R (Fun Double (Fun Double Double))

gsin :: RefSrcPos -> RefExp -> R (Fun Double Double)

gcos :: RefSrcPos -> RefExp -> R (Fun Double Double)

gtan :: RefSrcPos -> RefExp -> R (Fun Double Double)

ssin :: R (Fun Double Double)

scos :: R (Fun Double Double)

stan :: R (Fun Double Double)

gasin :: RefSrcPos -> RefExp -> R (Fun Double Double)

gacos :: RefSrcPos -> RefExp -> R (Fun Double Double)

gatan :: RefSrcPos -> RefExp -> R (Fun Double Double)

sasin :: R (Fun Double Double)

sacos :: R (Fun Double Double)

satan :: R (Fun Double Double)

gsinh :: RefSrcPos -> RefExp -> R (Fun Double Double)

gcosh :: RefSrcPos -> RefExp -> R (Fun Double Double)

gtanh :: RefSrcPos -> RefExp -> R (Fun Double Double)

ssinh :: R (Fun Double Double)

scosh :: R (Fun Double Double)

stanh :: R (Fun Double Double)

gasinh :: RefSrcPos -> RefExp -> R (Fun Double Double)

gacosh :: RefSrcPos -> RefExp -> R (Fun Double Double)

gatanh :: RefSrcPos -> RefExp -> R (Fun Double Double)

sasinh :: R (Fun Double Double)

sacosh :: R (Fun Double Double)

satanh :: R (Fun Double Double)

Fractional Double

Methods

(!/) :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Double))

(|/) :: R (Fun Double (Fun Double Double))

grecip :: RefSrcPos -> RefExp -> R (Fun Double Double)

srecip :: R (Fun Double Double)

gfromRational :: RefSrcPos -> RefExp -> R (Fun Rational Double)

sfromRational :: R (Fun Rational Double)

Real Double

Methods

gtoRational :: RefSrcPos -> RefExp -> R (Fun Double Rational)

stoRational :: R (Fun Double Rational)

Num Double

Methods

(!+) :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Double))

(!-) :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Double))

(!*) :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Double))

(|+) :: R (Fun Double (Fun Double Double))

(|-) :: R (Fun Double (Fun Double Double))

(|*) :: R (Fun Double (Fun Double Double))

gnegate :: RefSrcPos -> RefExp -> R (Fun Double Double)

snegate :: R (Fun Double Double)

gabs :: RefSrcPos -> RefExp -> R (Fun Double Double)

gsignum :: RefSrcPos -> RefExp -> R (Fun Double Double)

sabs :: R (Fun Double Double)

ssignum :: R (Fun Double Double)

gfromInteger :: RefSrcPos -> RefExp -> R (Fun Integer Double)

sfromInteger :: R (Fun Integer Double)

Enum Double

Methods

gsucc :: RefSrcPos -> RefExp -> R (Fun Double Double)

gpred :: RefSrcPos -> RefExp -> R (Fun Double Double)

ssucc :: R (Fun Double Double)

spred :: R (Fun Double Double)

gtoEnum :: RefSrcPos -> RefExp -> R (Fun Int Double)

stoEnum :: R (Fun Int Double)

gfromEnum :: RefSrcPos -> RefExp -> R (Fun Double Int)

sfromEnum :: R (Fun Double Int)

genumFrom :: RefSrcPos -> RefExp -> R (Fun Double (List Double))

senumFrom :: R (Fun Double (List Double))

genumFromThen :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double (List Double)))

senumFromThen :: R (Fun Double (Fun Double (List Double)))

genumFromTo :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double (List Double)))

senumFromTo :: R (Fun Double (Fun Double (List Double)))

genumFromThenTo :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double (Fun Double (List Double))))

senumFromThenTo :: R (Fun Double (Fun Double (Fun Double (List Double))))

Ord Double

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Ordering))

scompare :: R (Fun Double (Fun Double Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Bool))

(!<=) :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Bool))

(!>=) :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Bool))

(!>) :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Bool))

(|<) :: R (Fun Double (Fun Double Bool))

(|<=) :: R (Fun Double (Fun Double Bool))

(|>=) :: R (Fun Double (Fun Double Bool))

(|>) :: R (Fun Double (Fun Double Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Double))

gmin :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Double))

smax :: R (Fun Double (Fun Double Double))

smin :: R (Fun Double (Fun Double Double))

Eq Double

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Bool))

(!/=) :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Bool))

(|==) :: R (Fun Double (Fun Double Bool))

(|/=) :: R (Fun Double (Fun Double Bool))

Random Double

Methods

grandomR :: RandomGen g => RefSrcPos -> RefExp -> R (Fun (Tuple2 Double Double) (Fun g (Tuple2 Double g)))

srandomR :: RandomGen g => R (Fun (Tuple2 Double Double) (Fun g (Tuple2 Double g)))

grandom :: RandomGen g => RefSrcPos -> RefExp -> R (Fun g (Tuple2 Double g))

srandom :: RandomGen g => R (Fun g (Tuple2 Double g))

grandomRs :: RandomGen g => RefSrcPos -> RefExp -> R (Fun (Tuple2 Double Double) (Fun g (List Double)))

srandomRs :: RandomGen g => R (Fun (Tuple2 Double Double) (Fun g (List Double)))

grandoms :: RandomGen g => RefSrcPos -> RefExp -> R (Fun g (List Double))

srandoms :: RandomGen g => R (Fun g (List Double))

grandomRIO :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Double Double) (IO Double))

srandomRIO :: R (Fun (Tuple2 Double Double) (IO Double))

grandomIO :: RefSrcPos -> RefExp -> R (IO Double)

srandomIO :: R (IO Double)

Functor (URec Double)

Methods

fmap :: (a -> b) -> URec Double a -> URec Double b

(<$) :: a -> URec Double b -> URec Double a

Foldable (URec Double)

Methods

fold :: Monoid m => URec Double m -> m

foldMap :: Monoid m => (a -> m) -> URec Double a -> m

foldr :: (a -> b -> b) -> b -> URec Double a -> b

foldr' :: (a -> b -> b) -> b -> URec Double a -> b

foldl :: (b -> a -> b) -> b -> URec Double a -> b

foldl' :: (b -> a -> b) -> b -> URec Double a -> b

foldr1 :: (a -> a -> a) -> URec Double a -> a

foldl1 :: (a -> a -> a) -> URec Double a -> a

toList :: URec Double a -> [a]

null :: URec Double a -> Bool

length :: URec Double a -> Int

elem :: Eq a => a -> URec Double a -> Bool

maximum :: Ord a => URec Double a -> a

minimum :: Ord a => URec Double a -> a

sum :: Num a => URec Double a -> a

product :: Num a => URec Double a -> a

Generic1 (URec Double)

Associated Types

type Rep1 (URec Double :: * -> *) :: * -> *

Methods

from1 :: URec Double a -> Rep1 (URec Double) a

to1 :: Rep1 (URec Double) a -> URec Double a

Eq (URec Double p)

Methods

(==) :: URec Double p -> URec Double p -> Bool

(/=) :: URec Double p -> URec Double p -> Bool

Ord (URec Double p)

Methods

compare :: URec Double p -> URec Double p -> Ordering

(<) :: URec Double p -> URec Double p -> Bool

(<=) :: URec Double p -> URec Double p -> Bool

(>) :: URec Double p -> URec Double p -> Bool

(>=) :: URec Double p -> URec Double p -> Bool

max :: URec Double p -> URec Double p -> URec Double p

min :: URec Double p -> URec Double p -> URec Double p

Show (URec Double p)

Methods

showsPrec :: Int -> URec Double p -> ShowS

show :: URec Double p -> String

showList :: [URec Double p] -> ShowS

Generic (URec Double p)

Associated Types

type Rep (URec Double p) :: * -> *

Methods

from :: URec Double p -> Rep (URec Double p) x

to :: Rep (URec Double p) x -> URec Double p

data URec Double

Used for marking occurrences of Double#

data URec Double = UDouble {

• uDouble# :: Double#

}

type Rep1 (URec Double)

type Rep1 (URec Double) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UDouble" PrefixI True) (S1 (MetaSel (Just Symbol "uDouble#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UDouble))

type Rep (URec Double p)

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))

data Bool :: *

Constructors

False

True

Instances

Bounded Bool

Methods

minBound :: Bool

maxBound :: Bool

Enum Bool

Methods

succ :: Bool -> Bool

pred :: Bool -> Bool

toEnum :: Int -> Bool

fromEnum :: Bool -> Int

enumFrom :: Bool -> [Bool]

enumFromThen :: Bool -> Bool -> [Bool]

enumFromTo :: Bool -> Bool -> [Bool]

enumFromThenTo :: Bool -> Bool -> Bool -> [Bool]

Eq Bool

Methods

(==) :: Bool -> Bool -> Bool

(/=) :: Bool -> Bool -> Bool

Ord Bool

Methods

compare :: Bool -> Bool -> Ordering

(<) :: Bool -> Bool -> Bool

(<=) :: Bool -> Bool -> Bool

(>) :: Bool -> Bool -> Bool

(>=) :: Bool -> Bool -> Bool

max :: Bool -> Bool -> Bool

min :: Bool -> Bool -> Bool

Read Bool

Methods

readsPrec :: Int -> ReadS Bool

readList :: ReadS [Bool]

readPrec :: ReadPrec Bool

readListPrec :: ReadPrec [Bool]

Show Bool

Methods

showsPrec :: Int -> Bool -> ShowS

show :: Bool -> String

showList :: [Bool] -> ShowS

Generic Bool

Associated Types

type Rep Bool :: * -> *

Methods

from :: Bool -> Rep Bool x

to :: Rep Bool x -> Bool

Storable Bool

Methods

sizeOf :: Bool -> Int

alignment :: Bool -> Int

peekElemOff :: Ptr Bool -> Int -> IO Bool

pokeElemOff :: Ptr Bool -> Int -> Bool -> IO ()

peekByteOff :: Ptr b -> Int -> IO Bool

pokeByteOff :: Ptr b -> Int -> Bool -> IO ()

peek :: Ptr Bool -> IO Bool

poke :: Ptr Bool -> Bool -> IO ()

Random Bool

Methods

randomR :: RandomGen g => (Bool, Bool) -> g -> (Bool, g)

random :: RandomGen g => g -> (Bool, g)

randomRs :: RandomGen g => (Bool, Bool) -> g -> [Bool]

randoms :: RandomGen g => g -> [Bool]

randomRIO :: (Bool, Bool) -> IO Bool

randomIO :: IO Bool

Show Bool

Methods

gshowsPrec :: RefSrcPos -> RefExp -> R (Fun Int (Fun Bool ShowS))

sshowsPrec :: R (Fun Int (Fun Bool ShowS))

gshow :: RefSrcPos -> RefExp -> R (Fun Bool String)

sshow :: R (Fun Bool String)

gshowList :: RefSrcPos -> RefExp -> R (Fun (List Bool) ShowS)

sshowList :: R (Fun (List Bool) ShowS)

Read Bool

Methods

greadsPrec :: RefSrcPos -> RefExp -> R (Fun Int (ReadS Bool))

sreadsPrec :: R (Fun Int (ReadS Bool))

greadList :: RefSrcPos -> RefExp -> R (ReadS (List Bool))

sreadList :: R (ReadS (List Bool))

Bounded Bool

Methods

gminBound :: RefSrcPos -> RefExp -> R Bool

sminBound :: R Bool

gmaxBound :: RefSrcPos -> RefExp -> R Bool

smaxBound :: R Bool

Enum Bool

Methods

gsucc :: RefSrcPos -> RefExp -> R (Fun Bool Bool)

gpred :: RefSrcPos -> RefExp -> R (Fun Bool Bool)

ssucc :: R (Fun Bool Bool)

spred :: R (Fun Bool Bool)

gtoEnum :: RefSrcPos -> RefExp -> R (Fun Int Bool)

stoEnum :: R (Fun Int Bool)

gfromEnum :: RefSrcPos -> RefExp -> R (Fun Bool Int)

sfromEnum :: R (Fun Bool Int)

genumFrom :: RefSrcPos -> RefExp -> R (Fun Bool (List Bool))

senumFrom :: R (Fun Bool (List Bool))

genumFromThen :: RefSrcPos -> RefExp -> R (Fun Bool (Fun Bool (List Bool)))

senumFromThen :: R (Fun Bool (Fun Bool (List Bool)))

genumFromTo :: RefSrcPos -> RefExp -> R (Fun Bool (Fun Bool (List Bool)))

senumFromTo :: R (Fun Bool (Fun Bool (List Bool)))

genumFromThenTo :: RefSrcPos -> RefExp -> R (Fun Bool (Fun Bool (Fun Bool (List Bool))))

senumFromThenTo :: R (Fun Bool (Fun Bool (Fun Bool (List Bool))))

Ord Bool

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun Bool (Fun Bool Ordering))

scompare :: R (Fun Bool (Fun Bool Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun Bool (Fun Bool Bool))

(!<=) :: RefSrcPos -> RefExp -> R (Fun Bool (Fun Bool Bool))

(!>=) :: RefSrcPos -> RefExp -> R (Fun Bool (Fun Bool Bool))

(!>) :: RefSrcPos -> RefExp -> R (Fun Bool (Fun Bool Bool))

(|<) :: R (Fun Bool (Fun Bool Bool))

(|<=) :: R (Fun Bool (Fun Bool Bool))

(|>=) :: R (Fun Bool (Fun Bool Bool))

(|>) :: R (Fun Bool (Fun Bool Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun Bool (Fun Bool Bool))

gmin :: RefSrcPos -> RefExp -> R (Fun Bool (Fun Bool Bool))

smax :: R (Fun Bool (Fun Bool Bool))

smin :: R (Fun Bool (Fun Bool Bool))

Eq Bool

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun Bool (Fun Bool Bool))

(!/=) :: RefSrcPos -> RefExp -> R (Fun Bool (Fun Bool Bool))

(|==) :: R (Fun Bool (Fun Bool Bool))

(|/=) :: R (Fun Bool (Fun Bool Bool))

Ix Bool

Methods

grange :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Bool Bool) (List Bool))

srange :: R (Fun (Tuple2 Bool Bool) (List Bool))

gindex :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Bool Bool) (Fun Bool Int))

sindex :: R (Fun (Tuple2 Bool Bool) (Fun Bool Int))

ginRange :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Bool Bool) (Fun Bool Bool))

sinRange :: R (Fun (Tuple2 Bool Bool) (Fun Bool Bool))

grangeSize :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Bool Bool) Int)

srangeSize :: R (Fun (Tuple2 Bool Bool) Int)

Random Bool

Methods

grandomR :: RandomGen g => RefSrcPos -> RefExp -> R (Fun (Tuple2 Bool Bool) (Fun g (Tuple2 Bool g)))

srandomR :: RandomGen g => R (Fun (Tuple2 Bool Bool) (Fun g (Tuple2 Bool g)))

grandom :: RandomGen g => RefSrcPos -> RefExp -> R (Fun g (Tuple2 Bool g))

srandom :: RandomGen g => R (Fun g (Tuple2 Bool g))

grandomRs :: RandomGen g => RefSrcPos -> RefExp -> R (Fun (Tuple2 Bool Bool) (Fun g (List Bool)))

srandomRs :: RandomGen g => R (Fun (Tuple2 Bool Bool) (Fun g (List Bool)))

grandoms :: RandomGen g => RefSrcPos -> RefExp -> R (Fun g (List Bool))

srandoms :: RandomGen g => R (Fun g (List Bool))

grandomRIO :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Bool Bool) (IO Bool))

srandomRIO :: R (Fun (Tuple2 Bool Bool) (IO Bool))

grandomIO :: RefSrcPos -> RefExp -> R (IO Bool)

srandomIO :: R (IO Bool)

SingI Bool False

Methods

sing :: Sing False a

SingI Bool True

Methods

sing :: Sing True a

SingKind Bool (KProxy Bool)

Associated Types

type DemoteRep (KProxy Bool) (kparam :: KProxy (KProxy Bool)) :: *

Methods

fromSing :: Sing (KProxy Bool) a -> DemoteRep (KProxy Bool) kparam

type Rep 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

data Sing Bool where

• STrue :: Sing Bool True
• SFalse :: Sing Bool False

type (==) Bool a b

type (==) Bool a b = EqBool a b

type DemoteRep Bool (KProxy Bool)

type DemoteRep Bool (KProxy Bool) = Bool

type IOError = IOException

The Haskell 2010 type for exceptions in the IO monad. Any I/O operation may raise an IOError instead of returning a result. For a more general type of exception, including also those that arise in pure code, see Exception.

In Haskell 2010, this is an opaque type.

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