In Lua and Ruby, the only falsy values are nil and false. This makes it very convenient to check if a value is defined without worrying about what types the value may be. (It's usually easy to know if a value may be boolean.) If strings and numbers are allowed to be false, then I have to worry about how I will treat those special falsy values in every if statement. That's a lot of extra mental load, and it would be worse than if the interpreter to threw an error for non-boolean if expressions. Historically, when other languages allow "" and 0 to be false, it's because the language did not start out with a native boolean type, and they want backward compatibility. I hope you'll reconsider this.

The top-level object gets printed ok, since it is converted to its native (map) value, but the inner objects panic because runtime.object does not support conversion to String() and inner fields are not converted to native values.

Tests do not always pass. Because "abc" and "abc" should be equal, but "abc, {a:1,b:2,c:3}" and "abc, {b:2,c:3,a:1}" should be equal too. runtime.Object is map[Val]Val, but map doesn't support ordering. Playground implementation of pull request.

Instead, make it a separate, public interface, and check if Val implements this interface at runtime to determine how to pretty-print the value (and fall back on %v or something to print by default - which would end up using the .String() implementation?).

https://github.com/PuerkitoBio/agora/blob/31eb3645f349bc0fd577a00d87dfffef90d62195/compiler/emitter/emitter.go#L225

    case "=":
        e.assert(sym.Ar == parser.ArBinary, errors.New("expected `+` to have binary arity"))

the symbol should be =, not +.

Even required for simple cases like calling a func declared in the module, because the module itself is a function, so it needs to close over those funcs - see 46-json.agora.

A variable with the same name as one in a parent scope doesn't get defined in its local scope, only when it doesn't exist anywhere else.

Easy fix: at compile-time, save a list of locals in the func prototype. At func instantiation, force-declare all locals before running. Removes the need for expected vars count.

Since Int() operations return Float()s, such simple cases like the source files 34 now fail, because the keys on the args object are Int()s, not Float()s.

• [x] Run simple code
• [x] Call a Goblin function
• [x] Call native Go function from Goblin
• [x] Looping constructs
• [x] Clean printing of VM's state for debugging
• [x] Table/object type
• [x] Call methods on object, support for no-such-method
• [x] Access global variable (outside current func scope)
• [x] Support for the this keyword, bound to object
• [x] Refactor native functions/stdlib as objects?
• [x] arguments[] array to access all received arguments
• [x] Add K values to DUMP instructions, as comments
• [x] Bytecode compiler command-line
• [x] Dynamic loading of .goblin source files (and/or compiled bytecode)
• [x] Test file that runs all .goblin test data and compares output to expected
• [x] Syntax
• [x] Lexer
• [x] Parser
• [x] Module/package support (import "user/library")
• [x] Code generation
• [x] Ternary operator (?:)
• [x] Refactor Ctx.Load() by returning only the compiled Module, and have Module.Run() (Val, error) to execute it. Pass the ctx in the constructor of the module (and to each function's constructor).
• [x] Call a specific Goblin function from Go (get any *Func, possibly based on name?)
• [x] Make import a built-in function, not a keyword (so import can happen in an if, for example) Example: mod := import("dir/sub/mod")
• [x] Exception/error handling (https://draftin.com/documents/117086)
• [x] Make a debug built-in function or keyword, that takes a number as argument, to generate a DUMP (then debug the ternary operator bug for test file 19)
• [x] len() builtin, returns the number of items in an object if it is an object, the length of the string representation of the value otherwise
• [x] Make assignment to builtins/keywords fail
• [x] Cyclic dependencies don't work anymore now that Ctx.Load doesn't Run the modules
• [x] Support standard for loop (for i := 0; i < 10; i++)
• [x] test use as script in #!
• [x] Stdlib
• [x] Emitter tests to validate statements generation (i.e. an if, if else, func within a func within a func, etc.)
• [x] A complex-ier implementation of an agora program (a JSON parser/stringifier)
• [x] Finalize stdlib tests
• [x] Finalize stdlib docs
• [x] Review all docs, comments for godoc.org

Docs:

• [x] Internals + Native API on godoc
• [x] Readme with changelog, quick start, short example, links to docs, to contributing, and license
• [x] Wiki for language docs by version (ie: all pages for v0.1, then copy for v0.2, ...): installation/Getting started (detailed), similarities & differences vs Go, language reference, VM opcodes, roadmap, stdlib, known bugs (with links to issues), how to write native modules
• [x] Blog post to announce it