Qu

fold

Builtin index · Collections & strings

result = fold(xs, f, initial)

Input: xs, f, initial · Output: result

What it is

xs is a Vec/List; f is a two-argument function — the function itself, or a Str naming one you defined; initial is the starting accumulator value (fold only — reduce has no initial and instead starts from xs's first element).

Overloads

One call shape — this function is not overloaded.

CodeInputOutputDescription
result = fold(xs, f, initial)
xs Vec or Listxs is a Vec/List.
f Strf is a two-argument function — the function itself, or a Str naming one you defined.
initial —initial is the starting accumulator value (fold only — reduce has no initial and instead starts from xs's first element).
result —
Returns the final accumulated value (whatever type f produces).

Examples

From the documentation, and run by the build -- the output and the figure below are what the engine actually produced. Simplest first.

function is_even(n)
    return n mod 2 == 0
end function

function add2(a, b)
    return a + b
end function

print(filter(acc, "is_even"))     # (4, 16, 36)

print(fold(acc, "add2", 0))       # 91
output
(4, 16, 36)
91

from agent-guide

function is_even(x)
    return x mod 2 == 0
end function

function add2(a, b)
    return a + b
end function

function double(x)
    return x * 2
end function

xs = [1, 2, 3, 4, 5]
print(all(xs, is_even))           # false

print(any(xs, is_even))           # true

print(first(xs))                 # 1

print(last(xs))                  # 5

print(take(xs, 3))                # (1, 2, 3)

print(distinct([1, 1, 2, 2, 3])) # (1, 2, 3) -- first-seen order

print(flatten([[1, 2], [3, 4]]))  # (1, 2, 3, 4)

print(fold(xs, add2, 0))          # 15 -- with an initial value

print(reduce(xs, add2))           # 15 -- without one

print(map(xs, double))            # (2, 4, 6, 8, 10) -- collection first

print(map(xs, (x) := x * 10))     # (10, 20, 30, 40, 50) -- or write it inline

print(map(xs, "double"))          # (2, 4, 6, 8, 10) -- the name as a string still works

print(xs.map(double))             # (2, 4, 6, 8, 10) -- and so the method form works

print(zip([1, 2, 3], ["a", "b", "c"]))  # ((1, "a"), (2, "b"), (3, "c"))
output
false
true
1
5
(1, 2, 3)
(1, 2, 3)
(1, 2, 3, 4)
15
15
(2, 4, 6, 8, 10)
(10, 20, 30, 40, 50)
(2, 4, 6, 8, 10)
(2, 4, 6, 8, 10)
((1, "a"), (2, "b"), (3, "c"))

from collections-strings

See also

reduce — documented in the same entry.