text
stringlengths 0
601k
|
|---|
let f = function { x ; y } -> x |
type t = { x : unit ; } |
type s = { y : unit ; } ^ but is mixed here with fields of type t } ] | |
let x = [ % ocaml . error " Expression error " ] ^^^^^^^^^^^ } ] | |
let f [ % ocaml . error " Pattern error " ] = ( ) ^^^^^^^^^^^ } ] | |
let check f = f ( ) |
let f ~ x = ( ) |
let ( ) = check f ; ; } ] | |
let ( ) = f ~ y : 1 ^ } ] | |
let f ? x ~ a ? y ~ z = ( ) |
let g = f ? y : None ? x : None ~ a ( ) : ^^^^ ? x ' : a -> a ' : b -> ? y ' : c -> z ' : d -> unit } ] | |
let f ( g : ? x : _ -> _ ) = g ~ y : None ? x : None ; g ? x : None ( ) [ %% expect { | ^^^^ } ] | |
module Record = struct module type S = sig module Typed_field : Typed_fields_lib . S val form_for_field : ' a Typed_field . t -> ' a Form . t Computation . t end let attach_fieldname_to_error name t = Form . map_error t ~ f ( : Error . tag ~ tag ( : sprintf " in field " ^ name ) ) ; ; let make ( type a ) ( module M : S with type Typed_field . derived_on = a ) = let module Form_value = struct type ' a t = ' a Form . t Bonsai . Computation . t end in let module App = struct include Bonsai . Computation type ' a s = ' a Form . t let translate = Fn . id end in let module The_form_values = Typed_field_map . Make ( M . Typed_field ) ( Form_value ) in let module The_forms = Typed_field_map . Make ( M . Typed_field ) ( Form ) in let module The_results = Typed_field_map . Make ( M . Typed_field ) ( Or_error ) in let module To_forms = The_form_values . As_applicative . To_other_map ( App ) ( The_forms ) in let form_values_per_field = let f field = let % sub subform = M . form_for_field field in let % map . Computation subform = Form . Dynamic . error_hint subform in subform |> Form . Private . group_list |> Form . Private . suggest_label ( M . Typed_field . name field ) |> attach_fieldname_to_error ( M . Typed_field . name field ) in The_form_values . create { f } in let % map . Computation forms_per_field = To_forms . run form_values_per_field in let view = M . Typed_field . Packed . all |> List . map ~ f ( : fun { f = T field } -> Form . view ( The_forms . find forms_per_field field ) ) |> Form . View . Private . List in let value = let f field = Form . value ( The_forms . find forms_per_field field ) in The_results . As_applicative . transpose ( module Or_error ) ~ create ( : fun { f } -> M . Typed_field . create { f } ) ( The_results . create { f } ) in let set r = M . Typed_field . Packed . all |> List . map ~ f ( : fun { f = T field } -> Form . set ( The_forms . find forms_per_field field ) ( M . Typed_field . get field r ) ) |> Vdom . Effect . Many in Form . Expert . create ~ view ~ value ~ set ; ; end |
module Variant = struct module type S = sig module Typed_variant : Typed_variants_lib . S val form_for_variant : ' a Typed_variant . t -> ' a Form . t Computation . t end let make ( type a ) ( module M : S with type Typed_variant . derived_on = a ) = let % sub picker = Elements . Dropdown . enumerable [ % here ] ( module struct include M . Typed_variant . Packed let equal = [ % compare . equal : t ] end ) in let picker_value = picker >>| Form . value_or_default ~ default ( : List . hd_exn M . Typed_variant . Packed . all ) in let % sub inner = Bonsai . enum ( module M . Typed_variant . Packed ) ~ match_ : picker_value ~ with_ ( : fun { f = T p } -> let % map . Computation form_for_constructor = M . form_for_variant p in let parse_exn content = M . Typed_variant . create p content in let unparse kind = match M . Typed_variant . get p kind with | None -> let expected = M . Typed_variant . Packed . pack p in let found = M . Typed_variant . which kind in raise_s [ % message " BUG " [ % here ] ( expected : M . Typed_variant . Packed . t ) ( found : M . Typed_variant . Packed . t ) ] | Some v -> v in Form . project form_for_constructor ~ parse_exn ~ unparse ) in let % sub get_inner_form = Bonsai_extra . yoink inner in let % arr inner = inner and picker = picker and get_inner_form = get_inner_form in let view = Form . View . Private . Header_group { header_view = Form . view picker ; view = Form . view inner ; label = None ; tooltip = None } in let value = Form . value inner in let set value = let constructor = M . Typed_variant . which value in let open Ui_effect . Let_syntax in let % bind ( ) = Form . set picker constructor in let % bind inner = get_inner_form in Form . set inner value in Form . Expert . create ~ view ~ value ~ set ; ; end |
type ident = Ident . t Location . loc |
type path = Path . t Location . loc |
type type_expr = { type_desc : type_desc ; type_loc : Location . t ; type_type : Type0 . type_expr } | Ttyp_var of str option | Ttyp_tuple of type_expr list | Ttyp_arrow of type_expr * type_expr * explicitness * Asttypes . arg_label | Ttyp_ctor of variant | Ttyp_poly of type_expr list * type_expr | Ttyp_prover of type_expr | Ttyp_conv of type_expr * type_expr | Ttyp_opaque of type_expr | Ttyp_alias of type_expr * str | Ttyp_row of row_tag list * closed_flag * ident list option | Ttyp_row_subtract of type_expr * ident list { rtag_ident : ident ; rtag_arg : type_expr list ; rtag_loc : Location . t } |
type field_decl = { fld_ident : ident ; fld_type : type_expr ; fld_loc : Location . t ; fld_fld : Type0 . field_decl } |
type ctor_args = | Tctor_tuple of type_expr list | Tctor_record of field_decl list |
type ctor_decl = { ctor_ident : ident ; ctor_args : ctor_args ; ctor_ret : type_expr option ; ctor_loc : Location . t ; ctor_ctor : Type0 . ctor_decl } |
type type_decl = { tdec_ident : ident ; tdec_params : type_expr list ; tdec_desc : type_decl_desc ; tdec_loc : Location . t ; tdec_tdec : Type0 . type_decl } | Tdec_abstract | Tdec_alias of type_expr | Tdec_record of field_decl list | Tdec_variant of ctor_decl list | Tdec_open | Tdec_extend of path * ctor_decl list |
type pattern = { pat_desc : pattern_desc ; pat_loc : Location . t ; pat_type : Type0 . type_expr } | Tpat_any | Tpat_variable of ident | Tpat_constraint of pattern * type_expr | Tpat_tuple of pattern list | Tpat_or of pattern * pattern | Tpat_literal of literal | Tpat_record of ( path * pattern ) list | Tpat_ctor of path * pattern option | Tpat_row_ctor of ident * pattern list |
type convert_body = { conv_body_desc : convert_body_desc ; conv_body_loc : Location . t ; conv_body_type : Type0 . type_expr } | Tconv_record of ( path * convert_body ) list | Tconv_ctor of path * ( Asttypes . arg_label * convert_body ) list | Tconv_tuple of convert_body list | Tconv_arrow of convert_body * convert_body | Tconv_identity | Tconv_opaque { conv_desc : convert_desc ; conv_loc : Location . t ; conv_type : Type0 . type_expr } |
type expression = { exp_desc : expression_desc ; exp_loc : Location . t ; exp_type : Type0 . type_expr } | Texp_apply of expression * ( explicitness * Asttypes . arg_label * expression ) list | Texp_variable of path | Texp_literal of literal | Texp_fun of Asttypes . arg_label * pattern * expression * explicitness | Texp_newtype of ident * expression | Texp_seq of expression * expression | Texp_let of pattern * expression * expression | Texp_instance of ident * expression * expression | Texp_constraint of expression * type_expr | Texp_tuple of expression list | Texp_match of expression * ( pattern * expression ) list | Texp_field of expression * path | Texp_record of ( path * expression ) list * expression option | Texp_ctor of path * expression option | Texp_row_ctor of ident * expression list | Texp_unifiable of { mutable expression : expression option ; name : ident ; id : int } | Texp_if of expression * expression * expression option | Texp_read of convert * ( Asttypes . arg_label * expression ) list * expression | Texp_prover of convert * ( Asttypes . arg_label * expression ) list * expression | Texp_convert of convert |
type conv_type = | Ttconv_with of mode * type_decl | Ttconv_to of type_expr |
type signature_item = { sig_desc : signature_desc ; sig_loc : Location . t } | Tsig_value of ident * type_expr | Tsig_instance of ident * type_expr | Tsig_type of type_decl | Tsig_convtype of type_decl * conv_type * ident * type_expr | Tsig_rectype of type_decl list | Tsig_module of ident * module_sig | Tsig_modtype of ident * module_sig | Tsig_open of path | Tsig_typeext of variant * ctor_decl list | Tsig_request of type_expr * ctor_decl | Tsig_multiple of signature | Tsig_prover of signature | Tsig_convert of ident * type_expr | Tmty_sig of signature | Tmty_name of path | Tmty_alias of path | Tmty_abstract | Tmty_functor of str * module_sig * module_sig |
type statement = { stmt_desc : statement_desc ; stmt_loc : Location . t } | Tstmt_value of pattern * expression | Tstmt_instance of ident * expression | Tstmt_type of type_decl | Tstmt_convtype of type_decl * conv_type * ident * convert | Tstmt_rectype of type_decl list | Tstmt_module of ident * module_expr | Tstmt_modtype of ident * module_sig | Tstmt_open of path | Tstmt_open_instance of path | Tstmt_typeext of variant * ctor_decl list | Tstmt_request of type_expr * ctor_decl * ( pattern option * expression ) option | Tstmt_multiple of statements | Tstmt_prover of statements | Tstmt_convert of ident * type_expr * convert | Tmod_struct of statements | Tmod_name of path | Tmod_functor of str * module_sig * module_expr |
type iterator = { type_expr : iterator -> type_expr -> unit ; type_desc : iterator -> type_desc -> unit ; variant : iterator -> variant -> unit ; row_tag : iterator -> row_tag -> unit ; field_decl : iterator -> field_decl -> unit ; ctor_args : iterator -> ctor_args -> unit ; ctor_decl : iterator -> ctor_decl -> unit ; type_decl : iterator -> type_decl -> unit ; type_decl_desc : iterator -> type_decl_desc -> unit ; literal : iterator -> literal -> unit ; pattern : iterator -> pattern -> unit ; pattern_desc : iterator -> pattern_desc -> unit ; expression : iterator -> expression -> unit ; expression_desc : iterator -> expression_desc -> unit ; convert_body : iterator -> convert_body -> unit ; convert_body_desc : iterator -> convert_body_desc -> unit ; convert : iterator -> convert -> unit ; convert_desc : iterator -> convert_desc -> unit ; signature_item : iterator -> signature_item -> unit ; signature : iterator -> signature -> unit ; signature_desc : iterator -> signature_desc -> unit ; module_sig : iterator -> module_sig -> unit ; module_sig_desc : iterator -> module_sig_desc -> unit ; statement : iterator -> statement -> unit ; statements : iterator -> statements -> unit ; statement_desc : iterator -> statement_desc -> unit ; module_expr : iterator -> module_expr -> unit ; module_desc : iterator -> module_desc -> unit ; location : iterator -> Location . t -> unit ; longident : iterator -> Longident . t -> unit ; ident : iterator -> Ident . t -> unit ; path : iterator -> Path . t -> unit ; type0_expr : iterator -> Type0 . type_expr -> unit ; type0_decl : iterator -> Type0 . type_decl -> unit } |
let lid iter { Location . txt ; loc } = iter . longident iter txt ; iter . location iter loc |
let str iter ( { Location . txt = _ ; loc } : str ) = iter . location iter loc |
let ident iter ( { Location . txt ; loc } : Ident . t Location . loc ) = iter . ident iter txt ; iter . location iter loc |
let path iter ( { Location . txt ; loc } : Path . t Location . loc ) = iter . location iter loc ; iter . path iter txt |
let type_expr iter { type_desc ; type_loc ; type_type } = iter . location iter type_loc ; iter . type0_expr iter type_type ; iter . type_desc iter type_desc |
let type_desc iter = function | Ttyp_var name -> Option . iter ~ f ( : str iter ) name | Ttyp_tuple typs -> List . iter ~ f ( : iter . type_expr iter ) typs | Ttyp_arrow ( typ1 , typ2 , _ , _ ) -> iter . type_expr iter typ1 ; iter . type_expr iter typ2 | Ttyp_ctor variant -> iter . variant iter variant | Ttyp_poly ( vars , typ ) -> List . iter ~ f ( : iter . type_expr iter ) vars ; iter . type_expr iter typ | Ttyp_prover typ -> iter . type_expr iter typ | Ttyp_conv ( typ1 , typ2 ) -> iter . type_expr iter typ1 ; iter . type_expr iter typ2 | Ttyp_opaque typ -> iter . type_expr iter typ | Ttyp_alias ( typ , name ) -> str iter name ; iter . type_expr iter typ | Ttyp_row ( tags , _closed , min_tags ) -> Option . iter ~ f ( : List . iter ~ f ( : ident iter ) ) min_tags ; List . iter ~ f ( : iter . row_tag iter ) tags | Ttyp_row_subtract ( typ , tags ) -> iter . type_expr iter typ ; List . iter ~ f ( : ident iter ) tags |
let variant iter { var_ident ; var_params } = path iter var_ident ; List . iter ~ f ( : iter . type_expr iter ) var_params |
let row_tag iter { rtag_ident ; rtag_arg ; rtag_loc } = ident iter rtag_ident ; iter . location iter rtag_loc ; List . iter ~ f ( : iter . type_expr iter ) rtag_arg |
let field_decl iter { fld_ident ; fld_type ; fld_loc ; fld_fld } = iter . location iter fld_loc ; ident iter fld_ident ; iter . type_expr iter fld_type ; ignore fld_fld |
let ctor_args iter = function | Tctor_tuple typs -> List . iter ~ f ( : iter . type_expr iter ) typs | Tctor_record fields -> List . iter ~ f ( : iter . field_decl iter ) fields |
let ctor_decl iter { ctor_ident ; ctor_args ; ctor_ret ; ctor_loc ; ctor_ctor } = iter . location iter ctor_loc ; ident iter ctor_ident ; iter . ctor_args iter ctor_args ; Option . iter ~ f ( : iter . type_expr iter ) ctor_ret ; ignore ctor_ctor |
let type_decl iter { tdec_ident ; tdec_params ; tdec_desc ; tdec_loc ; tdec_tdec } = iter . location iter tdec_loc ; ident iter tdec_ident ; List . iter ~ f ( : iter . type_expr iter ) tdec_params ; iter . type_decl_desc iter tdec_desc ; ignore tdec_tdec |
let type_decl_desc iter = function | Tdec_abstract -> ( ) | Tdec_alias typ -> iter . type_expr iter typ | Tdec_record fields -> List . iter ~ f ( : iter . field_decl iter ) fields | Tdec_variant ctors -> List . iter ~ f ( : iter . ctor_decl iter ) ctors | Tdec_open -> ( ) | Tdec_extend ( name , ctors ) -> path iter name ; List . iter ~ f ( : iter . ctor_decl iter ) ctors |
let literal ( _iter : iterator ) ( _ : literal ) = ( ) |
let pattern iter { pat_desc ; pat_loc ; pat_type } = iter . location iter pat_loc ; iter . type0_expr iter pat_type ; iter . pattern_desc iter pat_desc |
let pattern_desc iter = function | Tpat_any -> ( ) | Tpat_variable name -> ident iter name | Tpat_constraint ( pat , typ ) -> iter . type_expr iter typ ; iter . pattern iter pat | Tpat_tuple pats -> List . iter ~ f ( : iter . pattern iter ) pats | Tpat_or ( p1 , p2 ) -> iter . pattern iter p1 ; iter . pattern iter p2 | Tpat_literal l -> iter . literal iter l | Tpat_record fields -> List . iter fields ~ f ( : fun ( name , pat ) -> path iter name ; iter . pattern iter pat ) | Tpat_ctor ( name , arg ) -> path iter name ; Option . iter ~ f ( : iter . pattern iter ) arg | Tpat_row_ctor ( name , args ) -> ident iter name ; List . iter ~ f ( : iter . pattern iter ) args |
let expression iter { exp_desc ; exp_loc ; exp_type } = iter . location iter exp_loc ; iter . type0_expr iter exp_type ; iter . expression_desc iter exp_desc |
let expression_desc iter = function | Texp_apply ( e , args ) -> iter . expression iter e ; List . iter args ~ f ( : fun ( _explicit , _label , e ) -> iter . expression iter e ) | Texp_variable name -> path iter name | Texp_literal l -> iter . literal iter l | Texp_fun ( _label , p , e , _explicit ) -> iter . pattern iter p ; iter . expression iter e | Texp_newtype ( name , e ) -> ident iter name ; iter . expression iter e | Texp_seq ( e1 , e2 ) -> iter . expression iter e1 ; iter . expression iter e2 | Texp_let ( p , e1 , e2 ) -> iter . pattern iter p ; iter . expression iter e1 ; iter . expression iter e2 | Texp_instance ( name , e1 , e2 ) -> ident iter name ; iter . expression iter e1 ; iter . expression iter e2 | Texp_constraint ( e , typ ) -> iter . type_expr iter typ ; iter . expression iter e | Texp_tuple es -> List . iter ~ f ( : iter . expression iter ) es | Texp_match ( e , cases ) -> iter . expression iter e ; List . iter cases ~ f ( : fun ( p , e ) -> iter . pattern iter p ; iter . expression iter e ) | Texp_field ( e , name ) -> path iter name ; iter . expression iter e | Texp_record ( bindings , default ) -> Option . iter ~ f ( : iter . expression iter ) default ; List . iter bindings ~ f ( : fun ( name , e ) -> path iter name ; iter . expression iter e ) | Texp_ctor ( name , arg ) -> path iter name ; Option . iter ~ f ( : iter . expression iter ) arg | Texp_row_ctor ( name , args ) -> ident iter name ; List . iter ~ f ( : iter . expression iter ) args | Texp_unifiable { expression ; name ; id = _ } -> ident iter name ; Option . iter ~ f ( : iter . expression iter ) expression | Texp_if ( e1 , e2 , e3 ) -> iter . expression iter e1 ; iter . expression iter e2 ; Option . iter ~ f ( : iter . expression iter ) e3 | Texp_read ( conv , conv_args , e ) -> iter . convert iter conv ; List . iter conv_args ~ f ( : fun ( _lbl , e ) -> iter . expression iter e ) ; iter . expression iter e | Texp_prover ( conv , conv_args , e ) -> iter . convert iter conv ; List . iter conv_args ~ f ( : fun ( _lbl , e ) -> iter . expression iter e ) ; iter . expression iter e | Texp_convert conv -> iter . convert iter conv |
let convert_body iter { conv_body_desc ; conv_body_loc ; conv_body_type } = iter . location iter conv_body_loc ; iter . type0_expr iter conv_body_type ; iter . convert_body_desc iter conv_body_desc |
let convert_body_desc iter = function | Tconv_record fields -> List . iter fields ~ f ( : fun ( field , conv ) -> path iter field ; iter . convert_body iter conv ) | Tconv_ctor ( name , args ) -> path iter name ; List . iter args ~ f ( : fun ( _label , conv ) -> iter . convert_body iter conv ) | Tconv_tuple convs -> List . iter ~ f ( : iter . convert_body iter ) convs | Tconv_arrow ( conv1 , conv2 ) -> iter . convert_body iter conv1 ; iter . convert_body iter conv2 | Tconv_identity | Tconv_opaque -> ( ) |
let convert iter { conv_desc ; conv_loc ; conv_type } = iter . location iter conv_loc ; iter . type0_expr iter conv_type ; iter . convert_desc iter conv_desc |
let convert_desc iter = function | Tconv_fun ( name , body ) -> ident iter name ; iter . convert iter body | Tconv_body body -> iter . convert_body iter body |
let type_conv iter = function | Ttconv_with ( _mode , decl ) -> iter . type_decl iter decl | Ttconv_to typ -> iter . type_expr iter typ |
let signature iter = List . iter ~ f ( : iter . signature_item iter ) |
let signature_item iter { sig_desc ; sig_loc } = iter . location iter sig_loc ; iter . signature_desc iter sig_desc |
let signature_desc iter = function | Tsig_value ( name , typ ) | Tsig_instance ( name , typ ) -> ident iter name ; iter . type_expr iter typ | Tsig_type decl -> iter . type_decl iter decl | Tsig_convtype ( decl , tconv , convname , typ ) -> iter . type_decl iter decl ; type_conv iter tconv ; ident iter convname ; iter . type_expr iter typ | Tsig_rectype decls -> List . iter ~ f ( : iter . type_decl iter ) decls | Tsig_module ( name , msig ) | Tsig_modtype ( name , msig ) -> ident iter name ; iter . module_sig iter msig | Tsig_open name -> path iter name | Tsig_typeext ( typ , ctors ) -> iter . variant iter typ ; List . iter ~ f ( : iter . ctor_decl iter ) ctors | Tsig_request ( typ , ctor ) -> iter . type_expr iter typ ; iter . ctor_decl iter ctor | Tsig_multiple sigs -> iter . signature iter sigs | Tsig_prover sigs -> iter . signature iter sigs | Tsig_convert ( name , typ ) -> ident iter name ; iter . type_expr iter typ |
let module_sig iter { msig_desc ; msig_loc } = iter . location iter msig_loc ; iter . module_sig_desc iter msig_desc |
let module_sig_desc iter = function | Tmty_sig sigs -> iter . signature iter sigs | Tmty_name name -> path iter name | Tmty_alias name -> path iter name | Tmty_abstract -> ( ) | Tmty_functor ( name , fsig , msig ) -> str iter name ; iter . module_sig iter fsig ; iter . module_sig iter msig |
let statements iter = List . iter ~ f ( : iter . statement iter ) |
let statement iter { stmt_desc ; stmt_loc } = iter . location iter stmt_loc ; iter . statement_desc iter stmt_desc |
let statement_desc iter = function | Tstmt_value ( p , e ) -> iter . pattern iter p ; iter . expression iter e | Tstmt_instance ( name , e ) -> ident iter name ; iter . expression iter e | Tstmt_type decl -> iter . type_decl iter decl | Tstmt_convtype ( decl , tconv , convname , conv ) -> iter . type_decl iter decl ; type_conv iter tconv ; ident iter convname ; iter . convert iter conv | Tstmt_rectype decls -> List . iter ~ f ( : iter . type_decl iter ) decls | Tstmt_module ( name , me ) -> ident iter name ; iter . module_expr iter me | Tstmt_modtype ( name , mty ) -> ident iter name ; iter . module_sig iter mty | Tstmt_open name -> path iter name | Tstmt_open_instance name -> path iter name | Tstmt_typeext ( typ , ctors ) -> iter . variant iter typ ; List . iter ~ f ( : iter . ctor_decl iter ) ctors | Tstmt_request ( typ , ctor , handler ) -> iter . type_expr iter typ ; iter . ctor_decl iter ctor ; Option . iter handler ~ f ( : fun ( p , e ) -> Option . iter ~ f ( : iter . pattern iter ) p ; iter . expression iter e ) | Tstmt_multiple stmts -> iter . statements iter stmts | Tstmt_prover stmts -> iter . statements iter stmts | Tstmt_convert ( name , typ , conv ) -> ident iter name ; iter . type_expr iter typ ; iter . convert iter conv |
let module_expr iter { mod_desc ; mod_loc } = iter . location iter mod_loc ; iter . module_desc iter mod_desc |
let module_desc iter = function | Tmod_struct stmts -> iter . statements iter stmts | Tmod_name name -> path iter name | Tmod_functor ( name , fsig , me ) -> str iter name ; iter . module_sig iter fsig ; iter . module_expr iter me |
let location ( _iter : iterator ) ( _ : Location . t ) = ( ) |
let longident iter = function | Longident . Lident _ -> ( ) | Ldot ( l , _ ) -> iter . longident iter l | Lapply ( l1 , l2 ) -> iter . longident iter l1 ; iter . longident iter l2 |
let path iter = function | Path . Pident ident -> iter . ident iter ident | Path . Pdot ( path , _ , _ ) | Path . Pocamldot ( path , _ , _ , _ ) -> iter . path iter path | Path . Papply ( path1 , path2 ) -> iter . path iter path1 ; iter . path iter path2 |
let ident ( _iter : iterator ) ( _ : Ident . t ) = ( ) |
let type0_decl ( _iter : iterator ) ( _ : Type0 . type_decl ) = ( ) |
let type0_expr ( _iter : iterator ) ( _ : Type0 . type_expr ) = ( ) |
let default_iterator = { type_expr ; type_desc ; variant ; row_tag ; field_decl ; ctor_args ; ctor_decl ; type_decl ; type_decl_desc ; literal ; pattern ; pattern_desc ; expression ; expression_desc ; convert_body ; convert_body_desc ; convert ; convert_desc ; signature_item ; signature ; signature_desc ; module_sig ; module_sig_desc ; statement ; statements ; statement_desc ; module_expr ; module_desc ; location ; longident ; ident ; path ; type0_decl ; type0_expr } |
type mapper = { type_expr : mapper -> type_expr -> type_expr ; type_desc : mapper -> type_desc -> type_desc ; variant : mapper -> variant -> variant ; row_tag : mapper -> row_tag -> row_tag ; field_decl : mapper -> field_decl -> field_decl ; ctor_args : mapper -> ctor_args -> ctor_args ; ctor_decl : mapper -> ctor_decl -> ctor_decl ; type_decl : mapper -> type_decl -> type_decl ; type_decl_desc : mapper -> type_decl_desc -> type_decl_desc ; literal : mapper -> literal -> literal ; pattern : mapper -> pattern -> pattern ; pattern_desc : mapper -> pattern_desc -> pattern_desc ; expression : mapper -> expression -> expression ; expression_desc : mapper -> expression_desc -> expression_desc ; convert : mapper -> convert -> convert ; convert_desc : mapper -> convert_desc -> convert_desc ; convert_body : mapper -> convert_body -> convert_body ; convert_body_desc : mapper -> convert_body_desc -> convert_body_desc ; signature_item : mapper -> signature_item -> signature_item ; signature : mapper -> signature -> signature ; signature_desc : mapper -> signature_desc -> signature_desc ; module_sig : mapper -> module_sig -> module_sig ; module_sig_desc : mapper -> module_sig_desc -> module_sig_desc ; statement : mapper -> statement -> statement ; statements : mapper -> statements -> statements ; statement_desc : mapper -> statement_desc -> statement_desc ; module_expr : mapper -> module_expr -> module_expr ; module_desc : mapper -> module_desc -> module_desc ; location : mapper -> Location . t -> Location . t ; longident : mapper -> Longident . t -> Longident . t ; ident : mapper -> Ident . t -> Ident . t ; path : mapper -> Path . t -> Path . t ; type0 : Type0_map . mapper } |
let with_backtrack_replace f = let snap = Type1 . Snapshot . create ( ) in let ret = f ( ) in Type1 . backtrack_replace snap ; ret |
let lid mapper { Location . txt ; loc } = { Location . txt = mapper . longident mapper txt ; loc = mapper . location mapper loc } |
let str mapper ( { Location . txt ; loc } : str ) = { Location . txt ; loc = mapper . location mapper loc } |
let ident mapper ( { Location . txt ; loc } : Ident . t Location . loc ) = { Location . txt = mapper . ident mapper txt ; loc = mapper . location mapper loc } |
let path mapper ( { Location . txt ; loc } : Path . t Location . loc ) = { Location . txt = mapper . path mapper txt ; loc = mapper . location mapper loc } |
let type_expr mapper { type_desc ; type_loc ; type_type } = let type_loc = mapper . location mapper type_loc in let type_desc = mapper . type_desc mapper type_desc in let type_type = with_backtrack_replace ( fun ( ) -> mapper . type0 . type_expr mapper . type0 type_type ) in { type_desc ; type_loc ; type_type } |
let type_desc mapper typ = match typ with | Ttyp_var name -> Ttyp_var ( Option . map ~ f ( : str mapper ) name ) | Ttyp_tuple typs -> Ttyp_tuple ( List . map ~ f ( : mapper . type_expr mapper ) typs ) | Ttyp_arrow ( typ1 , typ2 , explicit , label ) -> Ttyp_arrow ( mapper . type_expr mapper typ1 , mapper . type_expr mapper typ2 , explicit , label ) | Ttyp_ctor variant -> Ttyp_ctor ( mapper . variant mapper variant ) | Ttyp_poly ( vars , typ ) -> Ttyp_poly ( List . map ~ f ( : mapper . type_expr mapper ) vars , mapper . type_expr mapper typ ) | Ttyp_prover typ -> Ttyp_prover ( mapper . type_expr mapper typ ) | Ttyp_conv ( typ1 , typ2 ) -> Ttyp_conv ( mapper . type_expr mapper typ1 , mapper . type_expr mapper typ2 ) | Ttyp_opaque typ -> Ttyp_opaque ( mapper . type_expr mapper typ ) | Ttyp_alias ( typ , name ) -> Ttyp_alias ( mapper . type_expr mapper typ , str mapper name ) | Ttyp_row ( tags , closed , min_tags ) -> Ttyp_row ( List . map ~ f ( : mapper . row_tag mapper ) tags , closed , Option . map ~ f ( : List . map ~ f ( : ident mapper ) ) min_tags ) | Ttyp_row_subtract ( typ , tags ) -> Ttyp_row_subtract ( mapper . type_expr mapper typ , List . map ~ f ( : ident mapper ) tags ) |
let variant mapper { var_ident ; var_params } = { var_ident = path mapper var_ident ; var_params = List . map ~ f ( : mapper . type_expr mapper ) var_params } |
let row_tag mapper { rtag_ident ; rtag_arg ; rtag_loc } = { rtag_ident = ident mapper rtag_ident ; rtag_arg = List . map ~ f ( : mapper . type_expr mapper ) rtag_arg ; rtag_loc = mapper . location mapper rtag_loc } |
let field_decl mapper { fld_ident ; fld_type ; fld_loc ; fld_fld } = { fld_loc = mapper . location mapper fld_loc ; fld_ident = ident mapper fld_ident ; fld_type = mapper . type_expr mapper fld_type ; fld_fld = with_backtrack_replace ( fun ( ) -> mapper . type0 . field_decl mapper . type0 fld_fld ) } |
let ctor_args mapper = function | Tctor_tuple typs -> Tctor_tuple ( List . map ~ f ( : mapper . type_expr mapper ) typs ) | Tctor_record fields -> Tctor_record ( List . map ~ f ( : mapper . field_decl mapper ) fields ) |
let ctor_decl mapper { ctor_ident ; ctor_args ; ctor_ret ; ctor_loc ; ctor_ctor } = { ctor_loc = mapper . location mapper ctor_loc ; ctor_ident = ident mapper ctor_ident ; ctor_args = mapper . ctor_args mapper ctor_args ; ctor_ret = Option . map ~ f ( : mapper . type_expr mapper ) ctor_ret ; ctor_ctor = with_backtrack_replace ( fun ( ) -> mapper . type0 . ctor_decl mapper . type0 ctor_ctor ) } |
let type_decl mapper { tdec_ident ; tdec_params ; tdec_desc ; tdec_loc ; tdec_tdec } = { tdec_loc = mapper . location mapper tdec_loc ; tdec_ident = ident mapper tdec_ident ; tdec_params = List . map ~ f ( : mapper . type_expr mapper ) tdec_params ; tdec_desc = mapper . type_decl_desc mapper tdec_desc ; tdec_tdec = with_backtrack_replace ( fun ( ) -> mapper . type0 . type_decl mapper . type0 tdec_tdec ) } |
let type_decl_desc mapper = function | Tdec_abstract -> Tdec_abstract | Tdec_alias typ -> Tdec_alias ( mapper . type_expr mapper typ ) | Tdec_record fields -> Tdec_record ( List . map ~ f ( : mapper . field_decl mapper ) fields ) | Tdec_variant ctors -> Tdec_variant ( List . map ~ f ( : mapper . ctor_decl mapper ) ctors ) | Tdec_open -> Tdec_open | Tdec_extend ( name , ctors ) -> Tdec_extend ( path mapper name , List . map ~ f ( : mapper . ctor_decl mapper ) ctors ) |
let literal ( _iter : mapper ) ( l : literal ) = l |
let pattern mapper { pat_desc ; pat_loc ; pat_type } = { pat_loc = mapper . location mapper pat_loc ; pat_desc = mapper . pattern_desc mapper pat_desc ; pat_type = with_backtrack_replace ( fun ( ) -> mapper . type0 . type_expr mapper . type0 pat_type ) } |
let pattern_desc mapper = function | Tpat_any -> Tpat_any | Tpat_variable name -> Tpat_variable ( ident mapper name ) | Tpat_constraint ( pat , typ ) -> Tpat_constraint ( mapper . pattern mapper pat , mapper . type_expr mapper typ ) | Tpat_tuple pats -> Tpat_tuple ( List . map ~ f ( : mapper . pattern mapper ) pats ) | Tpat_or ( p1 , p2 ) -> Tpat_or ( mapper . pattern mapper p1 , mapper . pattern mapper p2 ) | Tpat_literal l -> Tpat_literal ( mapper . literal mapper l ) | Tpat_record fields -> Tpat_record ( List . map fields ~ f ( : fun ( name , pat ) -> ( path mapper name , mapper . pattern mapper pat ) ) ) | Tpat_ctor ( name , arg ) -> Tpat_ctor ( path mapper name , Option . map ~ f ( : mapper . pattern mapper ) arg ) | Tpat_row_ctor ( name , args ) -> Tpat_row_ctor ( ident mapper name , List . map ~ f ( : mapper . pattern mapper ) args ) |
let convert_body mapper { conv_body_desc ; conv_body_loc ; conv_body_type } = { conv_body_loc = mapper . location mapper conv_body_loc ; conv_body_desc = mapper . convert_body_desc mapper conv_body_desc ; conv_body_type = mapper . type0 . type_expr mapper . type0 conv_body_type } |
let convert_body_desc mapper = function | Tconv_record fields -> Tconv_record ( List . map fields ~ f ( : fun ( name , conv ) -> ( path mapper name , mapper . convert_body mapper conv ) ) ) | Tconv_ctor ( name , args ) -> Tconv_ctor ( path mapper name , List . map args ~ f ( : fun ( label , conv ) -> ( label , mapper . convert_body mapper conv ) ) ) | Tconv_tuple convs -> Tconv_tuple ( List . map ~ f ( : mapper . convert_body mapper ) convs ) | Tconv_arrow ( conv1 , conv2 ) -> Tconv_arrow ( mapper . convert_body mapper conv1 , mapper . convert_body mapper conv2 ) | Tconv_identity -> Tconv_identity | Tconv_opaque -> Tconv_opaque |
let convert mapper { conv_desc ; conv_loc ; conv_type } = { conv_loc = mapper . location mapper conv_loc ; conv_desc = mapper . convert_desc mapper conv_desc ; conv_type = mapper . type0 . type_expr mapper . type0 conv_type } |
let convert_desc mapper = function | Tconv_fun ( name , conv ) -> Tconv_fun ( ident mapper name , mapper . convert mapper conv ) | Tconv_body conv -> Tconv_body ( mapper . convert_body mapper conv ) |
let expression mapper { exp_desc ; exp_loc ; exp_type } = { exp_loc = mapper . location mapper exp_loc ; exp_desc = mapper . expression_desc mapper exp_desc ; exp_type = with_backtrack_replace ( fun ( ) -> mapper . type0 . type_expr mapper . type0 exp_type ) } |
let expression_desc mapper = function | Texp_apply ( e , args ) -> Texp_apply ( mapper . expression mapper e , List . map args ~ f ( : fun ( explicit , label , e ) -> ( explicit , label , mapper . expression mapper e ) ) ) | Texp_variable name -> Texp_variable ( path mapper name ) | Texp_literal l -> Texp_literal ( mapper . literal mapper l ) | Texp_fun ( label , p , e , explicit ) -> Texp_fun ( label , mapper . pattern mapper p , mapper . expression mapper e , explicit ) | Texp_newtype ( name , e ) -> Texp_newtype ( ident mapper name , mapper . expression mapper e ) | Texp_seq ( e1 , e2 ) -> Texp_seq ( mapper . expression mapper e1 , mapper . expression mapper e2 ) | Texp_let ( p , e1 , e2 ) -> Texp_let ( mapper . pattern mapper p , mapper . expression mapper e1 , mapper . expression mapper e2 ) | Texp_instance ( name , e1 , e2 ) -> Texp_instance ( ident mapper name , mapper . expression mapper e1 , mapper . expression mapper e2 ) | Texp_constraint ( e , typ ) -> Texp_constraint ( mapper . expression mapper e , mapper . type_expr mapper typ ) | Texp_tuple es -> Texp_tuple ( List . map ~ f ( : mapper . expression mapper ) es ) | Texp_match ( e , cases ) -> Texp_match ( mapper . expression mapper e , List . map cases ~ f ( : fun ( p , e ) -> ( mapper . pattern mapper p , mapper . expression mapper e ) ) ) | Texp_field ( e , name ) -> Texp_field ( mapper . expression mapper e , path mapper name ) | Texp_record ( bindings , default ) -> Texp_record ( List . map bindings ~ f ( : fun ( name , e ) -> ( path mapper name , mapper . expression mapper e ) ) , Option . map ~ f ( : mapper . expression mapper ) default ) | Texp_ctor ( name , arg ) -> Texp_ctor ( path mapper name , Option . map ~ f ( : mapper . expression mapper ) arg ) | Texp_row_ctor ( name , args ) -> Texp_row_ctor ( ident mapper name , List . map ~ f ( : mapper . expression mapper ) args ) | Texp_unifiable { expression ; name ; id } -> Texp_unifiable { id ; name = ident mapper name ; expression = Option . map ~ f ( : mapper . expression mapper ) expression } | Texp_if ( e1 , e2 , e3 ) -> Texp_if ( mapper . expression mapper e1 , mapper . expression mapper e2 , Option . map ~ f ( : mapper . expression mapper ) e3 ) | Texp_read ( conv , conv_args , e ) -> Texp_read ( mapper . convert mapper conv , List . map conv_args ~ f ( : fun ( label , e ) -> ( label , mapper . expression mapper e ) ) , mapper . expression mapper e ) | Texp_prover ( conv , conv_args , e ) -> Texp_prover ( mapper . convert mapper conv , List . map conv_args ~ f ( : fun ( label , e ) -> ( label , mapper . expression mapper e ) ) , mapper . expression mapper e ) | Texp_convert conv -> Texp_convert ( mapper . convert mapper conv ) |
let type_conv mapper = function | Ttconv_with ( mode , decl ) -> Ttconv_with ( mode , mapper . type_decl mapper decl ) | Ttconv_to typ -> Ttconv_to ( mapper . type_expr mapper typ ) |
let signature mapper = List . map ~ f ( : mapper . signature_item mapper ) |
let signature_item mapper { sig_desc ; sig_loc } = { sig_loc = mapper . location mapper sig_loc ; sig_desc = mapper . signature_desc mapper sig_desc } |
let signature_desc mapper = function | Tsig_value ( name , typ ) -> Tsig_value ( ident mapper name , mapper . type_expr mapper typ ) | Tsig_instance ( name , typ ) -> Tsig_instance ( ident mapper name , mapper . type_expr mapper typ ) | Tsig_type decl -> Tsig_type ( mapper . type_decl mapper decl ) | Tsig_convtype ( decl , tconv , convname , typ ) -> Tsig_convtype ( mapper . type_decl mapper decl , type_conv mapper tconv , ident mapper convname , mapper . type_expr mapper typ ) | Tsig_rectype decls -> Tsig_rectype ( List . map ~ f ( : mapper . type_decl mapper ) decls ) | Tsig_module ( name , msig ) -> Tsig_module ( ident mapper name , mapper . module_sig mapper msig ) | Tsig_modtype ( name , msig ) -> Tsig_modtype ( ident mapper name , mapper . module_sig mapper msig ) | Tsig_open name -> Tsig_open ( path mapper name ) | Tsig_typeext ( typ , ctors ) -> Tsig_typeext ( mapper . variant mapper typ , List . map ~ f ( : mapper . ctor_decl mapper ) ctors ) | Tsig_request ( typ , ctor ) -> Tsig_request ( mapper . type_expr mapper typ , mapper . ctor_decl mapper ctor ) | Tsig_multiple sigs -> Tsig_multiple ( mapper . signature mapper sigs ) | Tsig_prover sigs -> Tsig_prover ( mapper . signature mapper sigs ) | Tsig_convert ( name , typ ) -> Tsig_convert ( ident mapper name , mapper . type_expr mapper typ ) |
let module_sig mapper { msig_desc ; msig_loc } = { msig_loc = mapper . location mapper msig_loc ; msig_desc = mapper . module_sig_desc mapper msig_desc } |
let module_sig_desc mapper = function | Tmty_sig sigs -> Tmty_sig ( mapper . signature mapper sigs ) | Tmty_name name -> Tmty_name ( path mapper name ) | Tmty_alias name -> Tmty_alias ( path mapper name ) | Tmty_abstract -> Tmty_abstract | Tmty_functor ( name , fsig , msig ) -> Tmty_functor ( str mapper name , mapper . module_sig mapper fsig , mapper . module_sig mapper msig ) |
let statements mapper = List . map ~ f ( : mapper . statement mapper ) |
let statement mapper { stmt_desc ; stmt_loc } = { stmt_loc = mapper . location mapper stmt_loc ; stmt_desc = mapper . statement_desc mapper stmt_desc } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.