mmadt-notes.asciidoc

![mmadt-logo](https://www.mm-adt.org/assets/images/mm-adt-logo.png)

There are two kinds of objects in mm-ADT: types and values.

Values

1, 6, -5 ~> int values
true false ~> bool values
'ab' 'mab' ~> str values
0.3 32.78 ~> real values
['age':29] ~> rec values
[plus,2] ~> inst values

Canonical Types

int ~> a single int value
bool
str
real
rec
inst

Quantified Types

int{1,4} ~> one to four int values
int{4} ~> four int values
int{0.37} ~> a fuzzy int value
int{u_matrix} ~> an integer in quantum superposition

Quantifiers can come from any ordered ring with unity (see SRT: https://zenodo.org/record/2565243). Interestingly, mm-ADT instructions form a ring with unity (* is function composition and + is branching).

Refinement Types

int[is,[gt,5]] ~> a single int value greater than 5
int[is>5] ~> sugar syntax for the previous
int[is>5&<10] ~> a single int value between 5 and 10
int[choose[1,5,10]] ~> a single int value drawn from the enumerated choices
int[1|5|10] ~> sugar syntax for the previous
[1|5|10] ~> sugar syntax for the previous

Union Types

obj[choose,[int,bool,str]] ~> an int or bool or str
[int|bool|str] ~> sugar syntax for the previous
[int[is>2]|true|str{?}] ~> an int greater than 2 or the true bool value or a str or nothing.

Option/None/Some

int{0,1} ~> 0 or 1 int (Option)
int{?} ~> syntax sugar for the previous
int{0,0} ~> 0 ints (None)
int{0} ~> syntax sugar for the previous
int{1} ~> 1 int (Some)
int ~> syntax sugar for the previous

The sugars on quantifiers are: ? (zero or one), + (one or more), * (zero or more).

Certain vs. Potential

int => int[is,[gt,4]]   // embed the LHS obj into the RHS type

int{?}<=int[is,[gt,4]]  // the previous yields a int{?} range compilation (optional: some or none)
   int<=int[is,[gt,4]]  // force an int range (some) -- if range isn't met, failing type check

Embedded Types

int[plus,2] ~> an int embedded in the same ordered interger space shifted by 2
bool⇐int[gt,3] ~> a non-injective/surjective mapping from int to bool

[int[is>2]
|true
|str{?}[plus,'mm']]        ~> a int greater than 2, or a true value, or maybe a string with mm appended to it.

The Processor/Traverser Monad

Processor[Obj,Type,Model] Traverser[Obj,Type,Model,State]

A processor gets an input (stream) and embeds it into the provided type (query). The model is a read-only data structure specifying rewrites/schemas/global_values. A processor can be thought of as a "swarm" of traversers obeying the rules of the model.
A traverser references an obj and maintains a thread-local, read/write variable state accessed via [to] and [from] instructions.

I believe that a processor is just a traverser that controls an "internal swarm." Traversers/processes are computational context’s for the traversers/processes boxed within. Model and state should be one. And a model-state is read/write for the single traverser, but then read-only for the nested traverser swarm. Moving between swarms (model-ADTs) will be via [=rdf],[=neo4j],[=spark],[=kvstore], … This is what "freezes parental context" and spawns a new computational process. Communication between context’s is via

      ATraverser[A[Obj],Model-State] <=[=adt]=> BTraverser[B[Obj],Model-State]

okram/mmadt-notes.asciidoc