Mida.Language

Documentation

type SyntaxTree = [Sel]

Syntax tree in our case is just a collection of syntactic elements.

data Sel

Syntactic element corresponds to language features. Some of them have direct corresponding constructor in Element, others have to be simplified first.

Constructors

Value Natural

Literal value

Section [Sel]

Section

Multi [Sel]

Multivalue

CMulti [([Sel], [Sel])]

Conditional multivalue

Reference String

Reference (name of variable)

Range Natural Natural

Range of values

Product Sel Sel

Product of principles

Division Sel Sel

Division of principles

Sum Sel Sel

Sum of principles

Diff Sel Sel

Subtraction of principles

Loop Sel Sel

Loop

Rotation Sel Sel

Rotation

Reverse Sel

Reversed principle

Instances

Eq Sel

Show Sel

type Principle = [Element Natural]

Collection of elements for evaluation, representation of some aspect of voice.

data Element a

Fundamental type representing an atom for evaluation.

Constructors

Val a

Single value, evaluates to itself

Sec [Element a]

Universal container for other values

Mul [Element a]

Multivalue, the way to introduce varying elements

CMul [([Element a], [Element a])]

Conditional multivalue

Instances

Functor Element

Applicative Element

Foldable Element

Eq a => Eq (Element a)

Show a => Show (Element a)

data MidaEnv m a

Monad that implements MIDA environment.

Instances

Monad m => Monad (MidaEnv m)

Functor m => Functor (MidaEnv m)

Monad m => Applicative (MidaEnv m)

MonadThrow m => MonadThrow (MidaEnv m)

MonadCatch m => MonadCatch (MidaEnv m)

MonadMask m => MonadMask (MidaEnv m)

MonadIO m => MonadIO (MidaEnv m)

MonadException m => MonadException (MidaEnv m)

Monad m => HasEnv (MidaEnv m)

class Monad m => HasEnv m where

Type class for things that can be considered MIDA environment.

Methods

getDefs :: m Defs

Get collection of all definitions.

setDefs :: Defs -> m ()

Update definitions with given ones.

setRandGen :: Natural -> m ()

Set random generator seed.

newRandGen :: m TFGen

Split current random generator, update it, and return new one.

Instances

Monad m => HasEnv (MidaEnv m)

HasEnv m => HasEnv (ReaderT e m)

HasEnv m => HasEnv (StateT e m)

runMidaEnv :: Monad m => MidaEnv m a -> m a

Run state monad with MIDA environment.

addDef

Arguments

:: HasEnv m

=> String

Reference name

-> SyntaxTree

AST of its principle

-> m ()

Add a new definition to the environment.

remDef

Arguments

:: HasEnv m

=> String

Reference name

-> m ()

Remove definition given its name.

clearDefs :: HasEnv m => m ()

Remove all definitions, restoring default state of environment.

getPrin

Arguments

:: HasEnv m

=> String

Reference name

-> m SyntaxTree

Syntax tree

Get principle corresponding to given variable name.

getSrc

Arguments

:: HasEnv m

=> String

Reference name

-> m Text

Textual representation of source code

Get source code of definition given its name.

fullSrc :: HasEnv m => m Text

Reconstruct source code for all existing definitions.

getRefs :: HasEnv m => m [String]

Get all reference names defined at the moment.

purgeEnv

Arguments

:: HasEnv m

=> [String]

Top-level definitions

-> m ()

Purge environment removing definitions that are not used in construction of “top-level” definitions.

checkRecur

Arguments

:: HasEnv m

=> String

Reference name

-> SyntaxTree

Its syntax tree

-> m Bool

Check if definition with given name is depends on itself.

evalDef

Arguments

:: HasEnv m

=> String

Reference name

-> m [Natural]

Infinite stream of naturals or empty list

Evaluate definition given its name.

eval

Arguments

:: HasEnv m

=> SyntaxTree

Syntax tree

-> m [Natural]

Infinite stream of naturals or empty list

Evaluate given syntax tree.

toPrin

Arguments

:: HasEnv m

=> SyntaxTree

Syntax tree to transform

-> m Principle

Resulting principle

Transform SyntaxTree into Principle applying all necessary transformations and resolving references.