gemo - v1.0.1

gemo

Functions

cache_count

</> 
pub fn cache_count() -> Int

Get the amount of cached data.

cache_density

</> 
pub fn cache_density() -> Float

cache_size / cache_count

cache_size

</> 
pub fn cache_size() -> Int

Get the cache size in bytes.

memoize0

</> 
pub fn memoize0(func: fn() -> a, cb: fn() -> a) -> a

Takes the parent function as a key and executes the callback if its output is not already cached. This should be called with a use expression at the top of the function

Example:

fn complex_task() {
  use <- glemo.memoize0(complex_task)
  "./huge_file.csv"
  |> read_file
  |> hash
}

memoize1

</> 
pub fn memoize1(func: fn(a) -> b, arg1: a, cb: fn() -> b) -> b

Takes the parent function and its args as a key and executes the callback if its output is not already cached. This should be called with a use expression at the top of the function

Example:

fn fib(n) {
  use <- glemo.memoize1(fib, n)
  use <- bool.guard(n <= 1, n)
  fib(n - 1) + fib(n - 2)
}

memoize10

</> 
pub fn memoize10(
  func: fn(a, b, c, d, e, f, g, h, i, j) -> k,
  arg1: a,
  arg2: b,
  arg3: c,
  arg4: d,
  arg5: e,
  arg6: f,
  arg7: g,
  arg8: h,
  arg9: i,
  arg10: j,
  cb: fn() -> k,
) -> k

Same as memoize1 but with 10 args.

memoize2

</> 
pub fn memoize2(
  func: fn(a, b) -> c,
  arg1: a,
  arg2: b,
  cb: fn() -> c,
) -> c

Same as memoize1 but with 2 args.

memoize3

</> 
pub fn memoize3(
  func: fn(a, b, c) -> d,
  arg1: a,
  arg2: b,
  arg3: c,
  cb: fn() -> d,
) -> d

Same as memoize1 but with 3 args.

memoize4

</> 
pub fn memoize4(
  func: fn(a, b, c, d) -> e,
  arg1: a,
  arg2: b,
  arg3: c,
  arg4: d,
  cb: fn() -> e,
) -> e

Same as memoize1 but with 4 args.

memoize5

</> 
pub fn memoize5(
  func: fn(a, b, c, d, e) -> f,
  arg1: a,
  arg2: b,
  arg3: c,
  arg4: d,
  arg5: e,
  cb: fn() -> f,
) -> f

Same as memoize1 but with 5 args.

memoize6

</> 
pub fn memoize6(
  func: fn(a, b, c, d, e, f) -> g,
  arg1: a,
  arg2: b,
  arg3: c,
  arg4: d,
  arg5: e,
  arg6: f,
  cb: fn() -> g,
) -> g

Same as memoize1 but with 6 args.

memoize7

</> 
pub fn memoize7(
  func: fn(a, b, c, d, e, f, g) -> h,
  arg1: a,
  arg2: b,
  arg3: c,
  arg4: d,
  arg5: e,
  arg6: f,
  arg7: g,
  cb: fn() -> h,
) -> h

Same as memoize1 but with 7 args.

memoize8

</> 
pub fn memoize8(
  func: fn(a, b, c, d, e, f, g, h) -> i,
  arg1: a,
  arg2: b,
  arg3: c,
  arg4: d,
  arg5: e,
  arg6: f,
  arg7: g,
  arg8: h,
  cb: fn() -> i,
) -> i

Same as memoize1 but with 8 args.

memoize9

</> 
pub fn memoize9(
  func: fn(a, b, c, d, e, f, g, h, i) -> j,
  arg1: a,
  arg2: b,
  arg3: c,
  arg4: d,
  arg5: e,
  arg6: f,
  arg7: g,
  arg8: h,
  arg9: i,
  cb: fn() -> j,
) -> j

Same as memoize1 but with 9 args.

reset_cache

</> 
pub fn reset_cache() -> Nil
✨ Search Document