raw-feldspar-0.2: 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' ((AssertCMD (* -> *) (* -> Constraint) -> *, (AssertCMD (* -> *) (* -> Constraint) -> *, IO)) m ((AssertCMD (* -> *) (* -> Constraint) -> *, IO) 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 SizeSpec (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) => Seqy m (Manifest a) a Source # 

Methods

toSeq :: Manifest a -> Seq m a 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 SizeSpec (IArr a) Source # 
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 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 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

Methods

toInteger :: a -> Integer #

conversion to Integer

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 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 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 SomeNat 
Ord SomeSymbol 
Ord IOMode 
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 SrcLoc 
Ord SrcSpan 
Ord SrcSpanInfo 
Ord Boxed 

Methods

compare :: Boxed -> Boxed -> Ordering #

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

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

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

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

max :: Boxed -> Boxed -> Boxed #

min :: Boxed -> Boxed -> Boxed #

Ord Tool 

Methods

compare :: Tool -> Tool -> Ordering #

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

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

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

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

max :: Tool -> Tool -> Tool #

min :: Tool -> Tool -> Tool #

Ord Definition 
Ord Fixity 
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 Extensions 
Ord Id 

Methods

compare :: Id -> Id -> Ordering #

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

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

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

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

max :: Id -> Id -> Id #

min :: Id -> Id -> Id #

Ord StringLit 
Ord Storage 
Ord TypeQual 
Ord Sign 

Methods

compare :: Sign -> Sign -> Ordering #

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

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

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

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

max :: Sign -> Sign -> Sign #

min :: Sign -> Sign -> Sign #

Ord TypeSpec 
Ord DeclSpec 
Ord ArraySize 
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 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 Designator 
Ord Designation 
Ord Initializer 
Ord Init 

Methods

compare :: Init -> Init -> Ordering #

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

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

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

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

max :: Init -> Init -> Init #

min :: Init -> Init -> Init #

Ord Typedef 
Ord InitGroup 
Ord Field 

Methods

compare :: Field -> Field -> Ordering #

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

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

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

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

max :: Field -> Field -> Field #

min :: Field -> Field -> Field #

Ord FieldGroup 
Ord CEnum 

Methods

compare :: CEnum -> CEnum -> Ordering #

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

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

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

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

max :: CEnum -> CEnum -> CEnum #

min :: CEnum -> CEnum -> CEnum #

Ord Attr 

Methods

compare :: Attr -> Attr -> Ordering #

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

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

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

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

max :: Attr -> Attr -> Attr #

min :: Attr -> Attr -> Attr #

Ord Param 

Methods

compare :: Param -> Param -> Ordering #

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

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

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

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

max :: Param -> Param -> Param #

min :: Param -> Param -> Param #

Ord Params 
Ord Func 

Methods

compare :: Func -> Func -> Ordering #

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

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

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

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

max :: Func -> Func -> Func #

min :: Func -> Func -> Func #

Ord Stm 

Methods

compare :: Stm -> Stm -> Ordering #

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

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

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

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

max :: Stm -> Stm -> Stm #

min :: Stm -> Stm -> Stm #

Ord BlockItem 
Ord Signed 
Ord Const 

Methods

compare :: Const -> Const -> Ordering #

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

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

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

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

max :: Const -> Const -> Const #

min :: Const -> Const -> Const #

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 BinOp 

Methods

compare :: BinOp -> BinOp -> Ordering #

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

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

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

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

max :: BinOp -> BinOp -> BinOp #

min :: BinOp -> BinOp -> BinOp #

Ord AssignOp 
Ord UnOp 

Methods

compare :: UnOp -> UnOp -> Ordering #

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

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

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

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

max :: UnOp -> UnOp -> UnOp #

min :: UnOp -> UnOp -> UnOp #

Ord AsmOut 
Ord AsmIn 

Methods

compare :: AsmIn -> AsmIn -> Ordering #

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

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

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

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

max :: AsmIn -> AsmIn -> AsmIn #

min :: AsmIn -> AsmIn -> AsmIn #

