package pfff

You can search for identifiers within the package.

in-package search v0.2.0

package pfff

pfff-matcher

Legend:
Library
Module
Module type
Parameter
Class
Class type

type tok = Parse_info.info

and 'a wrap = 'a * tok

and 'a paren = tok * 'a * tok

and 'a brace = tok * 'a * tok

and 'a bracket = tok * 'a * tok

and 'a comma_list = ('a, tok) Common.either list

and 'a and_list = ('a, tok) Common.either list

and 'a star_list = ('a, tok) Common.either list

and 'a pipe_list = ('a, tok) Common.either list

and 'a semicolon_list = ('a, tok) Common.either list

type name =

| Name of string wrap

and lname = name

and uname = name

type long_name = qualifier * name

and qualifier = (name * tok) list

type ty =

| TyName of long_name
| TyVar of tok * name
| TyTuple of ty star_list
| TyTuple2 of ty star_list paren
| TyFunction of ty * tok * ty
| TyApp of ty_args * long_name
| TyTodo

and ty_args =

| TyArg1 of ty
| TyArgMulti of ty comma_list paren

and expr =

| C of constant
| L of long_name
| Constr of long_name * expr option
| Tuple of expr comma_list
| List of expr semicolon_list bracket
| Sequence of seq_expr paren
| Prefix of string wrap * expr
| Infix of expr * string wrap * expr
| FunCallSimple of long_name * argument list
| FunCall of expr * argument list
| RefAccess of tok * expr
| RefAssign of expr * tok * expr
| FieldAccess of expr * tok * long_name
| FieldAssign of expr * tok * long_name * tok * expr
| Record of record_expr brace
| New of tok * long_name
| ObjAccess of expr * tok * name
| LetIn of tok * rec_opt * let_binding and_list * tok * seq_expr
| Fun of tok * parameter list * match_action
| Function of tok * match_case pipe_list
| If of tok * seq_expr * tok * expr * (tok * expr) option
| Match of tok * seq_expr * tok * match_case pipe_list
| Try of tok * seq_expr * tok * match_case pipe_list
| While of tok * seq_expr * tok * seq_expr * tok
| For of tok * name * tok * seq_expr * for_direction * seq_expr * tok * seq_expr * tok
| ParenExpr of expr paren
| ExprTodo

and seq_expr = expr semicolon_list

and constant =

| Int of string wrap
| Float of string wrap
| Char of string wrap
| String of string wrap

and record_expr =

| RecordNormal of field_and_expr semicolon_list
| RecordWith of expr * tok * field_and_expr semicolon_list

and field_and_expr =

| FieldExpr of long_name * tok * expr
| FieldImplicitExpr of long_name

and argument =

| ArgExpr of expr
| ArgLabelTilde of name * expr
| ArgImplicitTildeExpr of tok * name
| ArgLabelQuestion of name * expr
| ArgImplicitQuestionExpr of tok * name

and match_case = pattern * match_action

and match_action =

| Action of tok * seq_expr
| WhenAction of tok * seq_expr * tok * seq_expr

and for_direction =

| To of tok
| Downto of tok

and rec_opt = tok option

and pattern =

| PatVar of name
| PatConstant of pattern_signed_constant
| PatConstr of long_name * pattern option
| PatConsInfix of pattern * tok * pattern
| PatTuple of pattern comma_list
| PatList of pattern semicolon_list bracket
| PatUnderscore of tok
| PatRecord of field_pattern semicolon_list brace
| PatAs of pattern * tok * name
| PatDisj of pattern * tok * pattern
| PatTyped of tok * pattern * tok * ty * tok
| ParenPat of pattern paren
| PatTodo

and pattern_signed_constant =

| C2 of constant
| CMinus of tok * constant
| CPlus of tok * constant

and field_pattern =

| PatField of long_name * tok * pattern
| PatImplicitField of long_name

and let_binding =

| LetClassic of let_def
| LetPattern of pattern * tok * seq_expr

and let_def = {

l_name : name;
l_params : parameter list;
l_tok : tok;
l_body : seq_expr;

}

and parameter =

| ParamPat of pattern
| ParamTodo

and labeled_simple_pattern = unit

type type_declaration =

| TyAbstract of ty_params * name
| TyDef of ty_params * name * tok * type_def_kind

and ty_params =

| TyNoParam
| TyParam1 of ty_parameter
| TyParamMulti of ty_parameter comma_list paren

and ty_parameter = tok * name

and type_def_kind =

| TyCore of ty
| TyAlgebric of constructor_declaration pipe_list
| TyRecord of field_declaration semicolon_list brace

and constructor_declaration = name * constructor_arguments

and constructor_arguments =

| NoConstrArg
| Of of tok * ty star_list

and field_declaration = {

fld_mutable : tok option;
fld_name : name;
fld_tok : tok;
fld_type : ty;

}

type module_type = unit

type module_expr =

| ModuleName of long_name
| ModuleStruct of tok * item list * tok
| ModuleTodo

and item =

| Type of tok * type_declaration and_list
| Exception of tok * name * constructor_arguments
| External of tok * name * tok * ty * tok * string wrap list
| Open of tok * long_name
| Val of tok * name * tok * ty
| Let of tok * rec_opt * let_binding and_list
| Module of tok * uname * tok * module_expr
| ItemTodo of tok

type sig_item = item

type struct_item = item

type toplevel =

| TopItem of item
| TopSeqExpr of seq_expr
| ScSc of tok
| TopDirective of tok

type program = toplevel list

type any =

| Ty of ty
| Expr of expr
| Pattern of pattern
| Item of item
| Toplevel of toplevel
| Program of program
| TypeDeclaration of type_declaration
| TypeDefKind of type_def_kind
| FieldDeclaration of field_declaration
| MatchCase of match_case
| LetBinding of let_binding
| Constant of constant
| Argument of argument
| Body of seq_expr
| Info of tok
| InfoList of tok list

val str_of_name : name -> string

val info_of_name : name -> tok

val uncomma : ('a, 'b) Common.either list -> 'a list

val unpipe : ('a, 'b) Common.either list -> 'a list

val name_of_long_name : ('a * 'b) -> 'b

val module_of_long_name : ((name * 'a) list * 'b) -> string

val module_infos_of_long_name : ((name * 'a) list * 'b) -> tok list