Module `Ocaml_typing.Errortrace`

type position =

| First
| Second

val swap_position : 
  Ocaml_typing.Errortrace.position ->
  Ocaml_typing.Errortrace.position

val print_pos : 
  Stdlib.Format.formatter ->
  Ocaml_typing.Errortrace.position ->
  unit

type expanded_type = {

ty : Ocaml_typing.Types.type_expr;
expanded : Ocaml_typing.Types.type_expr;

}

val trivial_expansion : 
  Ocaml_typing.Types.type_expr ->
  Ocaml_typing.Errortrace.expanded_type

trivial_expansion ty creates an expanded_type whose expansion is also ty. Usually, you want Ctype.expand_type instead, since the expansion carries useful information; however, in certain circumstances, the error is about the expansion of the type, meaning that actually performing the expansion produces more confusing or inaccurate output.

type 'a diff = {

got : 'a;
expected : 'a;

}

val map_diff : 
  ('a -> 'b) ->
  'a Ocaml_typing.Errortrace.diff ->
  'b Ocaml_typing.Errortrace.diff

map_diff f {expected;got} is {expected=f expected; got=f got}

type 'a escape_kind =

| Constructor of Ocaml_typing.Path.t
| Univ of Ocaml_typing.Types.type_expr
| Self
| Module_type of Ocaml_typing.Path.t
| Equation of 'a
| Constraint

Scope escape related errors

type 'a escape = {

kind : 'a Ocaml_typing.Errortrace.escape_kind;
context : Ocaml_typing.Types.type_expr option;

}

val map_escape : 
  ('a -> 'b) ->
  'a Ocaml_typing.Errortrace.escape ->
  'b Ocaml_typing.Errortrace.escape

val explain : 'a list -> (prev:'a option -> 'a -> 'b option) -> 'b option

type unification = private

| Unification

Type indices

type comparison = private

| Comparison

type fixed_row_case =

| Cannot_be_closed
| Cannot_add_tags of string list

type 'variety variant =

| Incompatible_types_for : string -> _ Ocaml_typing.Errortrace.variant
| No_tags : Ocaml_typing.Errortrace.position * (Ocaml_parsing.Asttypes.label * Ocaml_typing.Types.row_field) list -> _ Ocaml_typing.Errortrace.variant
| No_intersection : Ocaml_typing.Errortrace.unification Ocaml_typing.Errortrace.variant
| Fixed_row : Ocaml_typing.Errortrace.position * Ocaml_typing.Errortrace.fixed_row_case * Ocaml_typing.Types.fixed_explanation -> Ocaml_typing.Errortrace.unification Ocaml_typing.Errortrace.variant
| Presence_not_guaranteed_for : Ocaml_typing.Errortrace.position * string -> Ocaml_typing.Errortrace.comparison Ocaml_typing.Errortrace.variant
| Openness : Ocaml_typing.Errortrace.position -> Ocaml_typing.Errortrace.comparison Ocaml_typing.Errortrace.variant

type 'variety obj =

| Missing_field : Ocaml_typing.Errortrace.position * string -> _ Ocaml_typing.Errortrace.obj
| Abstract_row : Ocaml_typing.Errortrace.position -> _ Ocaml_typing.Errortrace.obj
| Self_cannot_be_closed : Ocaml_typing.Errortrace.unification Ocaml_typing.Errortrace.obj

type ('a, 'variety) elt =

