表达式 #

ex = :(1 + 2)
typeof(ex)
ex.head
ex.args

ex1 = :(a + b)
ex2 = Expr(:call, :+, :a, :b)
ex3 = parse("a + b")

ex = :(f(x, y))
ex.head
ex.args

ex = :(1 + 2 * 3)

ex = quote
    x = 1
    y = 2
    x + y
end

x = 10
ex = :($x + 2)

y = :z
ex = :($y = 10)

ex = :(:(1 + 2))

function traverse(ex::Expr)
    println("Head: ", ex.head)
    for arg in ex.args
        if arg isa Expr
            traverse(arg)
        else
            println("  Arg: ", arg)
        end
    end
end

traverse(:(1 + 2 * 3))

function replace_symbols(ex::Expr, mapping)
    for i in eachindex(ex.args)
        arg = ex.args[i]
        if arg isa Symbol && haskey(mapping, arg)
            ex.args[i] = mapping[arg]
        elseif arg isa Expr
            replace_symbols(arg, mapping)
        end
    end
    return ex
end

ex = :(a + b)
replace_symbols(ex, Dict(:a => :x, :b => :y))

function match_call(ex, func)
    ex isa Expr && ex.head == :call && ex.args[1] == func
end

ex = :(f(x, y))
match_call(ex, :f)

ex = :(1 + 2)
eval(ex)

x = 10
ex = :(x * 2)
eval(ex)

module MyModule
    x = 10
end

ex = :(x)
eval(MyModule, ex)

function safe_eval(ex)
    try
        eval(ex)
    catch e
        println("Error: $e")
        nothing
    end
end

dump(:(f(x)))
dump(:(a[i]))
dump(:(x = 1))
dump(quote
    x = 1
    y = 2
end)

function count_calls(ex::Expr, func)
    count = 0
    if ex.head == :call && ex.args[1] == func
        count += 1
    end
    for arg in ex.args
        if arg isa Expr
            count += count_calls(arg, func)
        end
    end
    return count
end

ex = :(f(f(x), f(y, f(z))))
count_calls(ex, :f)

function simplify(ex::Expr)
    if ex.head == :call && ex.args[1] == :+
        if ex.args[2] == 0
            return simplify(ex.args[3])
        elseif ex.args[3] == 0
            return simplify(ex.args[2])
        end
    end
    return ex
end

simplify(:(0 + x))
simplify(:(x + 0))

function generate_loop(var, start, stop, body)
    quote
        for $var in $start:$stop
            $body
        end
    end
end

ex = generate_loop(:i, 1, 10, :(println(i)))
eval(ex)