raw-feldspar-0.1: Resource-Aware Feldspar

Safe HaskellNone
LanguageHaskell2010

Feldspar

Contents

Synopsis

Documentation

Types

Syntax

data Data a Source #

Instances

FreeExp Data Source # 

Associated Types

type FreePred (Data :: * -> *) :: * -> Constraint #

Methods

constExp :: FreePred Data a => a -> Data a #

varExp :: FreePred Data a => VarId -> Data a #

EvalExp Data Source # 

Methods

evalExp :: Data a -> a #

Syntactic (Data a) Source #

Declaring Data as syntactic sugar

Associated Types

type Domain (Data a) :: * -> * #

type Internal (Data a) :: * #

Methods

desugar :: Data a -> ASTF (Domain (Data a)) (Internal (Data a)) #

sugar :: ASTF (Domain (Data a)) (Internal (Data a)) -> Data a #

PrimType' a => BulkTransferable (Data a) Source # 

Associated Types

type ContainerType (Data a) :: * Source #

PrimType' a => Transferable (Data a) Source # 
MarshalFeld (Data Double) Source # 

Associated Types

type HaskellRep (Data Double) :: * Source #

MarshalFeld (Data Float) Source # 

Associated Types

type HaskellRep (Data Float) :: * Source #

MarshalFeld (Data Int8) Source # 

Associated Types

type HaskellRep (Data Int8) :: * Source #

MarshalFeld (Data Int16) Source # 

Associated Types

type HaskellRep (Data Int16) :: * Source #

MarshalFeld (Data Int32) Source # 

Associated Types

type HaskellRep (Data Int32) :: * Source #

MarshalFeld (Data Int64) Source # 

Associated Types

type HaskellRep (Data Int64) :: * Source #

MarshalFeld (Data Word8) Source # 

Associated Types

type HaskellRep (Data Word8) :: * Source #

MarshalFeld (Data Word16) Source # 

Associated Types

type HaskellRep (Data Word16) :: * Source #

MarshalFeld (Data Word32) Source # 

Associated Types

type HaskellRep (Data Word32) :: * Source #

MarshalFeld (Data Word64) Source # 

Associated Types

type HaskellRep (Data Word64) :: * Source #

MarshalFeld (Data (Complex Double)) Source # 

Associated Types

type HaskellRep (Data (Complex Double)) :: * Source #

MarshalFeld (Data (Complex Float)) Source # 

Associated Types

type HaskellRep (Data (Complex Float)) :: * Source #

Type a => Storable (Data a) Source # 

Associated Types

type StoreRep (Data a) :: * Source #

type StoreSize (Data a) :: * Source #

Methods

newStoreRep :: MonadComp m => proxy (Data a) -> StoreSize (Data a) -> m (StoreRep (Data a)) Source #

initStoreRep :: MonadComp m => Data a -> m (StoreRep (Data a)) Source #

readStoreRep :: MonadComp m => StoreRep (Data a) -> m (Data a) Source #

unsafeFreezeStoreRep :: MonadComp m => StoreRep (Data a) -> m (Data a) Source #

writeStoreRep :: MonadComp m => StoreRep (Data a) -> Data a -> m () Source #

Type a => Forcible (Data a) Source # 

Associated Types

type ValueRep (Data a) :: * Source #

Methods

toValue :: MonadComp m => Data a -> m (ValueRep (Data a)) Source #

fromValue :: ValueRep (Data a) -> Data a Source #

(Formattable a, PrimType a, PrintfType r) => PrintfType (Data a -> r) Source # 

Methods

fprf :: Handle -> String -> [PrintfArg Data] -> Data a -> r Source #

