pub const host_language: Expr = STRING("gleam-erlang")

pub const sym_list: Expr = SYMBOL("list")

pub const sym_quasiquote: Expr = SYMBOL("quasiquote")

pub const sym_quote: Expr = SYMBOL("quote")

pub const sym_unquote: Expr = SYMBOL("unquote")

pub const sym_unquote_splicing: Expr = SYMBOL("splice-unquote")

pub fn add2(x: Expr, y: Expr) -> Expr

pub fn apply(env: Env, callable: Expr, args: List(Expr)) -> Expr

pub fn apply_macro(expr: Expr, env: Env) -> Expr

pub fn args_to_str(args: List(Expr)) -> String

pub fn bif_add(exprs: List(Expr), env: Env) -> Expr

pub fn bif_and(exprs: List(Expr), env: Env) -> Expr

pub fn bif_apply(exprs: List(Expr), env: Env) -> Expr

pub fn bif_assoc(exprs: List(Expr), env: Env) -> Expr

pub fn bif_atom(exprs: List(Expr), env: Env) -> Expr

pub fn bif_atomp(exprs: List(Expr), env: Env) -> Expr

pub fn bif_car(exprs: List(Expr), env: Env) -> Expr

pub fn bif_cdr(exprs: List(Expr), env: Env) -> Expr

pub fn bif_cons(exprs: List(Expr), env: Env) -> Expr

pub fn bif_containsp(exprs: List(Expr), env: Env) -> Expr

pub fn bif_count(exprs: List(Expr), env: Env) -> Expr

pub fn bif_custom_type_to_map(
  exprs: List(Expr),
  env: Env,
) -> Expr

pub fn bif_def_custom_type(exprs: List(Expr), env: Env) -> Expr

pub fn bif_deref(exprs: List(Expr), env: Env) -> Expr

pub fn bif_describe(exprs: List(Expr), env: Env) -> Expr

pub fn bif_dissoc(exprs: List(Expr), env: Env) -> Expr

pub fn bif_div(exprs: List(Expr), env: Env) -> Expr

pub fn bif_emptyp(exprs: List(Expr), env: Env) -> Expr

pub fn bif_eqp(exprs: List(Expr), env: Env) -> Expr

pub fn bif_eval(exprs: List(Expr), env: Env) -> Expr

pub fn bif_falsep(exprs: List(Expr), env: Env) -> Expr

pub fn bif_fnp(exprs: List(Expr), env: Env) -> Expr

pub fn bif_gensym(exprs: List(Expr), env: Env) -> Expr

pub fn bif_get(exprs: List(Expr), env: Env) -> Expr

pub fn bif_global_get(exprs: List(Expr), env: Env) -> Expr

pub fn bif_global_keys(exprs: List(Expr), env: Env) -> Expr

pub fn bif_gteqp(exprs: List(Expr), env: Env) -> Expr

pub fn bif_gtp(exprs: List(Expr), env: Env) -> Expr

pub fn bif_hash_map(exprs: List(Expr), env: Env) -> Expr

pub fn bif_hash_mapp(exprs: List(Expr), env: Env) -> Expr

pub fn bif_inspect(exprs: List(Expr), env: Env) -> Expr

pub fn bif_inspect_env(exprs: List(Expr), env: Env) -> Expr

pub fn bif_instanciate_custom_type(
  exprs: List(Expr),
  env: Env,
) -> Expr

pub fn bif_keys(exprs: List(Expr), env: Env) -> Expr

pub fn bif_keyword(exprs: List(Expr), env: Env) -> Expr

pub fn bif_keywordp(exprs: List(Expr), env: Env) -> Expr

pub fn bif_list(exprs: List(Expr), env: Env) -> Expr

pub fn bif_listp(exprs: List(Expr), env: Env) -> Expr

pub fn bif_load_file(exprs: List(Expr), env: Env) -> Expr

pub fn bif_lteqp(exprs: List(Expr), env: Env) -> Expr

pub fn bif_ltp(exprs: List(Expr), env: Env) -> Expr

pub fn bif_macrop(exprs: List(Expr), env: Env) -> Expr

pub fn bif_meta(exprs: List(Expr), env: Env) -> Expr

pub fn bif_mod(exprs: List(Expr), env: Env) -> Expr

pub fn bif_mul(exprs: List(Expr), env: Env) -> Expr

pub fn bif_nilp(exprs: List(Expr), env: Env) -> Expr

pub fn bif_not(exprs: List(Expr), env: Env) -> Expr

pub fn bif_numberp(exprs: List(Expr), env: Env) -> Expr

pub fn bif_or(exprs: List(Expr), env: Env) -> Expr

