package pfff

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

Parameters
Signature

package pfff

pfff-matcher

Legend:
Library
Module
Module type
Parameter
Class
Class type

Parameters

module X : PARAM

Signature

type ('a, 'b) matcher = 'a -> 'b -> X.tin -> ('a * 'b) X.tout

val (>>=) : 
  (X.tin -> ('a * 'b) X.tout) ->
  (('a * 'b) -> X.tin -> ('c * 'd) X.tout) ->
  X.tin ->
  ('c * 'd) X.tout

val (>||>) : (X.tin -> 'a X.tout) -> (X.tin -> 'a X.tout) -> X.tin -> 'a X.tout

val return : ('a * 'b) -> X.tin -> ('a * 'b) X.tout

val fail : unit -> X.tin -> ('a * 'b) X.tout

val fail2 : string -> X.tin -> ('a * 'b) X.tout

val m_option : ('a, 'b) matcher -> ('a option, 'b option) matcher

val m_ref : ('a, 'b) matcher -> ('a ref, 'b ref) matcher

val m_list : 
  ('a -> 'b -> X.tin -> ('c * 'd) X.tout) ->
  'a list ->
  'b list ->
  X.tin ->
  ('c list * 'd list) X.tout

val m_either : 
  ('a -> 'b -> X.tin -> ('c * 'd) X.tout) ->
  ('e -> 'f -> X.tin -> ('g * 'h) X.tout) ->
  ('a, 'e) Common.either ->
  ('b, 'f) Common.either ->
  X.tin ->
  (('c, 'g) Common.either * ('d, 'h) Common.either) X.tout

val m_bool : 'a -> 'a -> X.tin -> ('a * 'a) X.tout

val m_string : string -> string -> X.tin -> (string * string) X.tout

val m_info : A.tok -> B.tok -> X.tin -> (A.tok * B.tok) X.tout

val m_tok : A.tok -> B.tok -> X.tin -> (A.tok * B.tok) X.tout