Syntactic (Struct PrimType' Data a) Source # 
type FreePred Data Source # 
type Internal (Data a) Source # 
type Internal (Data a) = a
type Domain (Data a) Source # 
type ContainerType (Data a) Source # 
type ContainerType (Data a) = DArr a
type SizeSpec (Data a) Source # 
type HaskellRep (Data Double) Source # 
type HaskellRep (Data Float) Source # 
type HaskellRep (Data Int8) Source # 
type HaskellRep (Data Int16) Source # 
type HaskellRep (Data Int32) Source # 
type HaskellRep (Data Int64) Source # 
type HaskellRep (Data Word8) Source # 
type HaskellRep (Data Word16) Source # 
type HaskellRep (Data Word32) Source # 
type HaskellRep (Data Word64) Source # 
type HaskellRep (Data (Complex Double)) Source # 
type HaskellRep (Data (Complex Float)) Source # 
type StoreRep (Data a) Source # 
type StoreRep (Data a) = DRef a
type StoreSize (Data a) Source # 
type StoreSize (Data a) = ()
type ValueRep (Data a) Source # 
type ValueRep (Data a) = Data a
type Internal (Struct PrimType' Data a) Source # 
type Domain (Struct PrimType' Data a) Source # 

class (Syntactic a, Domain a ~ FeldDomain, Type (Internal a)) => Syntax a Source #

Specialization of the Syntactic class for the Feldspar domain

Instances

(Syntactic a, (~) (* -> *) (Domain a) FeldDomain, Type (Internal a)) => Syntax a Source # 

data Comp a Source #

Monad for computational effects: mutable data structures and control flow

Instances

Monad Comp Source # 

Methods

(>>=) :: Comp a -> (a -> Comp b) -> Comp b #

(>>) :: Comp a -> Comp b -> Comp b #

return :: a -> Comp a #

fail :: String -> Comp a #

Functor Comp Source # 

Methods

fmap :: (a -> b) -> Comp a -> Comp b #

(<$) :: a -> Comp b -> Comp a #

Applicative Comp Source # 

Methods

pure :: a -> Comp a #

(<*>) :: Comp (a -> b) -> Comp a -> Comp b #

(*>) :: Comp a -> Comp b -> Comp b #

(<*) :: Comp a -> Comp b -> Comp a #

MonadComp Comp Source # 

Methods

liftComp :: Comp a -> Comp a Source #

iff :: Data Bool -> Comp () -> Comp () -> Comp () Source #

for :: (Integral n, PrimType n) => IxRange (Data n) -> (Data n -> Comp ()) -> Comp () Source #

while :: Comp (Data Bool) -> Comp () -> Comp () Source #

MonadRun Comp Source # 

Methods

liftRun :: Comp a -> Run a Source #

Syntax a => Storable (Push Comp a) Source # 

Associated Types

type StoreRep (Push Comp a) :: * Source #

type StoreSize (Push Comp a) :: * Source #

type StoreRep (Push Comp a) Source # 
type StoreRep (Push Comp a) = (DRef Length, Arr a)
type StoreSize (Push Comp a) Source # 

Object-language types

module Data.Int

module Data.Word

data Complex a :: * -> * #

Complex numbers are an algebraic type.

For a complex number z, abs z is a number with the magnitude of z, but oriented in the positive real direction, whereas signum z has the phase of z, but unit magnitude.

The Foldable and Traversable instances traverse the real part first.

Constructors

~a :+ ~a infix 6

forms a complex number from its real and imaginary rectangular components.

Instances

Monad Complex 

Methods

(>>=) :: Complex a -> (a -> Complex b) -> Complex b #

(>>) :: Complex a -> Complex b -> Complex b #

return :: a -> Complex a #

fail :: String -> Complex a #

Functor Complex 

Methods

fmap :: (a -> b) -> Complex a -> Complex b #

(<$) :: a -> Complex b -> Complex a #

Applicative Complex 

Methods

pure :: a -> Complex a #

(<*>) :: Complex (a -> b) -> Complex a -> Complex b #

(*>) :: Complex a -> Complex b -> Complex b #

(<*) :: Complex a -> Complex b -> Complex a #

Foldable Complex 

Methods

fold :: Monoid m => Complex m -> m #

foldMap :: Monoid m => (a -> m) -> Complex a -> m #

foldr :: (a -> b -> b) -> b -> Complex a -> b #

foldr' :: (a -> b -> b) -> b -> Complex a -> b #

foldl :: (b -> a -> b) -> b -> Complex a -> b #

foldl' :: (b -> a -> b) -> b -> Complex a -> b #

foldr1 :: (a -> a -> a) -> Complex a -> a #

foldl1 :: (a -> a -> a) -> Complex a -> a #

toList :: Complex a -> [a] #

null :: Complex a -> Bool #

length :: Complex a -> Int #

elem :: Eq a => a -> Complex a -> Bool #

maximum :: Ord a => Complex a -> a #

minimum :: Ord a => Complex a -> a #

sum :: Num a => Complex a -> a #

product :: Num a => Complex a -> a #

Traversable Complex 

Methods

traverse :: Applicative f => (a -> f b) -> Complex a -> f (Complex b) #

sequenceA :: Applicative f => Complex (f a) -> f (Complex a) #

mapM :: Monad m => (a -> m b) -> Complex a -> m (Complex b) #

sequence :: Monad m => Complex (m a) -> m (Complex a) #

Generic1 Complex 

Associated Types

type Rep1 (Complex :: * -> *) :: * -> * #

Methods

from1 :: Complex a -> Rep1 Complex a #

to1 :: Rep1 Complex a -> Complex a #

(RealFloat a, Unbox a) => Vector Vector (Complex a) 
(RealFloat a, Unbox a) => MVector MVector (Complex a) 
Eq a => Eq (Complex a) 

Methods

(==) :: Complex a -> Complex a -> Bool #

(/=) :: Complex a -> Complex a -> Bool #

RealFloat a => Floating (Complex a) 

Methods

pi :: Complex a #

exp :: Complex a -> Complex a #

log :: Complex a -> Complex a #

sqrt :: Complex a -> Complex a #

(**) :: Complex a -> Complex a -> Complex a #

logBase :: Complex a -> Complex a -> Complex a #

sin :: Complex a -> Complex a #

cos :: Complex a -> Complex a #

tan :: Complex a -> Complex a #

asin :: Complex a -> Complex a #

acos :: Complex a -> Complex a #

atan :: Complex a -> Complex a #

sinh :: Complex a -> Complex a #

cosh :: Complex a -> Complex a #

tanh :: Complex a -> Complex a #

asinh :: Complex a -> Complex a #

acosh :: Complex a -> Complex a #

atanh :: Complex a -> Complex a #

log1p :: Complex a -> Complex a #

expm1 :: Complex a -> Complex a #

log1pexp :: Complex a -> Complex a #

log1mexp :: Complex a -> Complex a #

RealFloat a => Fractional (Complex a) 

Methods

(/) :: Complex a -> Complex a -> Complex a #

recip :: Complex a -> Complex a #

fromRational :: Rational -> Complex a #

Data a => Data (Complex a) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Complex a -> c (Complex a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Complex a) #

toConstr :: Complex a -> Constr #

dataTypeOf :: Complex a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Complex a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Complex a)) #

gmapT :: (forall b. Data b => b -> b) -> Complex a -> Complex a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Complex a -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Complex a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Complex a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Complex a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Complex a -> m (Complex a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Complex a -> m (Complex a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Complex a -> m (Complex a) #

RealFloat a => Num (Complex a) 

Methods

(+) :: Complex a -> Complex a -> Complex a #

(-) :: Complex a -> Complex a -> Complex a #

(*) :: Complex a -> Complex a -> Complex a #

negate :: Complex a -> Complex a #

abs :: Complex a -> Complex a #

signum :: Complex a -> Complex a #

fromInteger :: Integer -> Complex a #

Read a => Read (Complex a) 
Show a => Show (Complex a) 

Methods

showsPrec :: Int -> Complex a -> ShowS #

show :: Complex a -> String #

showList :: [Complex a] -> ShowS #

Generic (Complex a) 

Associated Types

type Rep (Complex a) :: * -> * #

Methods

from :: Complex a -> Rep (Complex a) x #

to :: Rep (Complex a) x -> Complex a #

Storable a => Storable (Complex a) 

Methods

sizeOf :: Complex a -> Int #

alignment :: Complex a -> Int #

peekElemOff :: Ptr (Complex a) -> Int -> IO (Complex a) #

pokeElemOff :: Ptr (Complex a) -> Int -> Complex a -> IO () #

peekByteOff :: Ptr b -> Int -> IO (Complex a) #

pokeByteOff :: Ptr b -> Int -> Complex a -> IO () #

peek :: Ptr (Complex a) -> IO (Complex a) #

poke :: Ptr (Complex a) -> Complex a -> IO () #

(Default a, RealFloat a) => Default (Complex a) 

Methods

def :: Complex a #

(RealFloat a, Unbox a) => Unbox (Complex a) 
PrimType' (Complex Double) Source # 
PrimType' (Complex Float) Source # 
Inhabited (Complex Double) Source # 
Inhabited (Complex Float) Source # 
Type (Complex Double) Source # 
Type (Complex Float) Source # 
MarshalFeld (Data (Complex Double)) Source # 

Associated Types

type HaskellRep (Data (Complex Double)) :: * Source #

MarshalFeld (Data (Complex Float)) Source # 

Associated Types

type HaskellRep (Data (Complex Float)) :: * Source #

MarshalHaskell (Complex Double) Source # 
MarshalHaskell (Complex Float) Source # 
(Eq a) :=> (Eq (Complex a)) 

Methods

ins :: Eq a :- Eq (Complex a) #

(Read a) :=> (Read (Complex a)) 

Methods

ins :: Read a :- Read (Complex a) #

(RealFloat a) :=> (Num (Complex a)) 

Methods

ins :: RealFloat a :- Num (Complex a) #

(RealFloat a) :=> (Fractional (Complex a)) 
(RealFloat a) :=> (Floating (Complex a)) 

Methods

ins :: RealFloat a :- Floating (Complex a) #

(Show a) :=> (Show (Complex a)) 

Methods

ins :: Show a :- Show (Complex a) #

Each (Complex a) (Complex b) a b 

Methods

each :: Traversal (Complex a) (Complex b) a b #

type Rep1 Complex 
data MVector s (Complex a) 
data MVector s (Complex a) = MV_Complex (MVector s (a, a))
type Rep (Complex a) 
data Vector (Complex a) 
data Vector (Complex a) = V_Complex (Vector (a, a))
type HaskellRep (Data (Complex Double)) Source # 
type HaskellRep (Data (Complex Float)) Source # 

class (Eq a, Show a, Typeable a) => PrimType' a Source #

Primitive supported types

Minimal complete definition

primTypeRep

Instances

PrimType' Bool Source # 
PrimType' Double Source # 
PrimType' Float Source # 
PrimType' Int8 Source # 
PrimType' Int16 Source # 
PrimType' Int32 Source # 
PrimType' Int64 Source # 
PrimType' Word8 Source # 
PrimType' Word16 Source # 
PrimType' Word32 Source # 
PrimType' Word64 Source # 
PrimType' (Complex Double) Source # 
PrimType' (Complex Float) Source # 
InterpBi (* -> Constraint, *) * (AssertCMD (* -> *) (* -> Constraint)) IO (Param1 (* -> Constraint) PrimType') # 

Methods

interpBi :: Param1 (* -> Constraint) PrimType' ((IO -> *, (IO -> *, AssertCMD (* -> *) (* -> Constraint))) m ((IO -> *, AssertCMD (* -> *) (* -> Constraint)) m fs)) a -> m a #

Syntactic (Struct PrimType' Data a) # 
type Internal (Struct PrimType' Data a) # 
type Domain (Struct PrimType' Data a) # 

class (PrimType' a, Type a) => PrimType a Source #

Alias for the conjunction of PrimType' and Type

Instances

CompTypeClass PrimType Source # 

Methods

compType :: (PrimType a, MonadC m) => proxy1 PrimType -> proxy2 a -> m Type #

compLit :: (PrimType a, MonadC m) => proxy PrimType -> a -> m Exp #

(PrimType' a, Type a) => PrimType a Source # 

data Ref a Source #

Mutable variable

Instances

Eq (Ref a) Source # 

Methods

(==) :: Ref a -> Ref a -> Bool #

(/=) :: Ref a -> Ref a -> Bool #

type DRef a = Ref (Data a) Source #

Reference specialized to Data elements

data Arr a Source #

Mutable array

Instances

Eq (Arr a) Source #

== checks if two Arr use the same physical array. The length and offset are ignored.

Methods

(==) :: Arr a -> Arr a -> Bool #

(/=) :: Arr a -> Arr a -> Bool #

Slicable (Arr a) Source # 

Methods

slice :: Data Index -> Data Length -> Arr a -> Arr a Source #

Finite (Arr a) Source # 

Methods

length :: Arr a -> Data Length Source #

(MarshalHaskell (Internal a), MarshalFeld a, Syntax a) => MarshalFeld (Arr a) Source # 

Associated Types

type HaskellRep (Arr a) :: * Source #

Methods

fwrite :: Handle -> Arr a -> Run () Source #

fread :: Handle -> Run (Arr a) Source #

type HaskellRep (Arr a) Source # 
type HaskellRep (Arr a) = [Internal a]

type DArr a = Arr (Data a) Source #

Array specialized to Data elements

data IArr a Source #

Immutable array

Instances

MonadComp m => Manifestable2 m (Manifest2 a) a Source #

manifest2 and manifestFresh2 are no-ops. manifestStore2 does a proper arrCopy.

MonadComp m => Manifestable m (Manifest a) a Source #

manifest and manifestFresh are no-ops. manifestStore does a proper arrCopy.

Methods

manifest :: Arr a -> Manifest a -> m (Manifest a) Source #

manifestFresh :: Manifest a -> m (Manifest a) Source #

manifestStore :: Arr a -> Manifest a -> m () Source #

(Syntax a, MonadComp m) => Pushy2 m (Manifest2 a) a Source # 

Methods

toPush2 :: Manifest2 a -> Push2 m a Source #

(Syntax a, MonadComp m) => Pushy2 m (Manifest a) a Source #

Convert to a Push2 with a single row

Methods

toPush2 :: Manifest a -> Push2 m a Source #

(Syntax a, MonadComp m) => Pushy m (Manifest a) a Source # 

Methods

toPush :: Manifest a -> Push m a Source #

Slicable (IArr a) Source # 

Methods

slice :: Data Index -> Data Length -> IArr a -> IArr a Source #

Finite (IArr a) Source # 

Methods

length :: IArr a -> Data Length Source #

Syntax a => Indexed (IArr a) Source # 

Associated Types

type IndexedElem (IArr a) :: * Source #

Methods

(!) :: IArr a -> Data Index -> IndexedElem (IArr a) Source #

(MarshalHaskell (Internal a), MarshalFeld a, Syntax a) => MarshalFeld (IArr a) Source # 

Associated Types

type HaskellRep (IArr a) :: * Source #

Methods

fwrite :: Handle -> IArr a -> Run () Source #

fread :: Handle -> Run (IArr a) Source #

Syntax a => Storable (Manifest2 a) Source # 
Syntax a => Storable (Manifest a) Source # 
ViewManifest2 (Manifest2 a) a Source # 
ViewManifest (Manifest a) a Source # 
Syntax a => Pully2 (Manifest a) a Source #

Convert to a Pull2 with a single row

Methods

toPull2 :: Manifest a -> Pull2 a Source #

type IndexedElem (IArr a) Source # 
type IndexedElem (IArr a) = a
type HaskellRep (IArr a) Source # 
type HaskellRep (IArr a) = [Internal a]
type StoreRep (Manifest2 a) Source # 
type StoreRep (Manifest a) Source # 
type StoreRep (Manifest a) = (DRef Length, Arr a)
type StoreSize (Manifest2 a) Source # 
type StoreSize (Manifest a) Source # 

type DIArr a = IArr (Data a) Source #

Immutable array specialized to Data elements

class Inhabited a Source #

Inhabited types

Minimal complete definition

example

Instances

Inhabited Bool Source # 

Methods

example :: Bool Source #

Inhabited Double Source # 
Inhabited Float Source # 

Methods

example :: Float Source #

Inhabited Int8 Source # 

Methods

example :: Int8 Source #

Inhabited Int16 Source # 

Methods

example :: Int16 Source #

Inhabited Int32 Source # 

Methods

example :: Int32 Source #

Inhabited Int64 Source # 

Methods

example :: Int64 Source #

Inhabited Word8 Source # 

Methods

example :: Word8 Source #

Inhabited Word16 Source # 
Inhabited Word32 Source # 
Inhabited Word64 Source # 
Inhabited (Complex Double) Source # 
Inhabited (Complex Float) Source # 
(Inhabited a, Inhabited b) => Inhabited (a, b) Source # 

Methods

example :: (a, b) Source #

(Inhabited a, Inhabited b, Inhabited c) => Inhabited (a, b, c) Source # 

Methods

example :: (a, b, c) Source #

(Inhabited a, Inhabited b, Inhabited c, Inhabited d) => Inhabited (a, b, c, d) Source # 

Methods

example :: (a, b, c, d) Source #

(Inhabited a, Inhabited b, Inhabited c, Inhabited d, Inhabited e) => Inhabited (a, b, c, d, e) Source # 

Methods

example :: (a, b, c, d, e) Source #

(Inhabited a, Inhabited b, Inhabited c, Inhabited d, Inhabited e, Inhabited f) => Inhabited (a, b, c, d, e, f) Source # 

Methods

example :: (a, b, c, d, e, f) Source #

(Inhabited a, Inhabited b, Inhabited c, Inhabited d, Inhabited e, Inhabited f, Inhabited g) => Inhabited (a, b, c, d, e, f, g) Source # 

Methods

example :: (a, b, c, d, e, f, g) Source #

(Inhabited a, Inhabited b, Inhabited c, Inhabited d, Inhabited e, Inhabited f, Inhabited g, Inhabited h) => Inhabited (a, b, c, d, e, f, g, h) Source # 

Methods

example :: (a, b, c, d, e, f, g, h) Source #

(Inhabited a, Inhabited b, Inhabited c, Inhabited d, Inhabited e, Inhabited f, Inhabited g, Inhabited h, Inhabited i) => Inhabited (a, b, c, d, e, f, g, h, i) Source # 

Methods

example :: (a, b, c, d, e, f, g, h, i) Source #

(Inhabited a, Inhabited b, Inhabited c, Inhabited d, Inhabited e, Inhabited f, Inhabited g, Inhabited h, Inhabited i, Inhabited j) => Inhabited (a, b, c, d, e, f, g, h, i, j) Source # 

Methods

example :: (a, b, c, d, e, f, g, h, i, j) Source #

(Inhabited a, Inhabited b, Inhabited c, Inhabited d, Inhabited e, Inhabited f, Inhabited g, Inhabited h, Inhabited i, Inhabited j, Inhabited k) => Inhabited (a, b, c, d, e, f, g, h, i, j, k) Source # 

Methods

example :: (a, b, c, d, e, f, g, h, i, j, k) Source #

(Inhabited a, Inhabited b, Inhabited c, Inhabited d, Inhabited e, Inhabited f, Inhabited g, Inhabited h, Inhabited i, Inhabited j, Inhabited k, Inhabited l) => Inhabited (a, b, c, d, e, f, g, h, i, j, k, l) Source # 

Methods

example :: (a, b, c, d, e, f, g, h, i, j, k, l) Source #

(Inhabited a, Inhabited b, Inhabited c, Inhabited d, Inhabited e, Inhabited f, Inhabited g, Inhabited h, Inhabited i, Inhabited j, Inhabited k, Inhabited l, Inhabited m) => Inhabited (a, b, c, d, e, f, g, h, i, j, k, l, m) Source # 

Methods

example :: (a, b, c, d, e, f, g, h, i, j, k, l, m) Source #

(Inhabited a, Inhabited b, Inhabited c, Inhabited d, Inhabited e, Inhabited f, Inhabited g, Inhabited h, Inhabited i, Inhabited j, Inhabited k, Inhabited l, Inhabited m, Inhabited n) => Inhabited (a, b, c, d, e, f, g, h, i, j, k, l, m, n) Source # 

Methods

example :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) Source #

(Inhabited a, Inhabited b, Inhabited c, Inhabited d, Inhabited e, Inhabited f, Inhabited g, Inhabited h, Inhabited i, Inhabited j, Inhabited k, Inhabited l, Inhabited m, Inhabited n, Inhabited o) => Inhabited (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) Source # 

Methods

example :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) Source #

class Syntactic a #

It is usually assumed that (desugar (sugar a)) has the same meaning as a.

Minimal complete definition

desugar, sugar

Associated Types

type Domain a :: * -> * #

type Internal a :: * #

Instances

Syntactic (Prim a) # 

Associated Types

type Domain (Prim a) :: * -> * #

type Internal (Prim a) :: * #

Methods

desugar :: Prim a -> ASTF (Domain (Prim a)) (Internal (Prim a)) #

sugar :: ASTF (Domain (Prim a)) (Internal (Prim a)) -> Prim a #

Syntactic (Data a) #

Declaring Data as syntactic sugar

Associated Types

type Domain (Data a) :: * -> * #

type Internal (Data a) :: * #

Methods

desugar :: Data a -> ASTF (Domain (Data a)) (Internal (Data a)) #

sugar :: ASTF (Domain (Data a)) (Internal (Data a)) -> Data a #

Syntax a => Syntactic (Option a) # 

Associated Types

type Domain (Option a) :: * -> * #

type Internal (Option a) :: * #

Methods

desugar :: Option a -> ASTF (Domain (Option a)) (Internal (Option a)) #

sugar :: ASTF (Domain (Option a)) (Internal (Option a)) -> Option a #

Syntax a => Syntactic (Validated a) # 

Associated Types

type Domain (Validated a) :: * -> * #

type Internal (Validated a) :: * #

Syntactic (ASTF sym a) 

Associated Types

type Domain (ASTF sym a) :: * -> * #

type Internal (ASTF sym a) :: * #

Methods

desugar :: ASTF sym a -> ASTF (Domain (ASTF sym a)) (Internal (ASTF sym a)) #

sugar :: ASTF (Domain (ASTF sym a)) (Internal (ASTF sym a)) -> ASTF sym a #

Syntactic (ASTFull sym a) 

Associated Types

type Domain (ASTFull sym a) :: * -> * #

type Internal (ASTFull sym a) :: * #

Methods

desugar :: ASTFull sym a -> ASTF (Domain (ASTFull sym a)) (Internal (ASTFull sym a)) #

sugar :: ASTF (Domain (ASTFull sym a)) (Internal (ASTFull sym a)) -> ASTFull sym a #

Syntactic (Struct PrimType' Data a) # 

type family Domain a :: * -> * #

Instances

type Domain () # 
type Domain () = FeldDomain
type Domain (Prim a) # 
type Domain (Data a) # 
type Domain (Option a) # 
type Domain (Validated a) # 
type Domain (a -> b) # 
type Domain (a -> b) = FeldDomain
type Domain (a, b) # 
type Domain (a, b) = FeldDomain
type Domain (ASTF sym a) 
type Domain (ASTF sym a) = sym
type Domain (ASTFull sym a) 
type Domain (ASTFull sym a) = sym
type Domain (a, b, c) # 
type Domain (a, b, c) = Domain a
type Domain (Struct PrimType' Data a) # 
type Domain (a, b, c, d) # 
type Domain (a, b, c, d) = Domain a
type Domain (a, b, c, d, e) # 
type Domain (a, b, c, d, e) = Domain a
type Domain (a, b, c, d, e, f) # 
type Domain (a, b, c, d, e, f) = Domain a
type Domain (a, b, c, d, e, f, g) # 
type Domain (a, b, c, d, e, f, g) = Domain a
type Domain (a, b, c, d, e, f, g, h) # 
type Domain (a, b, c, d, e, f, g, h) = Domain a
type Domain (a, b, c, d, e, f, g, h, i) # 
type Domain (a, b, c, d, e, f, g, h, i) = Domain a
type Domain (a, b, c, d, e, f, g, h, i, j) # 
type Domain (a, b, c, d, e, f, g, h, i, j) = Domain a
type Domain (a, b, c, d, e, f, g, h, i, j, k) # 
type Domain (a, b, c, d, e, f, g, h, i, j, k) = Domain a
type Domain (a, b, c, d, e, f, g, h, i, j, k, l) # 
type Domain (a, b, c, d, e, f, g, h, i, j, k, l) = Domain a
type Domain (a, b, c, d, e, f, g, h, i, j, k, l, m) # 
type Domain (a, b, c, d, e, f, g, h, i, j, k, l, m) = Domain a
type Domain (a, b, c, d, e, f, g, h, i, j, k, l, m, n) # 
type Domain (a, b, c, d, e, f, g, h, i, j, k, l, m, n) = Domain a
type Domain (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) # 
type Domain (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) = Domain a

type family Internal a :: * #

Instances

type Internal () # 
type Internal () = Int32
type Internal (Prim a) # 
type Internal (Prim a) = a
type Internal (Data a) # 
type Internal (Data a) = a
type Internal (Option a) # 
type Internal (Option a) = (Bool, Internal a)
type Internal (Validated a) # 
type Internal (a -> b) # 
type Internal (a -> b) = Internal a -> Internal b
type Internal (a, b) # 
type Internal (a, b) = (Internal a, Internal b)
type Internal (ASTF sym a) 
type Internal (ASTF sym a) = a
type Internal (ASTFull sym a) 
type Internal (ASTFull sym a) = a
type Internal (a, b, c) # 
type Internal (a, b, c) = ((Internal a, Internal b), Internal c)
type Internal (Struct PrimType' Data a) # 
type Internal (a, b, c, d) # 
type Internal (a, b, c, d) = ((Internal a, Internal b), (Internal c, Internal d))
type Internal (a, b, c, d, e) # 
type Internal (a, b, c, d, e) = (((Internal a, Internal b), Internal c), (Internal d, Internal e))
type Internal (a, b, c, d, e, f) # 
type Internal (a, b, c, d, e, f) = (((Internal a, Internal b), Internal c), ((Internal d, Internal e), Internal f))
type Internal (a, b, c, d, e, f, g) # 
type Internal (a, b, c, d, e, f, g) = (((Internal a, Internal b), (Internal c, Internal d)), ((Internal e, Internal f), Internal g))
type Internal (a, b, c, d, e, f, g, h) # 
type Internal (a, b, c, d, e, f, g, h) = (((Internal a, Internal b), (Internal c, Internal d)), ((Internal e, Internal f), (Internal g, Internal h)))
type Internal (a, b, c, d, e, f, g, h, i) # 
type Internal (a, b, c, d, e, f, g, h, i) = ((((Internal a, Internal b), Internal c), (Internal d, Internal e)), ((Internal f, Internal g), (Internal h, Internal i)))
type Internal (a, b, c, d, e, f, g, h, i, j) # 
type Internal (a, b, c, d, e, f, g, h, i, j) = ((((Internal a, Internal b), Internal c), (Internal d, Internal e)), (((Internal f, Internal g), Internal h), (Internal i, Internal j)))
type Internal (a, b, c, d, e, f, g, h, i, j, k) # 
type Internal (a, b, c, d, e, f, g, h, i, j, k) = ((((Internal a, Internal b), Internal c), ((Internal d, Internal e), Internal f)), (((Internal g, Internal h), Internal i), (Internal j, Internal k)))
type Internal (a, b, c, d, e, f, g, h, i, j, k, l) # 
type Internal (a, b, c, d, e, f, g, h, i, j, k, l) = ((((Internal a, Internal b), Internal c), ((Internal d, Internal e), Internal f)), (((Internal g, Internal h), Internal i), ((Internal j, Internal k), Internal l)))
type Internal (a, b, c, d, e, f, g, h, i, j, k, l, m) # 
type Internal (a, b, c, d, e, f, g, h, i, j, k, l, m) = ((((Internal a, Internal b), (Internal c, Internal d)), ((Internal e, Internal f), Internal g)), (((Internal h, Internal i), Internal j), ((Internal k, Internal l), Internal m)))
type Internal (a, b, c, d, e, f, g, h, i, j, k, l, m, n) # 
type Internal (a, b, c, d, e, f, g, h, i, j, k, l, m, n) = ((((Internal a, Internal b), (Internal c, Internal d)), ((Internal e, Internal f), Internal g)), (((Internal h, Internal i), (Internal j, Internal k)), ((Internal l, Internal m), Internal n)))
type Internal (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) # 
type Internal (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) = ((((Internal a, Internal b), (Internal c, Internal d)), ((Internal e, Internal f), (Internal g, Internal h))), (((Internal i, Internal j), (Internal k, Internal l)), ((Internal m, Internal n), Internal o)))

Front end

eval :: (Syntactic a, Domain a ~ FeldDomain) => a -> Internal a Source #

Evaluate a closed expression

showAST :: (Syntactic a, Domain a ~ FeldDomain) => a -> String Source #

Show the syntax tree using Unicode art

Only user assertions will be included.

drawAST :: (Syntactic a, Domain a ~ FeldDomain) => a -> IO () Source #

Draw the syntax tree on the terminal using Unicode art

Only user assertions will be included.

class Eq a => Bits a #

The Bits class defines bitwise operations over integral types.

  • Bits are numbered from 0 with bit 0 being the least significant bit.

Instances

Bits Bool 
Bits Int 

Methods

(.&.) :: Int -> Int -> Int #

(.|.) :: Int -> Int -> Int #

xor :: Int -> Int -> Int #

complement :: Int -> Int #

shift :: Int -> Int -> Int #

rotate :: Int -> Int -> Int #

zeroBits :: Int #

bit :: Int -> Int #

setBit :: Int -> Int -> Int #

clearBit :: Int -> Int -> Int #

complementBit :: Int -> Int -> Int #

testBit :: Int -> Int -> Bool #

bitSizeMaybe :: Int -> Maybe Int #

bitSize :: Int -> Int #

isSigned :: Int -> Bool #

shiftL :: Int -> Int -> Int #

unsafeShiftL :: Int -> Int -> Int #

shiftR :: Int -> Int -> Int #

unsafeShiftR :: Int -> Int -> Int #

rotateL :: Int -> Int -> Int #

rotateR :: Int -> Int -> Int #

popCount :: Int -> Int #

Bits Int8 
Bits Int16 
Bits Int32 
Bits Int64 
Bits Integer 
Bits Word 
Bits Word8 
Bits Word16 
Bits Word32 
Bits Word64 
Bits CChar 
Bits CSChar 
Bits CUChar 
Bits CShort 
Bits CUShort 
Bits CInt 
Bits CUInt 
Bits CLong 
Bits CULong 
Bits CLLong 
Bits CULLong 
Bits CPtrdiff 
Bits CSize 
Bits CWchar 
Bits CSigAtomic 
Bits CIntPtr 
Bits CUIntPtr 
Bits CIntMax 
Bits CUIntMax 
Bits a => Bits (Identity a) 
Bits a => Bits (Const k a b) 

Methods

(.&.) :: Const k a b -> Const k a b -> Const k a b #

(.|.) :: Const k a b -> Const k a b -> Const k a b #

xor :: Const k a b -> Const k a b -> Const k a b #

complement :: Const k a b -> Const k a b #

shift :: Const k a b -> Int -> Const k a b #

rotate :: Const k a b -> Int -> Const k a b #

zeroBits :: Const k a b #

bit :: Int -> Const k a b #

setBit :: Const k a b -> Int -> Const k a b #

clearBit :: Const k a b -> Int -> Const k a b #

complementBit :: Const k a b -> Int -> Const k a b #

testBit :: Const k a b -> Int -> Bool #

bitSizeMaybe :: Const k a b -> Maybe Int #

bitSize :: Const k a b -> Int #

isSigned :: Const k a b -> Bool #

shiftL :: Const k a b -> Int -> Const k a b #

unsafeShiftL :: Const k a b -> Int -> Const k a b #

shiftR :: Const k a b -> Int -> Const k a b #

unsafeShiftR :: Const k a b -> Int -> Const k a b #

rotateL :: Const k a b -> Int -> Const k a b #

rotateR :: Const k a b -> Int -> Const k a b #

popCount :: Const k a b -> Int #

class Bits b => FiniteBits b #

The FiniteBits class denotes types with a finite, fixed number of bits.

Since: 4.7.0.0

Minimal complete definition

finiteBitSize

Instances

FiniteBits Bool 
FiniteBits Int 
FiniteBits Int8 
FiniteBits Int16 
FiniteBits Int32 
FiniteBits Int64 
FiniteBits Word 
FiniteBits Word8 
FiniteBits Word16 
FiniteBits Word32 
FiniteBits Word64 
FiniteBits CChar 
FiniteBits CSChar 
FiniteBits CUChar 
FiniteBits CShort 
FiniteBits CUShort 
FiniteBits CInt 
FiniteBits CUInt 
FiniteBits CLong 
FiniteBits CULong 
FiniteBits CLLong 
FiniteBits CULLong 
FiniteBits CPtrdiff 
FiniteBits CSize 
FiniteBits CWchar 
FiniteBits CSigAtomic 
FiniteBits CIntPtr 
FiniteBits CUIntPtr 
FiniteBits CIntMax 
FiniteBits CUIntMax 
FiniteBits a => FiniteBits (Identity a) 
FiniteBits a => FiniteBits (Const k a b) 

Methods

finiteBitSize :: Const k a b -> Int #

countLeadingZeros :: Const k a b -> Int #

countTrailingZeros :: Const k a b -> Int #

class (Real a, Enum a) => Integral a where #

Integral numbers, supporting integer division.

Minimal complete definition

quotRem, toInteger

Instances

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 #

Integral Int8 

Methods

quot :: Int8 -> Int8 -> Int8 #

rem :: Int8 -> Int8 -> Int8 #

div :: Int8 -> Int8 -> Int8 #

mod :: Int8 -> Int8 -> Int8 #

quotRem :: Int8 -> Int8 -> (Int8, Int8) #

divMod :: Int8 -> Int8 -> (Int8, Int8) #

toInteger :: Int8 -> Integer #

Integral Int16 
Integral Int32 
Integral Int64 
Integral Integer 
Integral Word 

Methods

quot :: Word -> Word -> Word #

rem :: Word -> Word -> Word #

div :: Word -> Word -> Word #

mod :: Word -> Word -> Word #

quotRem :: Word -> Word -> (Word, Word) #

divMod :: Word -> Word -> (Word, Word) #

toInteger :: Word -> Integer #

Integral Word8 
Integral Word16 
Integral Word32 
Integral Word64 
Integral CChar 
Integral CSChar 
Integral CUChar 
Integral CShort 
Integral CUShort 
Integral CInt 

Methods

quot :: CInt -> CInt -> CInt #

rem :: CInt -> CInt -> CInt #

div :: CInt -> CInt -> CInt #

mod :: CInt -> CInt -> CInt #

quotRem :: CInt -> CInt -> (CInt, CInt) #

divMod :: CInt -> CInt -> (CInt, CInt) #

toInteger :: CInt -> Integer #

Integral CUInt 
Integral CLong 
Integral CULong 
Integral CLLong 
Integral CULLong 
Integral CPtrdiff 
Integral CSize 
Integral CWchar 
Integral CSigAtomic 
Integral CIntPtr 
Integral CUIntPtr 
Integral CIntMax 
Integral CUIntMax 
Integral Name 

Methods

quot :: Name -> Name -> Name #

rem :: Name -> Name -> Name #

div :: Name -> Name -> Name #

mod :: Name -> Name -> Name #

quotRem :: Name -> Name -> (Name, Name) #

divMod :: Name -> Name -> (Name, Name) #

toInteger :: Name -> Integer #

() :=> (Integral Int) 

Methods

ins :: () :- Integral Int #

() :=> (Integral Integer) 

Methods

ins :: () :- Integral Integer #

Integral a => Integral (Identity a) 
(Integral a) :=> (RealFrac (Ratio a)) 

Methods

ins :: Integral a :- RealFrac (Ratio a) #

(Integral a) :=> (Real (Ratio a)) 

Methods

ins :: Integral a :- Real (Ratio a) #

(Integral a) :=> (Ord (Ratio a)) 

Methods

ins :: Integral a :- Ord (Ratio a) #

(Integral a) :=> (Num (Ratio a)) 

Methods

ins :: Integral a :- Num (Ratio a) #

(Integral a) :=> (Fractional (Ratio a)) 

Methods

ins :: Integral a :- Fractional (Ratio a) #

(Integral a) :=> (Enum (Ratio a)) 

Methods

ins :: Integral a :- Enum (Ratio a) #

Class (Real a, Enum a) (Integral a) 

Methods

cls :: Integral a :- (Real a, Enum a) #

(Integral a, Show a) :=> (Show (Ratio a)) 

Methods

ins :: (Integral a, Show a) :- Show (Ratio a) #

(Integral a, Read a) :=> (Read (Ratio a)) 

Methods

ins :: (Integral a, Read a) :- Read (Ratio a) #

Integral a => Integral (Const k a b) 

Methods

quot :: Const k a b -> Const k a b -> Const k a b #

rem :: Const k a b -> Const k a b -> Const k a b #

div :: Const k a b -> Const k a b -> Const k a b #

mod :: Const k a b -> Const k a b -> Const k a b #

quotRem :: Const k a b -> Const k a b -> (Const k a b, Const k a b) #

divMod :: Const k a b -> Const k a b -> (Const k a b, Const k a b) #

toInteger :: Const k a b -> Integer #

class Eq a => Ord a #

The Ord class is used for totally ordered datatypes.

Instances of Ord can be derived for any user-defined datatype whose constituent types are in Ord. The declared order of the constructors in the data declaration determines the ordering in derived Ord instances. The Ordering datatype allows a single comparison to determine the precise ordering of two objects.

Minimal complete definition: either compare or <=. Using compare can be more efficient for complex types.

Minimal complete definition

compare | (<=)

Instances

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 #

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 #

Ord Double 
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 #

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 #

Ord Int8 

Methods

compare :: Int8 -> Int8 -> Ordering #

(<) :: Int8 -> Int8 -> Bool #

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

(>) :: Int8 -> Int8 -> Bool #

(>=) :: Int8 -> Int8 -> Bool #

max :: Int8 -> Int8 -> Int8 #

min :: Int8 -> Int8 -> Int8 #

Ord Int16 

Methods

compare :: Int16 -> Int16 -> Ordering #

(<) :: Int16 -> Int16 -> Bool #

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

(>) :: Int16 -> Int16 -> Bool #

(>=) :: Int16 -> Int16 -> Bool #

max :: Int16 -> Int16 -> Int16 #

min :: Int16 -> Int16 -> Int16 #

Ord Int32 

Methods

compare :: Int32 -> Int32 -> Ordering #

(<) :: Int32 -> Int32 -> Bool #

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

(>) :: Int32 -> Int32 -> Bool #

(>=) :: Int32 -> Int32 -> Bool #

max :: Int32 -> Int32 -> Int32 #

min :: Int32 -> Int32 -> Int32 #

Ord Int64 

Methods

compare :: Int64 -> Int64 -> Ordering #

(<) :: Int64 -> Int64 -> Bool #

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

(>) :: Int64 -> Int64 -> Bool #

(>=) :: Int64 -> Int64 -> Bool #

max :: Int64 -> Int64 -> Int64 #

min :: Int64 -> Int64 -> Int64 #

Ord Integer 
Ord Ordering 
Ord Word 

Methods

compare :: Word -> Word -> Ordering #

(<) :: Word -> Word -> Bool #

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

(>) :: Word -> Word -> Bool #

(>=) :: Word -> Word -> Bool #

max :: Word -> Word -> Word #

min :: Word -> Word -> Word #

Ord Word8 

Methods

compare :: Word8 -> Word8 -> Ordering #

(<) :: Word8 -> Word8 -> Bool #

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

(>) :: Word8 -> Word8 -> Bool #

(>=) :: Word8 -> Word8 -> Bool #

max :: Word8 -> Word8 -> Word8 #

min :: Word8 -> Word8 -> Word8 #

Ord Word16 
Ord Word32 
Ord Word64 
Ord TypeRep 
Ord Exp 

Methods

compare :: Exp -> Exp -> Ordering #

(<) :: Exp -> Exp -> Bool #

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

(>) :: Exp -> Exp -> Bool #

(>=) :: Exp -> Exp -> Bool #

max :: Exp -> Exp -> Exp #

min :: Exp -> Exp -> Exp #

Ord Match 

Methods

compare :: Match -> Match -> Ordering #

(<) :: Match -> Match -> Bool #

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

(>) :: Match -> Match -> Bool #

(>=) :: Match -> Match -> Bool #

max :: Match -> Match -> Match #

min :: Match -> Match -> Match #

Ord Clause 
Ord Pat 

Methods

compare :: Pat -> Pat -> Ordering #

(<) :: Pat -> Pat -> Bool #

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

(>) :: Pat -> Pat -> Bool #

(>=) :: Pat -> Pat -> Bool #

max :: Pat -> Pat -> Pat #

min :: Pat -> Pat -> Pat #

Ord Type 

Methods

compare :: Type -> Type -> Ordering #

(<) :: Type -> Type -> Bool #

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

(>) :: Type -> Type -> Bool #

(>=) :: Type -> Type -> Bool #

max :: Type -> Type -> Type #

min :: Type -> Type -> Type #

Ord Dec 

Methods

compare :: Dec -> Dec -> Ordering #

(<) :: Dec -> Dec -> Bool #

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

(>) :: Dec -> Dec -> Bool #

(>=) :: Dec -> Dec -> Bool #

max :: Dec -> Dec -> Dec #

min :: Dec -> Dec -> Dec #

Ord Name 

Methods

compare :: Name -> Name -> Ordering #

(<) :: Name -> Name -> Bool #

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

(>) :: Name -> Name -> Bool #

(>=) :: Name -> Name -> Bool #

max :: Name -> Name -> Name #

min :: Name -> Name -> Name #

Ord FunDep 
Ord TyVarBndr 
Ord InjectivityAnn 
Ord Overlap 
Ord () 

Methods

compare :: () -> () -> Ordering #

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

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

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

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

max :: () -> () -> () #

min :: () -> () -> () #

Ord TyCon 

Methods

compare :: TyCon -> TyCon -> Ordering #

(<) :: TyCon -> TyCon -> Bool #

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

(>) :: TyCon -> TyCon -> Bool #

(>=) :: TyCon -> TyCon -> Bool #

max :: TyCon -> TyCon -> TyCon #

min :: TyCon -> TyCon -> TyCon #

Ord BigNat 
Ord Void 

Methods

compare :: Void -> Void -> Ordering #

(<) :: Void -> Void -> Bool #

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

(>) :: Void -> Void -> Bool #

(>=) :: Void -> Void -> Bool #

max :: Void -> Void -> Void #

min :: Void -> Void -> Void #

Ord Version 
Ord ThreadId 
Ord BlockReason 
Ord ThreadStatus 
Ord AsyncException 
Ord ArrayException 
Ord ExitCode 
Ord CChar 

Methods

compare :: CChar -> CChar -> Ordering #

(<) :: CChar -> CChar -> Bool #

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

(>) :: CChar -> CChar -> Bool #

(>=) :: CChar -> CChar -> Bool #

max :: CChar -> CChar -> CChar #

min :: CChar -> CChar -> CChar #

Ord CSChar 
Ord CUChar 
Ord CShort 
Ord CUShort 
Ord CInt 

Methods

compare :: CInt -> CInt -> Ordering #

(<) :: CInt -> CInt -> Bool #

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

(>) :: CInt -> CInt -> Bool #

(>=) :: CInt -> CInt -> Bool #

max :: CInt -> CInt -> CInt #

min :: CInt -> CInt -> CInt #

Ord CUInt 

Methods

compare :: CUInt -> CUInt -> Ordering #

(<) :: CUInt -> CUInt -> Bool #

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

(>) :: CUInt -> CUInt -> Bool #

(>=) :: CUInt -> CUInt -> Bool #

max :: CUInt -> CUInt -> CUInt #

min :: CUInt -> CUInt -> CUInt #

Ord CLong 

Methods

compare :: CLong -> CLong -> Ordering #

(<) :: CLong -> CLong -> Bool #

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

(>) :: CLong -> CLong -> Bool #

(>=) :: CLong -> CLong -> Bool #

max :: CLong -> CLong -> CLong #

min :: CLong -> CLong -> CLong #

Ord CULong 
Ord CLLong 
Ord CULLong 
Ord CFloat 
Ord CDouble 
Ord CPtrdiff 
Ord CSize 

Methods

compare :: CSize -> CSize -> Ordering #

(<) :: CSize -> CSize -> Bool #

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

(>) :: CSize -> CSize -> Bool #

(>=) :: CSize -> CSize -> Bool #

max :: CSize -> CSize -> CSize #

min :: CSize -> CSize -> CSize #

Ord CWchar 
Ord CSigAtomic 
Ord CClock 
Ord CTime 

Methods

compare :: CTime -> CTime -> Ordering #

(<) :: CTime -> CTime -> Bool #

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

(>) :: CTime -> CTime -> Bool #

(>=) :: CTime -> CTime -> Bool #

max :: CTime -> CTime -> CTime #

min :: CTime -> CTime -> CTime #

Ord CUSeconds 
Ord CSUSeconds 
Ord CIntPtr 
Ord CUIntPtr 
Ord CIntMax 
Ord CUIntMax 
Ord All 

Methods

compare :: All -> All -> Ordering #

(<) :: All -> All -> Bool #

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

(>) :: All -> All -> Bool #

(>=) :: All -> All -> Bool #

max :: All -> All -> All #

min :: All -> All -> All #

Ord Any 

Methods

compare :: Any -> Any -> Ordering #

(<) :: Any -> Any -> Bool #

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

(>) :: Any -> Any -> Bool #

(>=) :: Any -> Any -> Bool #

max :: Any -> Any -> Any #

min :: Any -> Any -> Any #

Ord Fixity 
Ord Associativity 
Ord SourceUnpackedness 
Ord SourceStrictness 
Ord DecidedStrictness 
Ord ErrorCall 
Ord ArithException 
Ord SomeNat 
Ord SomeSymbol 
Ord IOMode 
Ord GeneralCategory 
Ord IntSet 
Ord Hash 

Methods

compare :: Hash -> Hash -> Ordering #

(<) :: Hash -> Hash -> Bool #

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

(>) :: Hash -> Hash -> Bool #

(>=) :: Hash -> Hash -> Bool #

max :: Hash -> Hash -> Hash #

min :: Hash -> Hash -> Hash #

Ord PragmasAndModuleName 
Ord PragmasAndModuleHead 
Ord ModuleHeadAndImports 
Ord ModuleName 
Ord SpecialCon 
Ord QName 

Methods

compare :: QName -> QName -> Ordering #

(<) :: QName -> QName -> Bool #

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

(>) :: QName -> QName -> Bool #

(>=) :: QName -> QName -> Bool #

max :: QName -> QName -> QName #

min :: QName -> QName -> QName #

Ord Name 

Methods

compare :: Name -> Name -> Ordering #

(<) :: Name -> Name -> Bool #

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

(>) :: Name -> Name -> Bool #

(>=) :: Name -> Name -> Bool #

max :: Name -> Name -> Name #

min :: Name -> Name -> Name #

Ord IPName 
Ord QOp 

Methods

compare :: QOp -> QOp -> Ordering #

(<) :: QOp -> QOp -> Bool #

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

(>) :: QOp -> QOp -> Bool #

(>=) :: QOp -> QOp -> Bool #

max :: QOp -> QOp -> QOp #

min :: QOp -> QOp -> QOp #

Ord Op 

Methods

compare :: Op -> Op -> Ordering #

(<) :: Op -> Op -> Bool #

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

(>) :: Op -> Op -> Bool #

(>=) :: Op -> Op -> Bool #

max :: Op -> Op -> Op #

min :: Op -> Op -> Op #

Ord CName 

Methods

compare :: CName -> CName -> Ordering #

(<) :: CName -> CName -> Bool #

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

(>) :: CName -> CName -> Bool #

(>=) :: CName -> CName -> Bool #

max :: CName -> CName -> CName #

min :: CName -> CName -> CName #

Ord Module 
Ord ExportSpec 
Ord Namespace 
Ord ImportDecl 
Ord ImportSpec 
Ord Assoc 

Methods

compare :: Assoc -> Assoc -> Ordering #

(<) :: Assoc -> Assoc -> Bool #

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

(>) :: Assoc -> Assoc -> Bool #

(>=) :: Assoc -> Assoc -> Bool #

max :: Assoc -> Assoc -> Assoc #

min :: Assoc -> Assoc -> Assoc #

Ord Decl 

Methods

compare :: Decl -> Decl -> Ordering #

(<) :: Decl -> Decl -> Bool #

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

(>) :: Decl -> Decl -> Bool #

(>=) :: Decl -> Decl -> Bool #

max :: Decl -> Decl -> Decl #

min :: Decl -> Decl -> Decl #

Ord PatternSynDirection 
Ord TypeEqn 
Ord Annotation 
Ord BooleanFormula 
Ord Role 

Methods

compare :: Role -> Role -> Ordering #

(<) :: Role -> Role -> Bool #

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

(>) :: Role -> Role -> Bool #

(>=) :: Role -> Role -> Bool #

max :: Role -> Role -> Role #

min :: Role -> Role -> Role #

Ord DataOrNew 
Ord Binds 

Methods

compare :: Binds -> Binds -> Ordering #

(<) :: Binds -> Binds -> Bool #

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

(>) :: Binds -> Binds -> Bool #

(>=) :: Binds -> Binds -> Bool #

max :: Binds -> Binds -> Binds #

min :: Binds -> Binds -> Binds #

Ord IPBind 

Methods

compare :: IPBind -> IPBind -> Ordering #