Language.Copilot.Language

Describes the language Copilot.

If you wish to add a new operator, the only modification needed is adding it in this module. But if you want it to be used in the random generated streams, add it to either opsF, opsF2 or opsF3

Operators and functions

mod :: (Streamable a, IntegralE a) => Spec a -> Spec a -> Spec a

div :: (Streamable a, IntegralE a) => Spec a -> Spec a -> Spec a

Beware : crash without any possible recovery if a division by 0 happens. Same risk with mod. Use div0 and mod0 if unsure.

mod0 :: (Streamable a, IntegralE a) => a -> Spec a -> Spec a -> Spec a

div0 :: (Streamable a, IntegralE a) => a -> Spec a -> Spec a -> Spec a

As mod and div, except that if the division would be by 0, it is instead by the first argument.

(<) :: (Streamable a, OrdE a) => Spec a -> Spec a -> Spec Bool

(<=) :: (Streamable a, OrdE a) => Spec a -> Spec a -> Spec Bool

(==) :: (Streamable a, EqE a) => Spec a -> Spec a -> Spec Bool

(/=) :: (Streamable a, EqE a) => Spec a -> Spec a -> Spec Bool

(>=) :: (Streamable a, OrdE a) => Spec a -> Spec a -> Spec Bool

(>) :: (Streamable a, OrdE a) => Spec a -> Spec a -> Spec Bool

not :: Spec Bool -> Spec Bool

(||) :: Spec Bool -> Spec Bool -> Spec Bool

(&&) :: Spec Bool -> Spec Bool -> Spec Bool

(^) :: Spec Bool -> Spec Bool -> Spec Bool

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

Boolean constants

data Bool

Constructors

False

True

Instances

Bounded Bool

Enum Bool

Eq Bool

Ord Bool

Show Bool

Assign Bool

Expr Bool

EqE Bool

Random Bool

Streamable Bool

Arithmetic operators (derived)

class (Eq a, Show a) => Num a where

Basic numeric class.

Minimal complete definition: all except negate or (-)

Methods

(+) :: a -> a -> a

(*) :: a -> a -> a

(-) :: a -> a -> a

negate :: a -> a

Unary negation.

abs :: a -> a

Absolute value.

signum :: a -> a

Sign of a number. The functions abs and signum should satisfy the law:

abs x * signum x == x

For real numbers, the signum is either -1 (negative), 0 (zero) or 1 (positive).

fromInteger :: Integer -> a

Conversion from an Integer. An integer literal represents the application of the function fromInteger to the appropriate value of type Integer, so such literals have type (Num a) => a.

Instances

Num Double

Num Float

Num Int

Num Int8

Num Int16

Num Int32

Num Int64

Num Integer

Num Word

Num Word8

Num Word16

Num Word32

Num Word64

Integral a => Num (Ratio a)

(Num a, NumE a, OrdE a) => Num (E a)

(Streamable a, NumE a) => Num (Spec a)

Division

class Num a => Fractional a where

Fractional numbers, supporting real division.

Minimal complete definition: fromRational and (recip or (/))

Methods

(/) :: a -> a -> a

fractional division

Instances

Fractional Double

Fractional Float

Integral a => Fractional (Ratio a)

(OrdE a, NumE a, Num a, Fractional a) => Fractional (E a)

(Streamable a, NumE a, Fractional a) => Fractional (Spec a)

mux :: Streamable a => Spec Bool -> Spec a -> Spec a -> Spec a

Beware : both sides are executed, even if the result of one is later discarded

class (Streamable a, Integral a) => CastIntTo a where

Methods

cast :: (Streamable b, IntegralE b) => Spec b -> Spec a

Instances

CastIntTo Int8

CastIntTo Int16

CastIntTo Int32

CastIntTo Int64

CastIntTo Word8

CastIntTo Word16

CastIntTo Word32

CastIntTo Word64

The next functions are used only to coerce the type of their argument

bool :: Spec Bool -> Spec Bool

int8 :: Spec Int8 -> Spec Int8

int16 :: Spec Int16 -> Spec Int16

int32 :: Spec Int32 -> Spec Int32

int64 :: Spec Int64 -> Spec Int64

word8 :: Spec Word8 -> Spec Word8

word16 :: Spec Word16 -> Spec Word16

word32 :: Spec Word32 -> Spec Word32

word64 :: Spec Word64 -> Spec Word64

float :: Spec Float -> Spec Float

double :: Spec Double -> Spec Double

The next functions provide easier access to typed external variables.

extB :: Var -> Phase -> Spec Bool

extI8 :: Var -> Phase -> Spec Int8

extI16 :: Var -> Phase -> Spec Int16

extI32 :: Var -> Phase -> Spec Int32

extI64 :: Var -> Phase -> Spec Int64

extW8 :: Var -> Phase -> Spec Word8

extW16 :: Var -> Phase -> Spec Word16

extW32 :: Var -> Phase -> Spec Word32

extW64 :: Var -> Phase -> Spec Word64

extF :: Var -> Phase -> Spec Float

extD :: Var -> Phase -> Spec Double

Set of operators from which to choose during the generation of random streams

opsF :: Operators

opsF2 :: Operators

opsF, opsF2 and opsF3 are feeded to Tests.Random.randomStreams. They allows the random generated streams to include lots of operators. If you add a new operator to Copilot, it would be nice to add it to one of those, that way it could be used in the random streams used for testing. opsF holds all the operators of arity 1, opsF2 of arity 2 and opsF3 of arity3 They are StreamableMaps, because operators are sorted based on their return type.

opsF3 :: Operators

Constructs of the copilot language

var :: Streamable a => Var -> Spec a

Stream variable reference

const :: Streamable a => a -> Spec a

A constant stream

drop :: Streamable a => Int -> Spec a -> Spec a

Drop i elements from a stream.

(++) :: Streamable a => [a] -> Spec a -> Spec a

Just a trivial wrapper over the Append constructor

(.=) :: Streamable a => Var -> Spec a -> Streams

Define a stream variable.

(..|) :: Sendable a => Send a -> Sends -> Sends

Allows to build a Sends from specification

The next functions are typed variable declarations to help the type-checker.

varB :: Var -> Spec Bool

varI8 :: Var -> Spec Int8

varI16 :: Var -> Spec Int16

varI32 :: Var -> Spec Int32

varI64 :: Var -> Spec Int64

varW8 :: Var -> Spec Word8

varW16 :: Var -> Spec Word16

varW32 :: Var -> Spec Word32

varW64 :: Var -> Spec Word64

varF :: Var -> Spec Float

varD :: Var -> Spec Double

The next functions help typing the send operations

sendW8 :: Var -> (Phase, Port) -> Send Word8

Typed constant declarations.

constB :: Bool -> Spec Bool

constI8 :: Int8 -> Spec Int8

constI16 :: Int16 -> Spec Int16

constI32 :: Int32 -> Spec Int32

constI64 :: Int64 -> Spec Int64

constW8 :: Word8 -> Spec Word8

constW16 :: Word16 -> Spec Word16

constW32 :: Word32 -> Spec Word32

constW64 :: Word64 -> Spec Word64

constF :: Float -> Spec Float

constD :: Double -> Spec Double