text
stringlengths 12
786k
|
|---|
module Make ( S : STRUCTURE ) = struct |
type ' a structure = ' a S . structure |
type variable = descriptor UnionFind . point id : int ; structure : variable structure option ; mutable mark : Mark . t ; } |
let id v = ( UnionFind . get v ) . id |
let structure v = ( UnionFind . get v ) . structure |
let fresh = let c = ref 0 in fun structure -> let id = Misc . postincrement c in let mark = Mark . none in UnionFind . fresh { id ; structure ; mark } |
let occurs_check x y = let black = Mark . fresh ( ) in let rec visit z = let desc = UnionFind . get z in if not ( Mark . same desc . mark black ) then begin desc . mark <- black ; if UnionFind . equivalent x z then raise ( Occurs ( x , y ) ) else Option . iter ( S . iter visit ) desc . structure end in visit y |
let rec unify ( v1 : variable ) ( v2 : variable ) : unit = if not ( UnionFind . equivalent v1 v2 ) then begin let desc1 = UnionFind . get v1 and desc2 = UnionFind . get v2 in let desc = match desc1 . structure , desc2 . structure with | None , None -> desc1 | None , Some _ -> occurs_check v1 v2 ; desc2 | Some _ , None -> occurs_check v2 v1 ; desc1 | Some s1 , Some s2 -> S . iter2 unify s1 s2 ; { desc1 with structure = Some s1 } in UnionFind . union v1 v2 ; UnionFind . set v1 desc end |
let unify v1 v2 = try unify v1 v2 with S . Iter2 -> raise ( Unify ( v1 , v2 ) ) |
type term = | TVar of int | TNode of term structure |
let rec decode ( v : variable ) : term = match structure v with | None -> TVar ( id v ) | Some t -> TNode ( S . map decode t ) end |
module Trusted : sig type ' a t val empty : ' a t val unsafe_create_uninitialized : len : int -> ' a t val create_obj_array : len : int -> ' a t val create : len : int -> ' a -> ' a t val singleton : ' a -> ' a t val get : ' a t -> int -> ' a val set : ' a t -> int -> ' a -> unit val swap : _ t -> int -> int -> unit val unsafe_get : ' a t -> int -> ' a val unsafe_set : ' a t -> int -> ' a -> unit val unsafe_set_omit_phys_equal_check : ' a t -> int -> ' a -> unit val unsafe_set_int : ' a t -> int -> int -> unit val unsafe_set_int_assuming_currently_int : ' a t -> int -> int -> unit val unsafe_set_assuming_currently_int : ' a t -> int -> ' a -> unit val unsafe_set_with_caml_modify : ' a t -> int -> ' a -> unit val set_with_caml_modify : ' a t -> int -> ' a -> unit val length : ' a t -> int val unsafe_blit : ( ' a t , ' a t ) Blit . blit val copy : ' a t -> ' a t val unsafe_clear_if_pointer : _ t -> int -> unit type ' a t = Obj_array . t let empty = Obj_array . empty let unsafe_create_uninitialized ~ len = Obj_array . create_zero ~ len let create_obj_array ~ len = Obj_array . create_zero ~ len let create ~ len x = Obj_array . create ~ len ( Caml . Obj . repr x ) let singleton x = Obj_array . singleton ( Caml . Obj . repr x ) let swap t i j = Obj_array . swap t i j let get arr i = Caml . Obj . obj ( Obj_array . get arr i ) let set arr i x = Obj_array . set arr i ( Caml . Obj . repr x ) let unsafe_get arr i = Caml . Obj . obj ( Obj_array . unsafe_get arr i ) let unsafe_set arr i x = Obj_array . unsafe_set arr i ( Caml . Obj . repr x ) let unsafe_set_int arr i x = Obj_array . unsafe_set_int arr i x let unsafe_set_int_assuming_currently_int arr i x = Obj_array . unsafe_set_int_assuming_currently_int arr i x ; ; let unsafe_set_assuming_currently_int arr i x = Obj_array . unsafe_set_assuming_currently_int arr i ( Caml . Obj . repr x ) ; ; let length = Obj_array . length let unsafe_blit = Obj_array . unsafe_blit let copy = Obj_array . copy let unsafe_set_omit_phys_equal_check t i x = Obj_array . unsafe_set_omit_phys_equal_check t i ( Caml . Obj . repr x ) ; ; let unsafe_set_with_caml_modify t i x = Obj_array . unsafe_set_with_caml_modify t i ( Caml . Obj . repr x ) ; ; let set_with_caml_modify t i x = Obj_array . set_with_caml_modify t i ( Caml . Obj . repr x ) let unsafe_clear_if_pointer = Obj_array . unsafe_clear_if_pointer end |
let invariant t = assert ( Caml . Obj . tag ( Caml . Obj . repr t ) <> Caml . Obj . double_array_tag ) |
let init l ~ f = if l < 0 then invalid_arg " Uniform_array . init " else ( let res = unsafe_create_uninitialized ~ len : l in for i = 0 to l - 1 do unsafe_set res i ( f i ) done ; res ) ; ; |
let of_array arr = init ~ f ( : Array . unsafe_get arr ) ( Array . length arr ) |
let map a ~ f = init ~ f ( : fun i -> f ( unsafe_get a i ) ) ( length a ) |
let mapi a ~ f = init ~ f ( : fun i -> f i ( unsafe_get a i ) ) ( length a ) |
let iter a ~ f = for i = 0 to length a - 1 do f ( unsafe_get a i ) done ; ; |
let iteri a ~ f = for i = 0 to length a - 1 do f i ( unsafe_get a i ) done ; ; |
let foldi a ~ init ~ f = let acc = ref init in for i = 0 to length a - 1 do acc := f i ! acc ( unsafe_get a i ) done ; ! acc ; ; |
let to_list t = List . init ~ f ( : get t ) ( length t ) |
let of_list l = let len = List . length l in let res = unsafe_create_uninitialized ~ len in List . iteri l ~ f ( : fun i x -> set res i x ) ; res ; ; |
let to_array t = Array . init ( length t ) ~ f ( : fun i -> unsafe_get t i ) |
let exists t ~ f = let rec loop t ~ f i = if i < 0 then false else f ( unsafe_get t i ) || loop t ~ f ( i - 1 ) in loop t ~ f ( length t - 1 ) ; ; |
let for_all t ~ f = let rec loop t ~ f i = if i < 0 then true else f ( unsafe_get t i ) && loop t ~ f ( i - 1 ) in loop t ~ f ( length t - 1 ) ; ; |
let map2_exn t1 t2 ~ f = let len = length t1 in if length t2 <> len then invalid_arg " Array . map2_exn " ; init len ~ f ( : fun i -> f ( unsafe_get t1 i ) ( unsafe_get t2 i ) ) ; ; |
let t_sexp_grammar ( type elt ) ( grammar : elt Sexplib0 . Sexp_grammar . t ) : elt t Sexplib0 . Sexp_grammar . t = Sexplib0 . Sexp_grammar . coerce ( Array . t_sexp_grammar grammar ) ; ; include Sexpable . Of_sexpable1 ( Array ) ( struct type nonrec ' a t = ' a t let to_sexpable = to_array let of_sexpable = of_array end ) type nonrec ' a t = ' a t let length = length let create_like ~ len t = if len = 0 then empty else ( assert ( length t > 0 ) ; create ~ len ( get t 0 ) ) ; ; let unsafe_blit = unsafe_blit end ) |
let fold t ~ init ~ f = let r = ref init in for i = 0 to length t - 1 do r := f ! r ( unsafe_get t i ) done ; ! r ; ; |
let min_elt t ~ compare = Container . min_elt ~ fold t ~ compare |
let max_elt t ~ compare = Container . max_elt ~ fold t ~ compare |
let compare compare_elt a b = if phys_equal a b then 0 else ( let len_a = length a in let len_b = length b in let ret = compare len_a len_b in if ret <> 0 then ret else ( let rec loop i = if i = len_a then 0 else ( let l = unsafe_get a i and r = unsafe_get b i in let res = compare_elt l r in if res <> 0 then res else loop ( i + 1 ) ) in loop 0 ) ) ; ; |
type ( ' a , ' b ) ' b term = | Term of ' a * ( ' a , ' b ) ' b term list | Var of ' b |
let print_term ( t ( : string , string ) string term ) term = print_string ^$ string_of_sexp ^$ sexp_of_term sexp_of_string sexp_of_string t |
type ( ' a , ' b ) ' b delta = ( ' b * ( ' a , ' b ) ' b term ) term list |
let rec robOccursCheck ( x : ' a ) ' a ( ts : ( ' b , ' a ) ' a term list ) list ( delta : ( ' b , ' a ) ' a delta ) delta = match ts with | [ ] -> true | h :: t -> ( match h with && robOccursCheck x t delta |
let subst_r ( x ( : ' a , ' b ) ' bterm ) ' bterm ( delta ( : ' a , ' b ) ' b delta ) delta : ( ' a , ' b ) ' bterm = let cur = ref x in ( try while true do match ! cur with done with Not_found -> ( ) ) ; ! cur |
let rec subst ( x , s ) s t = match t with | Var x ' -> if x = x ' then s else t | Term ( f , ls ) ls -> Term ( Termf , List . map ( subst ( x , s ) s ) s ls ) |
let rob ( sts : ( ( ' a , ' b ) ' b term * ( ' a , ' b ) ' b term ) term list ) list : ( ' a , ' b ) ' b delta option = let rec aux sts acc : ( ' a , ' b ) ' b delta = ( match sts with | [ ] -> acc | ( ox , oy ) oy :: t -> ( match x , y with try let res = aux sts [ ] in Some res with Not_found -> None |
let term , term_eoi = MGram . Entry . mk " term " , MGram . Entry . mk " term_eoi " |
let pair = MGram . Entry . mk " pair " |
let _ = begin MGram . Entry . clear term ; MGram . Entry . clear term_eoi ; MGram . Entry . clear pair ; EXTEND MGram GLOBAL : term term_eoi pair ; term_eoi : [ [ t = term ; EOI -> t ] ] ; term : [ [ f = LIDENT ; ( " " ; terms = LIST0 SELF SEP " , " ; ) " " -> Term ( Termf , terms ) terms | f = LIDENT -> Term ( f [ ] ) , | v = UIDENT -> Var v ] ] ; pair : [ [ ls = LIST1 [ l = term ; " " = ; r = term -> ( l , r ) r ] r SEP " , " ; EOI -> rob ls ] ] ; END ; end |
let term_of_string = MGram . parse_string term_eoi ( Loc . mk " < string ) " > |
let pair_of_string = MGram . parse_string pair ( Loc . mk " < pair ) " > |
type _ succ = Succ |
type _ nat = | NZ : zero nat | NS : ' a nat -> ' a succ nat |
type _ fin = | FZ : ' a succ fin | FS : ' a fin -> ' a succ fin |
type _ is_succ = IS : ' a succ is_succ |
let fin_succ : type n . n fin -> n is_succ = function | FZ -> IS | FS _ -> IS ; ; [ %% expect { | |
type _ succ = Succ |
type _ nat = NZ : zero nat | NS : ' a nat -> ' a succ nat |
type _ fin = FZ : ' a succ fin | FS : ' a fin -> ' a succ fin |
type _ is_succ = IS : ' a succ is_succ } ] ; ; | |
type ' a term = | Var of ' a fin | Leaf | Fork of ' a term * ' a term |
let var x = Var x |
let lift r : ' m fin -> ' n term = fun x -> Var ( r x ) |
let rec pre_subst f = function | Var x -> f x | Leaf -> Leaf | Fork ( t1 , t2 ) -> Fork ( pre_subst f t1 , pre_subst f t2 ) |
let comp_subst f g ( x : ' a fin ) = pre_subst f ( g x ) ; ; [ %% expect { | |
type ' a term = Var of ' a fin | Leaf | Fork of ' a term * ' a term ( ' b fin -> ' c term ) -> ( ' a fin -> ' b term ) -> ' a fin -> ' c term = < fun > } ] ; ; | |
let rec thin : type n . n succ fin -> n fin -> n succ fin = fun x y -> match x , y with | FZ , y -> FS y | FS x , FZ -> FZ | FS x , FS y -> FS ( thin x y ) [ %% expect { | } ] ; ; | |
let bind t f = match t with | None -> None | Some x -> f x [ %% expect { | } ] ; ; | |
let rec thick : type n . n succ fin -> n succ fin -> n fin option = fun x y -> match x , y with | FZ , FZ -> None | FZ , FS y -> Some y | FS x , FZ -> let IS = fin_succ x in Some FZ | FS x , FS y -> let IS = fin_succ x in bind ( thick x y ) ( fun x -> Some ( FS x ) ) [ %% expect { | } ] ; ; | |
let rec check : type n . n succ fin -> n succ term -> n term option = fun x t -> match t with | Var y -> bind ( thick x y ) ( fun x -> Some ( Var x ) ) | Leaf -> Some Leaf | Fork ( t1 , t2 ) -> bind ( check x t1 ) ( fun t1 -> bind ( check x t2 ) ( fun t2 -> Some ( Fork ( t1 , t2 ) ) ) ) [ %% expect { | } ] ; ; | |
let subst_var x t ' y = match thick x y with | None -> t ' | Some y ' -> Var y ' [ %% expect { | } ] ; ; | |
let subst x t ' = pre_subst ( subst_var x t ' ) ; ; [ %% expect { | } ] ; ; | |
type ( _ , _ ) alist = | Anil : ( ' n , ' n ) alist | Asnoc : ( ' m , ' n ) alist * ' m term * ' m succ fin -> ( ' m succ , ' n ) alist |
let rec sub : type m n . ( m , n ) alist -> m fin -> n term = function | Anil -> var | Asnoc ( s , t , x ) -> comp_subst ( sub s ) ( subst_var x t ) [ %% expect { | |
type ( _ , _ ) alist = Anil : ( ' n , ' n ) alist | Asnoc : ( ' m , ' n ) alist * ' m term * ' m succ fin -> ( ' m succ , ' n ) alist } ] ; ; | |
let rec append : type m n l . ( m , n ) alist -> ( l , m ) alist -> ( l , n ) alist = fun r s -> match s with | Anil -> r | Asnoc ( s , t , x ) -> Asnoc ( append r s , t , x ) [ %% expect { | } ] ; ; | |
type _ ealist = EAlist : ( ' a , ' b ) alist -> ' a ealist |
let asnoc a t ' x = EAlist ( Asnoc ( a , t ' , x ) ) [ %% expect { | |
type _ ealist = EAlist : ( ' a , ' b ) alist -> ' a ealist < fun > } ] ; ; | |
let rec weaken_fin : type n . n fin -> n succ fin = function | FZ -> FZ | FS x -> FS ( weaken_fin x ) |
let weaken_term t = pre_subst ( fun x -> Var ( weaken_fin x ) ) t |
let rec weaken_alist : type m n . ( m , n ) alist -> ( m succ , n succ ) alist = function | Anil -> Anil | Asnoc ( s , t , x ) -> Asnoc ( weaken_alist s , weaken_term t , weaken_fin x ) |
let rec sub ' : type m . m ealist -> m fin -> m term = function | EAlist Anil -> var | EAlist ( Asnoc ( s , t , x ) ) -> comp_subst ( sub ' ( EAlist ( weaken_alist s ) ) ) ( fun t ' -> weaken_term ( subst_var x t t ' ) ) |
let subst ' d = pre_subst ( sub ' d ) ; ; [ %% expect { | } ] ; ; | |
let flex_flex x y = match thick x y with | Some y ' -> asnoc Anil ( Var y ' ) x | None -> EAlist Anil |
let flex_rigid x t = bind ( check x t ) ( fun t ' -> Some ( asnoc Anil t ' x ) ) |
let rec amgu : type m . m term -> m term -> m ealist -> m ealist option = fun s t acc -> match s , t , acc with | Leaf , Leaf , _ -> Some acc | Leaf , Fork _ , _ -> None | Fork _ , Leaf , _ -> None | Fork ( s1 , s2 ) , Fork ( t1 , t2 ) , _ -> bind ( amgu s1 t1 acc ) ( amgu s2 t2 ) | Var x , Var y , EAlist Anil -> let IS = fin_succ x in Some ( flex_flex x y ) | Var x , t , EAlist Anil -> let IS = fin_succ x in flex_rigid x t | t , Var x , EAlist Anil -> let IS = fin_succ x in flex_rigid x t | s , t , EAlist ( Asnoc ( d , r , z ) ) -> bind ( amgu ( subst z r s ) ( subst z r t ) ( EAlist d ) ) ( fun ( EAlist d ) -> Some ( asnoc d r z ) ) |
let mgu s t = amgu s t ( EAlist Anil ) ; ; [ %% expect { | } ] ; ; | |
let s = Fork ( Var FZ , Fork ( Var ( FS ( FS FZ ) ) , Leaf ) ) |
let t = Fork ( Var ( FS FZ ) , Var ( FS FZ ) ) |
let d = match mgu s t with Some x -> x | None -> failwith " mgu " |
let s ' = subst ' d s |
let t ' = subst ' d t ; ; [ %% expect { | EAlist ( Asnoc ( Asnoc ( Anil , Fork ( Var FZ , Leaf ) , FZ ) , Var FZ , FZ ) ) Fork ( Fork ( Var FZ , Leaf ) , Fork ( Var FZ , Leaf ) ) Fork ( Fork ( Var FZ , Leaf ) , Fork ( Var FZ , Leaf ) ) } ] ; ; | |
let rec equal s t = match s , t with | T . Int , T . Int -> true | T . Bool , T . Bool -> true | T . Arrow ( t1 , t2 ) , T . Arrow ( s1 , s2 ) -> ( equal t1 s1 ) && ( equal t2 s2 ) | T . Product ss , T . Product ts -> List . for_all ( fun ( s , t ) -> equal s t ) ( List . combine ss ts ) | T . TVar { contents = Some s ' } , _ -> equal s ' t | _ , T . TVar { contents = Some t ' } -> equal s t ' | T . TVar x , T . TVar y -> x == y | _ , _ -> false |
let a1 : ( T . tp option ) ref = ref ( None ) ; ; |
let a2 : ( T . tp option ) ref = ref ( None ) ; ; |
let a3 : ( T . tp option ) ref = ref ( None ) ; ; |
let a4 : ( T . tp option ) ref = ref ( None ) ; ; |
let a5 : ( T . tp option ) ref = ref ( None ) ; ; |
let a6 : ( T . tp option ) ref = ref ( None ) ; ; |
let a7 : ( T . tp option ) ref = ref ( None ) ; ; |
let a8 : ( T . tp option ) ref = ref ( None ) ; ; |
let t1 = T . Arrow ( T . Product [ T . TVar ( a1 ) ; T . TVar ( a1 ) ] , T . TVar ( a2 ) ) ; ; |
let t2 = T . Arrow ( T . Product [ T . Int ; T . Int ] , T . TVar ( a1 ) ) ; ; |
let t3 = T . Arrow ( T . Product [ T . TVar ( a3 ) ; T . TVar ( a4 ) ] , T . TVar ( a4 ) ) ; ; |
let t4 = T . Arrow ( T . Product [ T . TVar ( a4 ) ; T . TVar ( a3 ) ] , T . TVar ( a3 ) ) ; ; |
let t5 = T . Arrow ( T . Product [ T . TVar ( a5 ) ; T . TVar ( a6 ) ] , T . TVar ( a6 ) ) ; ; |
let t6 = T . Arrow ( T . TVar ( a6 ) , T . TVar ( a5 ) ) ; ; |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.