package codept-lib

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

Printers

package codept-lib

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

module Arg : sig ... end

Arg submodule for functor arguments

module Divergence : sig ... end

Every time a module with an unknown signature is opened, it can possibly shadows all modules present in the current, or none. The Divergence module is use to store information about such divergence point, in order to be able to pinpoint to the user the exact moment where dependency computation might have gone awry.

module Origin : sig ... end

Module origin

type origin = Origin.t

Type-level tags

type extended = private

| Extended

type simple = private

| Simple

type tracked_signature = {

origin : Origin.t;
signature : signature;

}

Signature with tracked origin

and _ ty =

| Sig : tracked_signature -> 'any ty
(*
Classic module
*)
| Alias : {
1. path : Namespaced.t;
  (*
  Path.To.Target: projecting this path may create new dependencies
  *)
2. phantom : Divergence.t option;
  (*
  Track potential delayed dependencies after divergent accident:
```
module M = A  (* Alias { name = M; path = [A] } *)
open Unknownable (* <- divergence *)
open M (* Alias{ phantom = Some divergence } *)
```
  In the example above, M could be the local module .M, triggering the delayed alias dependency A. Or it could be a submodule Unknownable.M. Without sufficient information, codept defaults to computing an upper bound of dependencies, and therefore considers that M is .M, and the inferred dependencies for the above code snipet is {A,Unknowable} .
  *)
} -> extended ty
| Abstract : Id.t -> 'any ty
(*
Abstract module type may be refined during functor application, keeping track of their identity is thus important
*)
| Fun : 'a ty Arg.t option * 'a ty -> 'a ty
| Link : Namespaced.t -> extended ty
(*
Link to a compilation unit
*)
| Namespace : dict -> extended ty
(*
Namespace are open bundle of modules
*)

Core module or alias

and t = extended ty

and definition = {

modules : dict;
module_types : dict;

}

and signature =

| Blank
(*
Unknown signature, used as for extern module, placeholder, …
*)
| Exact of definition
| Divergence of {
1. point : Divergence.t;
2. before : signature;
3. after : definition;
}
(*
A divergent signature happens when a signature inference is disturbed by opening or including an unknowable module: module A = … include Extern (* <- divergence *) module B = A (* <- which A is this: .A or Extern.A ?*)
*)

and dict = t Name.map

type sty = simple ty

type named = Name.t * t

type level =

| Module
| Module_type

type modul_ = t

val is_exact : t -> bool

Helper function

val is_functor : t -> bool

module Dict : sig ... end

val spirit_away : Divergence.t -> t -> t

transform to a ghost module

val md : tracked_signature -> t

val empty : 'a Name.map

val create : ?origin:origin -> signature -> tracked_signature

val with_namespace : Paths.S.t -> Name.t -> t -> named

val namespace : Namespaced.t -> named

val aliases : t -> Namespaced.t list

val mockup : ?origin:Origin.t -> ?path:Pkg.t -> Name.t -> tracked_signature

Create a mockup module with empty signature

Printers

val pp : Format.formatter -> t -> unit

val reflect : Format.formatter -> t -> unit

val pp_signature : Format.formatter -> signature -> unit

val reflect_signature : Format.formatter -> signature -> unit

val reflect_modules : Format.formatter -> dict -> unit

val pp_alias : Format.formatter -> Paths.Expr.t option -> unit

val pp_level : Format.formatter -> level -> unit

val pp_mdict : Format.formatter -> dict -> unit

val pp_pair : Format.formatter -> (string * t) -> unit

val pp_arg : Format.formatter -> t Arg.t -> unit

module Schema : sig ... end

module Def : sig ... end

Helper functions for definitions

module Equal : sig ... end

Equalities

module Sig : sig ... end

Helper functions for signature

module Partial : sig ... end

Anonymous module and other partial definitions

module Namespace : sig ... end