AllenGeng/ocamlgithub · Datasets at Hugging Face

text stringlengths 12 786k
let deactivate ( sys : string ) : unit = activated := Strs . diff ! activated ( try Hashtbl . find active_dep sys with Not_found -> print_endline ( " WTF ? " ^ sys ) ; Strs . empty )
let indent_level = ref 0
let traceIndent ( ) = indent_level := ! indent_level + 2
let traceOutdent ( ) = indent_level := ! indent_level - 2
let mygprintf ( format : ( ' a , unit , doc , ' b ) format4 ) : ' a = let format = string_of_format format in let flen = String . length format in let fget = String . unsafe_get format in let rec literal acc i = let rec skipChars j = if j >= flen \|\| ( match fget j with ' ' % \| ' ' @ \| ' \ n ' -> true \| _ -> false ) then collect nil j else skipChars ( succ j ) in skipChars ( succ i ) and collect ( acc : doc ) ( i : int ) = if i >= flen then begin Obj . magic ( ( ) ) end else begin let c = fget i in if c = ' ' % then begin let j = skip_args ( succ i ) in match fget j with ' ' % -> literal acc j \| ' , ' -> collect acc ( succ j ) \| ' s ' \| ' c ' \| ' d ' \| ' i ' \| ' o ' \| ' x ' \| ' X ' \| ' u ' \| ' f ' \| ' e ' \| ' E ' \| ' g ' \| ' G ' \| ' b ' \| ' B ' -> Obj . magic ( fun b -> collect nil ( succ j ) ) \| ' L ' \| ' l ' \| ' n ' -> Obj . magic ( fun n -> collect nil ( succ ( succ j ) ) ) \| ' a ' -> Obj . magic ( fun pprinter arg -> collect nil ( succ j ) ) \| ' t ' -> Obj . magic ( fun pprinter -> collect nil ( succ j ) ) \| c -> invalid_arg ( " dprintf : unknown format % s " ^ String . make 1 c ) end else if c = ' ' @ then begin if i + 1 < flen then begin match fget ( succ i ) with ' [ ' \| ' ] ' \| ' ' ! \| ' ' ? \| ' ' ^ \| ' ' @ -> collect nil ( i + 2 ) \| ' ' < \| ' ' > -> collect nil ( i + 1 ) \| c -> invalid_arg ( " dprintf : unknown format " @ ^ String . make 1 c ) end else invalid_arg " dprintf : incomplete format " @ end else if c = ' \ n ' then begin collect nil ( i + 1 ) end else literal acc i end and skip_args j = match String . unsafe_get format j with ' 0 ' . . ' 9 ' \| ' ' \| ' . ' \| ' ' - -> skip_args ( succ j ) \| c -> j in collect nil 0
let traceTag ( sys : string ) : Pretty . doc = let rec ind ( i : int ) : string = if ( i <= 0 ) then " " else " " ^ ( ind ( i - 1 ) ) in ( text ( ( ind ! indent_level ) ^ " %%% " ^ sys ^ " : " ) )
let printtrace sys d : unit = fprint stderr ~ width : 80 ( ( traceTag sys ) ++ d ) ; flush stderr
let gtrace always f sys var ? loc do_subsys fmt = let cond = ( Strs . mem sys ! activated \|\| always && Strs . mem sys ! trace_sys ) && match var , loc with \| Some s , Some l -> ( ! tracevars = [ ] \|\| List . mem s ! tracevars ) && ( ! tracelocs = [ ] \|\| List . mem l . line ! tracelocs ) \| Some s , None -> ( ! tracevars = [ ] \|\| List . mem s ! tracevars ) \| None , Some l -> ( ! tracelocs = [ ] \|\| List . mem l . line ! tracelocs ) \| _ -> true in if cond then begin do_subsys ( ) ; gprintf ( f sys ) fmt end else mygprintf fmt
let trace sys ? var fmt = gtrace true printtrace sys var ignore fmt
let tracel sys ? var fmt = let loc = ! current_loc in let docloc sys doc = printtrace sys ( dprintf " ( % a ) " @? CilType . Location . pretty loc ++ indent 2 doc ) ; in gtrace true docloc sys var ~ loc ignore fmt
let tracei ( sys : string ) ? var ( ? subsys [ ] ) = fmt = let f sys d = printtrace sys d ; traceIndent ( ) in let g ( ) = activate sys subsys in gtrace true f sys var g fmt
let tracec sys fmt = gtrace false printtrace sys None ignore fmt
let traceu sys fmt = let f sys d = printtrace sys d ; traceOutdent ( ) in let g ( ) = deactivate sys in gtrace true f sys None g fmt
let traceli sys ? var ( ? subsys [ ] ) = fmt = let loc = ! current_loc in let g ( ) = activate sys subsys in let docloc sys doc : unit = printtrace sys ( dprintf " ( % a ) " CilType . Location . pretty loc ++ indent 2 doc ) ; traceIndent ( ) in gtrace true docloc sys var ~ loc g fmt
module OpamPackage = struct include OpamPackage let to_yojson t = ` String ( OpamPackage . to_string t ) let of_yojson = function \| ` String str -> ( match OpamPackage . of_string_opt str with \| Some x -> Ok x \| None -> Error " failed to parse version " ) \| _ -> Error " failed to parse version " end
module Track = struct type t = No_context let id = " opam - repo - track " let auto_cancel = true module Key = struct type t = { limit : int option ; repo : Git . Commit . t ; filter : string list } let digest { repo ; filter ; limit } = Git . Commit . hash repo ^ String . concat " ; " filter ^ " ; " ^ ( limit \|> Option . map string_of_int \|> Option . value ~ default " " ) : end let pp f { Key . repo ; filter ; _ } = Fmt . pf f " opam repo track \ n % a \ n % a " Git . Commit . pp_short repo Fmt . ( list string ) filter module Value = struct type package_definition = { package : OpamPackage . t ; digest : string } [ @@ deriving yojson ] type t = package_definition list [ @@ deriving yojson ] let marshal t = t \|> to_yojson \|> Yojson . Safe . to_string let unmarshal t = t \|> Yojson . Safe . from_string \|> of_yojson \|> Result . get_ok end let rec take n lst = match ( n , lst ) with 0 , _ -> [ ] \| _ , [ ] -> [ ] \| n , a :: q -> a :: take ( n - 1 ) q let take = function Some n -> take n \| None -> Fun . id let get_file path = Lwt_io . with_file ~ mode : Input ( Fpath . to_string path ) Lwt_io . read let get_versions ~ limit path = let open Lwt . Syntax in let open Rresult in Bos . OS . Dir . contents path >>\| ( fun versions -> versions \|> Lwt_list . map_p ( fun path -> let + content = get_file Fpath . ( path / " opam " ) in Value . { package = path \|> Fpath . basename \|> OpamPackage . of_string ; digest = Digest . ( string content \|> to_hex ) ; } ) ) \|> Result . get_ok \|> Lwt . map ( fun v -> v \|> List . sort ( fun a b -> - OpamPackage . compare a . Value . package b . package ) \|> take limit ) let build No_context job { Key . repo ; filter ; limit } = let open Lwt . Syntax in let open Rresult in let filter name = match filter with [ ] -> true \| lst -> List . mem ( Fpath . basename name ) lst in let * ( ) = Current . Job . start ~ level : Harmless job in Git . with_checkout ~ job repo @@ fun dir -> let result = Bos . OS . Dir . contents Fpath . ( dir / " packages " ) >>\| fun packages -> packages \|> List . filter filter \|> Lwt_list . map_s ( get_versions ~ limit ) \|> Lwt . map ( fun v -> List . flatten v ) in match result with Ok v -> Lwt . map Result . ok v \| Error e -> Lwt . return_error e end
module TrackCache = Misc . LatchedBuilder ( Track )
type t = package_definition [ @@ deriving yojson ]
let pkg t = t . package
let digest t = t . digest
module Map = OpamStd . Map . Make ( struct type nonrec t = t let compare a b = O . OpamPackage . compare a . package b . package let to_json { package ; digest } = ` A [ OpamPackage . to_json package ; ` String digest ] let of_json _ = None let to_string t = OpamPackage . to_string t . package end )
let v ~ limit ( ~ filter : string list ) ( repo : Git . Commit . t Current . t ) = let open Current . Syntax in Current . component " Track packages - % a " Fmt . ( list string ) filter \|> let > repo = repo in TrackCache . get ~ opkey " : track " No_context { filter ; repo ; limit }
type vec = { x : float ; y : float ; z : float }
type quat = { v : vec ; w : float }
let as_tuple v = v . x , v . y , v . z
let vzero = ( 0 . 0 , 0 . 0 , 0 . 0 )
let ( ) -^ a b = { x = a . x . - b . x ; y = a . y . - b . y ; z = a . z . - b . z ; }
let ( ) +^ a b = { x = a . x . + b . x ; y = a . y . + b . y ; z = a . z . + b . z ; }
let ( ) ^^ a b = { x = a . y . * b . z . - a . z . * b . y ; y = a . z . * b . x . - a . x . * b . z ; z = a . x . * b . y . - a . y . * b . x }
let vlength v = sqrt ( v . x . * v . x . + v . y . * v . y . + v . z . * v . z )
let vscale s v = { x = s . * v . x ; y = s . * v . y ; z = s . * v . z }
let vnormal v = vscale ( 1 . 0 . / ( vlength v ) ) v
let ( . ) ^^ a b = a . x . * b . x . + a . y . * b . y . + a . z . * b . z
let tb_project_to_sphere r x y = let d = sqrt ( x . * x . + y . * y ) in let z = if ( d < r . * 0 . 70710678118654752440 ) then sqrt ( r . * r . - d . * d ) else begin let t = r . / 1 . 41421356237309504880 in t . * t . / d end in z ; ;
let axis_to_quat ~ axis ~ phi = let ax = match axis with x , y , z -> { x = x ; y = y ; z = z } in let sax = vscale ( sin ( phi . / 2 . 0 ) ) ( vnormal ax ) in { v = sax ; w ( = cos ( phi . / 2 . 0 ) ) } ; ;
let trackball ~ p1 ~ p2 = match p1 with p1x , p1y -> match p2 with p2x , p2y -> if ( p1 = p2 ) then { v { = x = 0 . 0 ; y = 0 . 0 ; z = 0 . 0 } ; w = 1 . 0 } else begin let pp1 = { x = p1x ; y = p1y ; z ( = tb_project_to_sphere trackballsize p1x p1y ) } in let pp2 = { x = p2x ; y = p2y ; z ( = tb_project_to_sphere trackballsize p2x p2y ) } in let ax = pp2 ^^ pp1 in let d = pp1 -^ pp2 in let t = ( vlength d ) . / ( 2 . 0 . * trackballsize ) in let clamp x a b = if x < a then a else if x > b then b else x in let t = clamp t ( - 1 . 0 ) 1 . 0 in let phi = 2 . 0 . * asin ( t ) in axis_to_quat ( as_tuple ax ) phi end ; ;
let count = ref 0
let normalized_quat q = let minv = 1 . 0 . / ( sqrt ( ( q . v . ^^ q . v ) . + q . w . * q . w ) ) in { v = vscale minv q . v ; w = q . w . * minv } ; ;
let add_quats ~ q1 ~ q2 = let t1 = vscale q2 . w q1 . v in let t2 = vscale q1 . w q2 . v in let t3 = q2 . v ^^ q1 . v in let q = { v = t1 +^ t2 +^ t3 ; w = q1 . w . * q2 . w . - ( q1 . v . ^^ q2 . v ) } in incr count ; if ( ! count > renormcount ) then begin count := 0 ; normalized_quat q ; end else q ; ;
let unit_quat ( ) = { v { = x = 0 . 0 ; y = 0 . 0 ; z = 0 . 0 } ; w = 1 . 0 }
let build_rotmatrix ~ q = GlMat . of_array [ \| [ \| 1 . 0 . - 2 . 0 . * ( q . v . y . * q . v . y . + q . v . z . * q . v . z ) ; 2 . 0 . * ( q . v . x . * q . v . y . - q . v . z . * q . w ) ; 2 . 0 . * ( q . v . z . * q . v . x . + q . v . y . * q . w ) ; 0 . 0 ] ; \| [ \| 2 . 0 . * ( q . v . x . * q . v . y . + q . v . z . * q . w ) ; 1 . 0 . - 2 . 0 . * ( q . v . z . * q . v . z . + q . v . x . * q . v . x ) ; 2 . 0 . * ( q . v . y . * q . v . z . - q . v . x . * q . w ) ; 0 . 0 ] ; \| [ \| 2 . 0 . * ( q . v . z . * q . v . x . - q . v . y . * q . w ) ; 2 . 0 . * ( q . v . y . * q . v . z . + q . v . x . * q . w ) ; 1 . 0 . - 2 . 0 . * ( q . v . y . * q . v . y . + q . v . x . * q . v . x ) ; 0 . 0 ] ; \| [ \| 0 . 0 ; 0 . 0 ; 0 . 0 ; 1 . 0 ; ] \| ] \|
module Michelson = struct let prepare_origination_of_id_script ? delegate ( ? push_drops = 0 ) ( ? amount = " 2 " ) state ~ name ~ from ~ protocol_kind ~ parameter ~ init_storage = let id_script parameter = Fmt . str " parameter % s ; \ n \ storage % s ; \ n \ code \ n \ \ { \ n \ \ % s \ n \ \ { CAR ; NIL operation ; PAIR } \ n \ \ } ; \ n " parameter parameter ( match push_drops with \| 0 -> " # No push - drops " \| n -> Fmt . str " # % d push - drop % s \ n % s " n ( if n > 1 then " s " else " " ) ( List . init push_drops ~ f ( : fun ith -> Fmt . str " { PUSH string % S ; DROP } ; " ( Fmt . str " push - dropping % d adds stupid bytes to the contract " ith ) ) \|> String . concat ~ sep " :\ n " ) ) in let tmp = Caml . Filename . temp_file " little - id - script " " . tz " in System . write_file state tmp ~ content ( : id_script parameter ) >>= fun ( ) -> Dbg . e EF . ( wf " id_script % s : % s " parameter tmp ) ; let origination = let opt = Option . value_map ~ default [ ] : in [ " -- wait " ; " none " ; " originate " ; " contract " ; name ] @ ( match protocol_kind with \| ` Athens -> [ " for " ; from ] \| ` Babylon \| ` Carthage \| ` Delphi \| ` Edo \| ` Florence \| ` Granada \| ` Hangzhou \| ` Ithaca \| ` Alpha -> [ ] ) @ [ " transferring " ; amount ; " from " ; from ; " running " ; tmp ; " -- init " ; init_storage ; " -- force " ; " -- burn - cap " ; " 300000000000 " ; " -- gas - limit " ; " 1000000000000000 " ; " -- storage - limit " ; " 20000000000000 " ; " -- verbose - signing " ] @ opt delegate ~ f ( : fun s -> [ " -- delegate " ; s ] ) in return origination end
module Random = struct let run state ~ protocol ~ nodes ~ clients ~ until_level kind = assert ( Poly . equal kind ` Any ) ; let tbb = protocol . Tezos_protocol . time_between_blocks \|> List . hd \|> Option . value ~ default : 10 in let info fmt = Fmt . kstr ( fun s -> Console . sayf state Fmt . ( fun ppf ( ) -> pf ppf " Randomizer : % s " s ) ) fmt in let from = " bootacc - 0 " in let client = List . hd_exn clients in let pp_success ppf = function \| true -> Fmt . pf ppf " Success " \| false -> Fmt . pf ppf " Failure " in let valid_contracts = ref [ ] in let rec loop iteration = let client_cmd name l = Tezos_client . client_cmd ~ verbose : false state ~ client ~ id_prefix ( : Fmt . str " randomizer -% 04d -% s " iteration name ) l in let continue_or_not ( ) = Test_scenario . Queries . all_levels state ~ nodes >>= fun all_levels -> if List . for_all all_levels ~ f ( : function \| _ , ` Level l when l >= until_level -> true \| _ -> false ) then info " Max - level reached : % d " until_level else loop ( iteration + 1 ) in List . random_element [ ` Sleep ; ` Add_contract ; ` Call_contract ] \|> function \| Some ` Sleep -> let secs = Float . ( Random . float_range ( of_int tbb * 0 . 3 ) ( of_int tbb * 1 . 5 ) ) in info " Sleeping . % 2f seconds . " secs >>= fun ( ) -> System . sleep secs >>= fun ( ) -> continue_or_not ( ) \| Some ` Call_contract -> ( match List . random_element ! valid_contracts with \| None -> info " No valid contracts to call . " \| Some ( name , params ) -> client_cmd ( Fmt . str " transfer -% s " name ) [ " transfer " ; " 1 " ; " from " ; from ; " to " ; name ; " -- arg " ; params ] >>= fun ( success , _ ) -> info " Called % s ( % s ) : % a " name params pp_success success ) >>= fun ( ) -> continue_or_not ( ) \| Some ` Add_contract -> let name = Fmt . str " contract -% d " iteration in let push_drops = Random . int 100 in let parameter , init_storage = match List . random_element [ ` Unit ; ` String ] with \| Some ` String -> ( " string " , Fmt . str " % S " ( String . init ( Random . int 42 + 1 ) ~ f ( : fun _ -> Random . int 20 + 40 \|> Char . of_int_exn ) ) ) \| _ -> ( " unit " , " Unit " ) in Michelson . prepare_origination_of_id_script state ~ name ~ from ~ protocol_kind : protocol . Tezos_protocol . kind ~ parameter ~ init_storage ~ push_drops >>= fun origination -> client_cmd ( Fmt . str " originate -% s " name ) origination >>= fun ( success , _ ) -> if success then valid_contracts := ( name , init_storage ) :: ! valid_contracts ; info " Origination of ` % s ` ( % s : % s ) : ` % a ` . " name init_storage parameter pp_success success >>= fun ( ) -> continue_or_not ( ) \| None -> continue_or_not ( ) in loop 0 end
module Forge = struct let batch_transfer ( ? protocol_kind : Tezos_protocol . Protocol_kind . t = ` Babylon ) ( ? counter = 0 ) ( ? dst = [ ( " tz2KZPgf2rshxNUBXFcTaCemik1LH1v9qz3F " , 1 ) ] ) ~ src ~ fee ~ branch n : Ezjsonm . value = let open Ezjsonm in ignore protocol_kind ; dict [ ( " branch " , ` String branch ) ; ( " contents " , ` A ( List . map ( List . range 0 n ) ~ f ( : fun i -> let dest , amount = List . nth_exn dst ( i % List . length dst ) in ` O [ ( " kind " , ` String " transaction " ) ; ( " source " , ` String src ) ; ( " destination " , ` String dest ) ; ( " amount " , ` String ( Int . to_string amount ) ) ; ( " fee " , ` String ( Int . to_string ( Float . to_int ( fee . * 1000000 . ) ) ) ) ; ( " counter " , ` String ( Int . to_string ( counter + i ) ) ) ; ( " gas_limit " , ` String ( Int . to_string 127 ) ) ; ( " storage_limit " , ` String ( Int . to_string 277 ) ) ] ) ) ) ] let endorsement ( ? protocol_kind : Tezos_protocol . Protocol_kind . t = ` Babylon ) ~ branch level : Ezjsonm . value = let open Ezjsonm in ignore protocol_kind ; dict [ ( " branch " , ` String branch ) ; ( " contents " , ` A [ ` O [ ( " kind " , ` String " endorsement " ) ; ( " level " , int level ) ] ] ) ] end
type ' error trace = ' error Support . Lib . Monad . trace
module type BASE = sig val name : string type ' a elt type ' a_elt t val of_list : int list -> int t val to_list : int t -> int list val pp : Format . formatter -> int t -> unit end
module type ITER_VANILLA = sig type ' a elt type ' a t val iter : ( ' a elt -> unit ) -> ' a t -> unit end
module type ITER_SEQUENTIAL = sig include ITER_VANILLA val iter_e : ( ' a elt -> ( unit , ' trace ) result ) -> ' a t -> ( unit , ' trace ) result val iter_s : ( ' a elt -> unit Lwt . t ) -> ' a t -> unit Lwt . t val iter_es : ( ' a elt -> ( unit , ' trace ) result Lwt . t ) -> ' a t -> ( unit , ' trace ) result Lwt . t end
module type ITER_PARALLEL = sig include ITER_SEQUENTIAL val iter_p : ( ' a elt -> unit Lwt . t ) -> ' a t -> unit Lwt . t val iter_ep : ( ' a elt -> ( unit , ' error trace ) result Lwt . t ) -> ' a t -> ( unit , ' error trace ) result Lwt . t end
module type ITERI_VANILLA = sig type ' a elt type ' a t val iteri : ( int -> ' a elt -> unit ) -> ' a t -> unit end
module type ITERI_SEQUENTIAL = sig include ITERI_VANILLA val iteri_e : ( int -> ' a elt -> ( unit , ' trace ) result ) -> ' a t -> ( unit , ' trace ) result val iteri_s : ( int -> ' a elt -> unit Lwt . t ) -> ' a t -> unit Lwt . t val iteri_es : ( int -> ' a elt -> ( unit , ' trace ) result Lwt . t ) -> ' a t -> ( unit , ' trace ) result Lwt . t end
module type MAP_VANILLA = sig type ' a t val map : ( ' a -> ' b ) -> ' a t -> ' b t end
module type MAP_SEQUENTIAL = sig include MAP_VANILLA val map_e : ( ' a -> ( ' b , ' trace ) result ) -> ' a t -> ( ' b t , ' trace ) result val map_s : ( ' a -> ' b Lwt . t ) -> ' a t -> ' b t Lwt . t val map_es : ( ' a -> ( ' b , ' trace ) result Lwt . t ) -> ' a t -> ( ' b t , ' trace ) result Lwt . t end
module type MAP_PARALLEL = sig include MAP_SEQUENTIAL val map_p : ( ' a -> ' b Lwt . t ) -> ' a t -> ' b t Lwt . t val map_ep : ( ' a -> ( ' b , ' error trace ) result Lwt . t ) -> ' a t -> ( ' b t , ' error trace ) result Lwt . t end
module type REVMAP_VANILLA = sig type ' a t val rev : ' a t -> ' a t val rev_map : ( ' a -> ' b ) -> ' a t -> ' b t end
module type REVMAP_SEQUENTIAL = sig include REVMAP_VANILLA val rev_map_e : ( ' a -> ( ' b , ' trace ) result ) -> ' a t -> ( ' b t , ' trace ) result val rev_map_s : ( ' a -> ' b Lwt . t ) -> ' a t -> ' b t Lwt . t val rev_map_es : ( ' a -> ( ' b , ' trace ) result Lwt . t ) -> ' a t -> ( ' b t , ' trace ) result Lwt . t end
module type REVMAP_PARALLEL = sig include REVMAP_SEQUENTIAL val rev_map_p : ( ' a -> ' b Lwt . t ) -> ' a t -> ' b t Lwt . t val rev_map_ep : ( ' a -> ( ' b , ' error trace ) result Lwt . t ) -> ' a t -> ( ' b t , ' error trace ) result Lwt . t end
module type FOLDLEFT_VANILLA = sig type ' a elt type ' a t val fold_left : ( ' a -> ' b elt -> ' a ) -> ' a -> ' b t -> ' a end
module type FOLDLEFT_SEQUENTIAL = sig include FOLDLEFT_VANILLA val fold_left_e : ( ' a -> ' b elt -> ( ' a , ' trace ) result ) -> ' a -> ' b t -> ( ' a , ' trace ) result val fold_left_s : ( ' a -> ' b elt -> ' a Lwt . t ) -> ' a -> ' b t -> ' a Lwt . t val fold_left_es : ( ' a -> ' b elt -> ( ' a , ' trace ) result Lwt . t ) -> ' a -> ' b t -> ( ' a , ' trace ) result Lwt . t end
module type FOLDLEFTMAP_VANILLA = sig type ' a elt type ' a t val fold_left_map : ( ' a -> ' b elt -> ' a * ' c ) -> ' a -> ' b t -> ' a * ' c list end
module type FOLDLEFTMAP_SEQUENTIAL = sig include FOLDLEFTMAP_VANILLA val fold_left_map_e : ( ' a -> ' b elt -> ( ' a * ' c , ' trace ) result ) -> ' a -> ' b t -> ( ' a * ' c list , ' trace ) result val fold_left_map_s : ( ' a -> ' b elt -> ( ' a * ' c ) Lwt . t ) -> ' a -> ' b t -> ( ' a * ' c list ) Lwt . t val fold_left_map_es : ( ' a -> ' b elt -> ( ' a * ' c , ' trace ) result Lwt . t ) -> ' a -> ' b t -> ( ' a * ' c list , ' trace ) result Lwt . t end
module type FOLDRIGHT_VANILLA = sig type ' a t val fold_right : ( ' a -> ' b -> ' b ) -> ' a t -> ' b -> ' b end
module type FOLDRIGHT_SEQUENTIAL = sig include FOLDRIGHT_VANILLA val fold_right_e : ( ' a -> ' b -> ( ' b , ' trace ) result ) -> ' a t -> ' b -> ( ' b , ' trace ) result val fold_right_s : ( ' a -> ' b -> ' b Lwt . t ) -> ' a t -> ' b -> ' b Lwt . t val fold_right_es : ( ' a -> ' b -> ( ' b , ' trace ) result Lwt . t ) -> ' a t -> ' b -> ( ' b , ' trace ) result Lwt . t end
module type FOLDOOO_VANILLA = sig type ' a elt type ' a t val fold : ( ' b elt -> ' a -> ' a ) -> ' b t -> ' a -> ' a end
module type FOLDOOO_SEQUENTIAL = sig include FOLDOOO_VANILLA val fold_e : ( ' b elt -> ' a -> ( ' a , ' trace ) result ) -> ' b t -> ' a -> ( ' a , ' trace ) result val fold_s : ( ' b elt -> ' a -> ' a Lwt . t ) -> ' b t -> ' a -> ' a Lwt . t val fold_es : ( ' b elt -> ' a -> ( ' a , ' trace ) result Lwt . t ) -> ' b t -> ' a -> ( ' a , ' trace ) result Lwt . t end
module type EXISTFORALL_VANILLA = sig type ' a elt type ' a t val exists : ( ' a elt -> bool ) -> ' a t -> bool val for_all : ( ' a elt -> bool ) -> ' a t -> bool end
module type EXISTFORALL_SEQUENTIAL = sig include EXISTFORALL_VANILLA val exists_e : ( ' a elt -> ( bool , ' trace ) result ) -> ' a t -> ( bool , ' trace ) result val exists_s : ( ' a elt -> bool Lwt . t ) -> ' a t -> bool Lwt . t val exists_es : ( ' a elt -> ( bool , ' trace ) result Lwt . t ) -> ' a t -> ( bool , ' trace ) result Lwt . t val for_all_e : ( ' a elt -> ( bool , ' trace ) result ) -> ' a t -> ( bool , ' trace ) result val for_all_s : ( ' a elt -> bool Lwt . t ) -> ' a t -> bool Lwt . t val for_all_es : ( ' a elt -> ( bool , ' trace ) result Lwt . t ) -> ' a t -> ( bool , ' trace ) result Lwt . t end
module type EXISTFORALL_PARALLEL = sig include EXISTFORALL_SEQUENTIAL val exists_p : ( ' a elt -> bool Lwt . t ) -> ' a t -> bool Lwt . t val exists_ep : ( ' a elt -> ( bool , ' error trace ) result Lwt . t ) -> ' a t -> ( bool , ' error trace ) result Lwt . t val for_all_p : ( ' a elt -> bool Lwt . t ) -> ' a t -> bool Lwt . t val for_all_ep : ( ' a elt -> ( bool , ' error trace ) result Lwt . t ) -> ' a t -> ( bool , ' error trace ) result Lwt . t end
module type FILTER_VANILLA = sig type ' a elt type ' a t val filter : ( ' a -> bool ) -> ' a t -> ' a t end
module type FILTER_EXTRAS = sig include FILTER_VANILLA val filter_left : ( ' a , ' b ) Either . t t -> ' a t val filter_right : ( ' b , ' a ) Either . t t -> ' a t val filter_ok : ( ' a , ' b ) result t -> ' a t val filter_error : ( ' b , ' a ) result t -> ' a t end
module type FILTER_SEQUENTIAL = sig include FILTER_VANILLA val filter_e : ( ' a -> ( bool , ' trace ) result ) -> ' a t -> ( ' a t , ' trace ) result val filter_s : ( ' a -> bool Lwt . t ) -> ' a t -> ' a t Lwt . t val filter_es : ( ' a -> ( bool , ' trace ) result Lwt . t ) -> ' a t -> ( ' a t , ' trace ) result Lwt . t end
module type FILTER_PARALLEL = sig type ' a t val filter_p : ( ' a -> bool Lwt . t ) -> ' a t -> ' a t Lwt . t val filter_ep : ( ' a -> ( bool , ' error trace ) result Lwt . t ) -> ' a t -> ( ' a t , ' error trace ) result Lwt . t end
module type FILTERI_VANILLA = sig type ' a elt type ' a t val filteri : ( int -> ' a -> bool ) -> ' a t -> ' a t end
module type FILTERI_SEQUENTIAL = sig include FILTERI_VANILLA val filteri_e : ( int -> ' a -> ( bool , ' trace ) result ) -> ' a t -> ( ' a t , ' trace ) result val filteri_s : ( int -> ' a -> bool Lwt . t ) -> ' a t -> ' a t Lwt . t val filteri_es : ( int -> ' a -> ( bool , ' trace ) result Lwt . t ) -> ' a t -> ( ' a t , ' trace ) result Lwt . t end
module type FILTERI_PARALLEL = sig type ' a t val filteri_p : ( int -> ' a -> bool Lwt . t ) -> ' a t -> ' a t Lwt . t val filteri_ep : ( int -> ' a -> ( bool , ' error trace ) result Lwt . t ) -> ' a t -> ( ' a t , ' error trace ) result Lwt . t end
module type FILTERMAP_VANILLA = sig type ' a t val filter_map : ( ' a -> ' b option ) -> ' a t -> ' b t end
module type FILTERMAP_SEQUENTIAL = sig include FILTERMAP_VANILLA val filter_map_e : ( ' a -> ( ' b option , ' trace ) result ) -> ' a t -> ( ' b t , ' trace ) result val filter_map_s : ( ' a -> ' b option Lwt . t ) -> ' a t -> ' b t Lwt . t val filter_map_es : ( ' a -> ( ' b option , ' trace ) result Lwt . t ) -> ' a t -> ( ' b t , ' trace ) result Lwt . t end
module type FILTERMAP_PARALLEL = sig type ' a t val filter_map_p : ( ' a -> ' b option Lwt . t ) -> ' a t -> ' b t Lwt . t val filter_map_ep : ( ' a -> ( ' b option , ' error trace ) result Lwt . t ) -> ' a t -> ( ' b t , ' error trace ) result Lwt . t end
module type CONCATMAP_VANILLA = sig type ' a t val concat_map : ( ' a -> ' b t ) -> ' a t -> ' b t end
module type CONCATMAP_SEQUENTIAL = sig include CONCATMAP_VANILLA val concat_map_s : ( ' a -> ' b t Lwt . t ) -> ' a t -> ' b t Lwt . t val concat_map_e : ( ' a -> ( ' b t , ' error ) result ) -> ' a t -> ( ' b t , ' error ) result val concat_map_es : ( ' a -> ( ' b t , ' error ) result Lwt . t ) -> ' a t -> ( ' b t , ' error ) result Lwt . t end
module type CONCATMAP_PARALLEL = sig type ' a t val concat_map_p : ( ' a -> ' b t Lwt . t ) -> ' a t -> ' b t Lwt . t val concat_map_ep : ( ' a -> ( ' b t , ' error trace ) result Lwt . t ) -> ' a t -> ( ' b t , ' error trace ) result Lwt . t end
module type FIND_VANILLA = sig type ' a t val find : ( ' a -> bool ) -> ' a t -> ' a option end
module type FIND_SEQUENTIAL = sig include FIND_VANILLA val find_e : ( ' a -> ( bool , ' trace ) result ) -> ' a t -> ( ' a option , ' trace ) result val find_s : ( ' a -> bool Lwt . t ) -> ' a t -> ' a option Lwt . t val find_es : ( ' a -> ( bool , ' trace ) result Lwt . t ) -> ' a t -> ( ' a option , ' trace ) result Lwt . t end
module type FINDMAP_VANILLA = sig type ' a t val find_map : ( ' a -> ' b option ) -> ' a t -> ' b option end
module type FINDMAP_SEQUENTIAL = sig include FINDMAP_VANILLA val find_map_e : ( ' a -> ( ' b option , ' trace ) result ) -> ' a t -> ( ' b option , ' trace ) result val find_map_s : ( ' a -> ' b option Lwt . t ) -> ' a t -> ' b option Lwt . t val find_map_es : ( ' a -> ( ' b option , ' trace ) result Lwt . t ) -> ' a t -> ( ' b option , ' trace ) result Lwt . t end
module type PARTITION_VANILLA = sig type ' a t val partition : ( ' a -> bool ) -> ' a t -> ' a t * ' a t end
module type PARTITION_EXTRAS = sig include PARTITION_VANILLA val partition_either : ( ' a , ' b ) Either . t t -> ' a t * ' b t val partition_result : ( ' a , ' b ) result t -> ' a t * ' b t end
module type PARTITION_SEQUENTIAL = sig include PARTITION_VANILLA val partition_e : ( ' a -> ( bool , ' trace ) result ) -> ' a t -> ( ' a t * ' a t , ' trace ) result val partition_s : ( ' a -> bool Lwt . t ) -> ' a t -> ( ' a t * ' a t ) Lwt . t val partition_es : ( ' a -> ( bool , ' trace ) result Lwt . t ) -> ' a t -> ( ' a t * ' a t , ' trace ) result Lwt . t end
module type PARTITION_PARALLEL = sig include PARTITION_SEQUENTIAL val partition_p : ( ' a -> bool Lwt . t ) -> ' a t -> ( ' a t * ' a t ) Lwt . t val partition_ep : ( ' a -> ( bool , ' error trace ) result Lwt . t ) -> ' a t -> ( ' a t * ' a t , ' error trace ) result Lwt . t end
module type PARTITIONMAP_VANILLA = sig type ' a t val partition_map : ( ' a -> ( ' b , ' c ) Either . t ) -> ' a t -> ' b t * ' c t end
module type PARTITIONMAP_SEQUENTIAL = sig include PARTITIONMAP_VANILLA val partition_map_e : ( ' a -> ( ( ' b , ' c ) Either . t , ' trace ) result ) -> ' a t -> ( ' b t * ' c t , ' trace ) result val partition_map_s : ( ' a -> ( ' b , ' c ) Either . t Lwt . t ) -> ' a t -> ( ' b t * ' c t ) Lwt . t val partition_map_es : ( ' a -> ( ( ' b , ' c ) Either . t , ' trace ) result Lwt . t ) -> ' a t -> ( ' b t * ' c t , ' trace ) result Lwt . t end
module type PARTITIONMAP_PARALLEL = sig include PARTITIONMAP_SEQUENTIAL val partition_map_p : ( ' a -> ( ' b , ' c ) Either . t Lwt . t ) -> ' a t -> ( ' b t * ' c t ) Lwt . t val partition_map_ep : ( ' a -> ( ( ' b , ' c ) Either . t , ' error trace ) result Lwt . t ) -> ' a t -> ( ' b t * ' c t , ' error trace ) result Lwt . t end
module type COMBINE_VANILLA = sig type ' a t val combine : when_different_lengths ' : trace -> ' a t -> ' b t -> ( ( ' a * ' b ) t , ' trace ) result val combine_with_leftovers : ' a t -> ' b t -> ( ' a * ' b ) t * ( ' a list , ' b list ) Either . t option end
module type ALLDOUBLE_VANILLA = sig type ' a t val iter2 : when_different_lengths ' : trace -> ( ' a -> ' b -> unit ) -> ' a t -> ' b t -> ( unit , ' trace ) result val map2 : when_different_lengths ' : trace -> ( ' a -> ' b -> ' c ) -> ' a t -> ' b t -> ( ' c t , ' trace ) result val rev_map2 : when_different_lengths ' : trace -> ( ' a -> ' b -> ' c ) -> ' a t -> ' b t -> ( ' c t , ' trace ) result val fold_left2 : when_different_lengths ' : trace -> ( ' a -> ' b -> ' c -> ' a ) -> ' a -> ' b t -> ' c t -> ( ' a , ' trace ) result val fold_right2 : when_different_lengths ' : trace -> ( ' a -> ' b -> ' c -> ' c ) -> ' a t -> ' b t -> ' c -> ( ' c , ' trace ) result val for_all2 : when_different_lengths ' : trace -> ( ' a -> ' b -> bool ) -> ' a t -> ' b t -> ( bool , ' trace ) result val exists2 : when_different_lengths ' : trace -> ( ' a -> ' b -> bool ) -> ' a t -> ' b t -> ( bool , ' trace ) result end
module type ALLDOUBLE_SEQENTIAL = sig include ALLDOUBLE_VANILLA val iter2_e : when_different_lengths ' : trace -> ( ' a -> ' b -> ( unit , ' trace ) result ) -> ' a t -> ' b t -> ( unit , ' trace ) result val iter2_s : when_different_lengths ' : trace -> ( ' a -> ' b -> unit Lwt . t ) -> ' a t -> ' b t -> ( unit , ' trace ) result Lwt . t val iter2_es : when_different_lengths ' : trace -> ( ' a -> ' b -> ( unit , ' trace ) result Lwt . t ) -> ' a t -> ' b t -> ( unit , ' trace ) result Lwt . t val map2_e : when_different_lengths ' : trace -> ( ' a -> ' b -> ( ' c , ' trace ) result ) -> ' a t -> ' b t -> ( ' c t , ' trace ) result val map2_s : when_different_lengths ' : trace -> ( ' a -> ' b -> ' c Lwt . t ) -> ' a t -> ' b t -> ( ' c t , ' trace ) result Lwt . t val map2_es : when_different_lengths ' : trace -> ( ' a -> ' b -> ( ' c , ' trace ) result Lwt . t ) -> ' a t -> ' b t -> ( ' c t , ' trace ) result Lwt . t val rev_map2_e : when_different_lengths ' : trace -> ( ' a -> ' b -> ( ' c , ' trace ) result ) -> ' a t -> ' b t -> ( ' c t , ' trace ) result val rev_map2_s : when_different_lengths ' : trace -> ( ' a -> ' b -> ' c Lwt . t ) -> ' a t -> ' b t -> ( ' c t , ' trace ) result Lwt . t val rev_map2_es : when_different_lengths ' : trace -> ( ' a -> ' b -> ( ' c , ' trace ) result Lwt . t ) -> ' a t -> ' b t -> ( ' c t , ' trace ) result Lwt . t val fold_left2_e : when_different_lengths ' : trace -> ( ' a -> ' b -> ' c -> ( ' a , ' trace ) result ) -> ' a -> ' b t -> ' c t -> ( ' a , ' trace ) result val fold_left2_s : when_different_lengths ' : trace -> ( ' a -> ' b -> ' c -> ' a Lwt . t ) -> ' a -> ' b t -> ' c t -> ( ' a , ' trace ) result Lwt . t val fold_left2_es : when_different_lengths ' : trace -> ( ' a -> ' b -> ' c -> ( ' a , ' trace ) result Lwt . t ) -> ' a -> ' b t -> ' c t -> ( ' a , ' trace ) result Lwt . t val fold_right2_e : when_different_lengths ' : trace -> ( ' a -> ' b -> ' c -> ( ' c , ' trace ) result ) -> ' a t -> ' b t -> ' c -> ( ' c , ' trace ) result val fold_right2_s : when_different_lengths ' : trace -> ( ' a -> ' b -> ' c -> ' c Lwt . t ) -> ' a t -> ' b t -> ' c -> ( ' c , ' trace ) result Lwt . t val fold_right2_es : when_different_lengths ' : trace -> ( ' a -> ' b -> ' c -> ( ' c , ' trace ) result Lwt . t ) -> ' a t -> ' b t -> ' c -> ( ' c , ' trace ) result Lwt . t val for_all2_e : when_different_lengths ' : trace -> ( ' a -> ' b -> ( bool , ' trace ) result ) -> ' a t -> ' b t -> ( bool , ' trace ) result val for_all2_s : when_different_lengths ' : trace -> ( ' a -> ' b -> bool Lwt . t ) -> ' a t -> ' b t -> ( bool , ' trace ) result Lwt . t val for_all2_es : when_different_lengths ' : trace -> ( ' a -> ' b -> ( bool , ' trace ) result Lwt . t ) -> ' a t -> ' b t -> ( bool , ' trace ) result Lwt . t val exists2_e : when_different_lengths ' : trace -> ( ' a -> ' b -> ( bool , ' trace ) result ) -> ' a t -> ' b t -> ( bool , ' trace ) result val exists2_s : when_different_lengths ' : trace -> ( ' a -> ' b -> bool Lwt . t ) -> ' a t -> ' b t -> ( bool , ' trace ) result Lwt . t val exists2_es : when_different_lengths ' : trace -> ( ' a -> ' b -> ( bool , ' trace ) result Lwt . t ) -> ' a t -> ' b t -> ( bool , ' trace ) result Lwt . t end
type ' error trace = ' error Support . Lib . Monad . trace
module type BASE_E = sig val name : string type ' a elt type ( ' a_elt , ' e ) t val of_list : int list -> ( int , ' e ) t val to_list : ( int , ' e ) t -> ( int list , ' e ) result val pp : Format . formatter -> ( int , ' e ) t -> unit end
module type BASE_S = sig val name : string type ' a elt type ' a_elt t val of_list : int list -> int t val to_list : int t -> int list Lwt . t val pp : Format . formatter -> int t -> unit Lwt . t end
module type BASE_ES = sig val name : string type ' a elt type ( ' a_elt , ' e ) t val of_list : int list -> ( int , ' e ) t val to_list : ( int , ' e ) t -> ( int list , ' e ) result Lwt . t val pp : Format . formatter -> ( int , ' e ) t -> unit Lwt . t end
module type ITER_VANILLA = sig type ' a elt type ' a t val iter : ( ' a elt -> unit ) -> ' a t -> unit end

let deactivate ( sys : string ) : unit = activated := Strs . diff ! activated ( try Hashtbl . find active_dep sys with Not_found -> print_endline ( " WTF ? " ^ sys ) ; Strs . empty )

let indent_level = ref 0

let traceIndent ( ) = indent_level := ! indent_level + 2

let traceOutdent ( ) = indent_level := ! indent_level - 2

let mygprintf ( format : ( ' a , unit , doc , ' b ) format4 ) : ' a = let format = string_of_format format in let flen = String . length format in let fget = String . unsafe_get format in let rec literal acc i = let rec skipChars j = if j >= flen || ( match fget j with ' ' % | ' ' @ | ' \ n ' -> true | _ -> false ) then collect nil j else skipChars ( succ j ) in skipChars ( succ i ) and collect ( acc : doc ) ( i : int ) = if i >= flen then begin Obj . magic ( ( ) ) end else begin let c = fget i in if c = ' ' % then begin let j = skip_args ( succ i ) in match fget j with ' ' % -> literal acc j | ' , ' -> collect acc ( succ j ) | ' s ' | ' c ' | ' d ' | ' i ' | ' o ' | ' x ' | ' X ' | ' u ' | ' f ' | ' e ' | ' E ' | ' g ' | ' G ' | ' b ' | ' B ' -> Obj . magic ( fun b -> collect nil ( succ j ) ) | ' L ' | ' l ' | ' n ' -> Obj . magic ( fun n -> collect nil ( succ ( succ j ) ) ) | ' a ' -> Obj . magic ( fun pprinter arg -> collect nil ( succ j ) ) | ' t ' -> Obj . magic ( fun pprinter -> collect nil ( succ j ) ) | c -> invalid_arg ( " dprintf : unknown format % s " ^ String . make 1 c ) end else if c = ' ' @ then begin if i + 1 < flen then begin match fget ( succ i ) with ' [ ' | ' ] ' | ' ' ! | ' ' ? | ' ' ^ | ' ' @ -> collect nil ( i + 2 ) | ' ' < | ' ' > -> collect nil ( i + 1 ) | c -> invalid_arg ( " dprintf : unknown format " @ ^ String . make 1 c ) end else invalid_arg " dprintf : incomplete format " @ end else if c = ' \ n ' then begin collect nil ( i + 1 ) end else literal acc i end and skip_args j = match String . unsafe_get format j with ' 0 ' . . ' 9 ' | ' ' | ' . ' | ' ' - -> skip_args ( succ j ) | c -> j in collect nil 0

let traceTag ( sys : string ) : Pretty . doc = let rec ind ( i : int ) : string = if ( i <= 0 ) then " " else " " ^ ( ind ( i - 1 ) ) in ( text ( ( ind ! indent_level ) ^ " %%% " ^ sys ^ " : " ) )

let printtrace sys d : unit = fprint stderr ~ width : 80 ( ( traceTag sys ) ++ d ) ; flush stderr

let gtrace always f sys var ? loc do_subsys fmt = let cond = ( Strs . mem sys ! activated || always && Strs . mem sys ! trace_sys ) && match var , loc with | Some s , Some l -> ( ! tracevars = [ ] || List . mem s ! tracevars ) && ( ! tracelocs = [ ] || List . mem l . line ! tracelocs ) | Some s , None -> ( ! tracevars = [ ] || List . mem s ! tracevars ) | None , Some l -> ( ! tracelocs = [ ] || List . mem l . line ! tracelocs ) | _ -> true in if cond then begin do_subsys ( ) ; gprintf ( f sys ) fmt end else mygprintf fmt

let trace sys ? var fmt = gtrace true printtrace sys var ignore fmt

let tracel sys ? var fmt = let loc = ! current_loc in let docloc sys doc = printtrace sys ( dprintf " ( % a ) " @? CilType . Location . pretty loc ++ indent 2 doc ) ; in gtrace true docloc sys var ~ loc ignore fmt

let tracei ( sys : string ) ? var ( ? subsys [ ] ) = fmt = let f sys d = printtrace sys d ; traceIndent ( ) in let g ( ) = activate sys subsys in gtrace true f sys var g fmt

let tracec sys fmt = gtrace false printtrace sys None ignore fmt

let traceu sys fmt = let f sys d = printtrace sys d ; traceOutdent ( ) in let g ( ) = deactivate sys in gtrace true f sys None g fmt

let traceli sys ? var ( ? subsys [ ] ) = fmt = let loc = ! current_loc in let g ( ) = activate sys subsys in let docloc sys doc : unit = printtrace sys ( dprintf " ( % a ) " CilType . Location . pretty loc ++ indent 2 doc ) ; traceIndent ( ) in gtrace true docloc sys var ~ loc g fmt

module OpamPackage = struct include OpamPackage let to_yojson t = ` String ( OpamPackage . to_string t ) let of_yojson = function | ` String str -> ( match OpamPackage . of_string_opt str with | Some x -> Ok x | None -> Error " failed to parse version " ) | _ -> Error " failed to parse version " end

module Track = struct type t = No_context let id = " opam - repo - track " let auto_cancel = true module Key = struct type t = { limit : int option ; repo : Git . Commit . t ; filter : string list } let digest { repo ; filter ; limit } = Git . Commit . hash repo ^ String . concat " ; " filter ^ " ; " ^ ( limit |> Option . map string_of_int |> Option . value ~ default " " ) : end let pp f { Key . repo ; filter ; _ } = Fmt . pf f " opam repo track \ n % a \ n % a " Git . Commit . pp_short repo Fmt . ( list string ) filter module Value = struct type package_definition = { package : OpamPackage . t ; digest : string } [ @@ deriving yojson ] type t = package_definition list [ @@ deriving yojson ] let marshal t = t |> to_yojson |> Yojson . Safe . to_string let unmarshal t = t |> Yojson . Safe . from_string |> of_yojson |> Result . get_ok end let rec take n lst = match ( n , lst ) with 0 , _ -> [ ] | _ , [ ] -> [ ] | n , a :: q -> a :: take ( n - 1 ) q let take = function Some n -> take n | None -> Fun . id let get_file path = Lwt_io . with_file ~ mode : Input ( Fpath . to_string path ) Lwt_io . read let get_versions ~ limit path = let open Lwt . Syntax in let open Rresult in Bos . OS . Dir . contents path >>| ( fun versions -> versions |> Lwt_list . map_p ( fun path -> let + content = get_file Fpath . ( path / " opam " ) in Value . { package = path |> Fpath . basename |> OpamPackage . of_string ; digest = Digest . ( string content |> to_hex ) ; } ) ) |> Result . get_ok |> Lwt . map ( fun v -> v |> List . sort ( fun a b -> - OpamPackage . compare a . Value . package b . package ) |> take limit ) let build No_context job { Key . repo ; filter ; limit } = let open Lwt . Syntax in let open Rresult in let filter name = match filter with [ ] -> true | lst -> List . mem ( Fpath . basename name ) lst in let * ( ) = Current . Job . start ~ level : Harmless job in Git . with_checkout ~ job repo @@ fun dir -> let result = Bos . OS . Dir . contents Fpath . ( dir / " packages " ) >>| fun packages -> packages |> List . filter filter |> Lwt_list . map_s ( get_versions ~ limit ) |> Lwt . map ( fun v -> List . flatten v ) in match result with Ok v -> Lwt . map Result . ok v | Error e -> Lwt . return_error e end

module TrackCache = Misc . LatchedBuilder ( Track )

type t = package_definition [ @@ deriving yojson ]

let pkg t = t . package

let digest t = t . digest

module Map = OpamStd . Map . Make ( struct type nonrec t = t let compare a b = O . OpamPackage . compare a . package b . package let to_json { package ; digest } = ` A [ OpamPackage . to_json package ; ` String digest ] let of_json _ = None let to_string t = OpamPackage . to_string t . package end )

let v ~ limit ( ~ filter : string list ) ( repo : Git . Commit . t Current . t ) = let open Current . Syntax in Current . component " Track packages - % a " Fmt . ( list string ) filter |> let > repo = repo in TrackCache . get ~ opkey " : track " No_context { filter ; repo ; limit }

type vec = { x : float ; y : float ; z : float }

type quat = { v : vec ; w : float }

let as_tuple v = v . x , v . y , v . z

let vzero = ( 0 . 0 , 0 . 0 , 0 . 0 )

let ( ) -^ a b = { x = a . x . - b . x ; y = a . y . - b . y ; z = a . z . - b . z ; }

let ( ) +^ a b = { x = a . x . + b . x ; y = a . y . + b . y ; z = a . z . + b . z ; }

let ( ) ^^ a b = { x = a . y . * b . z . - a . z . * b . y ; y = a . z . * b . x . - a . x . * b . z ; z = a . x . * b . y . - a . y . * b . x }

let vlength v = sqrt ( v . x . * v . x . + v . y . * v . y . + v . z . * v . z )

let vscale s v = { x = s . * v . x ; y = s . * v . y ; z = s . * v . z }

let vnormal v = vscale ( 1 . 0 . / ( vlength v ) ) v

let ( . ) ^^ a b = a . x . * b . x . + a . y . * b . y . + a . z . * b . z

let tb_project_to_sphere r x y = let d = sqrt ( x . * x . + y . * y ) in let z = if ( d < r . * 0 . 70710678118654752440 ) then sqrt ( r . * r . - d . * d ) else begin let t = r . / 1 . 41421356237309504880 in t . * t . / d end in z ; ;

let axis_to_quat ~ axis ~ phi = let ax = match axis with x , y , z -> { x = x ; y = y ; z = z } in let sax = vscale ( sin ( phi . / 2 . 0 ) ) ( vnormal ax ) in { v = sax ; w ( = cos ( phi . / 2 . 0 ) ) } ; ;

let trackball ~ p1 ~ p2 = match p1 with p1x , p1y -> match p2 with p2x , p2y -> if ( p1 = p2 ) then { v { = x = 0 . 0 ; y = 0 . 0 ; z = 0 . 0 } ; w = 1 . 0 } else begin let pp1 = { x = p1x ; y = p1y ; z ( = tb_project_to_sphere trackballsize p1x p1y ) } in let pp2 = { x = p2x ; y = p2y ; z ( = tb_project_to_sphere trackballsize p2x p2y ) } in let ax = pp2 ^^ pp1 in let d = pp1 -^ pp2 in let t = ( vlength d ) . / ( 2 . 0 . * trackballsize ) in let clamp x a b = if x < a then a else if x > b then b else x in let t = clamp t ( - 1 . 0 ) 1 . 0 in let phi = 2 . 0 . * asin ( t ) in axis_to_quat ( as_tuple ax ) phi end ; ;

let count = ref 0

let normalized_quat q = let minv = 1 . 0 . / ( sqrt ( ( q . v . ^^ q . v ) . + q . w . * q . w ) ) in { v = vscale minv q . v ; w = q . w . * minv } ; ;

let add_quats ~ q1 ~ q2 = let t1 = vscale q2 . w q1 . v in let t2 = vscale q1 . w q2 . v in let t3 = q2 . v ^^ q1 . v in let q = { v = t1 +^ t2 +^ t3 ; w = q1 . w . * q2 . w . - ( q1 . v . ^^ q2 . v ) } in incr count ; if ( ! count > renormcount ) then begin count := 0 ; normalized_quat q ; end else q ; ;

let unit_quat ( ) = { v { = x = 0 . 0 ; y = 0 . 0 ; z = 0 . 0 } ; w = 1 . 0 }

let build_rotmatrix ~ q = GlMat . of_array [ | [ | 1 . 0 . - 2 . 0 . * ( q . v . y . * q . v . y . + q . v . z . * q . v . z ) ; 2 . 0 . * ( q . v . x . * q . v . y . - q . v . z . * q . w ) ; 2 . 0 . * ( q . v . z . * q . v . x . + q . v . y . * q . w ) ; 0 . 0 ] ; | [ | 2 . 0 . * ( q . v . x . * q . v . y . + q . v . z . * q . w ) ; 1 . 0 . - 2 . 0 . * ( q . v . z . * q . v . z . + q . v . x . * q . v . x ) ; 2 . 0 . * ( q . v . y . * q . v . z . - q . v . x . * q . w ) ; 0 . 0 ] ; | [ | 2 . 0 . * ( q . v . z . * q . v . x . - q . v . y . * q . w ) ; 2 . 0 . * ( q . v . y . * q . v . z . + q . v . x . * q . w ) ; 1 . 0 . - 2 . 0 . * ( q . v . y . * q . v . y . + q . v . x . * q . v . x ) ; 0 . 0 ] ; | [ | 0 . 0 ; 0 . 0 ; 0 . 0 ; 1 . 0 ; ] | ] |

module Michelson = struct let prepare_origination_of_id_script ? delegate ( ? push_drops = 0 ) ( ? amount = " 2 " ) state ~ name ~ from ~ protocol_kind ~ parameter ~ init_storage = let id_script parameter = Fmt . str " parameter % s ; \ n \ storage % s ; \ n \ code \ n \ \ { \ n \ \ % s \ n \ \ { CAR ; NIL operation ; PAIR } \ n \ \ } ; \ n " parameter parameter ( match push_drops with | 0 -> " # No push - drops " | n -> Fmt . str " # % d push - drop % s \ n % s " n ( if n > 1 then " s " else " " ) ( List . init push_drops ~ f ( : fun ith -> Fmt . str " { PUSH string % S ; DROP } ; " ( Fmt . str " push - dropping % d adds stupid bytes to the contract " ith ) ) |> String . concat ~ sep " :\ n " ) ) in let tmp = Caml . Filename . temp_file " little - id - script " " . tz " in System . write_file state tmp ~ content ( : id_script parameter ) >>= fun ( ) -> Dbg . e EF . ( wf " id_script % s : % s " parameter tmp ) ; let origination = let opt = Option . value_map ~ default [ ] : in [ " -- wait " ; " none " ; " originate " ; " contract " ; name ] @ ( match protocol_kind with | ` Athens -> [ " for " ; from ] | ` Babylon | ` Carthage | ` Delphi | ` Edo | ` Florence | ` Granada | ` Hangzhou | ` Ithaca | ` Alpha -> [ ] ) @ [ " transferring " ; amount ; " from " ; from ; " running " ; tmp ; " -- init " ; init_storage ; " -- force " ; " -- burn - cap " ; " 300000000000 " ; " -- gas - limit " ; " 1000000000000000 " ; " -- storage - limit " ; " 20000000000000 " ; " -- verbose - signing " ] @ opt delegate ~ f ( : fun s -> [ " -- delegate " ; s ] ) in return origination end

module Random = struct let run state ~ protocol ~ nodes ~ clients ~ until_level kind = assert ( Poly . equal kind ` Any ) ; let tbb = protocol . Tezos_protocol . time_between_blocks |> List . hd |> Option . value ~ default : 10 in let info fmt = Fmt . kstr ( fun s -> Console . sayf state Fmt . ( fun ppf ( ) -> pf ppf " Randomizer : % s " s ) ) fmt in let from = " bootacc - 0 " in let client = List . hd_exn clients in let pp_success ppf = function | true -> Fmt . pf ppf " Success " | false -> Fmt . pf ppf " Failure " in let valid_contracts = ref [ ] in let rec loop iteration = let client_cmd name l = Tezos_client . client_cmd ~ verbose : false state ~ client ~ id_prefix ( : Fmt . str " randomizer -% 04d -% s " iteration name ) l in let continue_or_not ( ) = Test_scenario . Queries . all_levels state ~ nodes >>= fun all_levels -> if List . for_all all_levels ~ f ( : function | _ , ` Level l when l >= until_level -> true | _ -> false ) then info " Max - level reached : % d " until_level else loop ( iteration + 1 ) in List . random_element [ ` Sleep ; ` Add_contract ; ` Call_contract ] |> function | Some ` Sleep -> let secs = Float . ( Random . float_range ( of_int tbb * 0 . 3 ) ( of_int tbb * 1 . 5 ) ) in info " Sleeping . % 2f seconds . " secs >>= fun ( ) -> System . sleep secs >>= fun ( ) -> continue_or_not ( ) | Some ` Call_contract -> ( match List . random_element ! valid_contracts with | None -> info " No valid contracts to call . " | Some ( name , params ) -> client_cmd ( Fmt . str " transfer -% s " name ) [ " transfer " ; " 1 " ; " from " ; from ; " to " ; name ; " -- arg " ; params ] >>= fun ( success , _ ) -> info " Called % s ( % s ) : % a " name params pp_success success ) >>= fun ( ) -> continue_or_not ( ) | Some ` Add_contract -> let name = Fmt . str " contract -% d " iteration in let push_drops = Random . int 100 in let parameter , init_storage = match List . random_element [ ` Unit ; ` String ] with | Some ` String -> ( " string " , Fmt . str " % S " ( String . init ( Random . int 42 + 1 ) ~ f ( : fun _ -> Random . int 20 + 40 |> Char . of_int_exn ) ) ) | _ -> ( " unit " , " Unit " ) in Michelson . prepare_origination_of_id_script state ~ name ~ from ~ protocol_kind : protocol . Tezos_protocol . kind ~ parameter ~ init_storage ~ push_drops >>= fun origination -> client_cmd ( Fmt . str " originate -% s " name ) origination >>= fun ( success , _ ) -> if success then valid_contracts := ( name , init_storage ) :: ! valid_contracts ; info " Origination of ` % s ` ( % s : % s ) : ` % a ` . " name init_storage parameter pp_success success >>= fun ( ) -> continue_or_not ( ) | None -> continue_or_not ( ) in loop 0 end

module Forge = struct let batch_transfer ( ? protocol_kind : Tezos_protocol . Protocol_kind . t = ` Babylon ) ( ? counter = 0 ) ( ? dst = [ ( " tz2KZPgf2rshxNUBXFcTaCemik1LH1v9qz3F " , 1 ) ] ) ~ src ~ fee ~ branch n : Ezjsonm . value = let open Ezjsonm in ignore protocol_kind ; dict [ ( " branch " , ` String branch ) ; ( " contents " , ` A ( List . map ( List . range 0 n ) ~ f ( : fun i -> let dest , amount = List . nth_exn dst ( i % List . length dst ) in ` O [ ( " kind " , ` String " transaction " ) ; ( " source " , ` String src ) ; ( " destination " , ` String dest ) ; ( " amount " , ` String ( Int . to_string amount ) ) ; ( " fee " , ` String ( Int . to_string ( Float . to_int ( fee . * 1000000 . ) ) ) ) ; ( " counter " , ` String ( Int . to_string ( counter + i ) ) ) ; ( " gas_limit " , ` String ( Int . to_string 127 ) ) ; ( " storage_limit " , ` String ( Int . to_string 277 ) ) ] ) ) ) ] let endorsement ( ? protocol_kind : Tezos_protocol . Protocol_kind . t = ` Babylon ) ~ branch level : Ezjsonm . value = let open Ezjsonm in ignore protocol_kind ; dict [ ( " branch " , ` String branch ) ; ( " contents " , ` A [ ` O [ ( " kind " , ` String " endorsement " ) ; ( " level " , int level ) ] ] ) ] end

type ' error trace = ' error Support . Lib . Monad . trace

module type BASE = sig val name : string type ' a elt type ' a_elt t val of_list : int list -> int t val to_list : int t -> int list val pp : Format . formatter -> int t -> unit end

module type ITER_VANILLA = sig type ' a elt type ' a t val iter : ( ' a elt -> unit ) -> ' a t -> unit end

module type ITER_SEQUENTIAL = sig include ITER_VANILLA val iter_e : ( ' a elt -> ( unit , ' trace ) result ) -> ' a t -> ( unit , ' trace ) result val iter_s : ( ' a elt -> unit Lwt . t ) -> ' a t -> unit Lwt . t val iter_es : ( ' a elt -> ( unit , ' trace ) result Lwt . t ) -> ' a t -> ( unit , ' trace ) result Lwt . t end

module type ITER_PARALLEL = sig include ITER_SEQUENTIAL val iter_p : ( ' a elt -> unit Lwt . t ) -> ' a t -> unit Lwt . t val iter_ep : ( ' a elt -> ( unit , ' error trace ) result Lwt . t ) -> ' a t -> ( unit , ' error trace ) result Lwt . t end

module type ITERI_VANILLA = sig type ' a elt type ' a t val iteri : ( int -> ' a elt -> unit ) -> ' a t -> unit end

module type ITERI_SEQUENTIAL = sig include ITERI_VANILLA val iteri_e : ( int -> ' a elt -> ( unit , ' trace ) result ) -> ' a t -> ( unit , ' trace ) result val iteri_s : ( int -> ' a elt -> unit Lwt . t ) -> ' a t -> unit Lwt . t val iteri_es : ( int -> ' a elt -> ( unit , ' trace ) result Lwt . t ) -> ' a t -> ( unit , ' trace ) result Lwt . t end

module type MAP_VANILLA = sig type ' a t val map : ( ' a -> ' b ) -> ' a t -> ' b t end

module type MAP_SEQUENTIAL = sig include MAP_VANILLA val map_e : ( ' a -> ( ' b , ' trace ) result ) -> ' a t -> ( ' b t , ' trace ) result val map_s : ( ' a -> ' b Lwt . t ) -> ' a t -> ' b t Lwt . t val map_es : ( ' a -> ( ' b , ' trace ) result Lwt . t ) -> ' a t -> ( ' b t , ' trace ) result Lwt . t end

module type MAP_PARALLEL = sig include MAP_SEQUENTIAL val map_p : ( ' a -> ' b Lwt . t ) -> ' a t -> ' b t Lwt . t val map_ep : ( ' a -> ( ' b , ' error trace ) result Lwt . t ) -> ' a t -> ( ' b t , ' error trace ) result Lwt . t end

module type REVMAP_VANILLA = sig type ' a t val rev : ' a t -> ' a t val rev_map : ( ' a -> ' b ) -> ' a t -> ' b t end

module type REVMAP_SEQUENTIAL = sig include REVMAP_VANILLA val rev_map_e : ( ' a -> ( ' b , ' trace ) result ) -> ' a t -> ( ' b t , ' trace ) result val rev_map_s : ( ' a -> ' b Lwt . t ) -> ' a t -> ' b t Lwt . t val rev_map_es : ( ' a -> ( ' b , ' trace ) result Lwt . t ) -> ' a t -> ( ' b t , ' trace ) result Lwt . t end

module type REVMAP_PARALLEL = sig include REVMAP_SEQUENTIAL val rev_map_p : ( ' a -> ' b Lwt . t ) -> ' a t -> ' b t Lwt . t val rev_map_ep : ( ' a -> ( ' b , ' error trace ) result Lwt . t ) -> ' a t -> ( ' b t , ' error trace ) result Lwt . t end

module type FOLDLEFT_VANILLA = sig type ' a elt type ' a t val fold_left : ( ' a -> ' b elt -> ' a ) -> ' a -> ' b t -> ' a end

module type FOLDLEFT_SEQUENTIAL = sig include FOLDLEFT_VANILLA val fold_left_e : ( ' a -> ' b elt -> ( ' a , ' trace ) result ) -> ' a -> ' b t -> ( ' a , ' trace ) result val fold_left_s : ( ' a -> ' b elt -> ' a Lwt . t ) -> ' a -> ' b t -> ' a Lwt . t val fold_left_es : ( ' a -> ' b elt -> ( ' a , ' trace ) result Lwt . t ) -> ' a -> ' b t -> ( ' a , ' trace ) result Lwt . t end

module type FOLDLEFTMAP_VANILLA = sig type ' a elt type ' a t val fold_left_map : ( ' a -> ' b elt -> ' a * ' c ) -> ' a -> ' b t -> ' a * ' c list end

module type FOLDLEFTMAP_SEQUENTIAL = sig include FOLDLEFTMAP_VANILLA val fold_left_map_e : ( ' a -> ' b elt -> ( ' a * ' c , ' trace ) result ) -> ' a -> ' b t -> ( ' a * ' c list , ' trace ) result val fold_left_map_s : ( ' a -> ' b elt -> ( ' a * ' c ) Lwt . t ) -> ' a -> ' b t -> ( ' a * ' c list ) Lwt . t val fold_left_map_es : ( ' a -> ' b elt -> ( ' a * ' c , ' trace ) result Lwt . t ) -> ' a -> ' b t -> ( ' a * ' c list , ' trace ) result Lwt . t end

module type FOLDRIGHT_VANILLA = sig type ' a t val fold_right : ( ' a -> ' b -> ' b ) -> ' a t -> ' b -> ' b end

module type FOLDRIGHT_SEQUENTIAL = sig include FOLDRIGHT_VANILLA val fold_right_e : ( ' a -> ' b -> ( ' b , ' trace ) result ) -> ' a t -> ' b -> ( ' b , ' trace ) result val fold_right_s : ( ' a -> ' b -> ' b Lwt . t ) -> ' a t -> ' b -> ' b Lwt . t val fold_right_es : ( ' a -> ' b -> ( ' b , ' trace ) result Lwt . t ) -> ' a t -> ' b -> ( ' b , ' trace ) result Lwt . t end

module type FOLDOOO_VANILLA = sig type ' a elt type ' a t val fold : ( ' b elt -> ' a -> ' a ) -> ' b t -> ' a -> ' a end

module type FOLDOOO_SEQUENTIAL = sig include FOLDOOO_VANILLA val fold_e : ( ' b elt -> ' a -> ( ' a , ' trace ) result ) -> ' b t -> ' a -> ( ' a , ' trace ) result val fold_s : ( ' b elt -> ' a -> ' a Lwt . t ) -> ' b t -> ' a -> ' a Lwt . t val fold_es : ( ' b elt -> ' a -> ( ' a , ' trace ) result Lwt . t ) -> ' b t -> ' a -> ( ' a , ' trace ) result Lwt . t end

module type EXISTFORALL_VANILLA = sig type ' a elt type ' a t val exists : ( ' a elt -> bool ) -> ' a t -> bool val for_all : ( ' a elt -> bool ) -> ' a t -> bool end

module type EXISTFORALL_SEQUENTIAL = sig include EXISTFORALL_VANILLA val exists_e : ( ' a elt -> ( bool , ' trace ) result ) -> ' a t -> ( bool , ' trace ) result val exists_s : ( ' a elt -> bool Lwt . t ) -> ' a t -> bool Lwt . t val exists_es : ( ' a elt -> ( bool , ' trace ) result Lwt . t ) -> ' a t -> ( bool , ' trace ) result Lwt . t val for_all_e : ( ' a elt -> ( bool , ' trace ) result ) -> ' a t -> ( bool , ' trace ) result val for_all_s : ( ' a elt -> bool Lwt . t ) -> ' a t -> bool Lwt . t val for_all_es : ( ' a elt -> ( bool , ' trace ) result Lwt . t ) -> ' a t -> ( bool , ' trace ) result Lwt . t end

module type EXISTFORALL_PARALLEL = sig include EXISTFORALL_SEQUENTIAL val exists_p : ( ' a elt -> bool Lwt . t ) -> ' a t -> bool Lwt . t val exists_ep : ( ' a elt -> ( bool , ' error trace ) result Lwt . t ) -> ' a t -> ( bool , ' error trace ) result Lwt . t val for_all_p : ( ' a elt -> bool Lwt . t ) -> ' a t -> bool Lwt . t val for_all_ep : ( ' a elt -> ( bool , ' error trace ) result Lwt . t ) -> ' a t -> ( bool , ' error trace ) result Lwt . t end

module type FILTER_VANILLA = sig type ' a elt type ' a t val filter : ( ' a -> bool ) -> ' a t -> ' a t end

module type FILTER_EXTRAS = sig include FILTER_VANILLA val filter_left : ( ' a , ' b ) Either . t t -> ' a t val filter_right : ( ' b , ' a ) Either . t t -> ' a t val filter_ok : ( ' a , ' b ) result t -> ' a t val filter_error : ( ' b , ' a ) result t -> ' a t end

module type FILTER_SEQUENTIAL = sig include FILTER_VANILLA val filter_e : ( ' a -> ( bool , ' trace ) result ) -> ' a t -> ( ' a t , ' trace ) result val filter_s : ( ' a -> bool Lwt . t ) -> ' a t -> ' a t Lwt . t val filter_es : ( ' a -> ( bool , ' trace ) result Lwt . t ) -> ' a t -> ( ' a t , ' trace ) result Lwt . t end

module type FILTER_PARALLEL = sig type ' a t val filter_p : ( ' a -> bool Lwt . t ) -> ' a t -> ' a t Lwt . t val filter_ep : ( ' a -> ( bool , ' error trace ) result Lwt . t ) -> ' a t -> ( ' a t , ' error trace ) result Lwt . t end

module type FILTERI_VANILLA = sig type ' a elt type ' a t val filteri : ( int -> ' a -> bool ) -> ' a t -> ' a t end

module type FILTERI_SEQUENTIAL = sig include FILTERI_VANILLA val filteri_e : ( int -> ' a -> ( bool , ' trace ) result ) -> ' a t -> ( ' a t , ' trace ) result val filteri_s : ( int -> ' a -> bool Lwt . t ) -> ' a t -> ' a t Lwt . t val filteri_es : ( int -> ' a -> ( bool , ' trace ) result Lwt . t ) -> ' a t -> ( ' a t , ' trace ) result Lwt . t end

module type FILTERI_PARALLEL = sig type ' a t val filteri_p : ( int -> ' a -> bool Lwt . t ) -> ' a t -> ' a t Lwt . t val filteri_ep : ( int -> ' a -> ( bool , ' error trace ) result Lwt . t ) -> ' a t -> ( ' a t , ' error trace ) result Lwt . t end

module type FILTERMAP_VANILLA = sig type ' a t val filter_map : ( ' a -> ' b option ) -> ' a t -> ' b t end

module type FILTERMAP_SEQUENTIAL = sig include FILTERMAP_VANILLA val filter_map_e : ( ' a -> ( ' b option , ' trace ) result ) -> ' a t -> ( ' b t , ' trace ) result val filter_map_s : ( ' a -> ' b option Lwt . t ) -> ' a t -> ' b t Lwt . t val filter_map_es : ( ' a -> ( ' b option , ' trace ) result Lwt . t ) -> ' a t -> ( ' b t , ' trace ) result Lwt . t end

module type FILTERMAP_PARALLEL = sig type ' a t val filter_map_p : ( ' a -> ' b option Lwt . t ) -> ' a t -> ' b t Lwt . t val filter_map_ep : ( ' a -> ( ' b option , ' error trace ) result Lwt . t ) -> ' a t -> ( ' b t , ' error trace ) result Lwt . t end

module type CONCATMAP_VANILLA = sig type ' a t val concat_map : ( ' a -> ' b t ) -> ' a t -> ' b t end

module type CONCATMAP_SEQUENTIAL = sig include CONCATMAP_VANILLA val concat_map_s : ( ' a -> ' b t Lwt . t ) -> ' a t -> ' b t Lwt . t val concat_map_e : ( ' a -> ( ' b t , ' error ) result ) -> ' a t -> ( ' b t , ' error ) result val concat_map_es : ( ' a -> ( ' b t , ' error ) result Lwt . t ) -> ' a t -> ( ' b t , ' error ) result Lwt . t end

module type CONCATMAP_PARALLEL = sig type ' a t val concat_map_p : ( ' a -> ' b t Lwt . t ) -> ' a t -> ' b t Lwt . t val concat_map_ep : ( ' a -> ( ' b t , ' error trace ) result Lwt . t ) -> ' a t -> ( ' b t , ' error trace ) result Lwt . t end

module type FIND_VANILLA = sig type ' a t val find : ( ' a -> bool ) -> ' a t -> ' a option end

module type FIND_SEQUENTIAL = sig include FIND_VANILLA val find_e : ( ' a -> ( bool , ' trace ) result ) -> ' a t -> ( ' a option , ' trace ) result val find_s : ( ' a -> bool Lwt . t ) -> ' a t -> ' a option Lwt . t val find_es : ( ' a -> ( bool , ' trace ) result Lwt . t ) -> ' a t -> ( ' a option , ' trace ) result Lwt . t end

module type FINDMAP_VANILLA = sig type ' a t val find_map : ( ' a -> ' b option ) -> ' a t -> ' b option end

module type FINDMAP_SEQUENTIAL = sig include FINDMAP_VANILLA val find_map_e : ( ' a -> ( ' b option , ' trace ) result ) -> ' a t -> ( ' b option , ' trace ) result val find_map_s : ( ' a -> ' b option Lwt . t ) -> ' a t -> ' b option Lwt . t val find_map_es : ( ' a -> ( ' b option , ' trace ) result Lwt . t ) -> ' a t -> ( ' b option , ' trace ) result Lwt . t end

module type PARTITION_VANILLA = sig type ' a t val partition : ( ' a -> bool ) -> ' a t -> ' a t * ' a t end

module type PARTITION_EXTRAS = sig include PARTITION_VANILLA val partition_either : ( ' a , ' b ) Either . t t -> ' a t * ' b t val partition_result : ( ' a , ' b ) result t -> ' a t * ' b t end

module type PARTITION_SEQUENTIAL = sig include PARTITION_VANILLA val partition_e : ( ' a -> ( bool , ' trace ) result ) -> ' a t -> ( ' a t * ' a t , ' trace ) result val partition_s : ( ' a -> bool Lwt . t ) -> ' a t -> ( ' a t * ' a t ) Lwt . t val partition_es : ( ' a -> ( bool , ' trace ) result Lwt . t ) -> ' a t -> ( ' a t * ' a t , ' trace ) result Lwt . t end

module type PARTITION_PARALLEL = sig include PARTITION_SEQUENTIAL val partition_p : ( ' a -> bool Lwt . t ) -> ' a t -> ( ' a t * ' a t ) Lwt . t val partition_ep : ( ' a -> ( bool , ' error trace ) result Lwt . t ) -> ' a t -> ( ' a t * ' a t , ' error trace ) result Lwt . t end

