Data.Propagator.Hetero

This module exports the types and functions needed to create cells of heterogeneous types, manipulate their data and wire them up for data propagation.

Networks

data Network

A network consists of cells and connections which propagate data between them.

empty :: Network

Represents an empty network.

data Error

Represents possible errors that may occur when modifying or using a network.

Constructors

InvalidCell (Some CellKey)

The specified cell could not be found.

InvalidConnect ConnectKey

The specified connection could not be found.

NoPropagation ConnectKey

The specified connection did not produce a value.

Conflict (Some CellKey)

The old value of the specified cell is incompatible with a new value propagated to it.

data Propagator a

Network modifications and data propagations are captured by the Propagator monad.

Instances

Applicative Propagator

Defined in Data.Propagator.Hetero

Methods

pure :: a -> Propagator a

(<*>) :: Propagator (a -> b) -> Propagator a -> Propagator b

liftA2 :: (a -> b -> c) -> Propagator a -> Propagator b -> Propagator c

(*>) :: Propagator a -> Propagator b -> Propagator b

(<*) :: Propagator a -> Propagator b -> Propagator a

Functor Propagator

Defined in Data.Propagator.Hetero

Methods

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

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

Monad Propagator

Defined in Data.Propagator.Hetero

Methods

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

(>>) :: Propagator a -> Propagator b -> Propagator b

return :: a -> Propagator a

runPropagator :: Propagator a -> Network -> Either Error (Network, a)

Applies modifications captured by the propagator monad to a network, thus producing a new network if no error occurred.

Cells

newtype CellKey (a :: Type)

Represents a unique identification of a network cell.

Such an identification should not be constructed manually, or else InvalidCell errors are possible. The raw identification is exposed for situations where cells should be managed externally, like in an IntMap.

Constructors

CellKey

Fields

• rawCellKey :: Int

Instances

Show (CellKey a)

Defined in Data.Propagator.Hetero

Methods

showsPrec :: Int -> CellKey a -> ShowS

show :: CellKey a -> String

showList :: [CellKey a] -> ShowS

Eq (CellKey a)

Defined in Data.Propagator.Hetero

Methods

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

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

Ord (CellKey a)

Defined in Data.Propagator.Hetero

Methods

compare :: CellKey a -> CellKey a -> Ordering

(<) :: CellKey a -> CellKey a -> Bool

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

(>) :: CellKey a -> CellKey a -> Bool

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

max :: CellKey a -> CellKey a -> CellKey a

min :: CellKey a -> CellKey a -> CellKey a

data CellKeys ts where

Represents a list of cell identifications of heterogeneous types.

Constructors

KNil :: CellKeys '[]

