Lava.Generic

Documentation

data Struct a

Constructors

Compound [Struct a]

Object a

Instances

Functor Struct

Methods

fmap :: (a -> b) -> Struct a -> Struct b

(<$) :: a -> Struct b -> Struct a

Sequent Struct

Methods

sequent :: Monad m => Struct (m a) -> m (Struct a)

Eq a => Eq (Struct a)

Methods

(==) :: Struct a -> Struct a -> Bool

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

Show a => Show (Struct a)

Methods

showsPrec :: Int -> Struct a -> ShowS

show :: Struct a -> String

showList :: [Struct a] -> ShowS

flatten :: Struct a -> [a]

transStruct :: Struct [a] -> [Struct a]

class Generic a where

Minimal complete definition

struct, construct

Methods

struct :: a -> Struct Symbol

construct :: Struct Symbol -> a

Instances

Generic ()

Methods

struct :: () -> Struct Symbol

construct :: Struct Symbol -> ()

Generic Symbol

Methods

struct :: Symbol -> Struct Symbol

construct :: Struct Symbol -> Symbol

Generic a => Generic [a]

Methods

struct :: [a] -> Struct Symbol

construct :: Struct Symbol -> [a]

Generic (Signal a)

Methods

struct :: Signal a -> Struct Symbol

construct :: Struct Symbol -> Signal a

(Generic a, Generic b) => Generic (a, b)

Methods

struct :: (a, b) -> Struct Symbol

construct :: Struct Symbol -> (a, b)

(Generic a, Generic b, Generic c) => Generic (a, b, c)

Methods

struct :: (a, b, c) -> Struct Symbol

construct :: Struct Symbol -> (a, b, c)

(Generic a, Generic b, Generic c, Generic d) => Generic (a, b, c, d)

Methods

struct :: (a, b, c, d) -> Struct Symbol

construct :: Struct Symbol -> (a, b, c, d)

(Generic a, Generic b, Generic c, Generic d, Generic e) => Generic (a, b, c, d, e)

Methods

struct :: (a, b, c, d, e) -> Struct Symbol

construct :: Struct Symbol -> (a, b, c, d, e)

(Generic a, Generic b, Generic c, Generic d, Generic e, Generic f) => Generic (a, b, c, d, e, f)

Methods

struct :: (a, b, c, d, e, f) -> Struct Symbol

construct :: Struct Symbol -> (a, b, c, d, e, f)

(Generic a, Generic b, Generic c, Generic d, Generic e, Generic f, Generic g) => Generic (a, b, c, d, e, f, g)

Methods

struct :: (a, b, c, d, e, f, g) -> Struct Symbol

construct :: Struct Symbol -> (a, b, c, d, e, f, g)

data Ops

Constructors

Ops

Fields

• equalSymbol :: Symbol -> Symbol -> Signal Bool
• delaySymbol :: Symbol -> Symbol -> Symbol
• ifSymbol :: Signal Bool -> (Symbol, Symbol) -> Symbol
• varSymbol :: String -> Symbol
• zeroSymbol :: Symbol

opsBool :: Ops

opsInt :: Ops

unSignal :: Signal a -> Symbol

ops :: Symbol -> Ops

equal :: Generic a => (a, a) -> Signal Bool

delay :: Generic a => a -> a -> a

zeroify :: Generic a => a -> a

symbolize :: Generic a => String -> a -> a

pickSymbol :: Generic a => String -> a -> Symbol

class ConstructiveSig a where

Minimal complete definition

zeroSig, varSig, randomSig

Methods

zeroSig :: Signal a

varSig :: String -> Signal a

randomSig :: Rnd -> Signal a

Instances

ConstructiveSig Bool

Methods

zeroSig :: Signal Bool

varSig :: String -> Signal Bool

randomSig :: Rnd -> Signal Bool

ConstructiveSig Int

Methods

zeroSig :: Signal Int

varSig :: String -> Signal Int

randomSig :: Rnd -> Signal Int

class Generic a => Constructive a where

Minimal complete definition

zero, var, random

Methods

zero :: a

var :: String -> a

random :: Rnd -> a

Instances

Constructive ()

Methods

zero :: ()

var :: String -> ()

random :: Rnd -> ()

ConstructiveSig a => Constructive (Signal a)

Methods

zero :: Signal a

var :: String -> Signal a

random :: Rnd -> Signal a

(Constructive a, Constructive b) => Constructive (a, b)

Methods

zero :: (a, b)

var :: String -> (a, b)

random :: Rnd -> (a, b)

(Constructive a, Constructive b, Constructive c) => Constructive (a, b, c)

Methods

zero :: (a, b, c)

var :: String -> (a, b, c)

random :: Rnd -> (a, b, c)

(Constructive a, Constructive b, Constructive c, Constructive d) => Constructive (a, b, c, d)

Methods

zero :: (a, b, c, d)

var :: String -> (a, b, c, d)

random :: Rnd -> (a, b, c, d)