module type PARTITIONMAP_VANILLA = sig type ' a t val partition_map : ( ' a -> ( ' b , ' c ) Either . t ) -> ' a t -> ' b t * ' c t end

module type PARTITIONMAP_SEQUENTIAL = sig include PARTITIONMAP_VANILLA val partition_map_e : ( ' a -> ( ( ' b , ' c ) Either . t , ' trace ) result ) -> ' a t -> ( ' b t * ' c t , ' trace ) result val partition_map_s : ( ' a -> ( ' b , ' c ) Either . t Lwt . t ) -> ' a t -> ( ' b t * ' c t ) Lwt . t val partition_map_es : ( ' a -> ( ( ' b , ' c ) Either . t , ' trace ) result Lwt . t ) -> ' a t -> ( ' b t * ' c t , ' trace ) result Lwt . t end

module type PARTITIONMAP_PARALLEL = sig include PARTITIONMAP_SEQUENTIAL val partition_map_p : ( ' a -> ( ' b , ' c ) Either . t Lwt . t ) -> ' a t -> ( ' b t * ' c t ) Lwt . t val partition_map_ep : ( ' a -> ( ( ' b , ' c ) Either . t , ' error trace ) result Lwt . t ) -> ' a t -> ( ' b t * ' c t , ' error trace ) result Lwt . t end