KCons :: CellKey a -> CellKeys ts -> CellKeys (a ': ts) infixr 3

data CellValues ts where

Represents a list of cell values of heterogeneous types.

Constructors

VNil :: CellValues '[]

VCons :: a -> CellValues ts -> CellValues (a ': ts) infixr 3

data Change a

Represents a potential change of a cell value.

Constructors

Changed a

Indicates that a cell value has been changed to the new value a.

Unchanged a

Indicates that a cell value did not change, i.e. needs no propagation.

Incompatible

Indicates that a new cell value contradicts the one that is already stored in the cell.

Instances

Applicative Change

Defined in Data.Propagator.Change

Methods

pure :: a -> Change a

(<*>) :: Change (a -> b) -> Change a -> Change b

liftA2 :: (a -> b -> c) -> Change a -> Change b -> Change c

(*>) :: Change a -> Change b -> Change b

(<*) :: Change a -> Change b -> Change a

Functor Change

Defined in Data.Propagator.Change

Methods

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

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

Monad Change

Defined in Data.Propagator.Change

Methods

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

(>>) :: Change a -> Change b -> Change b

return :: a -> Change a

Show a => Show (Change a)

Defined in Data.Propagator.Change

Methods

showsPrec :: Int -> Change a -> ShowS

show :: Change a -> String

showList :: [Change a] -> ShowS

Eq a => Eq (Change a)

Defined in Data.Propagator.Change

Methods

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

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

Ord a => Ord (Change a)

Defined in Data.Propagator.Change

Methods

compare :: Change a -> Change a -> Ordering

(<) :: Change a -> Change a -> Bool

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

(>) :: Change a -> Change a -> Bool

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

max :: Change a -> Change a -> Change a

min :: Change a -> Change a -> Change a

cell

Arguments

:: (CellKey a -> a)

Function which produces the initial value of the cell.

-> (a -> a -> Change a)

A function that describes how to join an existing cell value with a new one that the cell has received via propagation.

-> Propagator (CellKey a)

The identification of the newly constructed cell.

Constructs a new cell with a given initial value and a function which defines how to react if a new value is about to be written to the cell.

readCell :: CellKey a -> Propagator a

Reads the value of a specific cell.

writeCell :: a -> CellKey a -> Propagator ()

Writes a new value to a specific cell and starts to propagate potential changes through the network of connected cells.

removeCell :: CellKey a -> Propagator ()

Removes a cell from the network. This also removes all connections related to the cell.

label :: (a -> [b]) -> (b -> a) -> [CellKey a] -> Propagator [[b]]

If the content of a cell is an accumulation of multiple values [b], and every value b itself can be used as content a for the cell, then we can write every value b one after another to the cell and check if the network converges to a successful state.

As a result, we can enumerate all possible combinations of valid values for a given set of cells. This is often used in constraint solving algorithms.

This function does not perform any permanent network modifications.

Connections

newtype ConnectKey

Represents a unique identification of a network connection.

Such an identification should not be constructed manually, or else InvalidConnect errors are possible. The raw identification is exposed for situations where connections should be managed externally, like in an IntMap.

Constructors

ConnectKey

Fields

• rawConnectKey :: Int

Instances

Show ConnectKey

Defined in Data.Propagator.Hetero

Methods

showsPrec :: Int -> ConnectKey -> ShowS

show :: ConnectKey -> String

showList :: [ConnectKey] -> ShowS

Eq ConnectKey

Defined in Data.Propagator.Hetero

Methods

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

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

Ord ConnectKey

Defined in Data.Propagator.Hetero

Methods

compare :: ConnectKey -> ConnectKey -> Ordering

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

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

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

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

max :: ConnectKey -> ConnectKey -> ConnectKey

min :: ConnectKey -> ConnectKey -> ConnectKey

data ConnectState

When connecting cells, the ConnectState defines the initial behaviour of the connection.

Constructors

Live

The connection immediately starts to propagate data between the connected cells.

Idle

The connection is established, but no initial data propagation takes place.

Instances

Show ConnectState

Defined in Data.Propagator.Hetero

Methods

showsPrec :: Int -> ConnectState -> ShowS

show :: ConnectState -> String

showList :: [ConnectState] -> ShowS

Eq ConnectState

Defined in Data.Propagator.Hetero

Methods

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

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

Ord ConnectState

Defined in Data.Propagator.Hetero

Methods

compare :: ConnectState -> ConnectState -> Ordering

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

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

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

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

max :: ConnectState -> ConnectState -> ConnectState

min :: ConnectState -> ConnectState -> ConnectState

connect :: ConnectState -> CellKey a -> CellKey b -> (a -> Maybe b) -> Propagator ConnectKey

Connects a source cell to a target cell in order to propagate changes from the source to the target. The returned ConnectKey can be used to remove the connection via disconnect.

connect_ :: ConnectState -> CellKey a -> CellKey b -> (a -> Maybe b) -> Propagator ()

Same as connect, but discards the returned ConnectKey.

sync :: ConnectState -> CellKey a -> CellKey a -> Propagator (ConnectKey, ConnectKey)

Connects and synchronizes two cells, i.e. new values are propagated from the source to the target cell, and vice versa. Short form of syncWith Just Just.

sync_ :: ConnectState -> CellKey a -> CellKey a -> Propagator ()

Same as sync, but discards the returned ConnectKeys.

syncWith :: (a -> Maybe b) -> (b -> Maybe a) -> ConnectState -> CellKey a -> CellKey b -> Propagator (ConnectKey, ConnectKey)

Connects and synchronizes two cells using two translation functions f and g, i.e. new values are propagated from the source to the target cell using f, and vice versa using g.

syncWith_ :: (a -> Maybe b) -> (b -> Maybe a) -> ConnectState -> CellKey a -> CellKey b -> Propagator ()

Same as syncWith, but discards the returned ConnectKeys.

combine :: ConnectState -> CellKey a -> CellKey b -> CellKey c -> (a -> b -> Maybe c) -> Propagator ConnectKey

Connects two source cells to a target cell in order to propagate changes from the sources to the target. The returned ConnectKey can be used to remove the connection via disconnect.

combine_ :: ConnectState -> CellKey a -> CellKey b -> CellKey c -> (a -> b -> Maybe c) -> Propagator ()

Same as combine, but discards the returned ConnectKey.

combineMany :: ConnectState -> CellKeys ts -> CellKey a -> (CellValues ts -> Maybe a) -> Propagator ConnectKey

Connects several source cells to a target cell in order to propagate changes from the sources to the target. The returned ConnectKey can be used to remove the connection via disconnect.

combineMany_ :: ConnectState -> CellKeys ts -> CellKey a -> (CellValues ts -> Maybe a) -> Propagator ()

Same as combineMany, but discards the returned ConnectKey.

distribute :: ConnectState -> CellKey a -> [CellKey b] -> (a -> Maybe b) -> Propagator ConnectKey

Connects a source cells to several target cells in order to propagate changes from the source to the targets. The returned ConnectKey can be used to remove the connection via disconnect.

distribute_ :: ConnectState -> CellKey a -> [CellKey b] -> (a -> Maybe b) -> Propagator ()

Same as distribute, but discards the returned ConnectKey.

manyToMany :: ConnectState -> CellKeys xs -> [CellKey a] -> (CellValues xs -> Maybe a) -> Propagator ConnectKey

Connects several source cells to several target cells in order to propagate changes from the sources to the targets. The returned ConnectKey can be used to remove the connection via disconnect.

manyToMany_ :: ConnectState -> CellKeys xs -> [CellKey a] -> (CellValues xs -> Maybe a) -> Propagator ()

Same as manyToMany, but discards the returned ConnectKey.

disconnect :: ConnectKey -> Propagator ()

Removes a connection from the network.

Numeric

plus :: Num a => ConnectState -> CellKey a -> CellKey a -> CellKey a -> Propagator ()

plus s a b c connects three cells using the following propagation schema:

• a + b is propagated to c if a or b changes.
• c - b is propagated to a if b or c changes.
• c - a is propagated to b if a or c changes.

minus :: Num a => ConnectState -> CellKey a -> CellKey a -> CellKey a -> Propagator ()

minus s a b c connects three cells using the following propagation schema:

• a - b is propagated to c if a or b changes.
• b + c is propagated to a if b or c changes.
• a - c is propagated to b if a or c changes.

times :: Num a => ConnectState -> CellKey a -> CellKey a -> CellKey a -> Propagator ()

times s a b c connects three cells using the following propagation schema:

• a * b is propagated to c if a or b changes.

timesWith :: Num a => (a -> a -> a) -> ConnectState -> CellKey a -> CellKey a -> CellKey a -> Propagator ()

timesWith divOp s a b c connects three cells using the following propagation schema:

• a * b is propagated to c if a or b changes.
• divOp c b is propagated to a if b or c changes.
• divOp c a is propagated to b if a or c changes.

abs :: Num a => ConnectState -> CellKey a -> CellKey a -> Propagator ()

abs s a b connects two cells using the following propagation schema:

• |a| is propagated to b if a changes.

absWith :: Num a => (a -> a) -> ConnectState -> CellKey a -> CellKey a -> Propagator ()

absWith inv s a b connects two cells using the following propagation schema:

• |a| is propagated to b if a changes.
• inv b is propagated to a if b changes.

negate :: Num a => ConnectState -> CellKey a -> CellKey a -> Propagator ()

negate s a b connects two cells using the following propagation schema:

• -a is propagated to b if a changes.
• -b is propagated to a if b changes.

signum :: Num a => ConnectState -> CellKey a -> CellKey a -> Propagator ()

signum s a b connects two cells using the following propagation schema:

• Prelude.signum a is propagated to b if a changes.

signumWith :: Num a => (a -> a) -> ConnectState -> CellKey a -> CellKey a -> Propagator ()

signumWith inv s a b connects two cells using the following propagation schema:

• Prelude.signum a is propagated to b if a changes.
• inv b is propagated to a if b changes.