set(slice, index, value)
set(map, key, value)
set(object, member, value)

slice[index] = value
map[key] = value
map.key = value
object.member = value

import "tricks"

line 14: match failed: `fn inherit(Base) {
        tbl = reflect.valueOf(Base).elem().fieldByName("Fns").interface()
        for name, method = range tbl {
            if this.tbl[name] == undefined {
                this.tbl[name] = method
            }
        }
    }
}
` doesn't match `"fn" IDENT fnbody ?';'`
line 14: match failed: `for name, method = range tbl {
            if this.tbl[name] == undefined {
                this.tbl[name] = method
            }
        }
    }
}

of = fn(Class) {
` doesn't match `'}'`

    export sync
    > qexport sync

    export html and html/template package
    > qexport html html/template

    export all package
    > qexport std

>>> a = []byte
>>>type(a)
*builtin.Type
>>> a = append(a,'a')
line 1: reflect: call of reflect.Append on ptr Value
>>> 

a = "test"
   "bb"
println(a)

`a = "test"  "bb"`

qlang -genlib <GoPackageName> [<TargetDir>]

>>> build.default
line 1: match failed: `.default` doesn't match `'.' member`
line 1: match failed: `default` doesn't match `IDENT | "class" | "new" | "recove
r" | "main" | "import" | "as" | "export" | "include" | "type"`
>>> build["default"]
{amd64 windows c:\go\go1.6  true false gc [] [go1.1 go1.2 go1.3 go1.4 go1.5 go1.
6]  <nil> <nil> <nil> <nil> <nil> <nil> <nil>}
>>>

y = 3
typ = class {
    fn foo() {
        return y
    }
}

lang.InjectMethods("typ", []byte(`
    fn bar(v) {
        return y + v
    }
    fn setbar(v) {
        y; y = v
    }
`))

Fetching https://qlang.io/qlang?go-get=1
https fetch failed: Get https://qlang.io/qlang?go-get=1: x509: certificate is valid for www.qiniupkg.com, qiniupkg.com, not qlang.io
package qlang.io/qlang: unrecognized import path "qlang.io/qlang" (https fetch: Get https://qlang.io/qlang?go-get=1: x509: certificate is valid for www.qiniupkg.com, qiniupkg.com, not qlang.io)

    script := `
x = fn(a) {
    b = 1 + a
    return b
}

println(x(3)) 
`
    var Exports_log = map[string]interface{}{
        "Println": log.Println,
    }
    qlang.Import("log", Exports_log)
    lang, err := qlang.New(nil) // 参数 nil 也可以改为 qlang.InsertSemis
    if err != nil {

        log.Println(err)
        return
    }

    started := time.Now()

    err = lang.Eval(script)
    if err != nil {

        log.Println(err)
        return
    }
    log.Printf("qlang_fib %v", time.Since(started))

` doesn't match `"fn" (~'{' fnbody | afn)`
line 4: match failed: `return b
}

println(x(3))
` doesn't match `'}'`

qlang -test

// $QLANG_PATH/types/main.ql
Slice = class {}
export Slice

// $$QLANG_PATH/play.ql
import "types"
slice = new types.Slice("int")

// 报错：
2016/04/18 18:26:23 line 2: match failed: `.Slice("int")
println(slice)` doesn't match `EOF`
panic: line 2: match failed: `.Slice("int")
println(slice)` doesn't match `EOF`

obj := lang.Var("FooClass").(*exec.Class).New(arg1, arg2, ...) // 其中 FooClass 是 qlang 的类

member := obj.Member("a") // 相当于 obj.a

result := obj.Member("method").(*exec.Method).Call(arg1, arg2, ...) // 相当于 obj.method(arg1, arg2, ...)

Object = class {
    fn _init(){
        this.pos = 0
    }

    fn add() {
        this.pos += 1
    }
}


obj = new Object()
obj.add()

a = type(['a', 'b'])
println(a)

"newContext":              newContext,
"varContext":               varContext,

func newContext() *build.Context {
    return new(build.Context)
}
func varContext() build.Context {
    var ctx build.Context
    return ctx
}

type ImportMode uint
const ( 
    FindOnly ImportMode = 1 << iota
    AllowBinary
……
}
func (ctxt *Context) Import(path string, srcDir string, mode ImportMode) (*Package, error) {

build.Import("fmt","",0)

>>> build.import("fmt","",0)
line 1: invalid argument type: require `build.ImportMode`, but we got `int`

foo = fn(a, b) {
    return a+b
}

foo = fn(a int, b int) int {
    return a+b
}

fib = fn(n) {
    if n < 2 {
        return n
    }
    return fib(n-2) + fib(n-1)
}

fib(30)

BenchmarkGolang-4           1000           1723098 ns/op               1 B/op          0 allocs/op   
BenchmarkGopherlua-4           5         230613180 ns/op          539003 B/op       1391 allocs/op   
BenchmarkQlang-4               1        12594720400 ns/op       2801072688 B/op 52523860 allocs/op   
BenchmarkOtto-4                1        14532831200 ns/op       4954536800 B/op 75394539 allocs/op   

>>> doc(os)
package os
_name   string 
args    []string 
open    func(string) (*os.File, error) 
exit    func(int) 
_initSafe   func(qlang.Module) 
stdin   *os.File 
stderr  *os.File 
stdout  *os.File 
create  func(string) (*os.File, error) 

x = 1 + 2 * 3

x = 7

a = type(uint32(1))
println(a)