text stringlengths 0 601k |
|---|
let rec object_row ty = let ty = repr ty in match ty . desc with Tobject ( t , _ ) -> object_row t | Tfield ( _ , _ , _ , t ) -> object_row t | _ -> ty |
let opened_object ty = match ( object_row ty ) . desc with | Tvar -> true | Tunivar -> true | Tconstr _ -> true | _ -> false |
let close_object ty = let rec close ty = let ty = repr ty in match ty . desc with Tvar -> link_type ty ( newty2 ty . level Tnil ) | Tfield ( _ , _ , _ , ty ' ) -> close ty ' | _ -> assert false in match ( repr ty ) . desc with Tobject ( ty , _ ) -> close ty | _ -> assert false |
let row_variable ty = let rec find ty = let ty = repr ty in match ty . desc with Tfield ( _ , _ , _ , ty ) -> find ty | Tvar -> ty | _ -> assert false in match ( repr ty ) . desc with Tobject ( fi , _ ) -> find fi | _ -> assert false |
let set_object_name id rv params ty = match ( repr ty ) . desc with Tobject ( fi , nm ) -> set_name nm ( Some ( Path . Pident id , rv :: params ) ) | _ -> assert false |
let remove_object_name ty = match ( repr ty ) . desc with Tobject ( _ , nm ) -> set_name nm None | Tconstr ( _ , _ , _ ) -> ( ) | _ -> fatal_error " Ctype . remove_object_name " |
let hide_private_methods ty = match ( repr ty ) . desc with Tobject ( fi , nm ) -> nm := None ; let ( fl , _ ) = flatten_fields fi in List . iter ( function ( _ , k , _ ) -> match field_kind_repr k with Fvar r -> set_kind r Fabsent | _ -> ( ) ) fl | _ -> assert false |
let rec signature_of_class_type = function Tcty_constr ( _ , _ , cty ) -> signature_of_class_type cty | Tcty_signature sign -> sign | Tcty_fun ( _ , ty , cty ) -> signature_of_class_type cty |
let self_type cty = repr ( signature_of_class_type cty ) . cty_self |
let rec class_type_arity = function Tcty_constr ( _ , _ , cty ) -> class_type_arity cty | Tcty_signature _ -> 0 | Tcty_fun ( _ , _ , cty ) -> 1 + class_type_arity cty |
let sort_row_fields = Sort . list ( fun ( p , _ ) ( q , _ ) -> p < q ) |
let rec merge_rf r1 r2 pairs fi1 fi2 = match fi1 , fi2 with ( l1 , f1 as p1 ) :: fi1 ' , ( l2 , f2 as p2 ) :: fi2 ' -> if l1 = l2 then merge_rf r1 r2 ( ( l1 , f1 , f2 ) :: pairs ) fi1 ' fi2 ' else if l1 < l2 then merge_rf ( p1 :: r1 ) r2 pairs fi1 ' fi2 else merge_rf r1 ( p2 :: r2 ) pairs fi1 fi2 ' | [ ] , _ -> ( List ... |
let merge_row_fields fi1 fi2 = match fi1 , fi2 with [ ] , _ | _ , [ ] -> ( fi1 , fi2 , [ ] ) | [ p1 ] , _ when not ( List . mem_assoc ( fst p1 ) fi2 ) -> ( fi1 , fi2 , [ ] ) | _ , [ p2 ] when not ( List . mem_assoc ( fst p2 ) fi1 ) -> ( fi1 , fi2 , [ ] ) | _ -> merge_rf [ ] [ ] [ ] ( sort_row_fields fi1 ) ( sort_row_fi... |
let rec filter_row_fields erase = function [ ] -> [ ] | ( l , f as p ) :: fi -> let fi = filter_row_fields erase fi in match row_field_repr f with Rabsent -> fi | Reither ( _ , _ , false , e ) when erase -> set_row_field e Rabsent ; fi | _ -> p :: fi |
let rec closed_schema_rec ty = let ty = repr ty in if ty . level >= lowest_level then begin let level = ty . level in ty . level <- pivot_level - level ; match ty . desc with Tvar when level <> generic_level -> raise Non_closed | Tfield ( _ , kind , t1 , t2 ) -> if field_kind_repr kind = Fpresent then closed_schema_rec... |
let closed_schema ty = try closed_schema_rec ty ; unmark_type ty ; true with Non_closed -> unmark_type ty ; false |
let free_variables = ref [ ] |
let really_closed = ref None |
let rec free_vars_rec real ty = let ty = repr ty in if ty . level >= lowest_level then begin ty . level <- pivot_level - ty . level ; begin match ty . desc , ! really_closed with Tvar , _ -> free_variables := ( ty , real ) :: ! free_variables | Tconstr ( path , tl , _ ) , Some env -> begin try let ( _ , body ) = Env . ... |
let free_vars ? env ty = free_variables := [ ] ; really_closed := env ; free_vars_rec true ty ; let res = ! free_variables in free_variables := [ ] ; really_closed := None ; res |
let free_variables ? env ty = let tl = List . map fst ( free_vars ? env ty ) in unmark_type ty ; tl |
let rec closed_type ty = match free_vars ty with [ ] -> ( ) | ( v , real ) :: _ -> raise ( Non_closed ( v , real ) ) |
let closed_parameterized_type params ty = List . iter mark_type params ; let ok = try closed_type ty ; true with Non_closed _ -> false in List . iter unmark_type params ; unmark_type ty ; ok |
let closed_type_decl decl = try List . iter mark_type decl . type_params ; begin match decl . type_kind with Type_abstract -> ( ) | Type_variant v -> List . iter ( fun ( _ , tyl ) -> List . iter closed_type tyl ) v | Type_record ( r , rep ) -> List . iter ( fun ( _ , _ , ty ) -> closed_type ty ) r end ; begin match dec... |
type closed_class_failure = CC_Method of type_expr * bool * string * type_expr | CC_Value of type_expr * bool * string * type_expr |
let closed_class params sign = let ty = object_fields ( repr sign . cty_self ) in let ( fields , rest ) = flatten_fields ty in List . iter mark_type params ; mark_type rest ; List . iter ( fun ( lab , _ , ty ) -> if lab = dummy_method then mark_type ty ) fields ; try mark_type_node ( repr sign . cty_self ) ; List . ite... |
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 | _ -> ( ) end ; iter_type_expr ( iter_generalize tyl ... |
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 ( _ , _ , abbrev ) -> abbrev... |
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 -> raise ( Unify [ ( ty , newva... |
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_variance with Not_found -> List .... |
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 . add graph ! idx ( ty , ref pty ... |
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 , _ ) -> let abbrevs = proper_abbrevs p tl ! abbrev... |
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 , tl ) -> ( s , List . map copy ... |
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 , v , ty ) -> ( m , v , copy ty ) ) sig... |
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 univs = TypeHash . find node_univars i... |
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 , bound_t = List . assq ty visited ... |
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 . iter Lazy . force ! delayed_copy ; delayed_copy := [ ] ... |
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 ( path , tl , _ ) } as ty ) -> let abbrev... |
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_level then begin try up... |
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_expand_once_opt env ty ) with Canno... |
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 [ ] [ ] ty ) ; simple_abbrevs := Mnil ; v... |
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 let ty ' = try_expand_head env ty i... |
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 } , Some _ when t2 == repr t ' 2 -> ( ) | Some ... |
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 TypeSet . exists ( fun x -> not ( T... |
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_right TypeSet . add univars TypeSet . empty ... |
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 ) -> if List . exists ( fun t ... |
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 -> TypeSet . mem t known_univars ) tl... |
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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.