proj-oot-ootCoreNotes2

thinking about the bit on models of computation i just wrote, some primitives for oot: pointer (turing head location in memory) array (turing tape, imperatives) goto, while (imps) integers in variables functions in variable, function application logic gates if 2d arrays (automata) copying an expression in one step (cow) expressions linear lists of code variable environemnts (lambda) mu successor functions with multiple arguments function composition recursion, primitive recursion expression trees selection structural equality nock operator

other common concepts: call stacks strings dicts lists regex db tables relation? types maps, folds what from logic programming? transition table grammar category theory? lattices? ordering relations?

can strings, cellular automata, etc be generalized with a 'topology' (or is this a geometry? i think topology) on top of something unstructured like a graph? is this like oot. pattersn/graph regexs/structural types? relatio to Chu spaces?

---

some more stack ops:

FLAG: place an opaque 'flag' on the stack CLEAR-TO-FLAG, ROT-TO-FLAG, etc; applied in the section from the top of the stack (TOS) down to the first flag

a 'flag' is like an Oot 'boundary' and maybe the command should be called STACKBOUND instead of FLAG.

(http://www.reocities.com/connorbd/varaq/varaqspec.html has this)

---

also might want list-to-stack and stack-to-list ops; e.g. SHATTER to 'Reduces a list to its component elements and pushes them on the stack in order' [1] and CONSUME n or CONSUME-TO-BOUNDARY to take the first n elements of the stack (or all elements up to a BOUNDARY) and return them as a list

(http://www.reocities.com/connorbd/varaq/varaqspec.html has this)

also http://www.reocities.com/connorbd/varaq/varaqspec.html has

• empty? 'Examines a list on the stack and returns 1 if its value is null (pagh), a 0 if it contains anything.'
• split 'Pops a list off the stack and returns the first item and the rest of the list.'
• cons 'Takes an object and adds it to the head of a list. Equivalent to the LISP cons operator. '

---

http://www.reocities.com/connorbd/varaq/varaqspec.html also has some interesting stack-to-string ops:

• strtie 'Concatenates the top two strings on the stack into one.'
• compose 'Pops objects (executing proc objects if necessary) off the stack until a marker (placed by qaw) is hit and combines them into one string. '
• streq 'Pops the top two strings on the stack, compares them, and returns 1 if identical, 0 if not. '
• strcut 'Pops two values and a string and returns the section of the string between character startval and character endval.'
• strmeasure 'Pops a string off the stack and returns its length in characters. '
• explode 'Separates individual "words" in a string by whitespace.'

---

http://www.reocities.com/connorbd/varaq/varaqspec.html control flow and variables:

• by default, names are lookup up if defined, like LISP. There is a quote operator that allow the name itself to be specified.
• there is a 'set' operator to assign to a name
• there is an 'eval'
• there is an 'ifyes' and an 'ifno'
• there is a 'return' (they call it 'escape')
• there is a 'repeat'

---

[Self-proj-plbook-plChModelsOfComputation], and also the notes in section 'some ideas relating to generalizing/translating the instructions of Nock' in [Self-proj-oot-ootNotes12], make me think that defining an Oot core might just be picking one thing for each of these roles;

eg for Nock:

• what is the thing that is like an atom in Nock
• what is the thing that is like a cell in Nock
• what is the thing that is like the state in Nock
• what is the thing that is like the cons in Nock
• what is the thing that is like the instruction in Nock
• what is the thing that is like the select instruction in Nock
• what is the thing that is like the arg instruction in Nock
• what is the thing that is like the Nock instruction in Nock (the S combinator in combinatorial calc)
• what is the thing that is like the isCell instruction in Nock
• what is the thing that is like the addition instruction in Nock
• what is the thing that is like the structural equality instruction in Nock

and for the "another writeup" section of [Self-proj-plbook-plChModelsOfComputation]:

• what is the thing that provides data executed as code?
• what is the thing that provides abstraction?
• what is the thing that provides extensible memory?
• what is the thing that provides conditionals?
• what is the thing that provides looping?

and for the lambda calc model:

• what is the thing that is like substitution in lambda calc?
• what is the thing that is like variables in lambda calc? etc

and for the turing machine model:

• what is the thing that is like pointers in turing machines?
• what is the thing that is like instruction words in turing machines?
• what is the thing that is like the tape in turing machines? etc

and for the imperative language with WHILE model:

• what is the thing that is like while loops imperative languages with WHILE?

etc

and for Haskell:

• what is the thing that is like lists in Haskell?
• what is the thing that is partial function application in Haskell?
• what is the thing that is currying in Haskell?
• what is the thing that is types in Haskell?

etc

and for Python:

• what is the thing that is like lists in Python?
• what is the thing that is like dicts in Python?

etc

once (a) these lists are all completed, and (b) you have answer a few of those questions (for instance, if you only provided one thing like each thing in Nock, you'd be done, in terms of Turing completeness), you should have enough for a core language. Since i want Oot Core to not be orthogonal, but instead to have the sum of many basic models of computation, we should instead (c) answer almost all of the questions, for all the models of computation, and take the sum to be Oot Core.

i like the idea of starting with graphs as a data structure. The difference from dicts is just that in our library functions etc, we emphasize the whole graph as one object, not just those elements reachable from directly from the first node; and also that we provide a little more infrastructure than usual (labels, reification, etc) to give our graphs a little more 'flavor' (by which i mean, conventions for the interpretation of structural form). Similarly to how the 4-role (5-role, if you count the address of each instruction) system of syntax for Oot Assembly (see [Self-proj-oot-ootAssemblyNotes4]) gives a lot of 'flavor' to syntax.

---

so i guess mb:

first-class call stack, and first-class closures; goto, switch, but also while, repeat..until, if, foreach; grammar rule 'reductions'

probably not a full C-style 'for' b/c it seems kinda hacky, just syntactic sugar for a fancy 'while'. Perhaps a constrained 'for', though, which is always simply incrementing until it hits a limit

---

'return' to return in the middle of a fn; equivalent to assigning the return args to a temporary variable, then a JMP to the end of the fn, and insertion of a statement at the end that returns from those temp vars

(also 'break', 'continue')

---

keyword args and currying: hold onto future keyword until reqd args are satisfied

---

Oot needs a concept of:

• a variable/document that has various versions/revisions (which might be arranged in a chain (linear time), a DAG (version control), etc
• distinct from the concept of a particular value

---

starting with BASIC-like:

• types: string, bignum integer, bignum float, graph, higher-order functions, ADTs
• if
• goto
• some sort of concurrency thingamajig
• function defn
• function calling
  • with keywords, defaults
• macros (what else? syntax transforms? fexprs?)
• foreach
• continue
• break
• while
• stuff for constructing graphs
• patterns and pattern matching
• bools
• and/or/not
• isEq
• isPtrEq
• var assignment
• multidim arrays
• error handling stuff
• 'is'
• annotations (capable of representing transactions, labels, type annotations, function annotations, field annotations, assertions, etc)
• comments
• views

[2]