notes.txt

TODO

    while (function)

        - How can we identify function reference rather than execution?
        - (function) without arguments
        - when function is modest, greedy, or array
        - or even unary
            -> store function address on stdout

    (function) -> store function address instead of compiling call to function





    other loop atomics?
        forever {  }
        break -> jump out of loop
        while (function)
            loop state is function reference

    instead of named variables
        how about named pipes?


    iterations
    index start -> 1
    index delta -> 1
    inside each loop
        push index to stdin
    echo atomic
        modest stdin -> stdout


    index atomic is essentially a hard-coded variable
        zs_vm_set_index (self, value)
        zs_vm_set (self, "index", value)
        -> scoped, or perhaps not




    MENU:

        function [ phrase | phrase | phrase ]
            outputs whole number
            0 or less -> skip all
            1, 2, 3... -> matching phrase





Problem: how to compile & run a paper script
Problem: define test case for each atomic, in ZS
Problem: ZS strings must be UTF-8 safe (length delimited)


extension classes
    strings
    maths
    stats
    message/?
    cluster

    subproblems
        - how to assume class names to avoid over-typing?
        - what does perfect messaging look like?
            -> like input pipes
        - pass complex objects on message
            -> zsock_send style of a set of things in one frame


how to edit larger files...
    save compiled VM state automatically
    restore session automatically
    output function definitions to disk
    shell environment persistent and rich
    TAB should show most used commands first
    archive unused commands after X time
    :-)


atomic contracts:
    hint
    status (draft, stable, legacy)
    testcase (text)

selftests run through all atomic tests
    then for functions:
        hint (<something>)
        selftest (<something>)
        status (stable|draft|legacy)



- rewrite shell as repl primitive
    - read line of input, put onto pipe
    - execute input, display results if any
    - core of zs.c

- then shell is
    until (break) { repl }


- repl primitive takes list of lines, executes

- rewrite scaling primitives in ZS?
<
    k: (<Multiply by 1000> 1000 *)
    M: (<Multiply by 1M> 1000000 *)
> repl
    - default for * is "multiple by 1"?
    - how to add hint for function....
    k: <Multiply by 1000> (1000 *)

- pipes can probably be built as single tree structure?

- make zs_repl into an actor
    - accept input on pipe
    - return output to pipe (end of sentence)

- profile every function, simple counter, 'n top' atomic sorts & prints top n

- expressive constants: 1/2 1:2 2^16-1 1024*1024
    contain + - /: *x ^
    simple stack-based evaluator in zs_lex

help on function
    how to put function reference onto pipe
    (function)
    now (function) now -
    now (function (args)) now -

help (xyz)
    get hint on xyz if it's an atomic
    else show code for xyz if it's a function

    -> how do we know to pass a function rather than execute it?
    1. @ before function name
    2. atomic can force this



Multiline strings
    <
    some value
    >

    <
some value
>

Multi-line indented strings
    <
    some value
    and another value
    and then more
    >


string atomics
    1, many
        upper
        lower
        camel
        title
        slug
        size

    many
        paste
        sort
        first
        last

    2
        find        (find string in another)
        split       (split string into tokens)
        count       (count string in another)
        repeat      (repeat string N times)
        match       (string vs. pattern or pattern vs. string)
        replace     (string mashing,...)