Make (beluga.Beluga_parser.Signature

Parameters

module Disambiguation_state : Disambiguation_state.DISAMBIGUATION_STATE

module Lf_disambiguation : 
  Lf_disambiguation.LF_DISAMBIGUATION
    with type state = Disambiguation_state.state

module Clf_disambiguation : 
  Clf_disambiguation.CLF_DISAMBIGUATION
    with type state = Disambiguation_state.state

module Meta_disambiguation : 
  Meta_disambiguation.META_DISAMBIGUATION
    with type state = Disambiguation_state.state

module Comp_disambiguation : 
  Comp_disambiguation.COMP_DISAMBIGUATION
    with type state = Disambiguation_state.state

module Harpoon_disambiguation : 
  Harpoon_disambiguation.HARPOON_DISAMBIGUATION
    with type state = Disambiguation_state.state

Signature

include Support.Imperative_state.IMPERATIVE_STATE
  with type state = Disambiguation_state.state

type state = Disambiguation_state.state

val traverse_tuple2 : 
  state ->
  (state -> 'a1 -> 'b1) ->
  (state -> 'a2 -> 'b2) ->
  ('a1 * 'a2) ->
  'b1 * 'b2

val traverse_tuple3 : 
  state ->
  (state -> 'a1 -> 'b1) ->
  (state -> 'a2 -> 'b2) ->
  (state -> 'a3 -> 'b3) ->
  ('a1 * 'a2 * 'a3) ->
  'b1 * 'b2 * 'b3

val traverse_list : 
  state ->
  (state -> 'a -> 'b) ->
  'a Support.List.t ->
  'b Support.List.t

traverse_list state f [x1; x2; ...; xn] is [y1; y2; ...; yn] where yi = f state xi, and y1, y2, ..., yn are computed in order, meaning that y1 is computed first, then y2, etc.

val traverse_list1 : 
  state ->
  (state -> 'a -> 'b) ->
  'a Support.List1.t ->
  'b Support.List1.t

val traverse_list2 : 
  state ->
  (state -> 'a -> 'b) ->
  'a Support.List2.t ->
  'b Support.List2.t

val iter_list : 
  state ->
  (state -> 'a -> Stdlib.Unit.t) ->
  'a Support.List.t ->
  Stdlib.Unit.t

iter_list state f [x1; x2; ...; xn] is f state x1; f state x2; ...; f state xn.

val iter_list1 : 
  state ->
  (state -> 'a -> Stdlib.Unit.t) ->
  'a Support.List1.t ->
  Stdlib.Unit.t

val iter_list2 : 
  state ->
  (state -> 'a -> Stdlib.Unit.t) ->
  'a Support.List2.t ->
  Stdlib.Unit.t

val traverse_reverse_list : 
  state ->
  (state -> 'a -> 'b) ->
  'a Support.List.t ->
  'b Support.List.t

traverse_reverse_list state f [x1; x2; ...; xn] is [y1; y2; ...; yn] where yi = f state xi, and y1, y2, ..., yn are computed in reverse order, meaning that yn is computed first, then y(n-1), etc.

val traverse_reverse_list1 : 
  state ->
  (state -> 'a -> 'b) ->
  'a Support.List1.t ->
  'b Support.List1.t

val traverse_reverse_list2 : 
  state ->
  (state -> 'a -> 'b) ->
  'a Support.List2.t ->
  'b Support.List2.t

val iter_rev_list : 
  state ->
  (state -> 'a -> Stdlib.Unit.t) ->
  'a Support.List.t ->
  Stdlib.Unit.t

iter_rev_list state f [x1; x2; ...; xn] is f state xn; f state x(n-1); ...; f state x1.

val iter_rev_list1 : 
  state ->
  (state -> 'a -> Stdlib.Unit.t) ->
  'a Support.List1.t ->
  Stdlib.Unit.t

val iter_rev_list2 : 
  state ->
  (state -> 'a -> Stdlib.Unit.t) ->
  'a Support.List2.t ->
  Stdlib.Unit.t

val traverse_option : 
  state ->
  (state -> 'a -> 'b) ->
  'a Support.Option.t ->
  'b Support.Option.t

val iter_option : 
  state ->
  (state -> 'a -> Stdlib.Unit.t) ->
  'a Support.Option.t ->
  Stdlib.Unit.t

val seq_list : state -> (state -> 'a) Support.List.t -> 'a Support.List.t

val seq_list1 : state -> (state -> 'a) Support.List1.t -> 'a Support.List1.t

val iter_seq : 
  state ->
  (state -> Stdlib.Unit.t) Support.List.t ->
  Stdlib.Unit.t

Disambiguation

val disambiguate_pragma : 
  state ->
  Synprs.signature_pragma ->
  Synext.signature_pragma

val disambiguate_global_pragma : 
  state ->
  Synprs.signature_global_pragma ->
  Synext.signature_global_pragma

val disambiguate_totality_declaration : 
  state ->
  Synprs.signature_totality_declaration ->
  Synext.signature_totality_declaration

val disambiguate_numeric_totality_order : 
  state ->
  Support.Int.t Synprs.signature_totality_order ->
  Support.Int.t Synext.signature_totality_order

val disambiguate_named_totality_order : 
  state ->
  Beluga_syntax.Synext.Identifier.t Synprs.signature_totality_order ->
  Beluga_syntax.Synext.Identifier.t Synext.signature_totality_order

val disambiguate_declaration : 
  state ->
  Synprs.signature_declaration ->
  Synext.signature_declaration

val disambiguate_signature_file : 
  state ->
  Synprs.signature_file ->
  Synext.signature_file

val disambiguate_signature : state -> Synprs.signature -> Synext.signature