匿名函数 #

x -> x^2
(x, y) -> x + y
() -> println("Hello")

x -> begin
    y = x * 2
    y + 1
end

f = x -> x^2
f(5)

((x, y) -> x + y)(1, 2)

arr = [1, 2, 3, 4, 5]

map(x -> x^2, arr)
filter(x -> x > 2, arr)
reduce((a, b) -> a + b, arr)

arr = ["apple", "banana", "cherry"]
sort(arr, by = x -> length(x))
sort(arr, by = x -> x[1])

arr = [1, 2, 3, 4, 5]
any(x -> x > 3, arr)
all(x -> x > 0, arr)
count(x -> x % 2 == 0, arr)

d = Dict("a" => 1, "b" => 2, "c" => 3)
filter(p -> p.second > 1, d)
map(p -> p.first => p.second * 2, d)

map(arr) do x
    x^2
end

map(x -> x^2, arr)

map(arr) do x
    if x > 0
        x * 2
    else
        0
    end
end

open("file.txt", "r") do f
    read(f, String)
end

function with_resource(f)
    resource = acquire_resource()
    try
        return f(resource)
    finally
        release_resource(resource)
    end
end

with_resource() do r
    process(r)
end

function make_multiplier(n)
    x -> x * n
end

times_3 = make_multiplier(3)
times_3(5)

times_10 = make_multiplier(10)
times_10(5)

function make_counter()
    count = 0
    () -> (count += 1)
end

counter = make_counter()
counter()
counter()
counter()

function make_accumulator()
    total = 0
    x -> (total += x)
end

acc = make_accumulator()
acc(10)
acc(5)
acc(3)

function make_greeter(greeting)
    name -> println("$greeting, $name!")
end

say_hello = make_greeter("Hello")
say_hi = make_greeter("Hi")

say_hello("Julia")
say_hi("Julia")

map(x -> x^2, [1, 2, 3, 4, 5])
map((x, y) -> x + y, [1, 2, 3], [10, 20, 30])

filter(x -> x > 2, [1, 2, 3, 4, 5])
filter(x -> iseven(x), 1:20)

reduce((a, b) -> a + b, [1, 2, 3, 4, 5])
reduce((a, b) -> max(a, b), [3, 1, 4, 1, 5])

foldl((a, b) -> a - b, [1, 2, 3])
foldr((a, b) -> a - b, [1, 2, 3])

function my_map(f, arr)
    result = similar(arr, Any)
    for (i, x) in enumerate(arr)
        result[i] = f(x)
    end
    return result
end

my_map(x -> x^2, [1, 2, 3, 4, 5])

arr = [1, 2, 3, 4, 5]
arr |> (x -> filter(iseven, x)) |> (x -> map(y -> y^2, x))

compose(f, g) = x -> f(g(x))

double = x -> 2x
increment = x -> x + 1

double_then_increment = compose(increment, double)
increment_then_double = compose(double, increment)

double_then_increment(5)
increment_then_double(5)

function process_with_callback(data, callback)
    result = []
    for item in data
        push!(result, callback(item))
    end
    return result
end

process_with_callback([1, 2, 3, 4, 5], x -> x^2)
process_with_callback([1, 2, 3, 4, 5], x -> x > 2 ? x : nothing)