Alga.Language

Documentation

type SyntaxTree = [Sel]

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

data Sel

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

Constructors

Value NRatio

Literal value

Section [Sel]

Section

Multi [Sel]

Multivalue

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

Conditional multivalue

Reference String

Reference (name of variable)

Range NRatio NRatio

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

Methods

(==) :: Sel -> Sel -> Bool

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

Show Sel

Methods

showsPrec :: Int -> Sel -> ShowS

show :: Sel -> String

showList :: [Sel] -> ShowS

Arbitrary Sel

Methods

arbitrary :: Gen Sel

shrink :: Sel -> [Sel]

data Statement

Statement can be either definition or exposition. Expositions are only used in REPL.

Constructors

Definition String SyntaxTree

Exposition SyntaxTree

Instances

Eq Statement

Methods

(==) :: Statement -> Statement -> Bool

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

Show Statement

Methods

showsPrec :: Int -> Statement -> ShowS

show :: Statement -> String

showList :: [Statement] -> ShowS

Arbitrary Statement

Methods

arbitrary :: Gen Statement

shrink :: Statement -> [Statement]

type Principle = [Element NRatio]

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

type NRatio = Ratio Natural

Non-negative rational number is the best choice for our purposes, hence the synonym.

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 (NonEmpty ([Element a], [Element a]))

Conditional multivalue

Instances

Functor Element

Methods

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

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

Applicative Element

Methods

pure :: a -> Element a

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

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

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

Foldable Element

Methods

fold :: Monoid m => Element m -> m

foldMap :: Monoid m => (a -> m) -> Element a -> m

foldr :: (a -> b -> b) -> b -> Element a -> b

foldr' :: (a -> b -> b) -> b -> Element a -> b

foldl :: (b -> a -> b) -> b -> Element a -> b

foldl' :: (b -> a -> b) -> b -> Element a -> b

foldr1 :: (a -> a -> a) -> Element a -> a

foldl1 :: (a -> a -> a) -> Element a -> a

toList :: Element a -> [a]

null :: Element a -> Bool

length :: Element a -> Int

elem :: Eq a => a -> Element a -> Bool

maximum :: Ord a => Element a -> a

minimum :: Ord a => Element a -> a

sum :: Num a => Element a -> a

product :: Num a => Element a -> a

Eq a => Eq (Element a)

Methods

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

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

Show a => Show (Element a)

Methods

showsPrec :: Int -> Element a -> ShowS

show :: Element a -> String

showList :: [Element a] -> ShowS

data AlgaEnv m a

Monad that implements ALGA environment.

Instances

Monad m => Monad (AlgaEnv m)

Methods

(>>=) :: AlgaEnv m a -> (a -> AlgaEnv m b) -> AlgaEnv m b

(>>) :: AlgaEnv m a -> AlgaEnv m b -> AlgaEnv m b

return :: a -> AlgaEnv m a

fail :: String -> AlgaEnv m a

Functor m => Functor (AlgaEnv m)

Methods

fmap :: (a -> b) -> AlgaEnv m a -> AlgaEnv m b

(<$) :: a -> AlgaEnv m b -> AlgaEnv m a

Monad m => Applicative (AlgaEnv m)

Methods

pure :: a -> AlgaEnv m a

(<*>) :: AlgaEnv m (a -> b) -> AlgaEnv m a -> AlgaEnv m b

(*>) :: AlgaEnv m a -> AlgaEnv m b -> AlgaEnv m b

(<*) :: AlgaEnv m a -> AlgaEnv m b -> AlgaEnv m a

MonadIO m => MonadIO (AlgaEnv m)

Methods

liftIO :: IO a -> AlgaEnv m a

MonadThrow m => MonadThrow (AlgaEnv m)

Methods

throwM :: Exception e => e -> AlgaEnv m a

MonadCatch m => MonadCatch (AlgaEnv m)

Methods

catch :: Exception e => AlgaEnv m a -> (e -> AlgaEnv m a) -> AlgaEnv m a

MonadMask m => MonadMask (AlgaEnv m)

Methods

mask :: ((forall a. AlgaEnv m a -> AlgaEnv m a) -> AlgaEnv m b) -> AlgaEnv m b

uninterruptibleMask :: ((forall a. AlgaEnv m a -> AlgaEnv m a) -> AlgaEnv m b) -> AlgaEnv m b

MonadException m => MonadException (AlgaEnv m)

Methods

controlIO :: (RunIO (AlgaEnv m) -> IO (AlgaEnv m a)) -> AlgaEnv m a

Monad m => HasEnv (AlgaEnv m)

Methods

getDefs :: AlgaEnv m Defs

setDefs :: Defs -> AlgaEnv m ()

setRandGen :: Natural -> AlgaEnv m ()

newRandGen :: AlgaEnv m TFGen

class Monad m => HasEnv m where

Type class for things that can be considered ALGA environment.

Minimal complete definition

getDefs, setDefs, setRandGen, newRandGen

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 (AlgaEnv m)

Methods

getDefs :: AlgaEnv m Defs

setDefs :: Defs -> AlgaEnv m ()

setRandGen :: Natural -> AlgaEnv m ()

newRandGen :: AlgaEnv m TFGen

HasEnv m => HasEnv (StateT e m)

Methods

getDefs :: StateT e m Defs

setDefs :: Defs -> StateT e m ()

setRandGen :: Natural -> StateT e m ()

newRandGen :: StateT e m TFGen

HasEnv m => HasEnv (ReaderT * e m)

Methods

getDefs :: ReaderT * e m Defs

setDefs :: Defs -> ReaderT * e m ()

setRandGen :: Natural -> ReaderT * e m ()

newRandGen :: ReaderT * e m TFGen

runAlgaEnv :: Monad m => AlgaEnv m a -> m a

Run state monad with ALGA 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 [NRatio]

Infinite stream of naturals or empty list

Evaluate definition given its name.

eval

Arguments

:: HasEnv m

=> SyntaxTree

Syntax tree

-> m [NRatio]

Infinite stream of ratios 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.