(Constructive a, Constructive b, Constructive c, Constructive d, Constructive e) => Constructive (a, b, c, d, e)

Methods

zero :: (a, b, c, d, e)

var :: String -> (a, b, c, d, e)

random :: Rnd -> (a, b, c, d, e)

(Constructive a, Constructive b, Constructive c, Constructive d, Constructive e, Constructive f) => Constructive (a, b, c, d, e, f)

Methods

zero :: (a, b, c, d, e, f)

var :: String -> (a, b, c, d, e, f)

random :: Rnd -> (a, b, c, d, e, f)

(Constructive a, Constructive b, Constructive c, Constructive d, Constructive e, Constructive f, Constructive g) => Constructive (a, b, c, d, e, f, g)

Methods

zero :: (a, b, c, d, e, f, g)

var :: String -> (a, b, c, d, e, f, g)

random :: Rnd -> (a, b, c, d, e, f, g)

zeroList :: Constructive a => Int -> [a]

varList :: Constructive a => Int -> String -> [a]

randomList :: Constructive a => Int -> Rnd -> [a]

splitRndList :: Rnd -> [Rnd]

valRnd :: Rnd -> Int

class ConstructiveSig a => FiniteSig a where

Minimal complete definition

domainSig

Methods

domainSig :: [Signal a]

Instances

FiniteSig Bool

Methods

domainSig :: [Signal Bool]

class Constructive a => Finite a where

Minimal complete definition

domain

Methods

domain :: [a]

Instances

Finite ()

Methods

domain :: [()]

FiniteSig a => Finite (Signal a)

Methods

domain :: [Signal a]

(Finite a, Finite b) => Finite (a, b)

Methods

domain :: [(a, b)]

(Finite a, Finite b, Finite c) => Finite (a, b, c)

Methods

domain :: [(a, b, c)]

(Finite a, Finite b, Finite c, Finite d) => Finite (a, b, c, d)

Methods

domain :: [(a, b, c, d)]

(Finite a, Finite b, Finite c, Finite d, Finite e) => Finite (a, b, c, d, e)

Methods

domain :: [(a, b, c, d, e)]

(Finite a, Finite b, Finite c, Finite d, Finite e, Finite f) => Finite (a, b, c, d, e, f)

Methods

domain :: [(a, b, c, d, e, f)]

(Finite a, Finite b, Finite c, Finite d, Finite e, Finite f, Finite g) => Finite (a, b, c, d, e, f, g)

Methods

domain :: [(a, b, c, d, e, f, g)]

domainList :: Finite a => Int -> [[a]]

class Choice a where

Minimal complete definition

ifThenElse

Methods

ifThenElse :: Signal Bool -> (a, a) -> a

Instances

Choice ()

Methods

ifThenElse :: Signal Bool -> ((), ()) -> ()

Choice Symbol

Methods

ifThenElse :: Signal Bool -> (Symbol, Symbol) -> Symbol

Choice a => Choice [a]

Methods

ifThenElse :: Signal Bool -> ([a], [a]) -> [a]

Choice (Signal a)

Methods

ifThenElse :: Signal Bool -> (Signal a, Signal a) -> Signal a

Choice b => Choice (a -> b)

Methods

ifThenElse :: Signal Bool -> (a -> b, a -> b) -> a -> b

(Choice a, Choice b) => Choice (a, b)

Methods

ifThenElse :: Signal Bool -> ((a, b), (a, b)) -> (a, b)

(Choice a, Choice b, Choice c) => Choice (a, b, c)

Methods

ifThenElse :: Signal Bool -> ((a, b, c), (a, b, c)) -> (a, b, c)

(Choice a, Choice b, Choice c, Choice d) => Choice (a, b, c, d)

Methods

ifThenElse :: Signal Bool -> ((a, b, c, d), (a, b, c, d)) -> (a, b, c, d)

(Choice a, Choice b, Choice c, Choice d, Choice e) => Choice (a, b, c, d, e)

Methods

ifThenElse :: Signal Bool -> ((a, b, c, d, e), (a, b, c, d, e)) -> (a, b, c, d, e)

(Choice a, Choice b, Choice c, Choice d, Choice e, Choice f) => Choice (a, b, c, d, e, f)

Methods

ifThenElse :: Signal Bool -> ((a, b, c, d, e, f), (a, b, c, d, e, f)) -> (a, b, c, d, e, f)

(Choice a, Choice b, Choice c, Choice d, Choice e, Choice f, Choice g) => Choice (a, b, c, d, e, f, g)

Methods

ifThenElse :: Signal Bool -> ((a, b, c, d, e, f, g), (a, b, c, d, e, f, g)) -> (a, b, c, d, e, f, g)

mux :: Choice a => (Signal Bool, (a, a)) -> a

strongZipWith :: (a -> b -> c) -> [a] -> [b] -> [c]

lazyZipWith :: (a -> b -> c) -> [a] -> [b] -> [c]