eyg_analysis - v1.0.0

eyg/analysis/inference/levels_j/contextual

Types

Analysis

</> 
pub type Analysis(meta) {
  Analysis(
    bindings: dict.Dict(Int, binding.Binding),
    tree: #(
      tree.Expression(
        #(
          Result(Nil, error.Reason),
          isomorphic.Type(Int),
          isomorphic.Type(Int),
          List(#(String, isomorphic.Type(#(Bool, Int)))),
        ),
      ),
      #(
        Result(Nil, error.Reason),
        isomorphic.Type(Int),
        isomorphic.Type(Int),
        List(#(String, isomorphic.Type(#(Bool, Int)))),
      ),
    ),
    original: #(tree.Expression(meta), meta),
  )
}

Constructors

Context

</> 
pub type Context {
  Context(
    env: List(#(String, isomorphic.Type(#(Bool, Int)))),
    eff: isomorphic.Type(Int),
    refs: dict.Dict(v1.Cid, isomorphic.Type(#(Bool, Int))),
    level: Int,
    bindings: dict.Dict(Int, binding.Binding),
  )
}

Constructors

Env

</> 
pub type Env =
  List(#(String, isomorphic.Type(#(Bool, Int))))

Values

all_errors

</> 
pub fn all_errors(
  inference: Analysis(meta),
) -> List(#(meta, error.Reason))

arity_at

</> 
pub fn arity_at(
  inference: Analysis(meta),
  desired: meta,
) -> Result(Int, Nil)

builtins

</> 
pub fn builtins() -> List(
  #(String, isomorphic.Type(#(Bool, Int))),
)

case_

</> 
pub fn case_(label: String) -> isomorphic.Type(#(Bool, Int))

check

</> 
pub fn check(
  context: Context,
  source: #(tree.Expression(meta), meta),
) -> Analysis(meta)

count_args

</> 
pub fn count_args(type_: isomorphic.Type(a)) -> Result(Int, Nil)

do_infer

</> 
pub fn do_infer(
  source: #(tree.Expression(a), a),
  env: List(#(String, isomorphic.Type(#(Bool, Int)))),
  eff: isomorphic.Type(Int),
  refs: dict.Dict(v1.Cid, isomorphic.Type(#(Bool, Int))),
  level: Int,
  bindings: dict.Dict(Int, binding.Binding),
) -> #(
  dict.Dict(Int, binding.Binding),
  isomorphic.Type(Int),
  isomorphic.Type(Int),
  #(
    tree.Expression(
      #(
        Result(Nil, error.Reason),
        isomorphic.Type(Int),
        isomorphic.Type(Int),
        List(#(String, isomorphic.Type(#(Bool, Int)))),
      ),
    ),
    #(
      Result(Nil, error.Reason),
      isomorphic.Type(Int),
      isomorphic.Type(Int),
      List(#(String, isomorphic.Type(#(Bool, Int)))),
    ),
  ),
)

ftv

</> 
pub fn ftv(type_: isomorphic.Type(a)) -> set.Set(a)

handle

</> 
pub fn handle(label: String) -> isomorphic.Type(#(Bool, Int))

infer

</> 
pub fn infer(
  source: #(tree.Expression(a), a),
  eff: isomorphic.Type(Int),
  refs: dict.Dict(v1.Cid, isomorphic.Type(#(Bool, Int))),
  level: Int,
  bindings: dict.Dict(Int, binding.Binding),
) -> #(
  #(
    tree.Expression(
      #(
        Result(Nil, error.Reason),
        isomorphic.Type(Int),
        isomorphic.Type(Int),
        List(#(String, isomorphic.Type(#(Bool, Int)))),
      ),
    ),
    #(
      Result(Nil, error.Reason),
      isomorphic.Type(Int),
      isomorphic.Type(Int),
      List(#(String, isomorphic.Type(#(Bool, Int)))),
    ),
  ),
  dict.Dict(Int, binding.Binding),
)

missing_references

</> 
pub fn missing_references(
  inference: Analysis(meta),
) -> List(v1.Cid)

new_state

</> 
pub fn new_state() -> dict.Dict(a, b)

nocases

</> 
pub fn nocases() -> isomorphic.Type(#(Bool, Int))

poly_type

</> 
pub fn poly_type(
  inference: Analysis(meta),
) -> isomorphic.Type(#(Bool, Int))

pure

</> 
pub fn pure() -> Context

pure creates a new inference context to infer an expression with no effects. Any effect from the expression will be a type error

q

</> 
pub fn q(i: a) -> isomorphic.Type(#(Bool, a))

scope_at

</> 
pub fn scope_at(
  inference: Analysis(meta),
  desired: meta,
) -> Result(List(#(String, isomorphic.Type(#(Bool, Int)))), Nil)

type_

</> 
pub fn type_(inference: Analysis(meta)) -> isomorphic.Type(Int)

Returns the top type from the analysis over an expression

type_at

</> 
pub fn type_at(
  inference: Analysis(meta),
  desired: meta,
) -> Result(isomorphic.Type(Int), Nil)

unpure

</> 
pub fn unpure() -> Context

unpure creates a new inference context which accepts any effect.

with_effect

</> 
pub fn with_effect(
  context: Context,
  label: String,
  lift: isomorphic.Type(Int),
  lower: isomorphic.Type(Int),
) -> Context

with_effects

</> 
pub fn with_effects(
  context: Context,
  effects: List(
    #(String, #(isomorphic.Type(Int), isomorphic.Type(Int))),
  ),
) -> Context

with_references

</> 
pub fn with_references(
  context: Context,
  refs: dict.Dict(v1.Cid, isomorphic.Type(#(Bool, Int))),
) -> Context

Pass in a dictionary of reference to types. This dictionary is also used to look up the types of releases by there cid.

✨ Search Document