@closure function (x,y,z)
    x+a
end

julia> using FastClosures
INFO: Precompiling module FastClosures.
ERROR: LoadError: syntax: extra token "Symbol" after end of expression
 in include_from_node1(::String) at ./loading.jl:488
 in include_from_node1(::String) at /usr/local/Cellar/julia/0.5.2/lib/julia/sys.dylib:?
 in macro expansion; at ./none:2 [inlined]
 in anonymous at ./<missing>:?
 in eval(::Module, ::Any) at ./boot.jl:234
 in eval(::Module, ::Any) at /usr/local/Cellar/julia/0.5.2/lib/julia/sys.dylib:?
 in process_options(::Base.JLOptions) at ./client.jl:242
 in _start() at ./client.jl:321
 in _start() at /usr/local/Cellar/julia/0.5.2/lib/julia/sys.dylib:?
while loading /Users/dpo/.julia/v0.5/FastClosures/src/FastClosures.jl, in expression starting on line 15

julia> VERSION
v"0.5.2"

using FastClosures

function foo()
    x = 10
    c = ()->x
    x = 20
    c()
end

function bar()
    x = 10
    c = @closure ()->x
    x = 20
    c()
end

julia> foo()
20

julia> bar() # @closure breaks this!
10

function baz()
    x = 10
    c = ()->(x = 20)
    c()
    x
end

function qux()
    x = 10
    c = @closure ()->(x = 20)
    c()
    x
end

julia> baz()

20

julia> qux()
20

julia> using FastClosures

julia> A = rand(5,5);

julia> h(f1, f2, x) = f1(x) + f2(x)
h (generic function with 1 method)

julia> h(@closure x -> A * x, @closure x -> transpose(A) * x, rand(5))
ERROR: ArgumentError: Argument to @closure must be a closure!  (Got ((x->begin  # REPL[8], line 1:
            transpose(A) * x
        end), rand(5)))

julia> f1 = @closure x -> A * x
(::#7) (generic function with 1 method)

julia> f2 = @closure x -> transpose(A) * x
(::#9) (generic function with 1 method)

julia> h(f1, f2, rand(5))  # all ok!

using FastClosures
outer = [[1]]
@closure map(outer) do inner
    map(inner) do x
        x + 1
    end
end

julia> versioninfo()
Julia Version 1.7.3
Commit 742b9abb4d (2022-05-06 12:58 UTC)
Platform Info:
  OS: Linux (x86_64-pc-linux-gnu)
  CPU: 11th Gen Intel(R) Core(TM) i7-11700KF @ 3.60GHz
  WORD_SIZE: 64
  LIBM: libopenlibm
  LLVM: libLLVM-12.0.1 (ORCJIT, icelake-client)
Environment:
  JULIA_NUM_THREADS = 16

julia> using FastClosures

julia> # code_warntype problem
       function f1()
           if true
           end
           r = 1
           cb = ()->r
           identity(cb)
       end
f1 (generic function with 1 method)

julia> # code_warntype clean
       function f2()
           if true
           end
           r = 1
           cb = @closure ()->r
           identity(cb)
       end
f2 (generic function with 1 method)

julia> @code_warntype f1()
MethodInstance for f1()
  from f1() in Main at REPL[42]:2
Arguments
  #self#::Core.Const(f1)
Locals
  #16::var"#16#17"{Int64}
  cb::var"#16#17"{Int64}
  r::Int64
Body::var"#16#17"{Int64}
1 ─       Core.NewvarNode(:(#16))
│         Core.NewvarNode(:(cb))
│         Core.NewvarNode(:(r))
└──       goto #2 if not true
2 ─       (r = 1)
│   %6  = Main.:(var"#16#17")::Core.Const(var"#16#17")
│   %7  = Core.typeof(r::Core.Const(1))::Core.Const(Int64)
│   %8  = Core.apply_type(%6, %7)::Core.Const(var"#16#17"{Int64})
│         (#16 = %new(%8, r::Core.Const(1)))
│         (cb = #16::Core.Const(var"#16#17"{Int64}(1)))
│   %11 = Main.identity(cb::Core.Const(var"#16#17"{Int64}(1)))::Core.Const(var"#16#17"{Int64}(1))
└──       return %11


julia> @code_warntype f2()
MethodInstance for f2()
  from f2() in Main at REPL[43]:2
Arguments
  #self#::Core.Const(f2)
Locals
  cb::var"#18#19"{Int64}
  r@_3::Int64
  #18::var"#18#19"{Int64}
  r@_5::Int64
Body::var"#18#19"{Int64}
1 ─       Core.NewvarNode(:(cb))
│         Core.NewvarNode(:(r@_3))
└──       goto #2 if not true
2 ─       (r@_3 = 1)
│   %5  = r@_3::Core.Const(1)
│         (r@_5 = %5)
│   %7  = Main.:(var"#18#19")::Core.Const(var"#18#19")
│   %8  = Core.typeof(r@_5::Core.Const(1))::Core.Const(Int64)
│   %9  = Core.apply_type(%7, %8)::Core.Const(var"#18#19"{Int64})
│         (#18 = %new(%9, r@_5::Core.Const(1)))
│         (cb = #18::Core.Const(var"#18#19"{Int64}(1)))
│   %12 = Main.identity(cb::Core.Const(var"#18#19"{Int64}(1)))::Core.Const(var"#18#19"{Int64}(1))
└──       return %12

julia> f(x) = @closure i -> @inbounds x[i]
f (generic function with 1 method)

julia> f([])
ERROR: UndefVarError: pop not defined
Stacktrace:
 [1] macro expansion at /home/takafumi/.julia/packages/FastClosures/mMjMm/src/FastClosures.jl:51 [inlined]
 [2] f(::Array{Any,1}) at ./REPL[37]:1
 [3] top-level scope at REPL[38]:1

julia> @macroexpand @closure i -> @inbounds x[i]
quote
    #= /home/takafumi/.julia/packages/FastClosures/mMjMm/src/FastClosures.jl:51 =#
    let x = x, pop = pop
        #= /home/takafumi/.julia/packages/FastClosures/mMjMm/src/FastClosures.jl:52 =#
        i->begin
                #= REPL[40]:1 =#
                begin
                    $(Expr(:inbounds, true))
                    local #215#val = x[i]
                    $(Expr(:inbounds, :pop))
                    #215#val
                end
            end
    end
end

@closure x -> begin
    y::Float64 = 0.0
    y += x
    return y
end

let y = y, Float64 = Float64
    x->begin
        # ...
    end
end