package ocaml-base-compiler

  1. Overview
  2. Docs
package ocaml-base-compiler
Legend:
Library
Module
Module type
Parameter
Class
Class type

Detection of partial matches and unused match cases.

type 'pattern parmatch_case = {
  1. pattern : 'pattern;
  2. has_guard : bool;
  3. needs_refute : bool;
    (*

    true if the program text claims the case is unreachable, a la function _ -> .

    *)
}

Most checks in this file need not access all information about a case, and just need a few pieces of information. parmatch_case is those few pieces of information.

type 'category typed_case := 'category Typedtree.general_pattern parmatch_case
val typed_case : 'category Typedtree.case -> 'category typed_case
val const_compare : Asttypes.constant -> Asttypes.constant -> int

const_compare c1 c2 compares the actual values represented by c1 and c2, while simply using Stdlib.compare would compare the representations.

cf. MPR#5758

val le_pat : Typedtree.pattern -> Typedtree.pattern -> bool

le_pat p q means: forall V, V matches q implies V matches p

val le_pats : Typedtree.pattern list -> Typedtree.pattern list -> bool

le_pats (p1 .. pm) (q1 .. qn) means: forall i <= m, le_pat pi qi

module Compat (_ : sig ... end) : sig ... end

Exported compatibility functor, abstracted over constructor equality

exception Empty

lub p q is a pattern that matches all values matched by p and q. May raise Empty, when p and q are not compatible.

val lubs : Typedtree.pattern list -> Typedtree.pattern list -> Typedtree.pattern list

lubs [p1; ...; pn] [q1; ...; qk], where n < k, is [lub p1 q1; ...; lub pk qk].

val get_mins : ('a -> 'a -> bool) -> 'a list -> 'a list

Those two functions recombine one pattern and its arguments: For instance: (_,_)::p1::p2::rem -> (p1, p2)::rem The second one will replace mutable arguments by '_'

val set_args_erase_mutable : Typedtree.pattern -> Typedtree.pattern list -> Typedtree.pattern list
val pats_of_type : Env.t -> Types.type_expr -> Typedtree.pattern list

pats_of_type builds a list of patterns from a given expected type, for explosion of wildcard patterns in Typecore.type_pat.

There are four interesting cases:

  • the type is empty ()
  • no further explosion is necessary (Pat_any)
  • a single pattern is generated, from a record or tuple type or a single-variant type (tp)
  • a list of patterns, in the case that all branches are GADT constructors (tp1; ..; tpn).
val pressure_variants : Env.t -> Typedtree.pattern list -> unit
val pressure_variants_in_computation_pattern : Env.t -> Typedtree.computation Typedtree.general_pattern list -> unit

check_partial pred loc caselist and check_unused refute pred caselist are called with a function pred which will be given counter-example candidates: they may be partially ill-typed, and have to be type-checked to extract a valid counter-example. pred returns a valid counter-example or None. refute indicates that check_unused was called on a refutation clause.

val check_unused : (bool -> Typedtree.pattern -> Typedtree.pattern option) -> Typedtree.value typed_case list -> unit
val irrefutable : Typedtree.pattern -> bool
val inactive : partial:Typedtree.partial -> Typedtree.pattern -> bool

An inactive pattern is a pattern, matching against which can be duplicated, erased or delayed without change in observable behavior of the program. Patterns containing (lazy _) subpatterns or reads of mutable fields are active.

val check_ambiguous_bindings : Typedtree.value Typedtree.case list -> unit
val some_private_tag : Asttypes.label
OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct