tiffilore / monkey-business Goto Github PK

The intent is to make the bugs into tests; Fixing them is a later task

• add virgin monkey code
• add tests for bugs
• fix bugs
• add extended-repl
• add ast-extension for latex-trees

The Stringer-fct for asts basically mirrors the input - with some brackets for clarification.

In some cases, however, it is not readable any more.

expl:

>> let remainder = fn(x, y) { if(y > 0){let p = (x/y) * y; x - p}}
let remainder = fn(x, y) if(y > 0) let p = ((x / y) * y);(x - p);

more general:

>> if(cond){a;b} 
ifcond ab
>> if(cond){a}; b 
ifcond ab

it's also not always valid Monkey code:

>> let remainder = fn(x, y) { if(y > 0){let p = (x/y) * y; x - p}}
let remainder = fn(x, y) if(y > 0) let p = ((x / y) * y);(x - p);
>> let remainder = fn(x, y) if(y > 0) let p = ((x / y) * y);(x - p);
            __,__
   .--.  .-"     "-.  .--.
  / .. \/  .-. .-.  \/ .. \
 | |  '|  /   Y   \  |'  | |
 | \   \  \ 0 | 0 /  /   / |
  \ '- ,\.-"""""""-./, -' /
   ''-' /_   ^ ^   _\ '-''
       |  \._   _./  |
       \   \ '~' /   /
        '._ '-=-' _.'
           '-----'
Woops! We ran into some monkey business here!

Test (in pseudocode):

let ast1 = result of parsing input
let mirror = ast1.String()
let ast2 = result of parsing mirror

Then we want: ast1 == ast2

let mod(x,y) = fn(x,y){
   let d = x/y
   let p = d * y
   x-p
}


mod(2,1); r

• and why does a function point to an environment???

How can you write tests to ensure that Eval under any circumstances returns an object?

implements expression --> yellow
implements statement --> blue
program --> darker blue

• get rid of set prompt - was only there to play with settings at the beginning
• make pdfs single [mulit-dimensional] commands, not logging!

output only individual setting for cmd :setting

• for consistency

==
!=

• test setup implicitly also tests complex expressions that evaluate to the respective types
  => we do not need to test !!(2+2) and !!4 separately

• reference the book!!

mistake by me

• make snapshots of environment
• compare if environment changed --> output
  • as side-effect of let statements
  • when applying a function

• "hidden" means that they are not displayed in the help menu
• indent is just for the indentation of the console ast-trees
• showToken decides whether the tokens are shown or not
• mark them as hidden in the code (e.g. at settings)

let max = fn(x,y){if(x>y){x}else{y

• decide on (initial) command set

• add infractructure for commands (:command)

• implement :t <statement> (only shows the type of the object)

  • or t: <expression>

• implement :<show-tree-command>

• implement :<show-tree-with-eval>

• implement :<show environment-history> for last input

• implement :set historyand :unset history

• On ...
• main README
• test doc

• check license (guess it was MIT)
• only (4) --> find the unaltered code ...

since the repo mainly servers to catch runtime-errors, it might be considered to not let the repo crash if the evaluator does, but let it output a message and maybe some stack trace.

• what do we do with partial side-effects?
  • e.g. if there is an embedded let statement that succeeds before the evaluator crashes?
  • solutions:
    • set environment to empty one
    • before evaluation, save state of environment in a copy

environment setup:
let f = fn(){}
let null = if(false){}
let nil = if(true){}

X = {true, false, 5, f, null, nil}

input = setup + if(X){1} else {2}

--> discuss results