val m_wrap : 
  ('a -> 'b -> X.tin -> ('c * 'd) X.tout) ->
  ('a * A.tok) ->
  ('b * B.tok) ->
  X.tin ->
  (('c * A.tok) * ('d * B.tok)) X.tout

val m_name : 
  (MV.mvar * A.tok) ->
  B.name ->
  X.tin ->
  ((MV.mvar * A.tok) * B.name) X.tout

val m_dotted_name : 
  (MV.mvar * A.tok) list ->
  B.name list ->
  X.tin ->
  ((MV.mvar * A.tok) list * B.name list) X.tout

val m_qualified_name : 
  (MV.mvar * A.tok) list ->
  B.name list ->
  X.tin ->
  ((MV.mvar * A.tok) list * B.name list) X.tout

val m_module_name : 
  A.module_name ->
  B.module_name ->
  X.tin ->
  (A.module_name * B.module_name) X.tout

val m_resolved_name : 
  A.resolved_name ->
  B.resolved_name ->
  X.tin ->
  (A.resolved_name * B.resolved_name) X.tout

val m_expr : (A.expr, B.expr) matcher

val m_literal : 
  A.literal ->
  B.literal ->
  X.tin ->
  (A.literal * B.literal) X.tout

val m_action : A.action -> B.action -> X.tin -> (A.action * B.action) X.tout

val m_arithmetic_operator : 
  A.arithmetic_operator ->
  B.arithmetic_operator ->
  X.tin ->
  (A.arithmetic_operator * B.arithmetic_operator) X.tout

val m_special : 
  A.special ->
  B.special ->
  X.tin ->
  (A.special * B.special) X.tout

val m_id_info : 
  A.id_info ->
  B.id_info ->
  X.tin ->
  (A.id_info * B.id_info) X.tout

val m_container_operator : 
  A.container_operator ->
  B.container_operator ->
  X.tin ->
  (A.container_operator * B.container_operator) X.tout

val m_other_expr_operator : 
  A.other_expr_operator ->
  B.other_expr_operator ->
  X.tin ->
  (A.other_expr_operator * B.other_expr_operator) X.tout

val m_arguments : 
  A.arguments ->
  B.arguments ->
  X.tin ->
  (A.arguments * B.arguments) X.tout

val m_list__m_argument : 
  A.arguments ->
  B.arguments ->
  X.tin ->
  (A.arguments * B.arguments) X.tout

val m_argument : 
  A.argument ->
  A.argument ->
  X.tin ->
  (A.argument * B.argument) X.tout

val m_other_argument_operator : 
  A.other_argument_operator ->
  B.other_argument_operator ->
  X.tin ->
  (A.other_argument_operator * B.other_argument_operator) X.tout

val m_type_ : (A.type_, B.type_) matcher

val m_type_arguments : (A.type_arguments, B.type_arguments) matcher

val m_type_argument : 
  A.type_argument ->
  B.type_argument ->
  X.tin ->
  (A.type_argument * B.type_argument) X.tout

val m_other_type_operator : 
  A.other_type_operator ->
  B.other_type_operator ->
  X.tin ->
  (A.other_type_operator * B.other_type_operator) X.tout

val m_other_type_argument_operator : 
  A.other_type_argument_operator ->
  B.other_type_argument_operator ->
  X.tin ->
  (A.other_type_argument_operator * B.other_type_argument_operator) X.tout

val m_attribute : 
  A.attribute ->
  B.attribute ->
  X.tin ->
  (A.attribute * B.attribute) X.tout

val m_other_attribute_operator : 
  A.other_attribute_operator ->
  B.other_attribute_operator ->
  X.tin ->
  (A.other_attribute_operator * B.other_attribute_operator) X.tout

val m_stmt : A.stmt -> B.stmt -> X.tin -> (A.finally * B.finally) X.tout

val m_for_header : 
  A.for_header ->
  B.for_header ->
  X.tin ->
  (A.for_header * B.for_header) X.tout

val m_for_var_or_expr : 
  A.for_var_or_expr ->
  B.for_var_or_expr ->
  X.tin ->
  (A.for_var_or_expr * B.for_var_or_expr) X.tout

val m_label : A.label -> B.label -> X.tin -> (A.label * B.label) X.tout

val m_catch : A.catch -> B.catch -> X.tin -> (A.catch * B.catch) X.tout

val m_finally : (A.finally, B.finally) matcher

val m_case_and_body : 
  A.case_and_body ->
  B.case_and_body ->
  X.tin ->
  (A.case_and_body * B.case_and_body) X.tout

val m_case : A.case -> B.case -> X.tin -> (A.case * B.case) X.tout

val m_other_stmt_operator : 
  A.other_stmt_operator ->
  B.other_stmt_operator ->
  X.tin ->
  (A.other_stmt_operator * B.other_stmt_operator) X.tout

val m_pattern : 
  A.pattern ->
  B.pattern ->
  X.tin ->
  (A.pattern * B.pattern) X.tout

val m_other_pattern_operator : 
  A.other_pattern_operator ->
  B.other_pattern_operator ->
  X.tin ->
  (A.other_pattern_operator * B.other_pattern_operator) X.tout

val m_definition : 
  A.definition ->
  B.definition ->
  X.tin ->
  (A.definition * B.definition) X.tout

val m_entity : A.entity -> B.entity -> X.tin -> (A.entity * B.entity) X.tout

val m_definition_kind : 
  A.definition_kind ->
  B.definition_kind ->
  X.tin ->
  (A.definition_kind * B.definition_kind) X.tout

val m_type_parameter_constraint : 
  A.type_parameter_constraint ->
  B.type_parameter_constraint ->
  X.tin ->
  (A.type_parameter_constraint * B.type_parameter_constraint) X.tout

val m_type_parameter_constraints : 
  A.type_parameter_constraints ->
  B.type_parameter_constraints ->
  X.tin ->
  (A.type_parameter_constraints * B.type_parameter_constraints) X.tout

val m_type_parameter : 
  A.type_parameter ->
  B.type_parameter ->
  X.tin ->
  (A.type_parameter * B.type_parameter) X.tout

val m_function_definition : 
  A.function_definition ->
  B.function_definition ->
  X.tin ->
  (A.function_definition * B.function_definition) X.tout

val m_parameters : 
  A.parameters ->
  B.parameters ->
  X.tin ->
  (A.parameters * B.parameters) X.tout

val m_parameter : 
  A.parameter ->
  B.parameter ->
  X.tin ->
  (A.parameter * B.parameter) X.tout

val m_parameter_classic : 
  A.parameter_classic ->
  B.parameter_classic ->
  X.tin ->
  (A.parameter_classic * B.parameter_classic) X.tout

val m_other_parameter_operator : 
  A.other_parameter_operator ->
  B.other_parameter_operator ->
  X.tin ->
  (A.other_parameter_operator * B.other_parameter_operator) X.tout

val m_variable_definition : 
  A.variable_definition ->
  B.variable_definition ->
  X.tin ->
  (A.variable_definition * B.variable_definition) X.tout

val m_field : A.field -> B.field -> X.tin -> (A.field * B.field) X.tout

val m_type_definition : 
  A.type_definition ->
  B.type_definition ->
  X.tin ->
  (A.type_definition * B.type_definition) X.tout

val m_or_type : 
  A.or_type_element ->
  B.or_type_element ->
  X.tin ->
  (A.or_type_element * B.or_type_element) X.tout

val m_other_type_kind_operator : 
  A.other_type_kind_operator ->
  B.other_type_kind_operator ->
  X.tin ->
  (A.other_type_kind_operator * B.other_type_kind_operator) X.tout

val m_class_definition : 
  A.class_definition ->
  B.class_definition ->
  X.tin ->
  (A.class_definition * B.class_definition) X.tout

val m_class_kind : 
  A.class_kind ->
  B.class_kind ->
  X.tin ->
  (A.class_kind * B.class_kind) X.tout

val m_directive : 
  A.directive ->
  B.directive ->
  X.tin ->
  (A.directive * B.directive) X.tout

val m_alias : A.alias -> B.alias -> X.tin -> (A.alias * B.alias) X.tout

val m_other_directive_operator : 
  A.other_directive_operator ->
  B.other_directive_operator ->
  X.tin ->
  (A.other_directive_operator * B.other_directive_operator) X.tout

val m_item : A.item -> B.item -> X.tin -> (A.item * B.item) X.tout

val m_program : 
  A.program ->
  B.program ->
  X.tin ->
  (A.program * B.program) X.tout

val m_any : A.any -> B.any -> X.tin -> (A.any * B.any) X.tout