pebaz / lambdacore Goto Github PK

Cannot print arrays and arrays are flattened no matter their depth.

Quote: Don't evaluate symbol

'(+ 1 2)
    ⇒ (+ 1 2)

Use lcore_parse and lcore_interpret to make a REPL.

LambdaCore REPL runs the command if it has the first and last paren. This means that multi line statements contained within an open paren will become a syntax error after 3 enter keys are pressed without a closing paren.

• +
• -
• *
• /
• **
• 'etc'

Turn:

interpret(...) {
    ...interpret(...);
}

Into:

LambdaCore(...) {
    while let a = symbols.pop() {
        interpret(a);
    }
}

Since we can't do #17, use this and use Clojure's syntax highlighter.

Make sure that this is put somewhere that VS Code users can get to it.

Goes hand in hand with #15.

Need to support how the standard library will interact with the interpreter.

Need to implement #11 before starting this.

Allow code to be imported and interpreted to add names from another file.

• >
• >=
• <
• <=

Need to determine what CI/CD pipeline to use for distributing release versions of LambdaCore.

Trust Travis CI and AppVeyor template to test your Rust crate on 5 architectures and publish binary releases of it for Linux, macOS and Windows

Can't have functions defining local variables that can be accessed after the function is over.

Need to be able to support user defined types.

:: Type definition
(type 'person '[name age])

:: Instantiation
(set 'pebaz (new person "Pebaz" 24))

:: Usage
(print (get pebaz 'name))
(print (get pebaz "name"))

:: Future
(print pebaz/name)

Once the #29 Dict type is created, it will be easy to make type definitions return Dicts.

Use Asciinema to make tutorials and put them right on the front page of the website.

1. How to build
2. How to run
3. How to install via the installer
4. Brief syntax tutorial w/ reference to examples
5. Link to website
6. Link to downloads

Goes hand in hand with #44.

This doesn't make LambdaCore compain:

(dict 'a 1 'b 2 'c)

Backtick: Evaluate other parts of array while not evaluating others.

`(a list of ,(+ 2 3) elements)
    ⇒ (a list of 5 elements)

Tutorial, download, hook up to DevOps pipeline.

Eliminate duplicate symbol tables from being created by reusing the previous stack frame.

Why? Because it would be amazingly cool.

"Syntax Recognized by GitHub"

Dicts need to be able to be indexed using any value type?

(set 'info (dict "first name" "David" "last name" "Wallace"))
(set 'ms (dict 'first-name "Michael" 'last-name "Scott"))

(print (get info "first name"))
(print (get ms 'first-name))

Need to implement macros. Macros are just functions that have their arguments passed to them untouched rather than pre-evaluated.

Potential plan:

• Prevent the evaluation of Array from evaluating arguments.
• Implement a Macro variant for Value.
• Implement an eval built-in function for Macro designers to evaluate Arrays of code.

(defm setq '[key value] '[
    (set 'key (eval value))
])

(setq name "Pebaz")

Related: https://software-lab.de/doc/tut.html#fun

Returning from a function may work, but it is inconsistent and uses something that is not similar to a loop. If an error is created named ReturnError that holds the Value to return, it can escape any number of loops to return a value.

This may not be worth the effort to implement, but would simplify the inner-workings of LambdaCore and help the programmer's mental model when adding features.

Instead of only implicit return.

Use Rust modules instead of putting everything into a single file.

Since all functions return values instead of references, there is no way to modify any collection value. The swap function will allow this:

(set 'person (dict 'name "Pebaz"))
(swap 'person '[name] "Protodip")
(print (get person 'name))  :: Prints "Protodip"

The quoted list contains sequential indexes to any collection objects it finds along the way:

(set 'person (dict 'name "Pebaz" 'inventory [1 2 3]))
(swap 'person '[inventory 1] 222222)
(print (get (get person 'inventory) 1))  :: Prints 222222

This:

(print [(+ 3 5)])

Does not print 8