text stringlengths 12 786k |
|---|
let filter_all pat0 pss = let rec insert q qs env = match env with [ ] -> let q0 = normalize_pat q in [ q0 , [ simple_match_args q0 q @ qs ] ] | ( ( q0 , pss ) as c ) :: env -> if simple_match q0 q then ( q0 , ( ( simple_match_args q0 q @ qs ) :: pss ) ) :: env else c :... |
let rec set_last a = function [ ] -> [ ] | [ _ ] -> [ a ] | x :: l -> x :: set_last a l |
let rec mark_partial = function ( { pat_desc = Tpat_alias ( p , _ ) } :: ps ) :: pss -> mark_partial ( ( p :: ps ) :: pss ) | ( { pat_desc = Tpat_or ( p1 , p2 , _ ) } :: ps ) :: pss -> mark_partial ( ( p1 :: ps ) ( :: p2 :: ps ) :: pss ) | ( { pat... |
let close_variant env row = let row = Btype . row_repr row in let nm = List . fold_left ( fun nm ( tag , f ) -> match Btype . row_field_repr f with | Reither ( _ , _ , false , e ) -> Btype . set_row_field e Rabsent ; None | Rabsent | Reither ( _ , _ , true , _ ) | Rpr... |
let row_of_pat pat = match Ctype . expand_head pat . pat_env pat . pat_type with { desc = Tvariant row } -> Btype . row_repr row | _ -> assert false |
let full_match closing env = match env with false List . length env = c . cstr_consts + c . cstr_nonconsts let fields = List . map ( function ( { pat_desc = Tpat_variant ( tag , _ , _ ) } , _ ) -> tag | _ -> assert false ) env in let row = row_of_pat p in if closing && not ro... |
let extendable_match env = match env with let path = get_type_path p . pat_type p . pat_env in not ( Path . same path Predef . path_bool || Path . same path Predef . path_list || Path . same path Predef . path_option ) |
let should_extend ext env = match ext with | ( { pat_desc = Tpat_construct ( { cstr_tag ( = Cstr_constant _ | Cstr_block _ ) } , _ ) } as p , _ ) :: _ -> let path = get_type_path p . pat_type p . pat_env in Path . same path ext | _ -> false |
let complete_tags nconsts nconstrs tags = let seen_const = Array . create nconsts false and seen_constr = Array . create nconstrs false in List . iter ( function | Cstr_constant i -> seen_const . ( i ) <- true | Cstr_block i -> seen_constr . ( i ) <- true | _ -> assert false ) tags ; ... |
let pat_of_constr ex_pat cstr = { ex_pat with pat_desc = Tpat_construct ( cstr , omegas cstr . cstr_arity ) } |
let rec pat_of_constrs ex_pat = function { ex_pat with pat_desc = Tpat_or ( pat_of_constr ex_pat cstr , pat_of_constrs ex_pat rem , None ) } |
let complete_constrs p all_tags = match p . pat_desc with begin try let not_tags = complete_tags c . cstr_consts c . cstr_nonconsts all_tags in List . map ( fun tag -> let _ , targs = get_constr tag p . pat_type p . pat_env in { c with cstr_tag = tag ; cstr_args = targs ; cstr_arity = List... |
let build_other_constant proj make first next p env = let all = List . map ( fun ( p , _ ) -> proj p . pat_desc ) env in let rec try_const i = if List . mem i all then try_const ( next i ) else make_pat ( make i ) p . pat_type p . pat_env in try_const first |
let build_other ext env = match env with :: _ -> make_pat ( Tpat_construct ( { c with cstr_tag ( = Cstr_exception ( Path . Pident ( Ident . create " * exception " ) ) ) } , * [ ] ) ) Ctype . none Env . empty begin match ext with | Some ext when Path . same ext ( get... |
let rec has_instance p = match p . pat_desc with | Tpat_variant ( l , _ , r ) when is_absent l r -> false | Tpat_any | Tpat_var _ | Tpat_constant _ | Tpat_variant ( _ , None , _ ) -> true | Tpat_alias ( p , _ ) | Tpat_variant ( _ , Some p , _ ) -> has_instance p | Tpa... |
let rec satisfiable pss qs = match pss with match qs with | [ ] -> false | { pat_desc = Tpat_or ( q1 , q2 , _ ) } :: qs -> satisfiable pss ( q1 :: qs ) || satisfiable pss ( q2 :: qs ) | { pat_desc = Tpat_alias ( q , _ ) } :: qs -> satisfiable pss ( q :: qs ) | { ... |
type ' a result = | Rnone | Rsome of ' a |
let rec try_many f = function | [ ] -> Rnone | x :: rest -> begin match f x with | Rnone -> try_many f rest | r -> r end |
let rec exhaust ext pss n = match pss with let q0 = discr_pat omega pss in begin match filter_all q0 pss with | [ ] -> begin match exhaust ext ( filter_extra pss ) ( n - 1 ) with | Rsome r -> Rsome ( q0 :: r ) | r -> r end | constrs -> let try_non_omega ( p , pss ) = if is_absent_pat... |
let rec pressure_variants tdefs = function | [ ] -> false | [ ] :: _ -> true | pss -> let q0 = discr_pat omega pss in begin match filter_all q0 pss with [ ] -> pressure_variants tdefs ( filter_extra pss ) | constrs -> let rec try_non_omega = function ( p , pss ) :: rem -> let ok =... |
type answer = | Used | Unused | Upartial of Typedtree . pattern list |
let pretty_pat p = top_pretty Format . str_formatter p ; prerr_string ( Format . flush_str_formatter ( ) ) |
type matrix = pattern list list |
let pretty_line ps = List . iter ( fun p -> top_pretty Format . str_formatter p ; prerr_string " " < ; prerr_string ( Format . flush_str_formatter ( ) ) ; prerr_string " " ) > ps |
let pretty_matrix pss = prerr_endline " begin matrix " ; List . iter ( fun ps -> pretty_line ps ; prerr_endline " " ) pss ; prerr_endline " end matrix " |
type ' a row = { no_ors : ' a list ; ors : ' a list ; active : ' a list } |
let pretty_row { ors = ors ; no_ors = no_ors ; active = active } = pretty_line ors ; prerr_string " " * ; pretty_line no_ors ; prerr_string " " * ; pretty_line active |
let pretty_rows rs = prerr_endline " begin matrix " ; List . iter ( fun r -> pretty_row r ; prerr_endline " " ) rs ; prerr_endline " end matrix " |
let make_row ps = { ors [ ] = ; no_ors [ ] ; = active = ps } |
let make_rows pss = List . map make_row pss |
let rec unalias p = match p . pat_desc with |
let is_var p = match ( unalias p ) . pat_desc with |
let is_var_column rs = List . for_all ( fun r -> match r . active with | p :: _ -> is_var p | [ ] -> assert false ) rs |
let rec or_args p = match p . pat_desc with |
let remove r = match r . active with |
let remove_column rs = List . map remove rs |
let push_no_or r = match r . active with |
let push_or r = match r . active with |
let push_or_column rs = List . map push_or rs |
let discr_pat q rs = discr_pat q ( List . map ( fun r -> r . active ) rs ) |
let filter_one q rs = let rec filter_rec rs = match rs with | [ ] -> [ ] | r :: rem -> match r . active with | [ ] -> assert false | { pat_desc = Tpat_alias ( p , _ ) } :: ps -> filter_rec ( { r with active = p :: ps } :: rem ) | { pat_desc = Tpat_or ( p1 , p2 , ... |
let make_vector r = r . no_ors |
let make_matrix rs = List . map make_vector rs |
let union_res r1 r2 = match r1 , r2 with |
let extract_elements qs = let rec do_rec seen = function | [ ] -> [ ] | q :: rem -> { no_ors = List . rev_append seen rem @ qs . no_ors ; ors [ ] = ; active = [ q ] } :: do_rec ( q :: seen ) rem in do_rec [ ] qs . ors |
let transpose rs = match rs with let i = List . map ( fun x -> [ x ] ) r in List . fold_left ( List . map2 ( fun r x -> x :: r ) ) i rem |
let extract_columns pss qs = match pss with let rows = List . map extract_elements pss in transpose rows |
let rec every_satisfiables pss qs = match qs . active with begin match qs . ors with | [ ] -> if satisfiable ( make_matrix pss ) ( make_vector qs ) then Used else Unused | _ -> List . fold_right2 ( fun pss qs r -> match r with | Unused -> Unused | _ -> match qs . active with | [ q ]... |
let rec le_pat p q = match ( p . pat_desc , q . pat_desc ) with | ( Tpat_var _ | Tpat_any ) , _ -> true | Tpat_alias ( p , _ ) , _ -> le_pat p q | _ , Tpat_alias ( q , _ ) -> le_pat p q | Tpat_constant ( c1 ) , Tpat_constant ( c2 ) -> c1 = c2 | Tpat_construct ... |
let get_mins le ps = let rec select_rec r = function [ ] -> r | p :: ps -> if List . exists ( fun p0 -> le p0 p ) ps then select_rec r ps else select_rec ( p :: r ) ps in select_rec [ ] ( select_rec [ ] ps ) |
let rec lub p q = match p . pat_desc , q . pat_desc with let rs = lubs ps qs in make_pat ( Tpat_tuple rs ) p . pat_type p . pat_env let r = lub p q in make_pat ( Tpat_lazy r ) p . pat_type p . pat_env when c1 . cstr_tag = c2 . cstr_tag -> let rs = lubs ps1 ps2 in make_pat ( Tpat_constr... |
let pressure_variants tdefs patl = let pss = List . map ( fun p -> [ p ; omega ] ) patl in ignore ( pressure_variants ( Some tdefs ) pss ) |
let has_guard act = match act . exp_desc with |
let rec initial_matrix = function [ ] -> [ ] | ( pat , act ) :: rem -> if has_guard act then initial_matrix rem else [ pat ] :: initial_matrix rem |
let rec initial_all no_guard = function | [ ] -> if no_guard then raise NoGuard else [ ] | ( pat , act ) :: rem -> ( [ pat ] , pat . pat_loc ) :: initial_all ( no_guard && not ( has_guard act ) ) rem |
let rec do_filter_var = function | ( _ :: ps , loc ) :: rem -> ( ps , loc ) :: do_filter_var rem | _ -> [ ] |
let do_filter_one q pss = let rec filter_rec = function | ( { pat_desc = Tpat_alias ( p , _ ) } :: ps , loc ) :: pss -> filter_rec ( ( p :: ps , loc ) :: pss ) | ( { pat_desc = Tpat_or ( p1 , p2 , _ ) } :: ps , loc ) :: pss -> filter_rec ( ( p1 :: ps , ... |
let rec do_match pss qs = match qs with begin match pss with | ( [ ] , loc ) :: _ -> Some loc | _ -> None end | { pat_desc = Tpat_or ( q1 , q2 , _ ) } -> begin match do_match pss ( q1 :: qs ) with | None -> do_match pss ( q2 :: qs ) | r -> r end | { pat_desc = Tpat_an... |
let check_partial_all v casel = try let pss = initial_all true casel in do_match pss [ v ] with | NoGuard -> None |
let do_check_partial loc casel pss = match pss with begin match casel with | [ ] -> ( ) | _ -> Location . prerr_warning loc Warnings . All_clauses_guarded end ; Partial begin match exhaust None pss ( List . length ps ) with | Rnone -> Total | Rsome [ v ] -> let errmsg = try let buf =... |
let rec add_path path = function | [ ] -> [ path ] | x :: rem as paths -> if Path . same path x then paths else x :: add_path path rem |
let extendable_path path = not ( Path . same path Predef . path_bool || Path . same path Predef . path_list || Path . same path Predef . path_option ) |
let rec collect_paths_from_pat r p = match p . pat_desc with let path = get_type_path p . pat_type p . pat_env in List . fold_left collect_paths_from_pat ( if extendable_path path then add_path path r else r ) ps List . fold_left collect_paths_from_pat r ps List . fold_left ( fun r ( _ , p ) ... |
let do_check_fragile loc casel pss = let exts = List . fold_left ( fun r ( p , _ ) -> collect_paths_from_pat r p ) [ ] casel in match exts with | [ ] -> ( ) | _ -> match pss with | [ ] -> ( ) | ps :: _ -> List . iter ( fun ext -> match exhaust ( Some ext ) pss ( ... |
let check_partial loc casel = if Warnings . is_active ( Warnings . Partial_match " " ) then begin let pss = initial_matrix casel in let pss = get_mins le_pats pss in let total = do_check_partial loc casel pss in if total = Total && Warnings . is_active ( Warnings . Fragile_match " " ) then... |
let check_unused tdefs casel = if Warnings . is_active Warnings . Unused_match then let rec do_rec pref = function | [ ] -> ( ) | ( q , act ) :: rem -> let qs = [ q ] in begin try let pss = get_mins le_pats ( List . filter ( compats qs ) pref ) in let r = every_satisfiables ( ... |
let irrefutable pat = le_pat pat omega |
let rec inactive pat = match pat with false true List . for_all ( fun p -> inactive p . pat_desc ) ps inactive p . pat_desc List . exists ( fun ( _ , p ) -> inactive p . pat_desc ) ldps inactive p . pat_desc && inactive q . pat_desc |
let fluid pat = irrefutable pat && inactive pat . pat_desc |
let last_token = ref Parser . EOF |
let token lexbuf = let token = Lexer . token lexbuf in last_token := token ; token |
let rec skip_phrase lexbuf = match token lexbuf with | Parser . SEMISEMI | Parser . EOF -> ( ) | _ -> skip_phrase lexbuf | exception ( Lexer . Error ( Lexer . Unterminated_comment _ , _ ) | Lexer . Error ( Lexer . Unterminated_string , _ ) | Lexer . Error ( Lexer . Reser... |
let maybe_skip_phrase lexbuf = match ! last_token with | Parser . SEMISEMI | Parser . EOF -> ( ) | _ -> skip_phrase lexbuf |
let wrap parsing_fun lexbuf = try Docstrings . init ( ) ; Lexer . init ( ) ; let ast = parsing_fun lexbuf in Parsing . clear_parser ( ) ; Docstrings . warn_bad_docstrings ( ) ; last_token := Parser . EOF ; ast with | Lexer . Error ( Lexer . Illegal_character _ , _ ) a... |
let rec loop lexbuf in_error checkpoint = let module I = Parser . MenhirInterpreter in match checkpoint with | I . InputNeeded _env -> let triple = if in_error then ( Parser . EOF , lexbuf . Lexing . lex_curr_p , lexbuf . Lexing . lex_curr_p ) else let token = token lexbuf in ( token , ... |
let wrap_menhir entry lexbuf = let initial = entry lexbuf . Lexing . lex_curr_p in wrap ( fun lexbuf -> loop lexbuf false initial ) lexbuf |
let implementation = wrap_menhir Parser . Incremental . implementation |
let longident = wrap_menhir Parser . Incremental . parse_any_longident |
let val_ident = wrap_menhir Parser . Incremental . parse_val_longident |
let extended_module_path = wrap_menhir Parser . Incremental . parse_mod_ext_longident |
let simple_module_path = wrap_menhir Parser . Incremental . parse_mod_longident |
let type_ident = wrap_menhir Parser . Incremental . parse_mty_longident |
let prepare_error err = let open Syntaxerr in match err with | Unclosed ( opening_loc , opening , closing_loc , closing ) -> Location . errorf ~ loc : closing_loc ~ sub [ : Location . msg ~ loc : opening_loc " This ' % s ' might be unmatched " opening ] " Syntax error : ' % s '... |
let ( ) = Location . register_error_of_exn ( function | Syntaxerr . Error err -> Some ( prepare_error err ) | _ -> None ) |
type t = [ A of t and t | B of string ] ; let rec self stream acc = match stream with parser [ [ : ` ( EOI , _ ) ] : -> acc | [ : ` ( LIDENT x , _ ) ; xs ] : -> self xs ( A acc ( B x ) ) | [ : ` ( BLANKS _ | NEWLINE , _ ) ; xs ] : -> self xs acc... |
type spc = [ SPCterm of ( MLast . patt * option MLast . expr ) | SPCnterm of MLast . patt and MLast . expr | SPCsterm of MLast . patt ] ; MLast . Map . Expr . expr ( fun [ <: expr @ _loc < __strm >> -> <: expr < $ lid : v $ >> | e -> e ] ) ; fun [ <: expr < $ ... |
let string_of_file file = try let inchan = open_in_bin file in let len = in_channel_length inchan in let buf = Buffer . create len in Buffer . add_channel buf inchan len ; close_in inchan ; Buffer . contents buf with Sys_error err -> Printf . eprintf " Could not read the file % s , got error Sys_e... |
let parse parser lexer buf = try parser lexer buf with | LexError msg -> begin let pos = buf . Lexing . lex_start_p in let msg = Printf . sprintf " At line % d column % d : % s " %! pos . Lexing . pos_lnum ( pos . Lexing . pos_cnum - pos . Lexing . pos_bol ) msg in raise ( LexErro... |
let parse_string p_fun s = let buf = Lexing . from_string s in p_fun buf |
let parse_file p_fun f = let ic = open_in f in let buf = Lexing . from_channel ic in try let res = p_fun buf in close_in ic ; res with | e -> close_in ic ; Printf . fprintf stderr " Error in file % s %!\ n " f ; raise e |
let parse_expr f : Cnl_t . cnl_expr = parse Cnl_parser . main_expr ( Cnl_lexer . token ( string_buff ( ) ) ) f |
let parse_cnl_expr_from_string s : Cnl_t . cnl_expr = parse_string parse_expr s |
let parse_rule f : Cnl_t . cnl_rule = parse Cnl_parser . main ( Cnl_lexer . token ( string_buff ( ) ) ) f |
let parse_cnl_rule_from_string s : Cnl_t . cnl_rule = parse_string parse_rule s |
let parse_bmd_spec f : Bmd_t . bmd_spec = parse Bmd_parser . main ( Bmd_lexer . token ( string_buff ( ) ) ) f |
let parse_bmd_spec_from_string s : Bmd_t . bmd_spec = parse_string parse_bmd_spec s |
let parse_bmd_spec_from_file s : Bmd_t . bmd_spec = parse_file parse_bmd_spec s |
type error = | Lexing_error of Lex . error * Location . t | Parsing_error of string * Location . t |
let add_pos ( pos1 : Lexing . position ) ( pos2 : Lexing . position ) : Lexing . position = { pos_fname = pos1 . pos_fname ; pos_lnum = pos1 . pos_lnum + pos2 . pos_lnum - 1 ; pos_bol = pos1 . pos_bol + pos2 . pos_bol ; pos_cnum = pos1 . pos_cnum + pos2 . pos_cnum } |
let make_loc ? relative_to ( startpos , endpos ) = let abs pos = match relative_to with Some base -> add_pos base pos | None -> pos in { Location . loc_start = abs startpos ; Location . loc_end = abs endpos ; Location . loc_ghost = false } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.