jon.recoil.org

Module Mode.LinearitySource

Sourcemodule Const : sig ... end
include Common_axis_pos with module Const := Const
include Mode_intf.Common_axis with module Const := Const and type 'd t = (Const.t, 'd Allowance.pos) mode and type 'd hint_const := 'd Mode_intf.pos_hint_const
include Mode_intf.Common with module Const := Const and type simple_error = Const.t Mode_intf.simple_error with type 'd t = (Const.t, 'd Allowance.pos) mode
Sourcetype error

Takes a submode error accompanied by a pinpoint of the original submode, returns an explaining printer for each side. Each printer prints either a mode constant name, or "mode because ...". The function assumes pinpoint is already printed, which allows simplifying its own printing. The caller is responsible for printing pinpoint and placing the result of this function in a suitable linguistic context.

Sourcetype equate_error = Mode_intf.equate_step * error
Sourceval to_simple_error : error -> simple_error
Sourcetype 'd t = (Const.t, 'd Allowance.pos) mode

Left-only mode

Right-only mode

Left-right mode

include Allowance.Allow_disallow with type (_, _, 'd) sided = 'd t
Sourcetype (_, _, 'd) sided = 'd t
Sourceval disallow_right : ('a, 'b, 'l * 'r) sided -> ('a, 'b, 'l * Allowance.disallowed) sided

Disallows on the right.

Sourceval disallow_left : ('a, 'b, 'l * 'r) sided -> ('a, 'b, Allowance.disallowed * 'r) sided

Disallows a the left.

Sourceval allow_right : ('a, 'b, 'l * Allowance.allowed) sided -> ('a, 'b, 'l * 'r) sided

Generalizes a right-hand-side allowed to be any allowance.

Sourceval allow_left : ('a, 'b, Allowance.allowed * 'r) sided -> ('a, 'b, 'l * 'r) sided

Generalizes a left-hand-side allowed to be any allowance.

Sourceval min : lr
Sourceval max : lr
Sourceval legacy : lr
Sourceval newvar : unit -> ('l * 'r) t
Sourceval submode : ?pp:Mode_hint.pinpoint -> (Allowance.allowed * 'r) t -> ('l * Allowance.allowed) t -> (unit, error) result

Takes the actual and expected mode of something, check that the actual mode is less than the expected mode. In case of error, the error is returned and no mutation is done.

The two modes should be hinted sufficently that the submode is self-evident. In particular, the two modes should be about the "same thing". See the notes How to submode for details.

Sourceval submode_err : Mode_hint.pinpoint -> (Allowance.allowed * 'r) t -> ('l * Allowance.allowed) t -> unit

Similar to submode, but instead of returning an error, raise user-friendly errors directly, with pinpoint describing the thing whose actual and expected modes are being checked.

If you need more than pinpoint as the context in the error message, consider submode.

Sourceval equate : lr -> lr -> (unit, equate_error) result
Sourceval submode_exn : ?pp:Mode_hint.pinpoint -> (Allowance.allowed * 'r) t -> ('l * Allowance.allowed) t -> unit

Similiar to submode, but crashes the compiler if errors. Use this function if the submode is guaranteed to succeed.

Sourceval equate_exn : lr -> lr -> unit
Sourceval newvar_above : (Allowance.allowed * 'r) t -> ('l * 'r_) t * bool
Sourceval newvar_below : ('l * Allowance.allowed) t -> ('l_ * 'r) t * bool
Sourceval print : ?verbose:bool -> unit -> Ocaml_typing.Mode_intf.Fmt.formatter -> ('l * 'r) t -> unit
Sourceval zap_to_ceil : ('l * Allowance.allowed) t -> Const.t
Sourceval zap_to_floor : (Allowance.allowed * 'r) t -> Const.t
Sourceval of_const : ?hint:'d Mode_intf.pos_hint_const -> Const.t -> 'd t
Sourceval many : lr
Sourceval once : lr