Ord BlockType 
Ord ObjCIvarDecl 
Ord ObjCVisibilitySpec 
Ord ObjCIfaceDecl 
Ord ObjCPropAttr 
Ord ObjCMethodReq 
Ord ObjCParam 
Ord ObjCMethodProto 
Ord ObjCCatch 
Ord ObjCDictElem 
Ord ObjCRecv 
Ord ObjCArg 
Ord LambdaIntroducer 
Ord LambdaDeclarator 
Ord CaptureListEntry 
Ord ExeConfig 
Ord Addr 

Methods

compare :: Addr -> Addr -> Ordering #

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

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

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

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

max :: Addr -> Addr -> Addr #

min :: Addr -> Addr -> Addr #

Ord Pos 

Methods

compare :: Pos -> Pos -> Ordering #

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

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

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

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

max :: Pos -> Pos -> Pos #

min :: Pos -> Pos -> Pos #

Ord SrcLoc 
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 ModName 
Ord PkgName 
Ord Module 
Ord OccName 
Ord NameFlavour 
Ord NameSpace 
Ord Loc 

Methods

compare :: Loc -> Loc -> Ordering #

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

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

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

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

max :: Loc -> Loc -> Loc #

min :: Loc -> Loc -> Loc #

Ord Info 

Methods

compare :: Info -> Info -> Ordering #

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

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

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

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

max :: Info -> Info -> Info #

min :: Info -> Info -> Info #

Ord ModuleInfo 
Ord Fixity 
Ord FixityDirection 
Ord Lit 

Methods

compare :: Lit -> Lit -> Ordering #

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

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

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

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

max :: Lit -> Lit -> Lit #

min :: Lit -> Lit -> Lit #

Ord Body 

Methods

compare :: Body -> Body -> Ordering #

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

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

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

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

max :: Body -> Body -> Body #

min :: Body -> Body -> Body #

Ord Guard 

Methods

compare :: Guard -> Guard -> Ordering #

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

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

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

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

max :: Guard -> Guard -> Guard #

min :: Guard -> Guard -> Guard #

Ord Stmt 

Methods

compare :: Stmt -> Stmt -> Ordering #

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

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

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

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

max :: Stmt -> Stmt -> Stmt #

min :: Stmt -> Stmt -> Stmt #

Ord Range 

Methods

compare :: Range -> Range -> Ordering #

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

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

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

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

max :: Range -> Range -> Range #

min :: Range -> Range -> Range #

Ord TypeFamilyHead 
Ord TySynEqn 
Ord FamFlavour 
Ord Foreign 
Ord Callconv 
Ord Safety 
Ord Pragma 
Ord Inline 
Ord RuleMatch 
Ord Phases 
Ord RuleBndr 
Ord AnnTarget 
Ord SourceUnpackedness 
Ord SourceStrictness 
Ord DecidedStrictness 
Ord Con 

Methods

compare :: Con -> Con -> Ordering #

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

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

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

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

max :: Con -> Con -> Con #

min :: Con -> Con -> Con #

Ord Bang 

Methods

compare :: Bang -> Bang -> Ordering #

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

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

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

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

max :: Bang -> Bang -> Bang #

min :: Bang -> Bang -> Bang #

Ord FamilyResultSig 
Ord TyLit 

Methods

compare :: TyLit -> TyLit -> Ordering #

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

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

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

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

max :: TyLit -> TyLit -> TyLit #

min :: TyLit -> TyLit -> TyLit #

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 AnnLookup 
Ord LocalTime 
Ord UTCTime 
Ord NominalDiffTime 
Ord Day 

Methods

compare :: Day -> Day -> Ordering #

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

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

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

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

max :: Day -> Day -> Day #

min :: Day -> Day -> Day #

Ord UniversalTime 
Ord DiffTime 
() :=> (Ord Bool) 

Methods

ins :: () :- Ord Bool #

() :=> (Ord Char) 

Methods

ins :: () :- Ord Char #

() :=> (Ord Double) 

Methods

ins :: () :- Ord Double #

() :=> (Ord Float) 

Methods

ins :: () :- Ord Float #

() :=> (Ord Int) 

Methods

ins :: () :- Ord Int #

() :=> (Ord Integer) 

Methods

ins :: () :- Ord Integer #

() :=> (Ord ()) 

Methods

ins :: () :- Ord () #

() :=> (Ord (Dict a)) 

Methods

ins :: () :- Ord (Dict a) #

() :=> (Ord ((:-) a b)) 

Methods

