gloop

This module called Gloop introduces stack-safe, tall-call recursive, non-UI blocking while loops in Gleam The intent is to remove the additional mental burden recursion causes in Gleam.

For an example of how to use this library see gloop_test.gleam in the test folder.

Functions

pub fn blocking_do_while(
  state state: a,
  code_to_run code_to_run: fn(a) -> a,
  post_run_condition post_run_condition: fn(a) -> Bool,
) -> a

This blocking do while function checks the condition based on the communicated state at the end of a iteration. It therefore runs the code AT LEAST once. As the other blocking while function it is stack-safe and a few milliseconds faster than the non-blocking do while function. As before, it should not be used in the majority of cases.

pub fn blocking_while(
  state state: a,
  pre_run_condition pre_run_condition: fn(a) -> Bool,
  code_to_run code_to_run: fn(a) -> a,
) -> a

This blocking while function is stack-safe and checks the condition based on the communicated state. If the condition is true then the code is run and a new state is generated for the next iteration. If the condition is false then the code returns the final state and stops. As long as the condition is true, the while loop will continue without blowing up the stack. NOTE that this fuction blocks the UI from updating. It is slightly (a few msecs) faster than the non-blocking while function so if pure speed is what you are after AND you have a good idea of how many loops the function will execute then this function might be what you are after. In most cases ( >95% ) this is NOT the function you should use.

pub fn do_while(
  state state: a,
  code_to_run code_to_run: fn(a) -> a,
  post_run_condition post_run_condition: fn(a) -> Bool,
) -> a

This non-blocking do while function does the same thing as the blocking do while function, is stack-safe and does not block the UI. Again this is the function to select in the overwhelming majority of cases.

pub fn while(
  state state: a,
  pre_run_condition pre_run_condition: fn(a) -> Bool,
  code_to_run code_to_run: fn(a) -> a,
) -> a

This while function does the same thing as the blocking while function BUT does not block the UI from updating and is stack-safe. This is the function to use in the overwhelming majority of cases.

Search Document