module type COMBINE_VANILLA = sig type ' a t val combine : when_different_lengths ' : trace -> ' a t -> ' b t -> ( ( ' a * ' b ) t , ' trace ) result val combine_with_leftovers : ' a t -> ' b t -> ( ' a * ' b ) t * ( ' a list , ' b list ) Either . t option end

module type ALLDOUBLE_VANILLA = sig type ' a t val iter2 : when_different_lengths ' : trace -> ( ' a -> ' b -> unit ) -> ' a t -> ' b t -> ( unit , ' trace ) result val map2 : when_different_lengths ' : trace -> ( ' a -> ' b -> ' c ) -> ' a t -> ' b t -> ( ' c t , ' trace ) result val rev_map2 : when_different_lengths ' : trace -> ( ' a -> ' b -> ' c ) -> ' a t -> ' b t -> ( ' c t , ' trace ) result val fold_left2 : when_different_lengths ' : trace -> ( ' a -> ' b -> ' c -> ' a ) -> ' a -> ' b t -> ' c t -> ( ' a , ' trace ) result val fold_right2 : when_different_lengths ' : trace -> ( ' a -> ' b -> ' c -> ' c ) -> ' a t -> ' b t -> ' c -> ( ' c , ' trace ) result val for_all2 : when_different_lengths ' : trace -> ( ' a -> ' b -> bool ) -> ' a t -> ' b t -> ( bool , ' trace ) result val exists2 : when_different_lengths ' : trace -> ( ' a -> ' b -> bool ) -> ' a t -> ' b t -> ( bool , ' trace ) result end

module type ALLDOUBLE_SEQENTIAL = sig include ALLDOUBLE_VANILLA val iter2_e : when_different_lengths ' : trace -> ( ' a -> ' b -> ( unit , ' trace ) result ) -> ' a t -> ' b t -> ( unit , ' trace ) result val iter2_s : when_different_lengths ' : trace -> ( ' a -> ' b -> unit Lwt . t ) -> ' a t -> ' b t -> ( unit , ' trace ) result Lwt . t val iter2_es : when_different_lengths ' : trace -> ( ' a -> ' b -> ( unit , ' trace ) result Lwt . t ) -> ' a t -> ' b t -> ( unit , ' trace ) result Lwt . t val map2_e : when_different_lengths ' : trace -> ( ' a -> ' b -> ( ' c , ' trace ) result ) -> ' a t -> ' b t -> ( ' c t , ' trace ) result val map2_s : when_different_lengths ' : trace -> ( ' a -> ' b -> ' c Lwt . t ) -> ' a t -> ' b t -> ( ' c t , ' trace ) result Lwt . t val map2_es : when_different_lengths ' : trace -> ( ' a -> ' b -> ( ' c , ' trace ) result Lwt . t ) -> ' a t -> ' b t -> ( ' c t , ' trace ) result Lwt . t val rev_map2_e : when_different_lengths ' : trace -> ( ' a -> ' b -> ( ' c , ' trace ) result ) -> ' a t -> ' b t -> ( ' c t , ' trace ) result val rev_map2_s : when_different_lengths ' : trace -> ( ' a -> ' b -> ' c Lwt . t ) -> ' a t -> ' b t -> ( ' c t , ' trace ) result Lwt . t val rev_map2_es : when_different_lengths ' : trace -> ( ' a -> ' b -> ( ' c , ' trace ) result Lwt . t ) -> ' a t -> ' b t -> ( ' c t , ' trace ) result Lwt . t val fold_left2_e : when_different_lengths ' : trace -> ( ' a -> ' b -> ' c -> ( ' a , ' trace ) result ) -> ' a -> ' b t -> ' c t -> ( ' a , ' trace ) result val fold_left2_s : when_different_lengths ' : trace -> ( ' a -> ' b -> ' c -> ' a Lwt . t ) -> ' a -> ' b t -> ' c t -> ( ' a , ' trace ) result Lwt . t val fold_left2_es : when_different_lengths ' : trace -> ( ' a -> ' b -> ' c -> ( ' a , ' trace ) result Lwt . t ) -> ' a -> ' b t -> ' c t -> ( ' a , ' trace ) result Lwt . t val fold_right2_e : when_different_lengths ' : trace -> ( ' a -> ' b -> ' c -> ( ' c , ' trace ) result ) -> ' a t -> ' b t -> ' c -> ( ' c , ' trace ) result val fold_right2_s : when_different_lengths ' : trace -> ( ' a -> ' b -> ' c -> ' c Lwt . t ) -> ' a t -> ' b t -> ' c -> ( ' c , ' trace ) result Lwt . t val fold_right2_es : when_different_lengths ' : trace -> ( ' a -> ' b -> ' c -> ( ' c , ' trace ) result Lwt . t ) -> ' a t -> ' b t -> ' c -> ( ' c , ' trace ) result Lwt . t val for_all2_e : when_different_lengths ' : trace -> ( ' a -> ' b -> ( bool , ' trace ) result ) -> ' a t -> ' b t -> ( bool , ' trace ) result val for_all2_s : when_different_lengths ' : trace -> ( ' a -> ' b -> bool Lwt . t ) -> ' a t -> ' b t -> ( bool , ' trace ) result Lwt . t val for_all2_es : when_different_lengths ' : trace -> ( ' a -> ' b -> ( bool , ' trace ) result Lwt . t ) -> ' a t -> ' b t -> ( bool , ' trace ) result Lwt . t val exists2_e : when_different_lengths ' : trace -> ( ' a -> ' b -> ( bool , ' trace ) result ) -> ' a t -> ' b t -> ( bool , ' trace ) result val exists2_s : when_different_lengths ' : trace -> ( ' a -> ' b -> bool Lwt . t ) -> ' a t -> ' b t -> ( bool , ' trace ) result Lwt . t val exists2_es : when_different_lengths ' : trace -> ( ' a -> ' b -> ( bool , ' trace ) result Lwt . t ) -> ' a t -> ' b t -> ( bool , ' trace ) result Lwt . t end

type ' error trace = ' error Support . Lib . Monad . trace

module type BASE_E = sig val name : string type ' a elt type ( ' a_elt , ' e ) t val of_list : int list -> ( int , ' e ) t val to_list : ( int , ' e ) t -> ( int list , ' e ) result val pp : Format . formatter -> ( int , ' e ) t -> unit end

module type BASE_S = sig val name : string type ' a elt type ' a_elt t val of_list : int list -> int t val to_list : int t -> int list Lwt . t val pp : Format . formatter -> int t -> unit Lwt . t end

module type BASE_ES = sig val name : string type ' a elt type ( ' a_elt , ' e ) t val of_list : int list -> ( int , ' e ) t val to_list : ( int , ' e ) t -> ( int list , ' e ) result Lwt . t val pp : Format . formatter -> ( int , ' e ) t -> unit Lwt . t end

module type ITER_VANILLA = sig type ' a elt type ' a t val iter : ( ' a elt -> unit ) -> ' a t -> unit end