proj-oot-ootMainCore

Part of Oot Details.

Read Oot first.

TODO: mb rename Oot Core to 'Oot Mu', and use 'Oot Core' to refer to 'standard Oot minus the stdlib'

Details of Oot Core

The syntax of Oot and Oot Core are identical, and so has already been explained above. All that remains is to describe the builtin identifiers and operators.

General remarks on Oot Core

Common platform primitives which are special cases of more general primitives, or compositions of other primitives (for example: increment; xor; multiply-and-accumulate), are usually not in Oot Core, but they are in the Oot Standard Library. Since they are in the Standard Library, Oot implementations do not have to provide platform-specific implementations of these, but they may if they choose.

goto

targets a label

note that labels are 'first-class'; they can be assigned to variables (todo, how to quote them?)

todo: what limits on goto? i'm thinking: label must be within the current block, or its lexical ancestors; eg stack unwinding is done but not winding, that is you can't jump into the middle of another function? otoh do we really want to do unwinding, what about coroutines? probably we need some guileVM-like details here to present different options. Should be at least as powerful as computable goto as sometimes seen in C.

while

rep

(like "for" but "rep", short for "repeat" is thought to be easier to understand for beginners)

gcond

gcond is 'generalized cond'; it takes one argument, which is a comparison function, and returns a cond-like function

break

break-to-enclosing-label

intended to handle one of the 3 common usecases of goto in otherwise structured programming (break-to-enclosing-label/continue-to-enclosing-label, try/catch/finally, dispatch)

continue

continue-to-enclosing-label

intended to handle one of the 3 common usecases of goto in otherwise structured programming (break-to-enclosing-label/continue-to-enclosing-label, try/catch/finally, dispatch)

emit

• emit (unification of send, return, yield, throw; options for what message (object) to emit, whether to terminate execution, or if not whether to block on handling the emitted message or to continue immediately)
  • and receive/catch (mb just call this "on" as in onMouseDown)

note: try/catch/finally is intended to handle one of the 3 common usecases of goto in otherwise structured programming (break-to-enclosing-label/continue-to-enclosing-label, try/catch/finally, dispatch); note that in this role propagation up a handler tree is not needed, in fact no message passing at all is needed; that use SHOULD be well-optimized

tail call optimization

module

#include

imp

import

coercions

• str, int, float, bool

equality

• is-equal (structural) (===)
• is-pointer-equal (====)

ordering

• less-than-eq <=
• less-than <
• greater-than-eq >=
• greater-than >

Boolean logic

• and, or, not, xor

arithmetic

• add, sub, mul + - *
• neg (on numbers, negation; on functions, inversion) - (unary prefix)
• INF, NAN
• exp, log, pow
• ceil, floor, round, trunc
• sqrt
• abs, copysign, signum
• min, max
• const.e, const.pi
• clz (count leading zeros), ctz (count trailing zeros), popcnt (count number of ones)
• multiply-accumulate (MAC) ( https://en.wikipedia.org/wiki/Multiply%E2%80%93accumulate_operation ) (?: shouldn't this just be a compiler optimization?)

get/set, apply

• get
• set
• apply
• erase (like a 'set', but to actually erase the content of memory, for security)
• shallowcopy
• ?todo?: deepcopy (or does the language generate this automatically?)

todo explain that these are typeclass-ish 'protocols'

composite values

• len
• member
• nonzero
• items (like Python dict items)
• (un)serialize (options to 'serialize' can request an 'eval'-able, or ascii, serializations)
• (un)marshal (as per https://tools.ietf.org/html/rfc2713 section 2.3, this doesn't follow links to remote objects, but it does include relevant (non-binary-extension) code) (same options as serial)
• deepcopy
• deepseq

types

• isa

(there is no 'type' function, see the 'type system' section)

todo: more minimal basis set of the above; leave the rest to Oot; remember, platforms can optimize stuff in Oot, not just in Oot core? or otoh do we want Oot Core alone to be a good target for compilers? Yeah, probably the latter.. but then do we want to add the trig fns back in? and add more comparison ops, etc, from Oot? and while loops and switches (conds)?

todo: but we may want to at least drop the stuff that even webassembly couldnt handle in their MVP, eg pow, e, pi, log (otoh LuaVM? has a POW opcode). Not sure tho, they plan to get to that later. Otoh there will probably be embedded platforms where these are unavailable and unneeded, so mb drop them. Otoh there will be embedded platforms without floats at all, so does that mean we should drop inf, nan?

todo : what does LuaVM? have that we don't yet? (see [1]):

• vararg (probably dont want)
• self
• len
• setlist ("Set a range of array elements for a table")
• concat
• close (something about upvalues and the stack)

todo: what, if any, are LuaVM?'s restrictions on jmp targets?

summary:

• logic: not, test, testset (both test and testset can be used to implement both 'and' and 'or', see http://luaforge.net/docman/83/98/ANoFrillsIntroToLua51VMInstructions.pdf)
• loops: numeric for loop

todo:

'Oot' is built around a simple subset of itself called Oot Core. So,

todo

note: oot core and oot have thee same lexer and parser, but oot has a bunch of macros and metaprogrammed syntax that oot core does not

teach oot core first, then oot, then metaprogramming

todo