text stringlengths 12 786k |
|---|
let duplicate_type ty = Subst . type_expr Subst . identity ty |
let duplicate_class_type ty = Subst . class_type Subst . identity ty |
let rec iter_generalize tyl ty = let ty = repr ty in if ( ty . level > ! current_level ) && ( ty . level <> generic_level ) then begin set_level ty generic_level ; begin match ty . desc with Tconstr ( _ , _ , abbrev ) -> iter_abbrev ( iter_generalize tyl ) ! abbrev | _ -> ( ) ... |
let iter_generalize tyl ty = simple_abbrevs := Mnil ; iter_generalize tyl ty |
let generalize ty = iter_generalize ( ref [ ] ) ty |
let iterative_generalization min_level tyl = let tyl ' = ref [ ] in List . iter ( iter_generalize tyl ' ) tyl ; List . fold_right ( fun ty l -> if ty . level <= min_level then l else ty :: l ) ! tyl ' [ ] |
let rec generalize_structure var_level ty = let ty = repr ty in if ty . level <> generic_level then begin if ty . desc = Tvar && ty . level > var_level then set_level ty var_level else if ty . level > ! current_level then begin set_level ty generic_level ; begin match ty . desc with Tconstr ( _ ,... |
let generalize_structure var_level ty = simple_abbrevs := Mnil ; generalize_structure var_level ty |
let generalize_global ty = generalize_structure ! global_level ty |
let generalize_structure ty = generalize_structure ! current_level ty |
let rec generalize_spine ty = let ty = repr ty in if ty . level < ! current_level || ty . level = generic_level then ( ) else match ty . desc with Tarrow ( _ , _ , ty ' , _ ) | Tpoly ( ty ' , _ ) -> set_level ty generic_level ; generalize_spine ty ' | _ -> ( ) |
let forward_try_expand_once = ref ( fun env ty -> raise Cannot_expand ) |
let rec update_level env level ty = let ty = repr ty in if ty . level > level then begin begin match ty . desc with Tconstr ( p , tl , abbrev ) when level < Path . binding_time p -> begin try link_type ty ( ! forward_try_expand_once env ty ) ; update_level env level ty with Cannot_expand -> r... |
let rec generalize_expansive env var_level ty = let ty = repr ty in if ty . level <> generic_level then begin if ty . level > var_level then begin set_level ty generic_level ; match ty . desc with Tconstr ( path , tyl , abbrev ) -> let variance = try ( Env . find_type path env ) . type_var... |
let generalize_expansive env ty = simple_abbrevs := Mnil ; try generalize_expansive env ! nongen_level ty with Unify [ _ , ty ' ] -> raise ( Unify [ ty , ty ' ] ) |
let correct_levels ty = duplicate_type ty |
let limited_generalize ty0 ty = let ty0 = repr ty0 in let graph = Hashtbl . create 17 in let idx = ref lowest_level in let roots = ref [ ] in let rec inverse pty ty = let ty = repr ty in if ( ty . level > ! current_level ) || ( ty . level = generic_level ) then begin decr idx ; Hashtbl .... |
let rec find_repr p1 = function Mnil -> None | Mcons ( Public , p2 , ty , _ , _ ) when Path . same p1 p2 -> Some ty | Mcons ( _ , _ , _ , _ , rem ) -> find_repr p1 rem | Mlink { contents = rem } -> find_repr p1 rem |
let abbreviations = ref ( ref Mnil ) |
let rec copy ty = let ty = repr ty in match ty . desc with Tsubst ty -> ty | _ -> if ty . level <> generic_level then ty else let desc = ty . desc in save_desc ty desc ; let t = newvar ( ) in ty . desc <- Tsubst t ; t . desc <- begin match desc with | Tconstr ( p , tl , _ ) -> le... |
let instance sch = let ty = copy sch in cleanup_types ( ) ; ty |
let instance_list schl = let tyl = List . map copy schl in cleanup_types ( ) ; tyl |
let instance_constructor cstr = let ty_res = copy cstr . cstr_res in let ty_args = List . map copy cstr . cstr_args in cleanup_types ( ) ; ( ty_args , ty_res ) |
let instance_parameterized_type sch_args sch = let ty_args = List . map copy sch_args in let ty = copy sch in cleanup_types ( ) ; ( ty_args , ty ) |
let instance_parameterized_type_2 sch_args sch_lst sch = let ty_args = List . map copy sch_args in let ty_lst = List . map copy sch_lst in let ty = copy sch in cleanup_types ( ) ; ( ty_args , ty_lst , ty ) |
let instance_declaration decl = let decl = { decl with type_params = List . map copy decl . type_params ; type_manifest = may_map copy decl . type_manifest ; type_kind = match decl . type_kind with | Type_abstract -> Type_abstract | Type_variant cl -> Type_variant ( List . map ( fun ( s ,... |
let instance_class params cty = let rec copy_class_type = function Tcty_constr ( path , tyl , cty ) -> Tcty_constr ( path , List . map copy tyl , copy_class_type cty ) | Tcty_signature sign -> Tcty_signature { cty_self = copy sign . cty_self ; cty_vars = Vars . map ( function ( m , ... |
type inv_type_expr = { inv_type : type_expr ; mutable inv_parents : inv_type_expr list } |
let rec inv_type hash pty ty = let ty = repr ty in try let inv = TypeHash . find hash ty in inv . inv_parents <- pty @ inv . inv_parents with Not_found -> let inv = { inv_type = ty ; inv_parents = pty } in TypeHash . add hash ty inv ; iter_type_expr ( inv_type hash [ inv ] ) ty |
let compute_univars ty = let inverted = TypeHash . create 17 in inv_type inverted [ ] ty ; let node_univars = TypeHash . create 17 in let rec add_univar univ inv = match inv . inv_type . desc with Tpoly ( ty , tl ) when List . memq univ ( List . map repr tl ) -> ( ) | _ -> try ... |
let rec diff_list l1 l2 = if l1 == l2 then [ ] else match l1 with [ ] -> invalid_arg " Ctype . diff_list " | a :: l1 -> a :: diff_list l1 l2 |
let conflicts free bound = let bound = List . map repr bound in TypeSet . exists ( fun t -> List . memq ( repr t ) bound ) free |
let delayed_copy = ref [ ] |
let rec copy_sep fixed free bound visited ty = let ty = repr ty in let univars = free ty in if TypeSet . is_empty univars then if ty . level <> generic_level then ty else let t = newvar ( ) in delayed_copy := lazy ( t . desc <- Tlink ( copy ty ) ) :: ! delayed_copy ; t else try let t , bo... |
let instance_poly fixed univars sch = let vars = List . map ( fun _ -> newvar ( ) ) univars in let pairs = List . map2 ( fun u v -> repr u , ( v , [ ] ) ) univars vars in delayed_copy := [ ] ; let ty = copy_sep fixed ( compute_univars sch ) [ ] pairs sch in List . ite... |
let instance_label fixed lbl = let ty_res = copy lbl . lbl_res in let vars , ty_arg = match repr lbl . lbl_arg with { desc = Tpoly ( ty , tl ) } -> instance_poly fixed tl ty | ty -> [ ] , copy lbl . lbl_arg in cleanup_types ( ) ; ( vars , ty_arg , ty_res ) |
let unify ' = ref ( fun env ty1 ty2 -> raise ( Unify [ ] ) ) |
let rec subst env level priv abbrev ty params args body = if List . length params <> List . length args then raise ( Unify [ ] ) ; let old_level = ! current_level in current_level := level ; try let body0 = newvar ( ) in begin match ty with None -> ( ) | Some ( { desc = Tconstr ( ... |
let apply env params body args = try subst env generic_level Public ( ref Mnil ) None params args body with Unify _ -> raise Cannot_apply |
let previous_env = ref Env . empty |
let string_of_kind = function Public -> " public " | Private -> " private " |
let check_abbrev_env env = if env != ! previous_env then begin cleanup_abbrev ( ) ; previous_env := env end |
let expand_abbrev_gen kind find_type_expansion env ty = check_abbrev_env env ; match ty with { desc = Tconstr ( path , args , abbrev ) ; level = level } -> let lookup_abbrev = proper_abbrevs path args abbrev in begin match find_expans kind path ! lookup_abbrev with Some ty -> if level <> generic... |
let expand_abbrev = expand_abbrev_gen Public Env . find_type_expansion |
let safe_abbrev env ty = let snap = Btype . snapshot ( ) in try ignore ( expand_abbrev env ty ) ; true with Cannot_expand | Unify _ -> Btype . backtrack snap ; false |
let try_expand_once env ty = let ty = repr ty in match ty . desc with Tconstr _ -> repr ( expand_abbrev env ty ) | _ -> raise Cannot_expand |
let _ = forward_try_expand_once := try_expand_once |
let rec try_expand_head env ty = let ty ' = try_expand_once env ty in begin try try_expand_head env ty ' with Cannot_expand -> ty ' end |
let expand_head_once env ty = try expand_abbrev env ( repr ty ) with Cannot_expand -> assert false |
let expand_head_unif env ty = try try_expand_head env ty with Cannot_expand -> repr ty |
let expand_head env ty = let snap = Btype . snapshot ( ) in try try_expand_head env ty with Cannot_expand | Unify _ -> Btype . backtrack snap ; repr ty |
let expand_abbrev_opt = expand_abbrev_gen Private Env . find_type_expansion_opt |
let try_expand_once_opt env ty = let ty = repr ty in match ty . desc with Tconstr _ -> repr ( expand_abbrev_opt env ty ) | _ -> raise Cannot_expand |
let rec try_expand_head_opt env ty = let ty ' = try_expand_once_opt env ty in begin try try_expand_head_opt env ty ' with Cannot_expand -> ty ' end |
let expand_head_opt env ty = let snap = Btype . snapshot ( ) in try try_expand_head_opt env ty with Cannot_expand | Unify _ -> Btype . backtrack snap ; repr ty |
let enforce_constraints env ty = match ty with { desc = Tconstr ( path , args , abbrev ) ; level = level } -> let decl = Env . find_type path env in ignore ( subst env level Public ( ref Mnil ) None decl . type_params args ( newvar2 level ) ) | _ -> assert false |
let rec full_expand env ty = let ty = repr ( expand_head env ty ) in match ty . desc with Tobject ( fi , { contents = Some ( _ , v :: _ ) } ) when ( repr v ) . desc = Tvar -> newty2 ty . level ( Tobject ( fi , ref None ) ) | _ -> ty |
let generic_abbrev env path = try let ( _ , body ) = Env . find_type_expansion path env in ( repr body ) . level = generic_level with Not_found -> false |
let visited = ref [ ] |
let rec non_recursive_abbrev env ty0 ty = let ty = repr ty in if ty == repr ty0 then raise Recursive_abbrev ; if not ( List . memq ty ! visited ) then begin visited := ty :: ! visited ; match ty . desc with Tconstr ( p , args , abbrev ) -> begin try non_recursive_abbrev env ty0 ( try_expan... |
let correct_abbrev env path params ty = check_abbrev_env env ; let ty0 = newgenvar ( ) in visited := [ ] ; let abbrev = Mcons ( Public , path , ty0 , ty0 , Mnil ) in simple_abbrevs := abbrev ; try non_recursive_abbrev env ty0 ( subst env generic_level Public ( ref abbrev ) None [ ... |
let rec occur_rec env visited ty0 ty = if ty == ty0 then raise Occur ; match ty . desc with Tconstr ( p , tl , abbrev ) -> begin try if List . memq ty visited || ! Clflags . recursive_types then raise Occur ; iter_type_expr ( occur_rec env ( ty :: visited ) ty0 ) ty with Occur -> try le... |
let type_changed = ref false |
let merge r b = if b then r := true |
let occur env ty0 ty = let old = ! type_changed in try while type_changed := false ; occur_rec env [ ] ty0 ty ; ! type_changed do ( ) done ; merge type_changed old with exn -> merge type_changed old ; raise ( match exn with Occur -> Unify [ ] | _ -> exn ) |
let rec unify_univar t1 t2 = function ( cl1 , cl2 ) :: rem -> let find_univ t cl = try let ( _ , r ) = List . find ( fun ( t ' , _ ) -> t == repr t ' ) cl in Some r with Not_found -> None in begin match find_univ t1 cl1 , find_univ t2 cl2 with Some { contents = Some t ' 2 }... |
module TypeMap = Map . Make ( TypeOps ) |
let occur_univar env ty = let visited = ref TypeMap . empty in let rec occur_rec bound ty = let ty = repr ty in if ty . level >= lowest_level && if TypeSet . is_empty bound then ( ty . level <- pivot_level - ty . level ; true ) else try let bound ' = TypeMap . find ty ! visited in if TypeS... |
let add_univars = List . fold_left ( fun s ( t , _ ) -> TypeSet . add ( repr t ) s ) |
let get_univar_family univar_pairs univars = if univars = [ ] then TypeSet . empty else let rec insert s = function cl1 , ( _ :: _ as cl2 ) -> if List . exists ( fun ( t1 , _ ) -> TypeSet . mem ( repr t1 ) s ) cl1 then add_univars s cl2 else s | _ -> s in let s = List . fold... |
let univars_escape env univar_pairs vl ty = let family = get_univar_family univar_pairs vl in let visited = ref TypeSet . empty in let rec occur t = let t = repr t in if TypeSet . mem t ! visited then ( ) else begin visited := TypeSet . add t ! visited ; match t . desc with Tpoly ( t , tl ) ... |
let enter_poly env univar_pairs t1 tl1 t2 tl2 f = let old_univars = ! univar_pairs in let known_univars = List . fold_left ( fun s ( cl , _ ) -> add_univars s cl ) TypeSet . empty old_univars in let tl1 = List . map repr tl1 and tl2 = List . map repr tl2 in if List . exists ( fun t -> Typ... |
let univar_pairs = ref [ ] |
let rec has_cached_expansion p abbrev = match abbrev with Mnil -> false | Mcons ( _ , p ' , _ , _ , rem ) -> Path . same p p ' || has_cached_expansion p rem | Mlink rem -> has_cached_expansion p ! rem |
let expand_trace env trace = List . fold_right ( fun ( t1 , t2 ) rem -> ( repr t1 , full_expand env t1 ) ( :: repr t2 , full_expand env t2 ) :: rem ) trace [ ] |
let mkvariant fields closed = newgenty ( Tvariant { row_fields = fields ; row_closed = closed ; row_more = newvar ( ) ; row_bound = ( ) ; row_fixed = false ; row_name = None } ) |
let rigid_variants = ref false |
let deep_occur t0 ty = let rec occur_rec ty = let ty = repr ty in if ty . level >= lowest_level then begin if ty == t0 then raise Occur ; ty . level <- pivot_level - ty . level ; iter_type_expr occur_rec ty end in try occur_rec ty ; unmark_type ty ; false with Occur -> unmark_type ty ; true |
let rec unify env t1 t2 = if t1 == t2 then ( ) else let t1 = repr t1 in let t2 = repr t2 in if t1 == t2 then ( ) else try type_changed := true ; match ( t1 . desc , t2 . desc ) with ( Tvar , Tconstr _ ) when deep_occur t1 t2 -> unify2 env t1 t2 | ( Tconstr _ , Tvar ) when deep_... |
let unify env ty1 ty2 = try unify env ty1 ty2 with Unify trace -> raise ( Unify ( expand_trace env trace ) ) |
let unify_var env t1 t2 = let t1 = repr t1 and t2 = repr t2 in if t1 == t2 then ( ) else match t1 . desc with Tvar -> begin try occur env t1 t2 ; update_level env t1 . level t2 ; link_type t1 t2 with Unify trace -> raise ( Unify ( expand_trace env ( ( t1 , t2 ) :: trace ) ) ) end |... |
let _ = unify ' := unify_var |
let unify_pairs env ty1 ty2 pairs = univar_pairs := pairs ; unify env ty1 ty2 |
let unify env ty1 ty2 = univar_pairs := [ ] ; unify env ty1 ty2 |
let rec filter_arrow env t l = let t = expand_head_unif env t in match t . desc with Tvar -> let t1 = newvar ( ) and t2 = newvar ( ) in let t ' = newty ( Tarrow ( l , t1 , t2 , Cok ) ) in update_level env t . level t ' ; link_type t t ' ; ( t1 , t2 ) | Tarrow ( l ' ,... |
let rec filter_method_field env name priv ty = let ty = repr ty in match ty . desc with Tvar -> let level = ty . level in let ty1 = newvar2 level and ty2 = newvar2 level in let ty ' = newty2 level ( Tfield ( name , begin match priv with Private -> Fvar ( ref None ) | Public -> Fpresent end , ... |
let rec filter_method env name priv ty = let ty = expand_head_unif env ty in match ty . desc with Tvar -> let ty1 = newvar ( ) in let ty ' = newobj ty1 in update_level env ty . level ty ' ; link_type ty ty ' ; filter_method_field env name priv ty1 | Tobject ( f , _ ) -> filter_method_fie... |
let check_filter_method env name priv ty = ignore ( filter_method env name priv ty ) |
let filter_self_method env lab priv meths ty = let ty ' = filter_method env lab priv ty in try Meths . find lab ! meths with Not_found -> let pair = ( Ident . create lab , ty ' ) in meths := Meths . add lab pair ! meths ; pair |
let moregen_occur env level ty = let rec occur ty = let ty = repr ty in if ty . level > level then begin if ty . desc = Tvar && ty . level >= generic_level - 1 then raise Occur ; ty . level <- pivot_level - ty . level ; match ty . desc with Tvariant row when static_row row -> iter_row occur ... |
let may_instantiate inst_nongen t1 = if inst_nongen then t1 . level <> generic_level - 1 else t1 . level = generic_level |
let rec moregen inst_nongen type_pairs env t1 t2 = if t1 == t2 then ( ) else let t1 = repr t1 in let t2 = repr t2 in if t1 == t2 then ( ) else try match ( t1 . desc , t2 . desc ) with ( Tunivar , Tunivar ) -> unify_univar t1 t2 ! univar_pairs | ( Tvar , _ ) when may_instantiate in... |
let moregen inst_nongen type_pairs env patt subj = univar_pairs := [ ] ; moregen inst_nongen type_pairs env patt subj |
let moregeneral env inst_nongen pat_sch subj_sch = let old_level = ! current_level in current_level := generic_level - 1 ; let subj = duplicate_type ( instance subj_sch ) in current_level := generic_level ; let patt = instance pat_sch in let res = try moregen inst_nongen ( TypePairs . create 13 )... |
let rec rigidify_rec vars ty = let ty = repr ty in if ty . level >= lowest_level then begin ty . level <- pivot_level - ty . level ; match ty . desc with | Tvar -> if not ( List . memq ty ! vars ) then vars := ty :: ! vars | Tvariant row -> let row = row_repr row in let more = repr row . ... |
let rigidify ty = let vars = ref [ ] in rigidify_rec vars ty ; unmark_type ty ; ! vars |
let all_distinct_vars env vars = let tyl = ref [ ] in List . for_all ( fun ty -> let ty = expand_head env ty in if List . memq ty ! tyl then false else ( tyl := ty :: ! tyl ; ty . desc = Tvar ) ) vars |
let matches env ty ty ' = let snap = snapshot ( ) in let vars = rigidify ty in cleanup_abbrev ( ) ; let ok = try unify env ty ty ' ; all_distinct_vars env vars with Unify _ -> false in backtrack snap ; ok |
let expand_head_rigid env ty = let old = ! rigid_variants in rigid_variants := true ; let ty ' = expand_head_unif env ty in rigid_variants := old ; ty ' |
let normalize_subst subst = if List . exists ( function { desc = Tlink _ } , _ | _ , { desc = Tlink _ } -> true | _ -> false ) ! subst then subst := List . map ( fun ( t1 , t2 ) -> repr t1 , repr t2 ) ! subst |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.