Merge pull request #13 from MasonProtter/saner-closure-handling

Fix closure perf problem, removed MLStyle, use GithubActions

Author: MasonProtter

.travis.yml

@@ -1,16 +1,14 @@
 name = "LegibleLambdas"
 uuid = "f1f30506-32fe-5131-bd72-7c197988f9e5"
 authors = ["MasonProtter <mason.protter@gmail.com>", "Roger-luo <hiroger@qq.com>"]
-version = "0.2.1"
+version = "0.3.0"
 
 [deps]
-MLStyle = "d8e11817-5142-5d16-987a-aa16d5891078"
 MacroTools = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09"
 
 [compat]
-julia = "~1.0.0"
-MLStyle = "~0.3"
-MacroTools = "~0.5"
+julia = "1"
+MacroTools = "0.5"
 
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"

Project.toml

@@ -32,14 +32,16 @@ julia> g = @λ(x -> x + 1)
 (x -> x + 1)
 ```
 
-If you use julia **v1.1+**, anonymous returned by other functions will also benefit from increased legibility
-
+This 'just works' inside most closures too!
 ```julia
 julia> D(f, ϵ=1e-10) = @λ(x -> (f(x+ϵ)-f(x))/ϵ)
 D (generic function with 2 methods)
 
 julia> D(sin)
-(x -> (sin(x + 1e-10) - sin(x)) / 1e-10)
+(x -> ((sin)(x + 1e-10) - (sin)(x)) / 1e-10)
+
+julia> D(sin, 0.01)
+(x -> ((sin)(x + 0.01) - (sin)(x)) / 0.01)
 ```
 
 ## License

README.md

@@ -15,20 +15,90 @@ julia> @λ(x -> g(x)/3)
 (x -> g(x)/3)
 ```
 """
-:(@λ)
-
-# NOTE: Base.@locals is in v1.1
-@static if VERSION < v"1.1.0"
-    # NO Base.@locals
-    include("no_local.jl")
-else
-    # With Base.@locals
-    include("local.jl")
+macro λ(ex)
+    return parse_lambda(ex)
 end
 
 eval(:(const $(Symbol("@lambda")) = $(Symbol("@λ"))))
 
-include("replace_variable.jl")
-include("expr_printing.jl")
+"""
+    parse_lambda(ex)
+
+Parse a lambda expression to `LegibleLambda` constructor expression.
+"""
+function parse_lambda(ex)
+    if ex.head == :(->)
+        :(LegibleLambda($(QuoteNode(ex)), $(esc(ex))))
+    else
+        throw("Must be called on a Lambda expression")
+    end
+end
+
+#------------------------------------------------------------------------------------
+
+struct LegibleLambda{F <: Function} <: Function
+    ex::Expr
+    λ::F
+end
+
+(f::LegibleLambda)(args...) = (f.λ)(args...)
+
+function Base.show(io::IO, f::LegibleLambda)
+    show(io, MIME"text/plain"(), f)
+end
+
+function Base.show(io::IO, ::MIME"text/plain", f::LegibleLambda)
+    l_names = propertynames(f.λ)
+    ex = f.ex
+    foreach(l_names) do name
+        ex = postwalk(ex) do s
+            s === name ? getfield(f.λ, name) : s
+        end
+    end
+    ex_cut = ex |> (ex -> postwalk(cutlnn, ex)) |> (ex -> postwalk(cutblock, ex))
+    name = replace((repr(ex_cut |> pretty_kwargs)[2:end]), "->" => " -> ") 
+    print(io, name)
+end
+
+#------------------------------------------------------------------------------------
+
+cutlnn(x) = x
+function cutlnn(ex::Expr)
+    Expr(ex.head, ex.args[[!(arg isa LineNumberNode) for arg in ex.args]]...)
+end
+
+cutblock(x) = x
+function cutblock(ex::Expr)
+    if (ex.head == :block) && (length(ex.args)==1)
+        ex.args[1]
+    else
+        ex
+    end
+end
+
+tupleargs(x::Symbol) = (x,)
+function tupleargs(ex::Expr)
+    if ex.head == :tuple
+        Tuple(ex.args)
+    else
+        throw("expression must have head `:tuple`")
+    end
+end
+
+pretty_kwargs(x::Symbol) = x
+function pretty_kwargs(ex)
+    if ex.args[1] isa Expr
+        if ex.args[1].head == :block
+            exout = copy(ex)
+            exout.args[1].head = :tuple
+            exout
+        else
+            ex
+        end
+    else
+        ex
+    end
+end
+
 
 end

src/LegibleLambdas.jl

@@ -20,11 +20,7 @@ end
 @testset "Closures" begin
     D(f, ϵ=1e-10) = @λ(x -> (f(x+ϵ)-f(x))/ϵ)
 
-    if VERSION < v"1.1.0"
-        @test repr(D(sin)) == "(x -> (f(x + ϵ) - f(x)) / ϵ)"
-    else
-        @test repr(D(sin)) == "(x -> ((sin)(x + 1.0e-10) - (sin)(x)) / 1.0e-10)"
-    end
+    @test repr(D(sin)) == "(x -> ((sin)(x + 1.0e-10) - (sin)(x)) / 1.0e-10)"
 
     @test D(sin)(π) == -1.000000082740371
 end