pub fn bif_pr_str(exprs: List(Expr), env: Env) -> Expr

pub fn bif_println(exprs: List(Expr), env: Env) -> Expr

pub fn bif_prn(exprs: List(Expr), env: Env) -> Expr

pub fn bif_progn(exprs: List(Expr), env: Env) -> Expr

pub fn bif_read(exprs: List(Expr), env: Env) -> Expr

pub fn bif_read_string(exprs: List(Expr), env: Env) -> Expr

pub fn bif_readline(exprs: List(Expr), env: Env) -> Expr

pub fn bif_reset(exprs: List(Expr), env: Env) -> Expr

pub fn bif_sequentialp(exprs: List(Expr), env: Env) -> Expr

pub fn bif_show(exprs: List(Expr), env: Env) -> Expr

pub fn bif_slurp(exprs: List(Expr), env: Env) -> Expr

pub fn bif_str(exprs: List(Expr), env: Env) -> Expr

pub fn bif_stringp(exprs: List(Expr), env: Env) -> Expr

pub fn bif_sub(exprs: List(Expr), env: Env) -> Expr

pub fn bif_symbol(exprs: List(Expr), env: Env) -> Expr

pub fn bif_symbolp(exprs: List(Expr), env: Env) -> Expr

pub fn bif_throw(exprs: List(Expr), env: Env) -> Expr

pub fn bif_time_ms(exprs: List(Expr), env: Env) -> Expr

pub fn bif_to_hash_map(exprs: List(Expr), env: Env) -> Expr

pub fn bif_tokenize(exprs: List(Expr), env: Env) -> Expr

pub fn bif_trace(exprs: List(Expr), env: Env) -> Expr

pub fn bif_trace_clear(exprs: List(Expr), env: Env) -> Expr

pub fn bif_truep(exprs: List(Expr), env: Env) -> Expr

pub fn bif_vals(exprs: List(Expr), env: Env) -> Expr

pub fn bif_vec(exprs: List(Expr), env: Env) -> Expr

pub fn bif_vector(exprs: List(Expr), env: Env) -> Expr

pub fn bif_vectorp(exprs: List(Expr), env: Env) -> Expr

pub fn bif_with_meta(exprs: List(Expr), env: Env) -> Expr

pub fn bispform_def(exprs: List(Expr), env: Env) -> Expr

pub fn bispform_defmacro(exprs: List(Expr), env: Env) -> Expr

pub fn bispform_erase(exprs: List(Expr), env: Env) -> Expr

pub fn bispform_fn(exprs: List(Expr), env: Env) -> Expr

pub fn bispform_if(exprs: List(Expr), env: Env) -> Expr

pub fn bispform_let(exprs: List(Expr), env: Env) -> Expr

pub fn bispform_macro(exprs: List(Expr), env: Env) -> Expr

pub fn bispform_macroexpand(exprs: List(Expr), env: Env) -> Expr

pub fn bispform_macroexpand_all(
  exprs: List(Expr),
  env: Env,
) -> Expr

pub fn bispform_quasiquote(exprs: List(Expr), env: Env) -> Expr

pub fn bispform_quasiquote2(exprs: List(Expr), env: Env) -> Expr

pub fn bispform_quasiquote_expand(
  exprs: List(Expr),
  env: Env,
) -> Expr

pub fn bispform_quasiquote_expand2(
  exprs: List(Expr),
  env: Env,
) -> Expr

pub fn bispform_quote(exprs: List(Expr), env: Env) -> Expr

pub fn bispform_try(exprs: List(Expr), env: Env) -> Expr

pub fn compare(u: Expr, v: Expr) -> Order

pub fn compare_dict(us: List(Expr), vs: List(Expr)) -> Order

pub fn compare_list(us: List(Expr), vs: List(Expr)) -> Order

pub fn describe(expr: Expr) -> String

pub fn description(name: String) -> Description

pub fn description_with_text(
  name: String,
  text: String,
) -> Description

pub fn dict_to_str(dict: Dict(String, Expr)) -> String

pub fn div2(x: Expr, y: Expr) -> Expr

pub fn dump_closure(msg: String, expr: Expr) -> Bool

pub fn dump_dict(dict: Dict(String, Expr), env: Env) -> Bool

pub fn dump_env(title: String, env: Env) -> Bool

pub fn env_add_local_scope(env: Env, scope: Scope) -> Env

pub fn env_erase_global(env: Env, key: String) -> Expr

pub fn env_get(env: Env, key: String) -> Result(Expr, String)

pub fn env_get_global(env: Env, key: String) -> Expr

pub fn env_get_global_aux(env: Env, key: String) -> Expr

pub fn env_get_global_keys(env: Env) -> List(String)

