Anonymous immediately-invoked func expression.

Currently, bytecode.IsBytecode() only works for io.ReadSeeker types, but the Ctx.Load() can only guarantee an io.Reader. Other way to do this?

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

Docs:

• Internals + Native API on godoc
• Readme with changelog, quick start, short example, links to docs, to contributing, and license
• 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
• Blog post to announce it

• Built-in or keyword to get type of variable's value (a.(type) would be nice) is conv.Type(val)
• Decide what to do with numbers (most probably keep only Float)

v0.2?
Short-circuiting && and ||
Support func(){}() syntax (anonymous immediately-invoked func expression)
Closures (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)
Coroutines support
Range over whatever (for ... := range) using coroutine (range prepares the coro for execution and iterates it)

v0.3?
Prototype/metamethods support, get inspiration from Lua (http://tylerneylon.com/a/learn-lua/) or JS or a more Go-like approach using embed or something?
Review the this behaviour
Literal array notation, created as Object (like Lua)
i.e. ar := [10, "test", false]
Comma-separated lists in assignment statements (:=, = only)
switch statement
multiple return values

Beyond?

• Provide an implements built-in to check if an object provides the required fields? Kind of built-in duck-typing, a-la my implements.js library?
• Remove the need for return nil to be added by the parser?
• Much better compiler error messages
• Better errors in general (VM)
• Check limits (i.e. 2^48 for instruction's value, etc.)
• Refactor compiler
• REPL
• Optimizations
• Debugger

Support an extensible for...range notation, based on coroutines.

So that it doesn't need to expand at runtime.

Implement short-circuiting and return the truthy or falsy result value.

The raw string notation is supported in the source code (backtick strings, like in Go), but once saved as assembly source, it fails to run from this assembly source code, because a K value is expected to be on a single line.

Use an array instead of a hash when dense integer keys are used.

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 +.

Currently, this doesn't parse:

obj := {
key: val
}

Also, allow trailing comma even for last key-val pair, as in Go.

Remove this constraint in future versions, especially since it is impossible to use a pair of mutually depended upon functions at the moment.

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.

The missing language features.

Right now closures are "dumb", each function value keeps a reference to its whole environment recursively up until the module function. This makes closures easy to implement, but it keeps alive all values, regardless of whether or not they are actually used in the closure.

For better memory management, analyze the required values and keep only what's required.

Support reading from stdin if no file is provided. See ebnf2y CLI for example.

Make it consistent, maybe store in the agoraFuncVal, so that it stays with the value when a method is used in for..range and recover built-in.

Similar to Lua's.

Currently this debugging info is ignored by the emitter.

As discussed on golang-nuts:

https://groups.google.com/d/msg/golang-nuts/IAtAaXBfuJU/jtHewWu009wJ

Can't seem to read from Stdin, always returns empty string.

And optimize objects for array/slice usage.

For reference: https://groups.google.com/d/msg/golang-nuts/IAtAaXBfuJU/JXa_SDuysioJ
Also, test file 52.

Code review.

Will you provide a 0.3 version of your language?

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.

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.

1 TestFmtPrint gets func:%v... (no "!")

2 TestOsExec fails as echo is not a standalone program
Suggestion: make 'echo.bat' file containing '@echo %*'
Also, you would need to check for exp+"\r\n" too or ret.String()[:len(exp)] != exp instead
Note that if you had "hello world" windows would further complcate by placing " at each end

Otherwise it seems to work on win32 (GOOS=windows GOARCH=386)
Regards, Tony

Right now the compiler allows a := b++. Either disallow this notation, or make ++ and -- expressions (and then support prefix form too?)

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.

With = and :=.

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.

From return, but also from yield, and support multiple parameters to yield too, obviously.

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?).

See testdata/src/49-... test file, and http://play.golang.org/p/igaQ7F66yu for reference.

The string """ returns two characters \" instead of just the expected ". Same for \n, and probably all escapes.

fmt := import("fmt")

x := 0
fmt.Println(x) // A
y := x = x + 1
fmt.Println(x, y)

This program prints:

0
1 2

Comment out line A and it prints:

runtime error: index out of range

In my opinion, this code should not compile.

I ran these snippets using agora run -R

agora version: 8701d7f
Go version: go version devel +84975e4930dd Tue Sep 17 18:06:58 2013 -0700 linux/amd64

Provide a default implementation, so that values only need to "override" the operations hat are valid.