Fuzion • Idioms • Idiom # 315: Memoization

Idiom # 315: Memoization

Code

Let's look at two code examples that solve the same problem: How many ways are there to climb an 'n' stairs, taking 1 or 2 steps at the time?

Both versions use memoization to avoid unnecessary calculations, but they implement it in slightly different ways. You can learn about memoization effect in fuzion language from here

m(n) : memoize => 
  keep n _->        # Keep checks if the result is already stored in 'n' 
    f n             # Otherwise it calculates f(n), stores it and returns the result

1
2
3
4
m(n) : memoize => 
  keep n _->        # Keep checks if the result is already stored in 'n' 
    f n             # Otherwise it calculates f(n), stores it and returns the result
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Running Example

ex315 is

  # m(n) uses the memoize effect which reuses previously saved results
  m(n) : memoize =>
    keep n _->        # Keep checks if the result is already stored in 'n'
      f n             # Otherwise it calculates f(n), stores it and returns the result


  # If n is 0 or 1, there is only 1 way to climb
  # Otherwise we can reach the current step either with a single or double step
  f(n) =>
    if n <= 1 then 1 else f n-1 + f n-2

  # Print the number of ways for steps ranging from 5 to 8
  (5..8).for_each (n ->
    say "ways $n steps = {m n}")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
ex315 is
  # m(n) uses the memoize effect which reuses previously saved results
  m(n) : memoize =>
    keep n _->        # Keep checks if the result is already stored in 'n'
      f n             # Otherwise it calculates f(n), stores it and returns the result
  # If n is 0 or 1, there is only 1 way to climb
  # Otherwise we can reach the current step either with a single or double step
  f(n) =>
    if n <= 1 then 1 else f n-1 + f n-2
  # Print the number of ways for steps ranging from 5 to 8
  (5..8).for_each (n ->
    say "ways $n steps = {m n}")
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Running Example

The following example ways_memo is a separate memoization element. Inside it, a function m is defined, which uses the ways_memo.env.keep method to store and retrieve results. f is a regular recursive function. This structure separates the memory (ways_memo) from the rest of the logic.

This example could be made more efficient by also memoizing the recursive calls. For this, the calculations would need to happen directly in m, without a call to f.

# Example 2
# Results are not saved forever, but only as long as ways_memo is instated
ex315 is

# Defines a memoization effect that handles functions of type i32 -> i32
ways_memo : memoize.memoized i32 i32 is

# Main
ways_memo ! () ->

  # Function 'm' returns cached result or delegates computation to 'f' if not found
  m(n) =>
    ways_memo.env.keep n _->
      f n

  # Recursive function which returns Fibonacci value
  f(n) =>
    say "working on with result for $n"
    if n <= 1 then 1 else f n-1 + f n-2

  # First call:
  say "First call:"
  say "Result = {m 5}"

  # Second call: should reuse all values, no "working on..." should appear
  say "\nSecond call:"
  say "Result = {m 5}"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# Example 2
# Results are not saved forever, but only as long as ways_memo is instated
ex315 is
# Defines a memoization effect that handles functions of type i32 -> i32
ways_memo : memoize.memoized i32 i32 is
# Main
ways_memo ! () ->
  # Function 'm' returns cached result or delegates computation to 'f' if not found
  m(n) =>
    ways_memo.env.keep n _->
      f n
  # Recursive function which returns Fibonacci value
  f(n) =>
    say "working on with result for $n"
    if n <= 1 then 1 else f n-1 + f n-2
  # First call:
  say "First call:"
  say "Result = {m 5}"
  # Second call: should reuse all values, no "working on..." should appear
  say "\nSecond call:"
  say "Result = {m 5}"
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

last changed: 2025-05-13

next: Idiom # 316: Count occurrences in a list