eyg_interpreter - v3.1.0

eyg/interpreter/expression

Values

await

</> 
pub fn await(
  ret: Result(
    value.Value(a, #(List(#(state.Kontinue(a), a)), state.Env(a))),
    #(
      break.Reason(
        a,
        #(List(#(state.Kontinue(a), a)), state.Env(a)),
      ),
      a,
      state.Env(a),
      state.Stack(a),
    ),
  ),
) -> promise.Promise(
  Result(
    value.Value(a, #(List(#(state.Kontinue(a), a)), state.Env(a))),
    #(
      break.Reason(
        a,
        #(List(#(state.Kontinue(a), a)), state.Env(a)),
      ),
      a,
      state.Env(a),
      state.Stack(a),
    ),
  ),
)

call

</> 
pub fn call(
  f: value.Value(
    t,
    #(List(#(state.Kontinue(t), t)), state.Env(t)),
  ),
  args: List(
    #(
      value.Value(
        t,
        #(List(#(state.Kontinue(t), t)), state.Env(t)),
      ),
      t,
    ),
  ),
) -> Result(
  value.Value(t, #(List(#(state.Kontinue(t), t)), state.Env(t))),
  #(
    break.Reason(
      t,
      #(List(#(state.Kontinue(t), t)), state.Env(t)),
    ),
    t,
    state.Env(t),
    state.Stack(t),
  ),
)

Call an evaluated function with a list of args

call_field

</> 
pub fn call_field(
  record: value.Value(
    t,
    #(List(#(state.Kontinue(t), t)), state.Env(t)),
  ),
  field: String,
  meta: t,
  args: List(
    #(
      value.Value(
        t,
        #(List(#(state.Kontinue(t), t)), state.Env(t)),
      ),
      t,
    ),
  ),
) -> Result(
  value.Value(t, #(List(#(state.Kontinue(t), t)), state.Env(t))),
  #(
    break.Reason(
      t,
      #(List(#(state.Kontinue(t), t)), state.Env(t)),
    ),
    t,
    state.Env(t),
    state.Stack(t),
  ),
)

execute

</> 
pub fn execute(
  exp: #(tree.Expression(t), t),
  scope: List(
    #(
      String,
      value.Value(
        t,
        #(List(#(state.Kontinue(t), t)), state.Env(t)),
      ),
    ),
  ),
) -> Result(
  value.Value(t, #(List(#(state.Kontinue(t), t)), state.Env(t))),
  #(
    break.Reason(
      t,
      #(List(#(state.Kontinue(t), t)), state.Env(t)),
    ),
    t,
    state.Env(t),
    state.Stack(t),
  ),
)

Execute an expression within a scope

resume

</> 
pub fn resume(
  value: value.Value(
    m,
    #(List(#(state.Kontinue(m), m)), state.Env(m)),
  ),
  env: state.Env(m),
  k: state.Stack(m),
) -> Result(
  value.Value(m, #(List(#(state.Kontinue(m), m)), state.Env(m))),
  #(
    break.Reason(
      m,
      #(List(#(state.Kontinue(m), m)), state.Env(m)),
    ),
    m,
    state.Env(m),
    state.Stack(m),
  ),
)

Resume the interpretation loop with a value from a previous break position. This can be used to resume after any break but is normally used to implement effects and reference lookup

✨ Search Document