pub fn env_get_toplevel(env: Env) -> Env

pub fn env_replace_local_scope(env: Env, scope: Scope) -> Env

pub fn env_set_global(env: Env, key: String, value: Expr) -> Env

pub fn env_set_local(env: Env, key: String, value: Expr) -> Env

pub fn env_update_global_aux(
  env: Env,
  key: String,
  property_name: Expr,
  property_value: Expr,
) -> Nil

pub fn eval(exprs: List(Expr), result: Expr, env: Env) -> Expr

pub fn eval_contents(
  exprs: List(Expr),
  acc: List(Expr),
  env: Env,
) -> #(List(Expr), Env)

pub fn eval_expr(expr: Expr, env: Env) -> Expr

pub fn eval_funcall_args(
  exprs: List(Expr),
  env: Env,
) -> #(List(Expr), Env)

pub fn generate_new_env(
  pdic: PDic,
  default_bindings: Dict(String, Expr),
  init_files: List(String),
) -> Env

pub fn get_bif_result_value(expr: Expr) -> a

pub fn get_contents(expr: Expr) -> List(Expr)

pub fn get_macro(env: Env, ast: Expr) -> Result(Expr, String)

pub fn global_keys(prefix: String, env: Env) -> List(String)

pub fn indent(level: Int) -> String

pub fn info_to_str(inf: Info) -> String

pub fn initialize() -> Bool

pub fn inspect(expr: Expr) -> String

pub fn intern_keyword(str: String) -> Expr

pub fn intern_symbol(str: String) -> Expr

pub fn intern_symbol_or_keyword(str: String) -> Expr

pub fn is_empty_value(val: Expr) -> Bool

pub fn is_equal(first: Expr, second: Expr) -> Bool

pub fn is_false_value(val: Expr) -> Bool

pub fn is_nil_value(val: Expr) -> Bool

pub fn is_true_condition(e: Expr) -> Bool

pub fn is_true_value(val: Expr) -> Bool

pub fn local_scopes_to_string(
  scopes: List(Scope),
  acc: List(String),
) -> String

pub fn macroexpand(env: Env, ast: Expr) -> Expr

pub fn macroexpand_all(env: Env, ast: Expr) -> Expr

pub fn main() -> a

pub fn make_container(
  template_expr: Expr,
  contents: List(Expr),
) -> Expr

pub fn make_new_l4u_core_env(
  pdic: PDic,
  bifs: List(#(String, Expr)),
  files: List(String),
) -> Env

pub fn map_to_plist(
  mapdata: Dict(String, Expr),
  acc: List(Expr),
) -> List(Expr)

pub fn mul2(x: Expr, y: Expr) -> Expr

pub fn parse(
  tokens: List(String),
  env: Env,
) -> #(Expr, List(String))

pub fn parse_expr(token: String, env: Env) -> Expr

pub fn parse_list(
  tokens: List(String),
  acc: List(Expr),
  terminator: String,
  env: Env,
) -> #(List(Expr), List(String))

pub fn parse_string(str: String, env: Env) -> Expr

pub fn parse_string_block(str: String, env: Env) -> Expr

pub fn plist_to_map(
  plist: List(Expr),
  acc: Dict(String, Expr),
) -> Dict(String, Expr)

pub fn print(expr: Expr) -> String

pub fn print_2(expr: Expr) -> String

pub fn pstr(expr: Expr) -> String

pub fn quasiquote_(expr: Expr, env: Env) -> #(List(Expr), Env)

pub fn read(src: String, env: Env) -> List(Expr)

pub fn rep(src: String, env: Env) -> Expr

pub fn repl(env: Env, prompt: String) -> a

pub fn repl_print(result: Expr) -> Nil

pub fn show(expr: Expr) -> String

pub fn string_trim(source: String) -> String

pub fn sub2(x: Expr, y: Expr) -> Expr

pub fn to_l4u_bool(flag: Bool) -> Expr

pub fn to_simple_str(expr: Expr) -> String

pub fn tokenize(src: String, env: Env) -> List(String)

pub fn trace_closure_call(
  env: Env,
  callable: Expr,
  ecallable: a,
  bindings: Dict(String, Expr),
) -> Int

pub fn trace_closure_return(
  env: Env,
  callable: Expr,
  ecallable: a,
  rexpr: Expr,
  ip: Int,
) -> Bool

pub fn trace_set_last_expr(expr: Expr, env: Env) -> Bool

pub fn trace_set_last_funcall(expr: Expr, env: Env) -> Bool

pub fn uneval(expr: Expr) -> Expr

pub fn unwrap(expr: Expr) -> Expr

pub fn vars_to_string(vars: Dict(String, Expr)) -> String