memory_rec

支持递归，但并发不安全。 尾递归函数经过处理后不再是尾递归的，存在爆栈风险。

Examples

// 使用递归版的缓存需要对函数进行一些处理
//
// 很经典的阶乘函数，要想让它能够使用缓存需要以下几步
// pub fn factorial(i: Int) -> Int {
//   factorial_loop(i, i)
// }
//
// fn factorial_loop(i: Int, acc: Int) -> Int {
//   case i {
//     0 | 1 -> acc
//     _ -> factorial_loop(i - 1, acc * { i - 1 })
//   }
// }
// =======================================================================
// 1、
// pub fn factorial(i: Int) -> Int {
//   case i {
//     0 | 1 -> acc
//     _ -> factorial_loop(i - 1, acc * { i - 1 })
//   }
// }
//
// 2、
// fn factorial(rec: fn(#(Int, Int)) -> Int, t: #(Int, Int)) -> Int {
//   let #(i, acc) = t
//
//   case i {
//     0 | 1 -> acc
//     _ -> rec(#(i - 1, acc * { i - 1 }))
//   }
// }
//
// 处理完就是以下样子
pub fn factorial(rec: fn(#(Int, Int)) -> Int, t: #(Int, Int)) -> Int {
  let #(i, acc) = t

  case i {
    0 | 1 -> acc
    _ -> rec(#(i - 1, acc * { i - 1 }))
  }
}

import memory_rec
import gleam/time/timestamp

pub fn main() {
  let time = fn() { timestamp.system_time() |> timestamp.to_unix_seconds() }

  let assert Ok(factorial) = memory_rec.new(factorial)

  // 1. 5.299499034881592
  // 2. 1.6671595573425293
  int.range(0, 2, 0.0, fn(_, _) {
    let t = time()
    factorial(#(40_000, 40_000))
    echo time() -. t
  })
}

pub fn new(
  rec_func: fn(fn(key) -> val, key) -> val,
) -> Result(fn(key) -> val, actor.StartError)