| Diff : 'a Ocaml_typing.Errortrace.diff -> ('a, _) Ocaml_typing.Errortrace.elt
| Variant : 'variety Ocaml_typing.Errortrace.variant -> ('a, 'variety) Ocaml_typing.Errortrace.elt
| Obj : 'variety Ocaml_typing.Errortrace.obj -> ('a, 'variety) Ocaml_typing.Errortrace.elt
| Escape : 'a Ocaml_typing.Errortrace.escape -> ('a, _) Ocaml_typing.Errortrace.elt
| Incompatible_fields : {
1. name : string;
2. diff : Ocaml_typing.Types.type_expr Ocaml_typing.Errortrace.diff;
} -> ('a, _) Ocaml_typing.Errortrace.elt
| Rec_occur : Ocaml_typing.Types.type_expr * Ocaml_typing.Types.type_expr -> ('a, _) Ocaml_typing.Errortrace.elt
| Bad_jkind : Ocaml_typing.Types.type_expr * Ocaml_typing.Jkind.Violation.t -> ('a, _) Ocaml_typing.Errortrace.elt
| Bad_jkind_sort : Ocaml_typing.Types.type_expr * Ocaml_typing.Jkind.Violation.t -> ('a, _) Ocaml_typing.Errortrace.elt
| Unequal_var_jkinds : Ocaml_typing.Types.type_expr * Ocaml_typing.Types.jkind_lr * Ocaml_typing.Types.type_expr * Ocaml_typing.Types.jkind_lr -> ('a, _) Ocaml_typing.Errortrace.elt
| Unequal_tof_kind_jkinds : Ocaml_typing.Types.jkind_lr * Ocaml_typing.Types.jkind_lr -> ('a, _) Ocaml_typing.Errortrace.elt

type ('a, 'variety) t = ('a, 'variety) Ocaml_typing.Errortrace.elt list

type 'variety trace =
  (Ocaml_typing.Types.type_expr, 'variety) Ocaml_typing.Errortrace.t

type 'variety error =
  (Ocaml_typing.Errortrace.expanded_type, 'variety) Ocaml_typing.Errortrace.t

val map_types : 
  (Ocaml_typing.Types.type_expr -> Ocaml_typing.Types.type_expr) ->
  (Ocaml_typing.Errortrace.expanded_type, 'variety) Ocaml_typing.Errortrace.t ->
  (Ocaml_typing.Errortrace.expanded_type, 'variety) Ocaml_typing.Errortrace.t

merlin specific

val map : 
  ('a -> 'b) ->
  ('a, 'variety) Ocaml_typing.Errortrace.t ->
  ('b, 'variety) Ocaml_typing.Errortrace.t

val incompatible_fields : 
  name:string ->
  got:Ocaml_typing.Types.type_expr ->
  expected:Ocaml_typing.Types.type_expr ->
  (Ocaml_typing.Types.type_expr, _) Ocaml_typing.Errortrace.elt

val swap_trace : 
  ('a, 'variety) Ocaml_typing.Errortrace.t ->
  ('a, 'variety) Ocaml_typing.Errortrace.t

The traces ('variety t) are the core error types. However, we bundle them up into three "top-level" error types, which are used elsewhere: unification_error, equality_error, and moregen_error. In the case of equality_error, this has to bundle in extra information; in general, it distinguishes the three types of errors and allows us to distinguish traces that are being built (or processed) from those that are complete and have become the final error. These error types have the invariants that their traces are nonempty; we ensure that through three smart constructors with matching names.

type unification_error = private {

trace : Ocaml_typing.Errortrace.unification Ocaml_typing.Errortrace.error;

}

type equality_error = private {

trace : Ocaml_typing.Errortrace.comparison Ocaml_typing.Errortrace.error;
subst : (Ocaml_typing.Types.type_expr * Ocaml_typing.Types.type_expr) list;

}

type moregen_error = private {

trace : Ocaml_typing.Errortrace.comparison Ocaml_typing.Errortrace.error;

}

val unification_error : 
  trace:Ocaml_typing.Errortrace.unification Ocaml_typing.Errortrace.error ->
  Ocaml_typing.Errortrace.unification_error

val equality_error : 
  trace:Ocaml_typing.Errortrace.comparison Ocaml_typing.Errortrace.error ->
  subst:(Ocaml_typing.Types.type_expr * Ocaml_typing.Types.type_expr) list ->
  Ocaml_typing.Errortrace.equality_error

val moregen_error : 
  trace:Ocaml_typing.Errortrace.comparison Ocaml_typing.Errortrace.error ->
  Ocaml_typing.Errortrace.moregen_error

type comparison_error =

| Equality_error of Ocaml_typing.Errortrace.equality_error
| Moregen_error of Ocaml_typing.Errortrace.moregen_error

Wraps up the two different kinds of comparison errors in one type

val swap_unification_error : 
  Ocaml_typing.Errortrace.unification_error ->
  Ocaml_typing.Errortrace.unification_error

Lift swap_trace to unification_error

module Subtype : sig ... end

Module Ocaml_typing.Errortrace

Module `Ocaml_typing.Errortrace`