pounce-lang / js-core Goto Github PK

example
[0 1 [dup2 +] 3 times] explain -->

[] [0 1 [dup2 +] 3 times] 
[0 1 [dup2 +] 3 ] [times]
[0 1] [dup2 + [dup2 +] 2 times]
[0 1 0 1] [+ [dup2 +] 2 times]
[0 1 1] [[dup2 +] 2 times]
[0 1 1 [dup2 +] 2] [times]
[0 1 1] [dup2 + [dup2 +] 1 times]
[0 1 1 1 1] [+ [dup2 +] 1 times]
[0 1 1 2] [[dup2 +] 1 times]
[0 1 1 2 [dup2 +] 1] [times]
[0 1 1 2] [dup2 +]
[0 1 1 2 1 2] [+]
[0 1 1 2 3] []

may need to change word definition functions to return a record(object) instead of an array.
{status:"error", stack:s, program:pl, dictionary:wd, }
{status:"ok",

fbp-types was experimented with, but was not being maintained.

type checking for if-else strict mode requires both paths have the same type footprint

purr() should return an unfinished stack and program list (combined) if the maximum cycle count is exceeded. Same for the development interpreter.

play type footprint calculation independent of the underling stack
expected stack and resulting stack.

without having to use nested lists to describe trees or graphs, give these structures their own syntax to express in a succinct way a well behaved tree or graph.

possibly:
Tree Graph

more thoughts and syntax refinement are needed

examples
[1 2 3 4] [head... last] [head last] crouch --> [1 2 3] 4
[1 2 3 4] [first tail...] [first tail] crouch --> 1 [2 3 4]
[1 2 3 4] [head middle... last] [head middle last] crouch --> 1 [2 3] 4
[1 2 3 4] [first second rest...] [first second rest] crouch --> 1 2 [3 4]
[1 2 3 4] [head... next2last last] [head next2last last] crouch --> [1 2] 3 4

nefe/number-precision is mostly great, but if it is not needed \ or math has to be more efficient, add option to enable/disable.

If
[2 *] [twice] compose
and you wanted to change this word
[twice] decomp >>> [2 *]
built in words may decompose to some other words
or may just decompose the identity [+] decomp >>> [+]

compose (aka apply-with, invoke, induce, call, conjure, leap or pounce)
is powerful, but if nested it would probably be hard to predict (hilarity ensues).
So for now it should detect a nested case and warn or halt.

instead of having to stack shuffle like this

[1 0] # accumulator is a pair [acc index] the index is used to either multiply or add 
[swap uncons uncons drop [acc i] [acc [i 2 % 0 ==] [*] [+] ifte 1 i +] pounce [] cons cons] 
reduce```

if `crouch` and `pounce` could name elements in lists patterns and dis-assemble them, then less stack shuffling would be needed, like this
```[6 3 8 4 5 7 2 9 1] 
[1 0] # accumulator is a pair [acc index] the index is used to either multiply or add 
[[ele [acc i]] [ele acc [i 2 % 0 ==] [*] [+] ifte 1 i +] pounce cons-2 ] 
reduce```

``` [ [] cons cons ] [cons-2] compose ```

pre-processing of match could be syntactic sugar on compose

although state is stored on the stack, it is not really always the best place for all state storage concerns. possibly it is not the purest concatenative programming thought, to consider the storing a specific domains concern in a word. This is a thought experiment/branch that will propose and experiment with setting state (state machine and others) in various ways

Agda style "dependant" types are wanted/needed!?