ins :: () :- Ord (a :- b) #

Ord a => Ord [a] 

Methods

compare :: [a] -> [a] -> Ordering #

(<) :: [a] -> [a] -> Bool #

(<=) :: [a] -> [a] -> Bool #

(>) :: [a] -> [a] -> Bool #

(>=) :: [a] -> [a] -> Bool #

max :: [a] -> [a] -> [a] #

min :: [a] -> [a] -> [a] #

Ord a => Ord (Maybe a) 

Methods

compare :: Maybe a -> Maybe a -> Ordering #

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

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

(>) :: Maybe a -> Maybe a -> Bool #

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

max :: Maybe a -> Maybe a -> Maybe a #

min :: Maybe a -> Maybe a -> Maybe a #

Integral a => Ord (Ratio a) 

Methods

compare :: Ratio a -> Ratio a -> Ordering #

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

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

(>) :: Ratio a -> Ratio a -> Bool #

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

max :: Ratio a -> Ratio a -> Ratio a #

min :: Ratio a -> Ratio a -> Ratio a #

Ord (Ptr a) 

Methods

compare :: Ptr a -> Ptr a -> Ordering #

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

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

(>) :: Ptr a -> Ptr a -> Bool #

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

max :: Ptr a -> Ptr a -> Ptr a #

min :: Ptr a -> Ptr a -> Ptr a #

Ord (FunPtr a) 

Methods

compare :: FunPtr a -> FunPtr a -> Ordering #

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

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

(>) :: FunPtr a -> FunPtr a -> Bool #

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

max :: FunPtr a -> FunPtr a -> FunPtr a #

min :: FunPtr a -> FunPtr a -> FunPtr a #

Ord (V1 p) 

Methods

compare :: V1 p -> V1 p -> Ordering #

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

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

(>) :: V1 p -> V1 p -> Bool #

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

max :: V1 p -> V1 p -> V1 p #

min :: V1 p -> V1 p -> V1 p #

Ord (U1 p) 

Methods

compare :: U1 p -> U1 p -> Ordering #

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

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

(>) :: U1 p -> U1 p -> Bool #

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

max :: U1 p -> U1 p -> U1 p #

min :: U1 p -> U1 p -> U1 p #

Ord p => Ord (Par1 p) 

Methods

compare :: Par1 p -> Par1 p -> Ordering #

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

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

(>) :: Par1 p -> Par1 p -> Bool #

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

max :: Par1 p -> Par1 p -> Par1 p #

min :: Par1 p -> Par1 p -> Par1 p #

Ord a => Ord (Identity a) 

Methods

compare :: Identity a -> Identity a -> Ordering #

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

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

(>) :: Identity a -> Identity a -> Bool #

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

max :: Identity a -> Identity a -> Identity a #

min :: Identity a -> Identity a -> Identity a #

Ord a => Ord (Min a) 

Methods

compare :: Min a -> Min a -> Ordering #

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

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

(>) :: Min a -> Min a -> Bool #

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

max :: Min a -> Min a -> Min a #

min :: Min a -> Min a -> Min a #

Ord a => Ord (Max a) 

Methods

compare :: Max a -> Max a -> Ordering #

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

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

(>) :: Max a -> Max a -> Bool #

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

max :: Max a -> Max a -> Max a #

min :: Max a -> Max a -> Max a #

Ord a => Ord (First a) 

Methods

compare :: First a -> First a -> Ordering #

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

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

(>) :: First a -> First a -> Bool #

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

max :: First a -> First a -> First a #

min :: First a -> First a -> First a #

Ord a => Ord (Last a) 

Methods

compare :: Last a -> Last a -> Ordering #

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

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

(>) :: Last a -> Last a -> Bool #

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

max :: Last a -> Last a -> Last a #

min :: Last a -> Last a -> Last a #

Ord m => Ord (WrappedMonoid m) 
Ord a => Ord (Option a) 

Methods

compare :: Option a -> Option a -> Ordering #

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

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

(>) :: Option a -> Option a -> Bool #

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

max :: Option a -> Option a -> Option a #

min :: Option a -> Option a -> Option a #

Ord a => Ord (NonEmpty a) 

Methods

compare :: NonEmpty a -> NonEmpty a -> Ordering #

(<) :: NonEmpty a ->