package pfff

You can search for identifiers within the package.

in-package search v0.2.0

pfff-matcher

Legend:
Library
Module
Module type
Parameter
Class
Class type

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

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

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

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

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

val fail2 : string -> XMATCH.tin -> ('a * 'b) XMATCH.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 -> XMATCH.tin -> ('c * 'd) XMATCH.tout) ->
  'a list ->
  'b list ->
  XMATCH.tin ->
  ('c list * 'd list) XMATCH.tout

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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