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 ' ' % | ... |
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 . li... |
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 ~... |
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... |
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 . con... |
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_str... |
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 ; r... |
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 ) } i... |
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 co... |
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 .... |
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 \ \ { ... |
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... |
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... |
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 ) re... |
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 -> ... |
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... |
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 , ' tr... |
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 ... |
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 ) Lw... |
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 ... |
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 ... |
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 ... |
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_al... |
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 -> ' ... |
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 ) ... |
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 ... |
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 : ( '... |
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 -> (... |
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 ) ... |
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 : ( '... |
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_... |
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 )... |
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... |
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 ) res... |
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 -> ( ' ... |
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 ... |
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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.