yumaikas / StackTalk

title[ StackTalk ] "Stack Basics" note[ An object is a collection of named stacks A quotation is a malleable list of code symbols, delimited by [ and ] Strings can be written two ways: "This is a conventional string" this-is-a-symbol-string: There are 4 baseline stack operations: `$value $stack push` `$stack pop` `$stack peek` `$stack run` These let you manipulate arbitrarily named stacks. `run` is a bit special. It'll run top of $stack, if it is a quotation, otherwise it acts like peek There are shortcuts for these operations: [ 1 x: push ] can be writtn as [ 1 >x ] [ x: peek ] can be written as [ x. ] when you need no ambiguity [ x: pop ] can be written as [ x> ] [ x: run ] can be written as [ x ] ] "Quotation suffix autoswap" note[ This one is a little inspired by https://knucklecracker.com/wiki/doku.php?id=crpl:overview#warp_notation, but is ultimately a bit less generalized. I anticipate that quotations will be modified by a lot of words. Because of this, and because I think it reads better in a lot of cases, there's another rewrite [ 1 [ me> 1 + >me ] do ] can be written as [ 1 do[ me> 1 + >me ] ] This is how `note` has been working. This doesn't generalize to arbitrary word movement, just for quotations. ] Objects: note[ The current Object/scope is the top of the `me:` stack. `do` executes the quotation inside the scope of object below it in the stack. `$subject $quotation do` do single command Shorthand: [ AnObject [ aThing ] do ] can be written as [ AnObject .aThing ] You can use an existing object as a starting point for one of your own via `clone` [ 0 0 Object clone do[ >y >x ] >my2dPoint ] ] Quotations: note[ Quotations are a swiss-army-knife of a code structure You can call `string` on them to get their contents. [ [ a thing ] .string NB[ stack is " a thing " ] ] `interpolate` will copy values from the containing scope based on $names [ 1 >a 2 >b interpolate[ $a $b + ] NB[ stack is [ 1 2 + ] ] Objects copied this way are copied by reference, rather than deep cloned. You can get the list of symbols from a quotation code[ [ @ @ -- @ ] symbols each[ println ] NB[ print output: "@" "@" "--" "@" ] ] You can supply an interpretation ruleset, on the left side, you have patterns, on the right, consequent actions The patterns match against one or more symbols (as fetched by `symbols`). [ @ @ -- @ ] obj[ 0 >numInputValues 0 >numOutputValues input: >mode ] interperet[ @ [ input: mode ] -> [ numInputValues: inc ] -- [ input: mode ] -> [ output: >mode ] @ [ output: mode ] -> [ numOutputValues: inc ] * -> [ [ "Unrecogized symbol" _ ] fmt error ] ] >effect NB[ effect do[ numInputValues numOutputValues mode ] stack is [ 2 1 output ] ] ] Scope: note[ Stack name resolution order: - Own set of stacks, where state and method definitions live - Ordered list of modules. Symbol list is what is available at import time, need to explicitly refresh for updates - A reference to `Lobby`, where iterpreter-level state lives. Notably, -not- strictly lexical. `interpolate` provides a way to place values in from an outer scope. Also, unless you `freeze` a quotation, a new one is allocated each time you run. If a stack is resolved, then that should probably be cached on the current instance ] Experimental: note[ Some code snippets that I'm noodling on. experimental[ 1 >x 2 >y 3 >z [ x: y: z: ] from-stacks ] ] io: module[ load-by-default println: js: [ @ -- ] ffi[ (x) => console.log(x); ] readln: js: [ -- @ ] ffi[ () => ; ] ] math: module[ load-by-default +: js: [ @ @ -- @ ] ffi[ (x, y) => x+y; ] +: lua: [ @ @ -- @ ] ffi[ function(x, y) return x+y end ] -: js: [ @ @ -- @ ] ffi[ (x, y) => x-y; ] *: js: [ @ @ -- @ ] ffi[ (x, y) => x*y; ] gt: js: [ @ @ -- @] ffi[ (a, b) => a > b; ] lt: js: [ @ @ -- @] ffi[ (a, b) => a < b; ] div: js: [ @ @ -- @ ] ffi[ (x, y) => x/y; ] [ >n n. pop + n> push ] >+= ] Point: class[ usage[ 1 2 Point .fromPair >location 1 1 location .move location .pos NB[ stack is [ 2 3 ] ] location: drop ] fromPair: [ @ @ -- @ ] fn[ clone do[ >y >x ] ] init: [ -- ] method[ clone do[ 0 >x 0 >y ] ] pos: [ -- @ @ ] method[ x> y> ] moveByPair: [ @ @ -- ] method[ y: += x: += ] move: [ x y -- ] method[ your[ x> y> ] moveByPair ] ]