text stringlengths 12 786k |
|---|
let challenge_polynomial ~ one ~ add ~ mul chals = let ( + ) = add and ( * ) = mul in stage ( fun pt -> let k = Array . length chals in let pow_two_pows = let res = Array . init k ~ f ( : fun _ -> pt ) pt in for i = 1 to k - 1 do let y = res ( . i - 1 ) 1 in res ( . i )... |
module Make ( Inputs : Inputs with type Impl . field = Tock . Field . t and type Impl . Bigint . t = Tock . Bigint . R . t and type Inner_curve . Constant . Scalar . t = Tick . Field . t ) t = struct open Inputs open Impl module Other_field = struct module Packed = struct module Constant = Other_fi... |
let merge ( { dv = dv1 } as def1 , s1 ) ( { dv = dv2 } as def2 , s2 ) = Total . union def1 def2 , S . union dv1 ( S . union dv2 ( S . union s1 s2 ) ) |
let union ( { dv = dv1 } as def1 , s1 ) ( { dv = dv2 } as def2 , s2 ) = Total . union def1 def2 , S . union ( S . inter dv1 dv2 ) ( S . union s1 s2 ) |
let filter_env shared_set b_env = let filter n ( { t_sort = sort } as entry ) ( bounded , env ) = let entry = match sort with S . add n bounded , Env . add n entry env in Env . fold filter b_env ( S . empty , Env . empty ) |
let rec equation ( { eq_desc = desc } as eq ) = let eq , defnames , shared_set = match desc with | EQeq ( pat , e ) -> { eq with eq_desc = EQeq ( pat , expression e ) } , { Deftypes . empty with dv = Vars . fv_pat S . empty S . empty pat } , S . empty | EQpluseq ( ... |
let implementation impl = match impl . desc with | Econstdecl ( n , is_static , e ) -> { impl with desc = Econstdecl ( n , is_static , expression e ) } | Efundecl ( n , ( { f_body = e } as body ) ) -> { impl with desc = Efundecl ( n , { body with f_body = expression ... |
let implementation_list impl_list = Zmisc . iter implementation impl_list |
module Core_over_monad ( Monad : Preface_specs . MONAD ) ( Tape : Preface_specs . MONOID ) = struct type tape = Tape . t type ' a monad = ' a Monad . t type ' a t = ( ' a * tape ) monad let upper m = Monad . bind ( fun a -> Monad . return ( a , Tape . neutral ) ) m l... |
module Functor ( F : Preface_specs . FUNCTOR ) ( Tape : Preface_specs . MONOID ) = type ' a t = ( ' a * Tape . t ) F . t let map f x = F . map ( fun ( y , t ) -> ( f y , t ) ) x end ) |
module Applicative ( A : Preface_specs . APPLICATIVE ) ( Tape : Preface_specs . MONOID ) = type ' a t = ( ' a * Tape . t ) A . t let pure x = A . pure ( x , Tape . neutral ) let apply f v = let g ( x , t ) ( y , u ) = ( x y , Tape . combine t u ) in A . li... |
module Alternative ( A : Preface_specs . ALTERNATIVE ) ( Tape : Preface_specs . MONOID ) = Alternative . Over_applicative ( Applicative ( A ) ( Tape ) ) ( struct type ' a t = ( ' a * Tape . t ) A . t let neutral = A . neutral let combine writer_l writer_r = A . combine... |
module Monad ( M : Preface_specs . MONAD ) ( Tape : Preface_specs . MONOID ) = type ' a t = ( ' a * Tape . t ) M . t let return x = M . return ( x , Tape . neutral ) let bind f m = M . ( m >>= fun ( x , t ) -> f x >|= fun ( y , u ) -> ( y , Tape . combi... |
module Monad_plus ( M : Preface_specs . MONAD_PLUS ) ( Tape : Preface_specs . MONOID ) = Monad_plus . Over_monad ( Monad ( M ) ( Tape ) ) ( struct type ' a t = ( ' a * Tape . t ) M . t let neutral = M . neutral let combine writer_l writer_r = M . combine writer_l write... |
module Over_monad ( M : Preface_specs . MONAD ) ( Tape : Preface_specs . MONOID ) = struct include Core_over_monad ( M ) ( Tape ) module Monad = Monad ( M ) ( Tape ) include Monad end |
module Id = Unique_id . Int63 ( ) |
let io_stats = Io_stats . create ( ) |
module Time_ns_suppress_sexp_in_test = struct type t = Time_ns . t let sexp_of_t t = if am_running_inline_test then Sexp . List [ ] else Time_ns . sexp_of_t t end |
module Flush_result = struct type t = | Error | Consumer_left | Flushed of Time_ns_suppress_sexp_in_test . t [ @@ deriving sexp_of ] end |
module Line_ending = struct type t = | Dos | Unix [ @@ deriving sexp_of ] end |
module Check_buffer_age ' = struct type ' a t = { writer : ' a ; maximum_age : Time_ns . Span . t ; mutable bytes_received_at_now_minus_maximum_age : Int63 . t ; bytes_received_queue : Int63 . t Queue . t ; times_received_queue : Time_ns . t Queue . t ; mutable bytes_seen : Int63... |
type open_flags = ( Open_flags . t , exn ) Result . t [ @@ deriving sexp_of ] |
module Destroy_or_keep = struct type t = | Destroy | Keep [ @@ deriving sexp_of ] end |
module Scheduled = struct type t = ( Bigstring . t IOVec . t * Destroy_or_keep . t ) Deque . t let length ( t : t ) = Deque . fold t ~ init : 0 ~ f ( : fun n ( iovec , _ ) -> n + iovec . len ) end |
module Stop_reason = struct type t = | Error | Consumer_left [ @@ deriving sexp_of ] end |
type t = { id : Id . t ; mutable fd : Fd . t ; monitor : Monitor . t ; inner_monitor : Monitor . t ; mutable background_writer_state : [ ` Running | ` Not_running | ` Stopped_permanently of Stop_reason . t ] ; background_writer_stopped : unit Ivar . t ; syscall : [ ` Pe... |
let sexp_of_t t = [ % sexp ( t . fd : Fd . t_hum ) ] |
let sexp_of_t_internals { id ; fd ; monitor ; inner_monitor ; background_writer_state ; background_writer_stopped ; syscall ; bytes_received ; bytes_written ; scheduled = _ ; scheduled_bytes ; buf = _ ; scheduled_back ; back ; time_source ; flushes = _ ; close_state ; close_fin... |
type writer = t [ @@ deriving sexp_of ] |
let set_raise_when_consumer_leaves t bool = t . raise_when_consumer_leaves <- bool |
let bytes_to_write t = t . scheduled_bytes + t . back - t . scheduled_back |
let is_stopped_permanently t = match t . background_writer_state with | ` Stopped_permanently _ -> true | ` Running | ` Not_running -> false ; ; |
let invariant t : unit = try let check f field = f ( Field . get field t ) in Fields . iter ~ id : ignore ~ fd : ignore ~ monitor : ignore ~ inner_monitor : ignore ~ buf : ignore ~ background_writer_state : ( check ( function | ` Stopped_permanently _ -> assert ( bytes_to_write t = 0 ... |
module Check_buffer_age : sig type t = writer Check_buffer_age ' . t Bag . Elt . t option val dummy : t val create : writer -> maximum_age [ : ` At_most of Time . Span . t | ` Unlimited ] -> t val destroy : t -> unit val too_old : t -> unit Deferred . t module Internal_for_unit_test :... |
let flushed_or_failed_with_result t = match t . backing_out_channel with | Some backing_out_channel -> Backing_out_channel . flush backing_out_channel ; return ( Flush_result . Flushed ( Time_source . now t . time_source ) ) | None -> if Int63 . O . ( t . bytes_written = t . bytes_re... |
let eager_map t ~ f = if Deferred . is_determined t then return ( f ( Deferred . value_exn t ) ) else Deferred . map t ~ f ; ; |
let eager_bind t ~ f = if Deferred . is_determined t then f ( Deferred . value_exn t ) else Deferred . bind t ~ f ; ; |
let flushed_or_failed_unit t = eager_map ( flushed_or_failed_with_result t ) ~ f : ignore |
let flushed_time_ns t = eager_bind ( flushed_or_failed_with_result t ) ~ f ( : function | Flushed t -> Deferred . return t | Error | Consumer_left -> Deferred . never ( ) ) ; ; |
let flushed_time t = eager_map ( flushed_time_ns t ) ~ f : Time_ns . to_time_float_round_nearest |
let flushed t = eager_map ( flushed_time_ns t ) ~ f ( : ignore : Time_ns . t -> unit ) ; ; |
let set_backing_out_channel t backing_out_channel = t . backing_out_channel <- Some backing_out_channel ; ; |
let set_synchronous_backing_out_channel t backing_out_channel = let rec wait_until_no_bytes_to_write ( ) = if bytes_to_write t = 0 then ( set_backing_out_channel t backing_out_channel ; return ( ) ) else ( let % bind ( ) = flushed t in wait_until_no_bytes_to_write ( ) ) in wait_until_no_... |
let set_synchronous_out_channel t out_channel = set_synchronous_backing_out_channel t ( Backing_out_channel . of_out_channel out_channel ) ; ; |
let using_synchronous_backing_out_channel t = Option . is_some t . backing_out_channel |
let clear_synchronous_out_channel t = if is_some t . backing_out_channel then ( assert ( bytes_to_write t = 0 ) ; t . backing_out_channel <- None ) ; ; |
let with_synchronous_backing_out_channel t backing_out_channel ~ f = let saved_backing_out_channel = t . backing_out_channel in Monitor . protect ( fun ( ) -> let % bind ( ) = set_synchronous_backing_out_channel t backing_out_channel in f ( ) ) ~ finally ( : fun ( ) -> t . backing_o... |
let with_synchronous_out_channel t out_channel ~ f = with_synchronous_backing_out_channel t ~ f ( Backing_out_channel . of_out_channel out_channel ) ; ; |
let set_fd t fd = let % map ( ) = flushed t in t . fd <- fd ; ; |
let consumer_left t = Ivar . read t . consumer_left |
let close_finished t = Ivar . read t . close_finished |
let close_started t = Ivar . read t . close_started |
let is_closed t = match t . close_state with | ` Open -> false | ` Closed | ` Closed_and_flushing -> true ; ; |
let is_open t = not ( is_closed t ) |
let writers_to_flush_at_shutdown : t Bag . t = Bag . create ( ) |
let final_flush ? force t = let producers_flushed = Deferred . List . iter ~ how ` : Parallel ~ f ( : fun f -> f ( ) ) ( Bag . to_list t . producers_to_flush_at_close ) in let force = match force with | Some fc -> fc | None -> ( match Fd . kind t . fd with | File -> Deferred .... |
let close ? force_close t = if debug then Debug . log " Writer . close " t [ % sexp_of : t ] ; ( match t . close_state with | ` Closed_and_flushing | ` Closed -> ( ) | ` Open -> t . close_state <- ` Closed_and_flushing ; Ivar . fill t . close_started ( ) ; final_flu... |
let ( ) = Shutdown . at_shutdown ( fun ( ) -> if debug then Debug . log_string " Writer . at_shutdown " ; Deferred . List . iter ~ how ` : Parallel ( Bag . to_list writers_to_flush_at_shutdown ) ~ f ( : fun t -> Deferred . any_unit [ final_flush t ; close_finished t ] ... |
let fill_flushes { bytes_written ; flushes ; time_source ; _ } = if not ( Queue . is_empty flushes ) then ( let now = Time_source . now time_source in let rec loop ( ) = match Queue . peek flushes with | None -> ( ) | Some ( ivar , z ) -> if Int63 . ( z <= bytes_written ... |
let stop_permanently t ( outcome : Stop_reason . t ) = t . background_writer_state <- ` Stopped_permanently outcome ; Deque . clear t . scheduled ; t . scheduled_bytes <- 0 ; t . buf <- Bigstring . create 0 ; t . scheduled_back <- 0 ; t . back <- 0 ; Ivar . fill_if_empty... |
let stopped_permanently t = Ivar . read t . background_writer_stopped |
let die t sexp = stop_permanently t Error ; raise_s sexp ; ; |
type buffer_age_limit = [ ` At_most of Time . Span . t | ` Unlimited ] |
let create ? buf_len ( ? syscall = ` Per_cycle ) ? buffer_age_limit ( ? raise_when_consumer_leaves = true ) ( ? line_ending = Line_ending . Unix ) ? time_source fd = let time_source = match time_source with | Some x -> Time_source . read_only x | None -> Time_source . wall_clock ( )... |
let set_buffer_age_limit t maximum_age = Check_buffer_age . destroy t . check_buffer_age ; t . check_buffer_age <- Check_buffer_age . create t ~ maximum_age ; ; |
let of_out_channel oc kind = create ( Fd . of_out_channel oc kind ) |
let can_write t = match t . close_state with | ` Open | ` Closed_and_flushing -> true | ` Closed -> false ; ; |
let ensure_can_write t = if not ( can_write t ) then raise_s [ % message " attempt to use closed writer " ~ _ ( : t : t ) ] ; ; |
let open_file ( ? append = false ) ? buf_len ? syscall ( ? perm = 0o666 ) ? line_ending ? time_source file = let mode = [ ` Wronly ; ` Creat ] in let mode = ( if append then ` Append else ` Trunc ) :: mode in Unix . openfile file ~ mode ~ perm >>| create ? buf_len ? syscall... |
let with_close t ~ f = Monitor . protect f ~ finally ( : fun ( ) -> close t ) |
let with_writer_exclusive t f = let % bind ( ) = Unix . lockf t . fd Exclusive in Monitor . protect f ~ finally ( : fun ( ) -> let % map ( ) = flushed t in Unix . unlockf t . fd ) ; ; |
let with_file ? perm ? append ? syscall ( ? exclusive = false ) ? line_ending ? time_source file ~ f = let % bind t = open_file ? perm ? append ? syscall ? line_ending ? time_source file in with_close t ~ f ( : fun ( ) -> if exclusive then with_writer_exclusive t ( fun ( ) -> f t ) ... |
let got_bytes t n = t . bytes_received <- Int63 . ( t . bytes_received + of_int n ) |
let add_iovec t kind ( iovec : _ IOVec . t ) ~ count_bytes_as_received = assert ( t . scheduled_back = t . back ) ; if count_bytes_as_received then got_bytes t iovec . len ; if not ( is_stopped_permanently t ) then ( t . scheduled_bytes <- t . scheduled_bytes + iovec . len ; Deq... |
let schedule_unscheduled t kind = let need_to_schedule = t . back - t . scheduled_back in assert ( need_to_schedule >= 0 ) ; if need_to_schedule > 0 then ( let pos = t . scheduled_back in t . scheduled_back <- t . back ; add_iovec t kind ( IOVec . of_bigstring t . buf ~ pos ~ len :... |
let dummy_iovec = IOVec . empty IOVec . bigstring_kind |
let mk_iovecs t = schedule_unscheduled t Keep ; let n_iovecs = Int . min ( Deque . length t . scheduled ) ( Lazy . force IOVec . max_iovecs ) in let iovecs = Array . create ~ len : n_iovecs dummy_iovec in let contains_mmapped_ref = ref false in let iovecs_len = ref 0 in with_return ( fun... |
let is_running = function | ` Running -> true | _ -> false ; ; |
let fd_closed t = if not ( is_closed t ) then die t [ % message " writer fd unexpectedly closed " ] ; ; |
let rec start_write t = if debug then Debug . log " Writer . start_write " t [ % sexp_of : t ] ; assert ( is_running t . background_writer_state ) ; let iovecs , contains_mmapped , iovecs_len = mk_iovecs t in let handle_write_result = function | ` Already_closed -> fd_closed t | ` ... |
let maybe_start_writer t = match t . background_writer_state with | ` Stopped_permanently _ | ` Running -> ( ) | ` Not_running -> if bytes_to_write t > 0 then ( t . background_writer_state <- ` Running ; schedule ~ monitor : t . inner_monitor ~ priority : Priority . low ( fun ( ... |
let give_buf t desired = assert ( desired > 0 ) ; assert ( not ( is_stopped_permanently t ) ) ; got_bytes t desired ; let buf_len = Bigstring . length t . buf in let available = buf_len - t . back in if desired <= available then ( let pos = t . back in t . back <- t . back + de... |
let write_gen_internal ( type a ) t src ~ src_pos ~ src_len ~ allow_partial_write ( ~ blit_to_bigstring : ( a , Bigstring . t ) Blit . blit ) = if is_stopped_permanently t then got_bytes t src_len else ( match t . backing_out_channel with | Some backing_out_channel -> got_bytes t src_len ;... |
let write_direct t ~ f = if is_stopped_permanently t then None else ( let pos = t . back in let len = Bigstring . length t . buf - pos in let x , written = f t . buf ~ pos ~ len in if written < 0 || written > len then raise_s [ % message " [ write_direct ] ' s [ ~ f ] argument re... |
let write_gen_unchecked ? pos ? len t src ~ blit_to_bigstring ~ length = let src_pos , src_len = Ordered_collection_common . get_pos_len_exn ( ) ? pos ? len ~ total_length ( : length src ) in write_gen_internal t src ~ src_pos ~ src_len ~ allow_partial_write : true ~ blit_to_bigstring ; ; |
let write_gen_whole_unchecked t src ~ blit_to_bigstring ~ length = let src_len = length src in write_gen_internal t src ~ src_pos : 0 ~ src_len ~ allow_partial_write : false ~ blit_to_bigstring ( : fun ~ src ~ src_pos ~ dst ~ dst_pos ~ len -> assert ( src_pos = 0 ) ; assert ( len = src_le... |
let write_bytes ? pos ? len t src = write_gen_unchecked ? pos ? len t src ~ blit_to_bigstring : Bigstring . From_bytes . blit ~ length : Bytes . length ; ; |
let write ? pos ? len t src = write_gen_unchecked ? pos ? len t src ~ blit_to_bigstring : Bigstring . From_string . blit ~ length : String . length ; ; |
let write_bigstring ? pos ? len t src = write_gen_unchecked ? pos ? len t src ~ blit_to_bigstring : Bigstring . blit ~ length : Bigstring . length ; ; |
let write_iobuf ? pos ? len t iobuf = let iobuf = Iobuf . read_only ( Iobuf . no_seek iobuf ) in write_gen_unchecked ? pos ? len t iobuf ~ blit_to_bigstring : Iobuf . Peek . To_bigstring . blit ~ length : Iobuf . length ; ; |
let write_substring t substring = write_bytes t ( Substring . base substring ) ~ pos ( : Substring . pos substring ) ~ len ( : Substring . length substring ) ; ; |
let write_bigsubstring t bigsubstring = write_bigstring t ( Bigsubstring . base bigsubstring ) ~ pos ( : Bigsubstring . pos bigsubstring ) ~ len ( : Bigsubstring . length bigsubstring ) ; ; |
let writef t = ksprintf ( fun s -> write t s ) |
let write_gen ? pos ? len t src ~ blit_to_bigstring ~ length = try write_gen_unchecked ? pos ? len t src ~ blit_to_bigstring ~ length with | exn -> die t [ % message " Writer . write_gen : error writing value " ( exn : exn ) ] ; ; |
let write_gen_whole t src ~ blit_to_bigstring ~ length = try write_gen_whole_unchecked t src ~ blit_to_bigstring ~ length with | exn -> die t [ % message " Writer . write_gen_whole : error writing value " ( exn : exn ) ] ; ; |
let to_formatter t = Format . make_formatter ( fun str pos len -> let str = Bytes . of_string str in ensure_can_write t ; write_substring t ( Substring . create str ~ pos ~ len ) ) ignore ; ; |
let write_char t c = if is_stopped_permanently t then got_bytes t 1 else ( match t . backing_out_channel with | Some backing_out_channel -> got_bytes t 1 ; Backing_out_channel . output_char backing_out_channel c ; t . bytes_written <- Int63 . ( t . bytes_written + of_int 1 ) | None -> if B... |
let newline ? line_ending t = let line_ending = match line_ending with | Some x -> x | None -> t . line_ending in ( match line_ending with | Unix -> ( ) | Dos -> write_char t ' \ r ' ) ; write_char t ' \ n ' ; ; |
let write_line ? line_ending t s = write t s ; newline t ? line_ending ; ; |
let write_byte t i = write_char t ( char_of_int ( i % 256 ) ) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.