package codept-lib

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

Parameters
Signature

codept-lib
- Approx_parser
- Ast_converter
- Cmi
- Debug
- Dep_zipper
  - Make
    
    Env
    
    Param
  - Outline
    
    Env
- Deps
  - Edge
- Envt
  - Core
- Fault
  - Level
  - Log
  - Policy
- Format_compat
- Format_tags
- Id
- Loc
  - Sch
- Longident_converter
- M2l
  - Annot
    
    Access
  - Build
  - Sch
  - Sig_only
- Modname
  - Map
- Module
  - Arg
  - Def
  - Dict
  - Divergence
  - Equal
  - Namespace
  - Origin
  - Partial
  - Schema
  - Sig
- Mresult
  - Error
  - Ok
- Name
  - Map
  - Set
- Namespaced
  - Map
  - Set
- Option
  - List'
- Paths
  - Expr
    
    Map
  - Make_expr
    
    Map
    
    S
  - Simple
    
    Map
    
    Set
  - simple_core
- Pkg
  - Map
  - Set
- Pp
- Pparse_compat
- Read
- Schema
  - Lbl
- Schematic
  - Ext
  - L
  - Label
    
    X
  - Record
  - Tuple
  - Untyped
  - Version
  - label
- Schematic_indices
  - N
- Slex
- Solver
  - Directed
    
    Envt
    
    Eval
    
    Param
  - Failure
  - Make
    
    Envt
    
    Eval
    
    Param
- Sparser
- Stage
  - envt
  - generic_outliner
  - outliner
  - param
- Standard_faults
- Standard_policies
- Summary
  - View
- Support
  - Map
    
    Make
    
    X
    
    S
- Transforms
- Uloc
  - Pp
- Unit
  - Group
    
    Map
  - Set
- Unitname
  - Map
  - Set
- Win32_compat
- With_deps
- Zipper
- Zipper_def
  - fold
  - s
    
    Abbrevs
    
    T
  - tree
- Zipper_fold
  - Make
    
    Env
    
    X
  - Zpath
    
    Abbrevs
    
    X
- Zipper_pp
  - Make
    
    Def
    
    Abbrevs
    
    T
    
    R
  - Opaque
    
    Def
    
    Abbrevs
    
    T
  - Result_printer
    
    T
- Zipper_skeleton
  - State
    
    Env
  - state
codept-lib.bundled
- Bundle

Legend:
Library
Module
Module type
Parameter
Class
Class type

Create a solver using the environment module Envt for name resolution and dependendy tracking and the parameter module Param

Parameters

module Envt : Stage.envt

module Param : Stage.param

module Eval : Stage.outliner with type envt := Envt.t

Signature

type state = {

resolved : Unit.r Pkg.map;
env : Envt.t;
pending : Eval.on_going i list;
postponed : Unit.s list;

}

val start : Envt.t -> Unit.s list -> state

val eval : ?learn:bool -> state -> Eval.on_going i -> state

eval ~learn {resolved; envt; rest} unit try to compute the signature of unit, and if successful add the unit to the resolved list. Otherwise, the unit is added to the unresolved list. The learn parameter determines, if the environment is updated when the unit is fully resolved

val resolve_dependencies : 
  ?learn:bool ->
  state ->
  (Envt.t * Unit.r list, state) result

val resolve_split_dependencies : 
  Envt.t ->
  Unit.s list Unit.pair ->
  (Unit.r list Unit.pair, [> `Mli of state | `Ml of Unit.r list * state ])
    result

Resolve mli unit first, then use the new environment to resolve ml units

val alias_resolver : state -> Failure.alias_resolver

Resolve current aliases

val blocker : Eval.on_going Failure.blocker

expose current blocker on an on_going element

val approx_and_try_harder : state -> state

Add approximation to make cycle resolvable, possibly adding spurious dependencies. Drop intermediary units that are deemed non-resolvable

val eq : state -> state -> bool

Compare if two states would lead to the same result for the solver (weak equality?).

val solve : Envt.t -> Unit.s list Unit.pair -> Unit.r list Unit.pair

Solve *