text
stringlengths 0
601k
|
|---|
let pp f { major ; minor ; additional_info } = Format . fprintf f " % i . % i % s " major minor ( string_of_additional_info additional_info ) |
let to_string x = Format . asprintf " % a " pp x |
let current = { major = 12 ; minor = 0 ; additional_info = Dev } |
let current_string = to_string current |
module Version_error = struct type t = { payload : Csexp . t option ; message : string } let payload t = t . payload let message t = t . message let create ? payload ~ message ( ) = { payload ; message } exception E of t let to_response_error { payload ; message } = Response . Error . create ~ kind : Invalid_request ? payload ~ message ( ) end |
module Staged = struct type ( ' req , ' resp ) request = { encode_req : ' req -> Call . t ; decode_resp : Csexp . t -> ( ' resp , Response . Error . t ) result } type ' payload notification = { encode : ' payload -> Call . t } end |
module Make ( Fiber : Fiber ) = struct module Handler = struct type ' state t = { menu : Menu . t ; handle_request : Menu . t -> ' state -> Types . Request . t -> Response . t Fiber . t ; handle_notification : Menu . t -> ' state -> Call . t -> ( unit , Response . Error . t ) result Fiber . t ; prepare_request : ' req ' resp . Menu . t -> ( ' req , ' resp ) Decl . Request . witness -> ( ( ' req , ' resp ) Staged . request , Version_error . t ) result ; prepare_notification : ' a . Menu . t -> ' a Decl . Notification . witness -> ( ' a Staged . notification , Version_error . t ) result } let handle_request t = t . handle_request t . menu let handle_notification t = t . handle_notification t . menu let prepare_request t = t . prepare_request t . menu let prepare_notification t = t . prepare_notification t . menu end module Builder = struct open Decl type ' s r_handler = | R : ( ' s -> ' req -> ' resp Fiber . t ) * ( ' req , ' resp ) Decl . Generation . t -> ' s r_handler type ' s n_handler = | N : ( ' s -> ' payload -> unit Fiber . t ) * ( ' payload , unit ) Decl . Generation . t -> ' s n_handler type packed = T : ' a Method_version . Map . t Univ_map . Key . t -> packed type ' state t = { mutable declared_requests : packed list Method_name . Map . t * Univ_map . t ; mutable declared_notifications : packed list Method_name . Map . t * Univ_map . t ; implemented_requests : ' state r_handler Method_version . Map . t Method_name . Table . t ; implemented_notifications : ' state n_handler Method_version . Map . t Method_name . Table . t } type ( _ , _ , _ ) field_witness = | Declared_requests : ( _ , Method_name . t * ( ' req , ' resp ) Decl . Generation . t Method_version . Map . t Univ_map . Key . t , ( ' req , ' resp ) Decl . Generation . t ) field_witness | Declared_notifs : ( _ , Method_name . t * ( ' a , unit ) Decl . Generation . t Method_version . Map . t Univ_map . Key . t , ( ' a , unit ) Decl . Generation . t ) field_witness | Impl_requests : ( ' state , string , ' state r_handler ) field_witness | Impl_notifs : ( ' state , string , ' state n_handler ) field_witness let get ( type st a b ) ( t : st t ) ( witness : ( st , a , b ) field_witness ) ( key : a ) : b Method_version . Map . t option = match witness with | Declared_requests -> let _ , key = key in let _ , table = t . declared_requests in Univ_map . find table key | Declared_notifs -> let _ , key = key in let _ , table = t . declared_notifications in Univ_map . find table key | Impl_requests -> Method_name . Table . find t . implemented_requests key | Impl_notifs -> Method_name . Table . find t . implemented_notifications key let set ( type st a b ) ( t : st t ) ( witness : ( st , a , b ) field_witness ) ( key : a ) ( value : b Method_version . Map . t ) = match witness with | Declared_requests -> let name , key = key in let known_keys , table = t . declared_requests in t . declared_requests <- ( Method_name . Map . add_multi known_keys name ( T key ) , Univ_map . set table key value ) | Declared_notifs -> let name , key = key in let known_keys , table = t . declared_notifications in t . declared_notifications <- ( Method_name . Map . add_multi known_keys name ( T key ) , Univ_map . set table key value ) | Impl_requests -> Method_name . Table . set t . implemented_requests key value | Impl_notifs -> Method_name . Table . set t . implemented_notifications key value let registered_procedures { declared_requests = declared_request_keys , declared_request_table ; declared_notifications = declared_notification_keys , declared_notification_table ; implemented_requests ; implemented_notifications } = let batch_declarations which declared_keys declaration_table = Method_name . Map . foldi declared_keys ~ init [ ] : ~ f ( : fun name keys acc -> let generations = List . fold_left keys ~ init [ ] : ~ f ( : fun acc ( T key ) -> match Univ_map . find declaration_table key with | None -> Code_error . raise " versioning : method found in versioning table without \ actually being declared " [ ( " method_ " , Dyn . String name ) ; ( " table " , Dyn . String ( " known_ " ^ which ^ " _table " ) ) ] | Some listing -> Method_version . Map . keys listing @ acc ) in ( name , generations ) :: acc ) in let declared_requests = batch_declarations " request " declared_request_keys declared_request_table in let declared_notifications = batch_declarations " notification " declared_notification_keys declared_notification_table in let batch_implementations table = Method_name . Table . foldi table ~ init [ ] : ~ f ( : fun name listing acc -> ( name , Method_version . Map . keys listing ) :: acc ) in let implemented_requests = batch_implementations implemented_requests in let implemented_notifications = batch_implementations implemented_notifications in List . concat [ declared_requests ; declared_notifications ; implemented_requests ; implemented_notifications ] let create ( ) = let declared_requests = ( Method_name . Map . empty , Univ_map . empty ) in let declared_notifications = ( Method_name . Map . empty , Univ_map . empty ) in let implemented_requests = Method_name . Table . create 16 in let implemented_notifications = Method_name . Table . create 16 in { declared_requests ; declared_notifications ; implemented_requests ; implemented_notifications } let register_generic t ~ method_ ~ generations ~ registry ~ registry_key ~ other ~ other_key ~ pack = let ( ) = match get t other other_key with | None -> ( ) | Some _ -> Code_error . raise " attempted to implement and declare method " [ ( " method " , Dyn . String method_ ) ] in let prior_registered_generations = match get t registry registry_key with | None -> Method_version . Map . empty | Some s -> s in let all_generations , duplicate_generations = List . fold_left generations ~ init ( : prior_registered_generations , Method_version . Set . empty ) ~ f ( : fun ( acc , dups ) ( n , gen ) -> match Method_version . Map . add acc n ( pack gen ) with | Error _ -> ( acc , Method_version . Set . add dups n ) | Ok acc ' -> ( acc ' , dups ) ) in if Method_version . Set . is_empty duplicate_generations then set t registry registry_key all_generations else Code_error . raise " attempted to register duplicate generations for RPC method " [ ( " method " , Dyn . String method_ ) ; ( " duplicated " , Method_version . Set . to_dyn duplicate_generations ) ] let declare_request t proc = register_generic t ~ method_ : proc . Request . decl . method_ ~ generations : proc . Request . generations ~ registry : Declared_requests ~ other : Impl_requests ~ registry_key ( : proc . Request . decl . method_ , proc . Request . decl . key ) ~ other_key : proc . Request . decl . method_ ~ pack ( : fun rc -> rc ) let declare_notification t proc = register_generic t ~ method_ : proc . Notification . decl . method_ ~ generations : proc . Notification . generations ~ registry : Declared_notifs ~ other : Impl_notifs ~ registry_key : ( proc . Notification . decl . method_ , proc . Notification . decl . key ) ~ other_key : proc . Notification . decl . method_ ~ pack ( : fun nc -> nc ) let implement_request t proc f = register_generic t ~ method_ : proc . Request . decl . method_ ~ generations : proc . Request . generations ~ registry : Impl_requests ~ other : Declared_requests ~ registry_key : proc . Request . decl . method_ ~ other_key ( : proc . Request . decl . method_ , proc . Request . decl . key ) ~ pack ( : fun r -> R ( f , r ) ) let implement_notification t proc f = register_generic t ~ method_ : proc . Notification . decl . method_ ~ generations : proc . Notification . generations ~ registry : Impl_notifs ~ other : Declared_notifs ~ registry_key : proc . Notification . decl . method_ ~ other_key ( : proc . Notification . decl . method_ , proc . Notification . decl . key ) ~ pack ( : fun n -> N ( f , n ) ) let lookup_method_generic t ~ menu ~ table ~ key ~ method_ k s = match ( get t table key , Method_name . Map . find menu method_ ) with | None , _ -> let payload = Sexp . record [ ( " method " , Atom method_ ) ] in k ( Version_error . create ~ message " : invalid method " ~ payload ( ) ) | _ , None -> let payload = Sexp . record [ ( " method " , Atom method_ ) ] in k ( Version_error . create ~ message " : remote and local have no common version for method " ~ payload ( ) ) | Some subtable , Some version -> s ( subtable , version ) let raise_version_bug ~ method_ ~ selected ~ verb ~ known = Code_error . raise " bug with version negotiation ; selected bad method version " [ ( " message " , Dyn . String ( " version is " ^ verb ) ) ; ( " method " , Dyn . String method_ ) ; ( " implemented versions " , Dyn . List ( List . map ~ f ( : fun i -> Dyn . Int i ) known ) ) ; ( " selected version " , Dyn . Int selected ) ] let to_handler t ~ session_version = let open Fiber . O in let handle_request menu state ( _id , ( n : Call . t ) ) = lookup_method_generic t ~ menu ~ table : Impl_requests ~ key : n . method_ ~ method_ : n . method_ ( fun e -> Fiber . return ( Error ( Version_error . to_response_error e ) ) ) ( fun ( handlers , version ) -> match Method_version . Map . find handlers version with | None -> raise_version_bug ~ method_ : n . method_ ~ selected : version ~ verb " : unimplemented " ~ known ( : Method_version . Map . keys handlers ) | Some ( R ( f , T gen ) ) -> ( match Conv . of_sexp gen . req ~ version ( : session_version state ) n . params with | Error e -> Fiber . return ( Error ( Response . Error . of_conv e ) ) | Ok req -> let + resp = f state ( gen . upgrade_req req ) in Ok ( Conv . to_sexp gen . resp ( gen . downgrade_resp resp ) ) ) ) in let handle_notification menu state ( n : Call . t ) = lookup_method_generic t ~ menu ~ table : Impl_notifs ~ key : n . method_ ~ method_ : n . method_ ( fun e -> Fiber . return ( Error ( Version_error . to_response_error e ) ) ) ( fun ( handlers , version ) -> match Method_version . Map . find handlers version with | None -> raise_version_bug ~ method_ : n . method_ ~ selected : version ~ verb " : unimplemented " ~ known ( : Method_version . Map . keys handlers ) | Some ( N ( f , T gen ) ) -> ( match Conv . of_sexp gen . req ~ version ( : session_version state ) n . params with | Error e -> Fiber . return ( Error ( Response . Error . of_conv e ) ) | Ok req -> let + ( ) = f state ( gen . upgrade_req req ) in Ok ( ) ) ) in let prepare_request ( type a b ) menu ( decl : ( a , b ) Decl . Request . witness ) : ( ( a , b ) Staged . request , Version_error . t ) result = let method_ = decl . Decl . method_ in lookup_method_generic t ~ menu ~ table : Declared_requests ~ key ( : method_ , decl . key ) ~ method_ ( fun e -> Error e ) ( fun ( decls , version ) -> match Method_version . Map . find decls version with | None -> raise_version_bug ~ method_ ~ selected : version ~ verb " : undeclared " ~ known ( : Method_version . Map . keys decls ) | Some ( T gen ) -> let encode_req ( req : a ) = { Call . method_ ; params = Conv . to_sexp gen . req ( gen . downgrade_req req ) } in let decode_resp sexp = match Conv . of_sexp gen . resp ~ version ( : 3 , 0 ) sexp with | Ok resp -> Ok ( gen . upgrade_resp resp ) | Error e -> Error ( Response . Error . of_conv e ) in Ok { Staged . encode_req ; decode_resp } ) in let prepare_notification ( type a ) menu ( decl : a Decl . Notification . witness ) : ( a Staged . notification , Version_error . t ) result = let method_ = decl . Decl . method_ in lookup_method_generic t ~ menu ~ table : Declared_notifs ~ key ( : method_ , decl . key ) ~ method_ ( fun e -> Error e ) ( fun ( decls , version ) -> match Method_version . Map . find decls version with | None -> raise_version_bug ~ method_ ~ selected : version ~ verb " : undeclared " ~ known ( : Method_version . Map . keys decls ) | Some ( T gen ) -> let encode ( req : a ) = { Call . method_ ; params = Conv . to_sexp gen . req ( gen . downgrade_req req ) } in Ok { Staged . encode } ) in fun ~ menu -> { Handler . menu ; handle_request ; handle_notification ; prepare_request ; prepare_notification } end end |
module type S = sig type data module Lang : sig val register : Syntax . t -> data -> unit module Instance : sig type t = { syntax : Syntax . t ; data : data ; version : Syntax . Version . t } end val get_exn : string -> Instance . t end val load_exn : Path . t -> f ( : Lang . Instance . t -> ' a Decoder . t ) -> ' a val load : Path . t -> f ( : Lang . Instance . t -> ' a Decoder . t ) -> ' a Or_exn . t val parse_contents : Lexing . lexbuf -> f ( : Lang . Instance . t -> ' a Decoder . t ) -> ' a end |
module Make ( Data : sig type t struct module Lang = struct type t = { syntax : Syntax . t ; data : Data . t } module Instance = struct type t = { syntax : Syntax . t ; data : Data . t ; version : Syntax . Version . t } end let langs = Table . create ( module String ) 32 let register syntax data = let name = Syntax . name syntax in if Table . mem langs name then Code_error . raise " Versioned_file . Lang . register : already registered " [ ( " name " , Dyn . string name ) ] ; Table . add_exn langs name { syntax ; data } let parse first_line : Instance . t = let { First_line . lang = name_loc , name ; version = ver_loc , ver } = first_line in let dune_lang_ver = Decoder . parse Syntax . Version . decode Univ_map . empty ( Atom ( ver_loc , Atom . of_string ver ) ) in match Table . find langs name with | None -> User_error . raise ~ loc : name_loc [ Pp . textf " Unknown language % S . " name ] ~ hints ( : User_message . did_you_mean name ~ candidates ( : Table . keys langs ) ) | Some t -> Syntax . check_supported ~ dune_lang_ver t . syntax ( ver_loc , dune_lang_ver ) ; { syntax = t . syntax ; data = t . data ; version = dune_lang_ver } let get_exn name : Instance . t = let t = Table . find_exn langs name in { syntax = t . syntax ; data = t . data ; version = Syntax . greatest_supported_version t . syntax } end let parse_lang_exn lb = let first_line = First_line . lex lb in let lang = Lang . parse first_line in ( lang , Parser . parse lb ~ mode : Many_as_one ) let parse_ast ( ( lang : Lang . Instance . t ) , ast ) ~ f = let parsing_context = Univ_map . singleton ( Syntax . key lang . syntax ) ( Active lang . version ) in Decoder . parse ( Decoder . enter ( f lang ) ) parsing_context ast let parse_contents lb ~ f = let ast = parse_lang_exn lb in parse_ast ast ~ f let load fn ~ f = Io . with_lexbuf_from_file fn ~ f ( : fun lb -> Result . try_with ( fun ( ) -> parse_contents lb ~ f ) ) let load_exn fn ~ f = Result . ok_exn ( load fn ~ f ) end |
let no_more_lang = let open Decoder in let + ( _ : _ list ) = multi_field " lang " ( let + loc = loc and + _ = repeat raw in User_error . raise ~ loc [ Pp . text " The ( lang . . ) line cannot appear more than once . " ] ) in ( ) |
module Versioned_direct_stream_writer = struct module Direct_stream_writer = Pipe_rpc . Direct_stream_writer type ' input t = | T : { convert : ( ' input -> ' output ) ; writer : ' output Direct_stream_writer . t } -> ' input t let create ~ convert ~ writer = T { convert ; writer } let write ( T { convert ; writer } ) input = Direct_stream_writer . write writer ( convert input ) let write_without_pushback ( T { convert ; writer } ) input = Direct_stream_writer . write_without_pushback writer ( convert input ) let close ( T { convert = _ ; writer } ) = Direct_stream_writer . close writer let is_closed ( T { convert = _ ; writer } ) = Direct_stream_writer . is_closed writer let closed ( T { convert = _ ; writer } ) = Direct_stream_writer . closed writer end |
let failed_conversion x = Error . create " type conversion failure " x [ % sexp_of : [ ` Msg | ` Query | ` Response | ` Error | ` State | ` Update ] * [ ` Rpc of string ] * [ ` Version of int ] * exn ] |
let multiple_registrations x = Error . create " multiple rpc registrations " x [ % sexp_of : [ ` Rpc of string ] * [ ` Version of int ] ] |
let unknown_version x = Error . create " unknown rpc version " x [ % sexp_of : string * int ] |
module Callee_converts = struct module Rpc = struct module Simple = struct type ( ' query , ' response ) adapter = { adapt : ' state . ( ' state -> ' query -> ' response Deferred . t ) -> ' state Implementation . t } type ( ' query , ' response ) t = { name : string ; adapters : ( ' query , ' response ) adapter Int . Map . t } [ @@ deriving fields ] let create ~ name = { name ; adapters = Int . Map . empty } let wrap_error fn = ( fun state query -> fn state query >>| function | Ok value -> Ok value | Error error -> Error ( Error . to_string_hum error ) ) let add { name ; adapters } rpc adapter = if String . ( ) <> name ( Rpc . name rpc ) then Or_error . error " Rpc names don ' t agree " ( name , Rpc . name rpc ) [ % sexp_of : string * string ] else let version = Rpc . version rpc in match Map . find adapters version with | Some _ -> Or_error . error " Version already exists " ( name , version ) [ % sexp_of : string * int ] | None -> let adapters = Map . set adapters ~ key : version ~ data : adapter in Ok { name ; adapters } let add_rpc_version t old_rpc upgrade downgrade = let adapt fn = let adapted state old_query = fn state ( upgrade old_query ) >>| fun result -> downgrade result in Rpc . implement old_rpc adapted in add t old_rpc { adapt } let add_rpc_version_with_failure t old_rpc upgrade_or_error downgrade_or_error = let adapt fn = let adapted state old_query = let open Deferred . Result . Monad_infix in return ( upgrade_or_error old_query ) >>= fun query -> fn state query >>= fun response -> return ( downgrade_or_error response ) in Rpc . implement old_rpc ( wrap_error adapted ) in add t old_rpc { adapt } let add_version t ~ version ~ bin_query ~ bin_response upgrade downgrade = let rpc = Rpc . create ~ name : t . name ~ version ~ bin_query ~ bin_response in add_rpc_version t rpc upgrade downgrade let add_version_with_failure t ~ version ~ bin_query ~ bin_response upgrade downgrade = let rpc = Rpc . create ~ name : t . name ~ version ~ bin_query ~ bin_response in add_rpc_version_with_failure t rpc upgrade downgrade let implement t fn = Map . data t . adapters |> List . map ~ f ( : fun { adapt } -> adapt fn ) end module type S = sig type query type response val implement_multi : ? log_not_previously_seen_version ( : name : string -> int -> unit ) -> ( ' state -> version : int -> query -> response Deferred . t ) -> ' state Implementation . t list val rpcs : unit -> Any . t list val versions : unit -> Int . Set . t val name : string end module Make ( Model : sig val name : string type query type response end ) = struct let name = Model . name type ' s impl = ' s -> version : int -> Model . query -> Model . response Deferred . t type implementer = { implement : ' s . log_version ( : int -> unit ) -> ' s impl -> ' s Implementation . t } let registry : ( int , implementer * Any . t ) Hashtbl . t = Int . Table . create ~ size : 1 ( ) let implement_multi ? log_not_previously_seen_version f = let log_version = match log_not_previously_seen_version with | None -> ignore | Some f -> Memo . general ( f ~ name ) in List . map ( Hashtbl . data registry ) ~ f ( : fun ( i , _rpc ) -> i . implement ~ log_version f ) let rpcs ( ) = List . map ( Hashtbl . data registry ) ~ f ( : fun ( _ , rpc ) -> rpc ) let versions ( ) = Int . Set . of_list ( Hashtbl . keys registry ) module Register ( Version_i : sig type query [ @@ deriving bin_io ] type response [ @@ deriving bin_io ] val version : int val model_of_query : query -> Model . query val response_of_model : Model . response -> response end ) = struct open Version_i let rpc = Rpc . create ~ name ~ version ~ bin_query ~ bin_response let ( ) = let implement ~ log_version f = Rpc . implement rpc ( fun s q -> log_version version ; match Result . try_with ( fun ( ) -> Version_i . model_of_query q ) with | Error exn -> Error . raise ( failed_conversion ( ` Query , ` Rpc name , ` Version version , exn ) ) | Ok q -> f s ~ version q >>| fun r -> match Result . try_with ( fun ( ) -> Version_i . response_of_model r ) with | Ok r -> r | Error exn -> Error . raise ( failed_conversion ( ` Response , ` Rpc name , ` Version version , exn ) ) ) in match Hashtbl . find registry version with | None -> Hashtbl . set registry ~ key : version ~ data ( { : implement } , Any . Rpc rpc ) | Some _ -> Error . raise ( multiple_registrations ( ` Rpc name , ` Version version ) ) end end end module Pipe_rpc = struct module type S = sig type query type response type error val implement_multi : ? log_not_previously_seen_version ( : name : string -> int -> unit ) -> ( ' state -> version : int -> query -> ( response Pipe . Reader . t , error ) Result . t Deferred . t ) -> ' state Implementation . t list val implement_direct_multi : ? log_not_previously_seen_version ( : name : string -> int -> unit ) -> ( ' state -> version : int -> query -> response Versioned_direct_stream_writer . t -> ( unit , error ) Result . t Deferred . t ) -> ' state Implementation . t list val rpcs : unit -> Any . t list val versions : unit -> Int . Set . t val name : string end module Make ( Model : sig val name : string type query type response type error end ) = struct let name = Model . name type ' s impl = | Pipe of ( ' s -> version : int -> Model . query -> ( Model . response Pipe . Reader . t , Model . error ) Result . t Deferred . t ) | Direct of ( ' s -> version : int -> Model . query -> Model . response Versioned_direct_stream_writer . t -> ( unit , Model . error ) Result . t Deferred . t ) type implementer = { implement : ' s . log_version ( : int -> unit ) -> ' s impl -> ' s Implementation . t } let registry = Int . Table . create ~ size : 1 ( ) let implement_multi_gen ? log_not_previously_seen_version impl = let log_version = match log_not_previously_seen_version with | None -> ignore | Some f -> Memo . general ( f ~ name ) in List . map ( Hashtbl . data registry ) ~ f ( : fun ( i , _ ) -> i . implement ~ log_version impl ) let implement_multi ? log_not_previously_seen_version f = implement_multi_gen ? log_not_previously_seen_version ( Pipe f ) let implement_direct_multi ? log_not_previously_seen_version f = implement_multi_gen ? log_not_previously_seen_version ( Direct f ) let rpcs ( ) = List . map ( Hashtbl . data registry ) ~ f ( : fun ( _ , rpc ) -> rpc ) let versions ( ) = Int . Set . of_list ( Int . Table . keys registry ) module type Version_shared = sig type query [ @@ deriving bin_io ] type response [ @@ deriving bin_io ] type error [ @@ deriving bin_io ] val version : int val model_of_query : query -> Model . query val error_of_model : Model . error -> error val client_pushes_back : bool end module Make_shared ( Version_i : Version_shared ) ( Convert : sig val convert_elt ( : Model . response -> Version_i . response ) Or_error . t val convert_pipe : Model . response Pipe . Reader . t -> Version_i . response Pipe . Reader . t end ) = struct open Version_i open Convert let rpc = Pipe_rpc . create ~ name ~ version ~ bin_query ~ bin_response ~ bin_error ? client_pushes_back ( : Option . some_if client_pushes_back ( ) ) ( ) let wrapped_model_of_query q = match Version_i . model_of_query q with | exception exn -> Error . raise ( failed_conversion ( ` Response , ` Rpc name , ` Version version , exn ) ) | q -> q let wrapped_error_of_model error = match Version_i . error_of_model error with | error -> Error error | exception exn -> Error . raise ( failed_conversion ( ` Error , ` Rpc name , ` Version version , exn ) ) let implement ~ log_version impl = match impl with | Pipe f -> Pipe_rpc . implement rpc ( fun s q -> log_version version ; f s ~ version ( wrapped_model_of_query q ) >>= function | Ok pipe -> Monitor . handle_errors ( fun ( ) -> return ( Ok ( convert_pipe pipe ) ) ) ( fun exn -> Error . raise ( failed_conversion ( ` Response , ` Rpc name , ` Version version , exn ) ) ) | Error error -> return ( wrapped_error_of_model error ) ) | Direct f -> let convert_elt = Or_error . ok_exn convert_elt in Pipe_rpc . implement_direct rpc ( fun s q dsw -> let writer = Versioned_direct_stream_writer . create ~ convert : convert_elt ~ writer : dsw in f s ~ version ( wrapped_model_of_query q ) writer >>| function | Ok ( ) -> Ok ( ) | Error error -> wrapped_error_of_model error ) let ( ) = match Hashtbl . find registry version with | None -> Hashtbl . set registry ~ key : version ~ data ( { : implement } , Any . Pipe rpc ) | Some _ -> Error . raise ( multiple_registrations ( ` Rpc name , ` Version version ) ) end module Register_raw ( Version_i : sig include Version_shared val response_of_model : Model . response Pipe . Reader . t -> response Pipe . Reader . t end ) = Make_shared ( Version_i ) ( struct let convert_elt = Or_error . error_string " cannot use direct interface with Register_raw " let convert_pipe = Version_i . response_of_model end ) module Register ( Version_i : sig include Version_shared val response_of_model : Model . response -> response end ) = Make_shared ( Version_i ) ( struct let convert_elt = Ok Version_i . response_of_model let convert_pipe pipe = Pipe . map pipe ~ f : Version_i . response_of_model end ) end end module State_rpc = struct module type S = sig type query type state type update type error val implement_multi : ? log_not_previously_seen_version ( : name : string -> int -> unit ) -> ( ' connection_state -> version : int -> query -> ( state * update Pipe . Reader . t , error ) Result . t Deferred . t ) -> ' connection_state Implementation . t list val rpcs : unit -> Any . t list val versions : unit -> Int . Set . t val name : string end module Make ( Model : sig val name : string type query type state type update type error end ) = struct let name = Model . name type ' s impl = ' s -> version : int -> Model . query -> ( Model . state * Model . update Pipe . Reader . t , Model . error ) Result . t Deferred . t type implementer = { implement : ' s . log_version ( : int -> unit ) -> ' s impl -> ' s Implementation . t } let registry = Int . Table . create ~ size : 1 ( ) let implement_multi ? log_not_previously_seen_version f = let log_version = match log_not_previously_seen_version with | None -> ignore | Some f -> Memo . general ( f ~ name ) in List . map ( Hashtbl . data registry ) ~ f ( : fun ( i , _ ) -> i . implement ~ log_version f ) let rpcs ( ) = List . map ( Hashtbl . data registry ) ~ f ( : fun ( _ , rpc ) -> rpc ) let versions ( ) = Int . Set . of_list ( Int . Table . keys registry ) module type Version_shared = sig type query [ @@ deriving bin_io ] type state [ @@ deriving bin_io ] type update [ @@ deriving bin_io ] type error [ @@ deriving bin_io ] val version : int val model_of_query : query -> Model . query val state_of_model : Model . state -> state val error_of_model : Model . error -> error val client_pushes_back : bool end module Register_raw ( Version_i : sig include Version_shared val update_of_model : Model . state -> Model . update Pipe . Reader . t -> update Pipe . Reader . t end ) = struct open Version_i let rpc = State_rpc . create ~ name ~ version ~ bin_query ~ bin_state ~ bin_update ~ bin_error ? client_pushes_back ( : Option . some_if client_pushes_back ( ) ) ( ) let ( ) = let implement ~ log_version f = State_rpc . implement rpc ( fun s q -> log_version version ; match Version_i . model_of_query q with | exception exn -> Error . raise ( failed_conversion ( ` Response , ` Rpc name , ` Version version , exn ) ) | q -> f s ~ version q >>= function | Ok ( model_state , pipe ) -> let state = match Version_i . state_of_model model_state with | state -> state | exception exn -> Error . raise ( failed_conversion ( ` State , ` Rpc name , ` Version version , exn ) ) in Monitor . handle_errors ( fun ( ) -> return ( Ok ( state , Version_i . update_of_model model_state pipe ) ) ) ( fun exn -> Error . raise ( failed_conversion ( ` Update , ` Rpc name , ` Version version , exn ) ) ) | Error error -> return ( match Version_i . error_of_model error with | error -> Error error | exception exn -> Error . raise ( failed_conversion ( ` Error , ` Rpc name , ` Version version , exn ) ) ) ) in match Hashtbl . find registry version with | None -> Hashtbl . set registry ~ key : version ~ data ( { : implement } , Any . State rpc ) | Some _ -> Error . raise ( multiple_registrations ( ` Rpc name , ` Version version ) ) end module Register ( Version_i : sig include Version_shared val update_of_model : Model . update -> update end ) = struct include Register_raw ( struct include Version_i let update_of_model _state pipe = Pipe . map ~ f : update_of_model pipe end ) end end end module One_way = struct module type S = sig type msg val implement_multi : ? log_not_previously_seen_version ( : name : string -> int -> unit ) -> ( ' state -> version : int -> msg -> unit ) -> ' state Implementation . t list val rpcs : unit -> Any . t list val versions : unit -> Int . Set . t val name : string end module Make ( Model : sig val name : string type msg end ) = struct let name = Model . name type ' s impl = ' s -> version : int -> Model . msg -> unit type implementer = { implement : ' s . log_version ( : int -> unit ) -> ' s impl -> ' s Implementation . t ; } let registry : ( int , implementer * Any . t ) Hashtbl . t = Int . Table . create ~ size : 1 ( ) let implement_multi ? log_not_previously_seen_version f = let log_version = match log_not_previously_seen_version with | None -> ignore | Some f -> Memo . general ( f ~ name ) in List . map ( Hashtbl . data registry ) ~ f ( : fun ( i , _rpc ) -> i . implement ~ log_version f ) let rpcs ( ) = List . map ( Hashtbl . data registry ) ~ f ( : fun ( _ , rpc ) -> rpc ) let versions ( ) = Int . Set . of_list ( Hashtbl . keys registry ) module Register ( Version_i : sig type msg [ @@ deriving bin_io ] val version : int val model_of_msg : msg -> Model . msg end ) = struct open Version_i let rpc = One_way . create ~ name ~ version ~ bin_msg let ( ) = let implement ~ log_version f = One_way . implement rpc ( fun s q -> log_version version ; match Result . try_with ( fun ( ) -> Version_i . model_of_msg q ) with | Error exn -> Error . raise ( failed_conversion ( ` Msg , ` Rpc name , ` Version version , exn ) ) | Ok q -> f s ~ version q ) in match Hashtbl . find registry version with | None -> Hashtbl . set registry ~ key : version ~ data ( { : implement } , Any . One_way rpc ) | Some _ -> Error . raise ( multiple_registrations ( ` Rpc name , ` Version version ) ) end end end end |
module Menu = struct module Model = struct let name = " __Versioned_rpc . Menu " type query = unit type response = Description . t list end include Callee_converts . Rpc . Make ( Model ) let rpc_name = Model . name module V1 = struct module T = struct let version = 1 type query = unit [ @@ deriving bin_io ] type response = ( string * int ) list [ @@ deriving bin_io ] let model_of_query q = q let response_of_model = List . map ~ f ( : fun { Description . name ; version } -> ( name , version ) ) end include T include Register ( T ) end module Current_version = V1 let add impls = let menu = List . map impls ~ f : Implementation . description in let menu_impls = implement_multi ( fun _ ~ version : _ ( ) -> return menu ) in impls @ menu_impls type t = Int . Set . t String . Table . t [ @@ deriving sexp_of ] let supported_rpcs t = let open List . Monad_infix in String . Table . to_alist t >>= fun ( name , versions ) -> Int . Set . to_list versions >>| fun version -> { Description . name ; version } let supported_versions t ~ rpc_name = Option . value ~ default : Int . Set . empty ( Hashtbl . find t rpc_name ) let of_entries entries = Hashtbl . map ~ f : Int . Set . of_list ( String . Table . of_alist_multi entries ) let request conn = Rpc . dispatch Current_version . rpc conn ( ) >>| fun result -> Result . map result ~ f : of_entries let create descriptions = List . map descriptions ~ f ( : fun { Description . name ; version } -> ( name , version ) ) |> of_entries end |
module Connection_with_menu = struct type t = { connection : Connection . t ; menu : Menu . t } [ @@ deriving fields ] let create connection = let open Deferred . Or_error . Monad_infix in Menu . request connection >>| fun menu -> { connection ; menu } let create_directly connection menu = { connection ; menu } end |
module Caller_converts = struct let most_recent_common_version ~ rpc_name ~ caller_versions ~ callee_versions ~ callee_menu = match Set . max_elt ( Set . inter callee_versions caller_versions ) with | Some version -> Ok version | None -> error_s [ % message " caller and callee share no common versions for rpc " ( rpc_name : string ) ( caller_versions : Int . Set . t ) ( callee_versions : Int . Set . t ) ( callee_menu : Menu . t ) ] let % expect_test " highest version number is taken in most_recent_common_version " = let rpc_name = " the - rpc " in let menu = Menu . of_entries [ rpc_name , 2 ] in let result = most_recent_common_version ~ rpc_name ~ caller_versions ( : Int . Set . of_list [ 1 ; 2 ; 3 ] ) ~ callee_versions ( : Int . Set . of_list [ 2 ] ) ~ callee_menu : menu in print_s [ % sexp ( result : int Or_error . t ) ] ; [ % expect { | ( Ok 2 ) } ] | ; ; let % expect_test " error from most_recent_common_version looks reasonable " = let the_rpc = " the - rpc " in let not_the_rpc = " other - rpc " in let menu = Menu . of_entries [ not_the_rpc , 1 ; not_the_rpc , 2 ] in let result = most_recent_common_version ~ rpc_name : the_rpc ~ caller_versions ( : Int . Set . of_list [ 1 ; 2 ; 3 ] ) ~ callee_versions ( : Menu . supported_versions menu ~ rpc_name : the_rpc ) ~ callee_menu : menu in print_s [ % sexp ( result : int Or_error . t ) ] ; [ % expect { | ( Error ( " caller and callee share no common versions for rpc " ( rpc_name the - rpc ) ( caller_versions ( 1 2 3 ) ) ( callee_versions ( ) ) ( callee_menu ( ( other - rpc ( 1 2 ) ) ) ) ) ) } ] | ; ; module Dispatch = struct module Make ( M : Monad ) = struct open M let with_specific_version ~ version ~ connection ~ name ~ query ~ dispatcher ~ registry = match Hashtbl . find registry version with | None -> return ( Error ( unknown_version ( name , version ) ) ) | Some ( dispatch , _rpc ) -> dispatcher dispatch connection query let with_version_menu { Connection_with_menu . connection ; menu } query ~ name ~ versions ~ registry ~ dispatcher = let callee_versions = Menu . supported_versions menu ~ rpc_name : name in let caller_versions = versions ( ) in match most_recent_common_version ~ rpc_name : name ~ caller_versions ~ callee_versions ~ callee_menu : menu with | Error e -> return ( Error e ) | Ok version -> with_specific_version ~ version ~ connection ~ name ~ query ~ registry ~ dispatcher end module Async = Make ( Deferred ) module Direct = Make ( Monad . Ident ) end module Rpc = struct module type S = sig type query type response val dispatch_multi : Connection_with_menu . t -> query -> response Or_error . t Deferred . t val rpcs : unit -> Any . t list val versions : unit -> Int . Set . t val name : string end module Make ( Model : sig val name : string type query type response end ) = struct let name = Model . name let registry = Int . Table . create ~ size : 1 ( ) let rpcs ( ) = List . map ( Hashtbl . data registry ) ~ f ( : fun ( _ , rpc ) -> rpc ) let versions ( ) = Int . Set . of_list ( Int . Table . keys registry ) let dispatch_multi conn_with_menu query = Dispatch . Async . with_version_menu conn_with_menu query ~ name ~ versions ~ registry ~ dispatcher : Fn . id module Register ' ( Version_i : sig type query [ @@ deriving bin_io ] type response [ @@ deriving bin_io ] val version : int val query_of_model : Model . query -> query val model_of_response : Model . query -> response -> Model . response end ) = struct open Version_i let rpc = Rpc . create ~ name ~ version ~ bin_query ~ bin_response let ( ) = let dispatch conn mq = match Result . try_with ( fun ( ) -> Version_i . query_of_model mq ) with | Error exn -> return ( Error ( failed_conversion ( ` Query , ` Rpc name , ` Version version , exn ) ) ) | Ok q -> Rpc . dispatch rpc conn q >>| fun result -> Result . bind result ~ f ( : fun r -> match Result . try_with ( fun ( ) -> Version_i . model_of_response mq r ) with | Ok r -> Ok r | Error exn -> Error ( failed_conversion ( ` Response , ` Rpc name , ` Version version , exn ) ) ) in match Hashtbl . find registry version with | None -> Hashtbl . set registry ~ key : version ~ data ( : dispatch , Any . Rpc rpc ) | Some _ -> Error . raise ( multiple_registrations ( ` Rpc name , ` Version version ) ) end module Register ( Version_i : sig type query [ @@ deriving bin_io ] type response [ @@ deriving bin_io ] val version : int val query_of_model : Model . query -> query val model_of_response : response -> Model . response end ) = Register ' ( struct include Version_i let model_of_response _ r = model_of_response r end ) end end module Pipe_rpc = struct module type S = sig type query type response type error val dispatch_multi : Connection_with_menu . t -> query -> ( response Or_error . t Pipe . Reader . t * Pipe_rpc . Metadata . t , error ) Result . t Or_error . t Deferred . t val dispatch_iter_multi : Connection_with_menu . t -> query -> f ( : response Pipe_rpc . Pipe_message . t -> Pipe_rpc . Pipe_response . t ) -> ( Pipe_rpc . Id . t , error ) Result . t Or_error . t Deferred . t val abort_multi : Connection_with_menu . t -> Pipe_rpc . Id . t -> unit Or_error . t val rpcs : unit -> Any . t list val versions : unit -> Int . Set . t val name : string end module Make ( Model : sig val name : string type query type response type error end ) = struct type dispatcher = { abort : Connection . t -> Pipe_rpc . Id . t -> unit ; dispatch : Connection . t -> Model . query -> ( Model . response Or_error . t Pipe . Reader . t * Pipe_rpc . Metadata . t , Model . error ) Result . t Or_error . t Deferred . t ; dispatch_iter : Connection . t -> Model . query -> f ( : Model . response Pipe_rpc . Pipe_message . t -> Pipe_rpc . Pipe_response . t ) -> ( Pipe_rpc . Id . t , Model . error ) Result . t Or_error . t Deferred . t } let name = Model . name let registry : ( dispatcher * Any . t ) Int . Table . t = Int . Table . create ~ size : 1 ( ) let rpcs ( ) = List . map ( Hashtbl . data registry ) ~ f ( : fun ( _ , rpc ) -> rpc ) let versions ( ) = Int . Set . of_list ( Int . Table . keys registry ) let dispatch_iter_multi conn_with_menu query ~ f = Dispatch . Async . with_version_menu conn_with_menu query ~ name ~ versions ~ registry ~ dispatcher ( : fun { dispatch_iter ; _ } conn query -> dispatch_iter conn query ~ f ) let dispatch_multi conn_with_menu query = Dispatch . Async . with_version_menu conn_with_menu query ~ name ~ versions ~ registry ~ dispatcher ( : fun { dispatch ; _ } conn query -> dispatch conn query ) let abort_multi conn_with_menu id = Dispatch . Direct . with_version_menu conn_with_menu id ~ name ~ versions ~ registry ~ dispatcher ( : fun { abort ; _ } conn id -> abort conn id ; Ok ( ) ) module type Version_shared = sig type query [ @@ deriving bin_io ] type response [ @@ deriving bin_io ] type error [ @@ deriving bin_io ] val version : int val query_of_model : Model . query -> query val model_of_error : error -> Model . error val client_pushes_back : bool end module Make_shared ( Version_i : Version_shared ) ( Convert : sig val convert_elt : ( Version_i . response -> Model . response ) Or_error . t val convert_pipe : Version_i . response Pipe . Reader . t -> Model . response Or_error . t Pipe . Reader . t end ) = struct open Version_i open Convert let rpc = Pipe_rpc . create ~ name ~ version ~ bin_query ~ bin_response ~ bin_error ? client_pushes_back ( : Option . some_if client_pushes_back ( ) ) ( ) let wrapped_query_of_model q = match Version_i . query_of_model q with | exception exn -> return ( Error ( failed_conversion ( ` Query , ` Rpc name , ` Version version , exn ) ) ) | q -> return ( Ok q ) let convert_result result ~ convert_ok = match result with | Error _ as e -> e | Ok ( Error e ) -> ( match Version_i . model_of_error e with | e ' -> Ok ( Error e ' ) | exception exn -> Error ( failed_conversion ( ` Error , ` Rpc name , ` Version version , exn ) ) ) | Ok ( Ok ok ) -> Ok ( Ok ( convert_ok ok ) ) let dispatch conn q = wrapped_query_of_model q >>=? fun q -> Pipe_rpc . dispatch rpc conn q >>| fun result -> convert_result result ~ convert_ok ( : fun ( pipe , id ) -> ( convert_pipe pipe , id ) ) let dispatch_iter conn q ~ f = let convert_elt = Or_error . ok_exn convert_elt in wrapped_query_of_model q >>=? fun q -> let convert_message ( m : _ Pipe_rpc . Pipe_message . t ) = match m with | Closed _ as closed -> closed | Update u -> Update ( convert_elt u ) in Pipe_rpc . dispatch_iter rpc conn q ~ f ( : fun message -> f ( convert_message message ) ) >>| fun result -> convert_result result ~ convert_ok : Fn . id let abort conn id = Pipe_rpc . abort rpc conn id let ( ) = match Hashtbl . find registry version with | None -> Hashtbl . set registry ~ key : version ~ data ( { : abort ; dispatch ; dispatch_iter } , Any . Pipe rpc ) | Some _ -> Error . raise ( multiple_registrations ( ` Rpc name , ` Version version ) ) end module Register_raw ( Version_i : sig include Version_shared val model_of_response : response Pipe . Reader . t -> Model . response Or_error . t Pipe . Reader . t end ) = Make_shared ( Version_i ) ( struct let convert_elt = Or_error . error_string " Cannot use Direct with Register_raw " let convert_pipe = Version_i . model_of_response end ) module Register ( Version_i : sig include Version_shared val model_of_response : response -> Model . response end ) = Make_shared ( Version_i ) ( struct let convert_elt = Ok Version_i . model_of_response let convert_pipe rs = Pipe . map rs ~ f ( : fun r -> match Version_i . model_of_response r with | r -> Ok r | exception exn -> Error ( failed_conversion ( ` Response , ` Rpc name , ` Version Version_i . version , exn ) ) ) end ) end end module State_rpc = struct module type S = sig type query type state type update type error val dispatch_multi : Connection_with_menu . t -> query -> ( state * update Or_error . t Pipe . Reader . t * State_rpc . Metadata . t , error ) Result . t Or_error . t Deferred . t val rpcs : unit -> Any . t list val versions : unit -> Int . Set . t val name : string end module Make ( Model : sig val name : string type query type state type update type error end ) = struct let name = Model . name let registry = Int . Table . create ~ size : 1 ( ) let rpcs ( ) = List . map ( Hashtbl . data registry ) ~ f ( : fun ( _ , rpc ) -> rpc ) let versions ( ) = Int . Set . of_list ( Int . Table . keys registry ) let dispatch_multi conn_with_menu query = Dispatch . Async . with_version_menu conn_with_menu query ~ name ~ versions ~ registry ~ dispatcher : Fn . id module type Version_shared = sig type query [ @@ deriving bin_io ] type state [ @@ deriving bin_io ] type update [ @@ deriving bin_io ] type error [ @@ deriving bin_io ] val version : int val query_of_model : Model . query -> query val model_of_state : state -> Model . state val model_of_error : error -> Model . error val client_pushes_back : bool end module Register_raw ( Version_i : sig include Version_shared val model_of_update : update Pipe . Reader . t -> Model . update Or_error . t Pipe . Reader . t end ) = struct open Version_i let rpc = State_rpc . create ~ name ~ version ~ bin_query ~ bin_state ~ bin_update ~ bin_error ? client_pushes_back ( : Option . some_if client_pushes_back ( ) ) ( ) let ( ) = let dispatch conn q = match Version_i . query_of_model q with | exception exn -> return ( Error ( failed_conversion ( ` Query , ` Rpc name , ` Version version , exn ) ) ) | q -> State_rpc . dispatch rpc conn q >>| fun result -> match result with | Error exn -> Error exn | Ok ( Error e ) -> ( match Version_i . model_of_error e with | e ' -> Ok ( Error e ' ) | exception exn -> Error ( failed_conversion ( ` Error , ` Rpc name , ` Version version , exn ) ) ) | Ok ( Ok ( state , pipe , id ) ) -> match Version_i . model_of_state state with | exception exn -> Error ( failed_conversion ( ` State , ` Rpc name , ` Version version , exn ) ) | state -> Ok ( Ok ( state , Version_i . model_of_update pipe , id ) ) in match Hashtbl . find registry version with | None -> Hashtbl . set registry ~ key : version ~ data ( : dispatch , Any . State rpc ) | Some _ -> Error . raise ( multiple_registrations ( ` Rpc name , ` Version version ) ) end module Register ( Version_i : sig include Version_shared val model_of_update : update -> Model . update end ) = struct include Register_raw ( struct include Version_i let model_of_update rs = Pipe . map rs ~ f ( : fun r -> match Version_i . model_of_update r with | r -> Ok r | exception exn -> Error ( failed_conversion ( ` Update , ` Rpc name , ` Version version , exn ) ) ) end ) end end end module One_way = struct module type S = sig type msg val dispatch_multi : Connection_with_menu . t -> msg -> unit Or_error . t val rpcs : unit -> Any . t list val versions : unit -> Int . Set . t val name : string end module Make ( Model : sig val name : string type msg end ) = struct let name = Model . name let registry = Int . Table . create ~ size : 1 ( ) let rpcs ( ) = List . map ( Hashtbl . data registry ) ~ f ( : fun ( _ , rpc ) -> rpc ) let versions ( ) = Int . Set . of_list ( Int . Table . keys registry ) let dispatch_multi conn_with_menu msg = Dispatch . Direct . with_version_menu conn_with_menu msg ~ name ~ versions ~ registry ~ dispatcher : Fn . id module Register ( Version_i : sig type msg [ @@ deriving bin_io ] val version : int val msg_of_model : Model . msg -> msg end ) = struct open Version_i let rpc = One_way . create ~ name ~ version ~ bin_msg let ( ) = let dispatch conn q = match Result . try_with ( fun ( ) -> Version_i . msg_of_model q ) with | Error exn -> Error ( failed_conversion ( ` Msg , ` Rpc name , ` Version version , exn ) ) | Ok q -> One_way . dispatch rpc conn q in match Hashtbl . find registry version with | None -> Hashtbl . set registry ~ key : version ~ data ( : dispatch , Any . One_way rpc ) | Some _ -> Error . raise ( multiple_registrations ( ` Rpc name , ` Version version ) ) end end end end |
module Both_convert = struct module Plain = struct module type S = sig type caller_query type callee_query type caller_response type callee_response val dispatch_multi : Connection_with_menu . t -> caller_query -> caller_response Or_error . t Deferred . t val implement_multi : ? log_not_previously_seen_version ( : name : string -> int -> unit ) -> ( ' state -> version : int -> callee_query -> callee_response Deferred . t ) -> ' state Implementation . t list val rpcs : unit -> Any . t list val versions : unit -> Int . Set . t val name : string end module Make ( Model : sig val name : string module Caller : sig type query type response end module Callee : sig type query type response end end ) = struct open Model let name = name module Caller = Caller_converts . Rpc . Make ( struct let name = name include Caller end ) module Callee = Callee_converts . Rpc . Make ( struct let name = name include Callee end ) let % test _ = Int . Set . equal ( Caller . versions ( ) ) ( Callee . versions ( ) ) module Register ( Version : sig open Model val version : int type query [ @@ deriving bin_io ] type response [ @@ deriving bin_io ] val query_of_caller_model : Caller . query -> query val callee_model_of_query : query -> Callee . query val response_of_callee_model : Callee . response -> response val caller_model_of_response : response -> Caller . response end ) = struct include Callee . Register ( struct include Version let model_of_query = callee_model_of_query let response_of_model = response_of_callee_model end ) include Caller . Register ( struct include Version let query_of_model = query_of_caller_model let model_of_response = caller_model_of_response end ) let % test _ = Int . Set . equal ( Caller . versions ( ) ) ( Callee . versions ( ) ) end let dispatch_multi = Caller . dispatch_multi let implement_multi = Callee . implement_multi let versions ( ) = Caller . versions ( ) let rpcs ( ) = Caller . rpcs ( ) end end module Pipe_rpc = struct module type S = sig type caller_query type callee_query type caller_response type callee_response type caller_error type callee_error val dispatch_multi : Connection_with_menu . t -> caller_query -> ( caller_response Or_error . t Pipe . Reader . t * Pipe_rpc . Metadata . t , caller_error ) Result . t Or_error . t Deferred . t val dispatch_iter_multi : Connection_with_menu . t -> caller_query -> f ( : caller_response Pipe_rpc . Pipe_message . t -> Pipe_rpc . Pipe_response . t ) -> ( Pipe_rpc . Id . t , caller_error ) Result . t Or_error . t Deferred . t val abort_multi : Connection_with_menu . t -> Pipe_rpc . Id . t -> unit Or_error . t val implement_multi : ? log_not_previously_seen_version ( : name : string -> int -> unit ) -> ( ' state -> version : int -> callee_query -> ( callee_response Pipe . Reader . t , callee_error ) Result . t Deferred . t ) -> ' state Implementation . t list val implement_direct_multi : ? log_not_previously_seen_version ( : name : string -> int -> unit ) -> ( ' state -> version : int -> callee_query -> callee_response Versioned_direct_stream_writer . t -> ( unit , callee_error ) Result . t Deferred . t ) -> ' state Implementation . t list val rpcs : unit -> Any . t list val versions : unit -> Int . Set . t val name : string end module Make ( Model : sig val name : string module Caller : sig type query type response type error end module Callee : sig type query type response type error end end ) = struct open Model let name = name module Caller = Caller_converts . Pipe_rpc . Make ( struct let name = name include Caller end ) module Callee = Callee_converts . Pipe_rpc . Make ( struct let name = name include Callee end ) let % test _ = Int . Set . equal ( Caller . versions ( ) ) ( Callee . versions ( ) ) module type Version_shared = sig val version : int type query [ @@ deriving bin_io ] type response [ @@ deriving bin_io ] type error [ @@ deriving bin_io ] val query_of_caller_model : Model . Caller . query -> query val callee_model_of_query : query -> Model . Callee . query val error_of_callee_model : Model . Callee . error -> error val caller_model_of_error : error -> Model . Caller . error val client_pushes_back : bool end module Register_raw ( Version_i : sig include Version_shared val response_of_callee_model : Model . Callee . response Pipe . Reader . t -> response Pipe . Reader . t val caller_model_of_response : response Pipe . Reader . t -> Model . Caller . response Or_error . t Pipe . Reader . t end ) = struct include Callee . Register_raw ( struct include Version_i let model_of_query = callee_model_of_query let response_of_model = response_of_callee_model let error_of_model = error_of_callee_model end ) include Caller . Register_raw ( struct include Version_i let query_of_model = query_of_caller_model let model_of_response = caller_model_of_response let model_of_error = caller_model_of_error end ) end module Register ( Version_i : sig include Version_shared val response_of_callee_model : Model . Callee . response -> response val caller_model_of_response : response -> Model . Caller . response end ) = struct include Callee . Register ( struct include Version_i let model_of_query = callee_model_of_query let response_of_model = response_of_callee_model let error_of_model = error_of_callee_model end ) include Caller . Register ( struct include Version_i let query_of_model = query_of_caller_model let model_of_response = caller_model_of_response let model_of_error = caller_model_of_error end ) end let dispatch_multi = Caller . dispatch_multi let dispatch_iter_multi = Caller . dispatch_iter_multi let abort_multi = Caller . abort_multi let implement_multi = Callee . implement_multi let implement_direct_multi = Callee . implement_direct_multi let versions ( ) = Caller . versions ( ) let rpcs ( ) = Caller . rpcs ( ) end end module State_rpc = struct module type S = sig type caller_query type callee_query type caller_state type callee_state type caller_update type callee_update type caller_error type callee_error val dispatch_multi : Connection_with_menu . t -> caller_query -> ( caller_state * caller_update Or_error . t Pipe . Reader . t * State_rpc . Metadata . t , caller_error ) Result . t Or_error . t Deferred . t val implement_multi : ? log_not_previously_seen_version ( : name : string -> int -> unit ) -> ( ' state -> version : int -> callee_query -> ( callee_state * callee_update Pipe . Reader . t , callee_error ) Result . t Deferred . t ) -> ' state Implementation . t list val rpcs : unit -> Any . t list val versions : unit -> Int . Set . t val name : string end module Make ( Model : sig val name : string module Caller : sig type query type state type update type error end module Callee : sig type query type state type update type error end end ) = struct open Model let name = name module Caller = Caller_converts . State_rpc . Make ( struct let name = name include Caller end ) module Callee = Callee_converts . State_rpc . Make ( struct let name = name include Callee end ) let % test _ = Int . Set . equal ( Caller . versions ( ) ) ( Callee . versions ( ) ) module type Version_shared = sig val version : int type query [ @@ deriving bin_io ] type state [ @@ deriving bin_io ] type update [ @@ deriving bin_io ] type error [ @@ deriving bin_io ] val query_of_caller_model : Model . Caller . query -> query val callee_model_of_query : query -> Model . Callee . query val caller_model_of_state : state -> Model . Caller . state val state_of_callee_model : Model . Callee . state -> state val caller_model_of_error : error -> Model . Caller . error val error_of_callee_model : Model . Callee . error -> error val client_pushes_back : bool end module Register_raw ( Version_i : sig include Version_shared val caller_model_of_update : update Pipe . Reader . t -> Model . Caller . update Or_error . t Pipe . Reader . t val update_of_callee_model : Model . Callee . state -> Model . Callee . update Pipe . Reader . t -> update Pipe . Reader . t end ) = struct include Callee . Register_raw ( struct include Version_i let model_of_query = callee_model_of_query let state_of_model = state_of_callee_model let update_of_model = update_of_callee_model let error_of_model = error_of_callee_model end ) include Caller . Register_raw ( struct include Version_i let query_of_model = query_of_caller_model let model_of_state = caller_model_of_state let model_of_update = caller_model_of_update let model_of_error = caller_model_of_error end ) end module Register ( Version_i : sig include Version_shared val update_of_callee_model : Model . Callee . update -> update val caller_model_of_update : update -> Model . Caller . update end ) = struct include Callee . Register ( struct include Version_i let model_of_query = callee_model_of_query let state_of_model = state_of_callee_model let update_of_model = update_of_callee_model let error_of_model = error_of_callee_model end ) include Caller . Register ( struct include Version_i let query_of_model = query_of_caller_model let model_of_state = caller_model_of_state let model_of_update = caller_model_of_update let model_of_error = caller_model_of_error end ) end let dispatch_multi = Caller . dispatch_multi let implement_multi = Callee . implement_multi let versions ( ) = Caller . versions ( ) let rpcs ( ) = Caller . rpcs ( ) end end module One_way = struct module type S = sig type caller_msg type callee_msg val dispatch_multi : Connection_with_menu . t -> caller_msg -> unit Or_error . t val implement_multi : ? log_not_previously_seen_version ( : name : string -> int -> unit ) -> ( ' state -> version : int -> callee_msg -> unit ) -> ' state Implementation . t list val rpcs : unit -> Any . t list val versions : unit -> Int . Set . t val name : string end module Make ( Model : sig val name : string module Caller : sig type msg end module Callee : sig type msg end end ) = struct open Model let name = name module Caller = Caller_converts . One_way . Make ( struct let name = name include Caller end ) module Callee = Callee_converts . One_way . Make ( struct let name = name include Callee end ) let % test _ = Int . Set . equal ( Caller . versions ( ) ) ( Callee . versions ( ) ) module Register ( Version : sig open Model val version : int type msg [ @@ deriving bin_io ] val msg_of_caller_model : Caller . msg -> msg val callee_model_of_msg : msg -> Callee . msg end ) = struct include Callee . Register ( struct include Version let model_of_msg = callee_model_of_msg end ) include Caller . Register ( struct include Version let msg_of_model = msg_of_caller_model end ) let % test _ = Int . Set . equal ( Caller . versions ( ) ) ( Callee . versions ( ) ) end let dispatch_multi = Caller . dispatch_multi let implement_multi = Callee . implement_multi let versions ( ) = Caller . versions ( ) let rpcs ( ) = Caller . rpcs ( ) end end end |
let from_just op msg = match op with | Some x -> x | None -> failwith @@ msg " ^: Expected Some . Got None . " |
module Serialization ( S : sig type t val t : t Irmin . Type . t end ) = struct open S let pp = Irmin . Type . pp_json ~ minify : false t let of_string s = let decoder = Jsonm . decoder ( ` String s ) in let res = try Irmin . Type . decode_json t decoder with Invalid_argument s -> ( failwith @@ sprintf " AO_Value . of_string :\ \ Invalid_argument : % s " s ) in let _ = match res with | Ok _ -> ( ) | Error ( ` Msg str ) -> ( printf " Decoding error : % s \ n " str ; printf " While decoding : % s \ n " s ) in res end |
module MakeVersionedDS ( Config : CONFIG ) ( OM : MERGEABLE ) ( AO_value : Irmin . Contents . Conv with type t = OM . t ) = struct module S = Irmin_git . AO ( Git_unix . FS ) ( AO_value ) include AO_value type adt = OM . t let create config = let level = Irmin . Private . Conf . key ~ doc " : The Zlib compression level . " " level " Irmin . Private . Conf . ( some int ) None in let root = Irmin . Private . Conf . get config Irmin . Private . Conf . root in let level = Irmin . Private . Conf . get config level in Git_unix . FS . create ? root ? level ( ) let create ( ) = create @@ Irmin_git . config Config . root module type MY_TREE = TAG_TREE with type value = AO_value . t let add_and_link : type a . ( module MY_TREE with type t = a ) -> S . t -> AO_value . t -> a -> ( K . t * a ) Lwt . t = fun ( module T ) t v tree -> ( S . add t v ) >>= fun k -> let tag = T . tag_of_hash k in T . add tree tag v >>= fun tree ' -> Lwt . return ( k , tree ' ) let of_adt : type a . ( module MY_TREE with type t = a ) -> adt -> a -> ( t * a ) Lwt . t = fun ( module T ) adt tr -> begin create ( ) >>= fun ao_store -> add_and_link ( module T ) ao_store adt tr >>= fun ( _ , tr ' ) -> Lwt . return ( adt , tr ' ) end let to_adt ( t : t ) : adt Lwt . t = Lwt . return t let merge ( ~ old : t Irmin . Merge . promise ) ( v1 : t ) ( v2 : t ) = if v1 = v2 then Irmin . Merge . ok v1 else begin let open Irmin . Merge . Infix in old ( ) >>=* fun old -> let old = from_just old " merge " in let v = OM . merge ~ ancestor : old v1 v2 in Irmin . Merge . ok v end let merge = Irmin . Merge . ( option ( v t merge ) ) end |
module Make ( Config : CONFIG ) = struct module IWarehouse : IRMIN_DATA_STRUCTURE with type adt = Tpcc . Warehouse . t = struct module OM = Tpcc . Warehouse module AO_value : Irmin . Contents . Conv with type t = OM . t = struct type adt = OM . t type t = OM . t let t = let open Irmin . Type in let open Tpcc . Warehouse in record " t " ( fun w_id w_ytd -> { w_id ; w_ytd } ) |+ field " w_id " id ( fun t -> t . w_id ) |+ field " w_ytd " int32 ( fun t -> t . w_ytd ) |> sealr include Serialization ( struct type t = adt let t = t end ) end include MakeVersionedDS ( Config ) ( OM ) ( AO_value ) end module IDistrict : IRMIN_DATA_STRUCTURE with type adt = Tpcc . District . t = struct module OM = Tpcc . District module AO_value : Irmin . Contents . Conv with type t = OM . t = struct type adt = OM . t type t = OM . t let t = let open Irmin . Type in let open Tpcc . District in ( ( ( ( record " madt " ( fun d_id -> fun d_w_id -> fun d_ytd -> { d_id ; d_w_id ; d_ytd } ) ) |+ ( field " d_id " id ( fun t -> t . d_id ) ) ) |+ ( field " d_w_id " id ( fun t -> t . d_w_id ) ) ) |+ ( field " d_ytd " int32 ( fun t -> t . d_ytd ) ) ) |> sealr include Serialization ( struct type t = adt let t = t end ) end include MakeVersionedDS ( Config ) ( OM ) ( AO_value ) end module IOrder : IRMIN_DATA_STRUCTURE with type adt = Tpcc . Order . t = struct module OM = Tpcc . Order module AO_value : Irmin . Contents . Conv with type t = OM . t = struct type adt = OM . t type t = OM . t let t = let open Irmin . Type in let open Tpcc . Order in ( ( ( ( ( ( ( record " t " ( fun o_id -> fun o_w_id -> fun o_d_id -> fun o_c_id -> fun o_ol_cnt -> fun o_carrier_id -> { o_id ; o_w_id ; o_d_id ; o_c_id ; o_ol_cnt ; o_carrier_id } ) ) |+ ( field " o_id " id ( fun t -> t . o_id ) ) ) |+ ( field " o_w_id " id ( fun t -> t . o_w_id ) ) ) |+ ( field " o_d_id " id ( fun t -> t . o_d_id ) ) ) |+ ( field " o_c_id " id ( fun t -> t . o_c_id ) ) ) |+ ( field " o_ol_cnt " int32 ( fun t -> t . o_ol_cnt ) ) ) |+ ( field " o_carrier_id " bool ( fun t -> t . o_carrier_id ) ) ) |> sealr include Serialization ( struct type t = adt let t = t end ) end include MakeVersionedDS ( Config ) ( OM ) ( AO_value ) end module INewOrder : IRMIN_DATA_STRUCTURE with type adt = Tpcc . NewOrder . t = struct module OM = Tpcc . NewOrder module AO_value : Irmin . Contents . Conv with type t = OM . t = struct type adt = OM . t type t = OM . t let t = let open Irmin . Type in let open Tpcc . NewOrder in ( ( ( ( record " t " ( fun no_o_id -> fun no_d_id -> fun no_w_id -> { no_o_id ; no_d_id ; no_w_id } ) ) |+ ( field " no_o_id " id ( fun t -> t . no_o_id ) ) ) |+ ( field " no_d_id " id ( fun t -> t . no_d_id ) ) ) |+ ( field " no_w_id " id ( fun t -> t . no_w_id ) ) ) |> sealr include Serialization ( struct type t = adt let t = t end ) end include MakeVersionedDS ( Config ) ( OM ) ( AO_value ) end module IOrderLine : IRMIN_DATA_STRUCTURE with type adt = Tpcc . OrderLine . t = struct module OM = Tpcc . OrderLine module AO_value : Irmin . Contents . Conv with type t = OM . t = struct type adt = OM . t type t = OM . t let t = let open Irmin . Type in let open Tpcc . OrderLine in ( ( ( ( ( ( ( ( ( ( record " t " ( fun ol_o_id -> fun ol_d_id -> fun ol_w_id -> fun ol_num -> fun ol_amt -> fun ol_i_id -> fun ol_supply_w_id -> fun ol_qty -> fun ol_delivery_d -> { ol_o_id ; ol_d_id ; ol_w_id ; ol_num ; ol_amt ; ol_i_id ; ol_supply_w_id ; ol_qty ; ol_delivery_d } ) ) |+ ( field " ol_o_id " id ( fun t -> t . ol_o_id ) ) ) |+ ( field " ol_d_id " id ( fun t -> t . ol_d_id ) ) ) |+ ( field " ol_w_id " id ( fun t -> t . ol_w_id ) ) ) |+ ( field " ol_num " int32 ( fun t -> t . ol_num ) ) ) |+ ( field " ol_amt " int32 ( fun t -> t . ol_amt ) ) ) |+ ( field " ol_i_id " id ( fun t -> t . ol_i_id ) ) ) |+ ( field " ol_supply_w_id " id ( fun t -> t . ol_supply_w_id ) ) ) |+ ( field " ol_qty " int32 ( fun t -> t . ol_qty ) ) ) |+ ( field " ol_delivery_d " ( option float ) ( fun t -> t . ol_delivery_d ) ) ) |> sealr include Serialization ( struct type t = adt let t = t end ) end include MakeVersionedDS ( Config ) ( OM ) ( AO_value ) end module IItem : IRMIN_DATA_STRUCTURE with type adt = Tpcc . Item . t = struct module OM = Tpcc . Item module AO_value : Irmin . Contents . Conv with type t = OM . t = struct type adt = OM . t type t = OM . t let t = let open Irmin . Type in let open Tpcc . Item in ( ( ( ( record " t " ( fun i_id -> fun i_name -> fun i_price -> { i_id ; i_name ; i_price } ) ) |+ ( field " i_id " id ( fun t -> t . i_id ) ) ) |+ ( field " i_name " string ( fun t -> t . i_name ) ) ) |+ ( field " i_price " int32 ( fun t -> t . i_price ) ) ) |> sealr include Serialization ( struct type t = adt let t = t end ) end include MakeVersionedDS ( Config ) ( OM ) ( AO_value ) end module IHist : IRMIN_DATA_STRUCTURE with type adt = Tpcc . Hist . t = struct module OM = Tpcc . Hist module AO_value : Irmin . Contents . Conv with type t = OM . t = struct type adt = OM . t type t = OM . t let t = let open Irmin . Type in let open Tpcc . Hist in ( ( ( ( ( ( ( record " t " ( fun h_c_id -> fun h_c_d_id -> fun h_c_w_id -> fun h_d_id -> fun h_w_id -> fun h_amt -> { h_c_id ; h_c_d_id ; h_c_w_id ; h_d_id ; h_w_id ; h_amt } ) ) |+ ( field " h_c_id " id ( fun t -> t . h_c_id ) ) ) |+ ( field " h_c_d_id " id ( fun t -> t . h_c_d_id ) ) ) |+ ( field " h_c_w_id " id ( fun t -> t . h_c_w_id ) ) ) |+ ( field " h_d_id " id ( fun t -> t . h_d_id ) ) ) |+ ( field " h_w_id " id ( fun t -> t . h_w_id ) ) ) |+ ( field " h_amt " int32 ( fun t -> t . h_amt ) ) ) |> sealr include Serialization ( struct type t = adt let t = t end ) end include MakeVersionedDS ( Config ) ( OM ) ( AO_value ) end module IStock : IRMIN_DATA_STRUCTURE with type adt = Tpcc . Stock . t = struct module OM = Tpcc . Stock module AO_value : Irmin . Contents . Conv with type t = OM . t = struct type adt = OM . t type t = OM . t let t = let open Irmin . Type in let open Tpcc . Stock in ( ( ( ( ( ( record " t " ( fun s_i_id -> fun s_w_id -> fun s_qty -> fun s_ytd -> fun s_order_cnt -> { s_i_id ; s_w_id ; s_qty ; s_ytd ; s_order_cnt } ) ) |+ ( field " s_i_id " id ( fun t -> t . s_i_id ) ) ) |+ ( field " s_w_id " id ( fun t -> t . s_w_id ) ) ) |+ ( field " s_qty " int32 ( fun t -> t . s_qty ) ) ) |+ ( field " s_ytd " int32 ( fun t -> t . s_ytd ) ) ) |+ ( field " s_order_cnt " int32 ( fun t -> t . s_order_cnt ) ) ) |> sealr include Serialization ( struct type t = adt let t = t end ) end include MakeVersionedDS ( Config ) ( OM ) ( AO_value ) end module ICustomer : IRMIN_DATA_STRUCTURE with type adt = Tpcc . Customer . t = struct module OM = Tpcc . Customer module AO_value : Irmin . Contents . Conv with type t = OM . t = struct type adt = OM . t type t = OM . t let t = let open Irmin . Type in let open Tpcc . Customer in ( ( ( ( ( ( ( ( record " t " ( fun c_id -> fun c_d_id -> fun c_w_id -> fun c_bal -> fun c_ytd_payment -> fun c_payment_cnt -> fun c_delivery_cnt -> { c_id ; c_d_id ; c_w_id ; c_bal ; c_ytd_payment ; c_payment_cnt ; c_delivery_cnt } ) ) |+ ( field " c_id " id ( fun t -> t . c_id ) ) ) |+ ( field " c_d_id " id ( fun t -> t . c_d_id ) ) ) |+ ( field " c_w_id " id ( fun t -> t . c_w_id ) ) ) |+ ( field " c_bal " int32 ( fun t -> t . c_bal ) ) ) |+ ( field " c_ytd_payment " int32 ( fun t -> t . c_ytd_payment ) ) ) |+ ( field " c_payment_cnt " int32 ( fun t -> t . c_payment_cnt ) ) ) |+ ( field " c_delivery_cnt " int32 ( fun t -> t . c_delivery_cnt ) ) ) |> sealr include Serialization ( struct type t = adt let t = t end ) end include MakeVersionedDS ( Config ) ( OM ) ( AO_value ) end end |
type _ witnesses = . . |
type _ migration = . . |
type _ migration += Undefined : _ migration |
type ' a migration_info = { mutable next_version : ' a migration ; mutable previous_version : ' a migration ; } |
module type Ast = sig module Parsetree : sig type structure type signature type toplevel_phrase type core_type type expression type pattern type case type type_declaration type type_extension type extension_constructor end module Config : sig val ast_impl_magic_number : string val ast_intf_magic_number : string end end |
type ' a _types = ' a constraint ' a = < structure : _ ; signature : _ ; toplevel_phrase : _ ; core_type : _ ; expression : _ ; pattern : _ ; case : _ ; type_declaration : _ ; type_extension : _ ; extension_constructor : _ ; > ; ; |
type ' a get_structure = ' x constraint ' a _types = < structure : ' x ; . . > |
type ' a get_signature = ' x constraint ' a _types = < signature : ' x ; . . > |
type ' a get_toplevel_phrase = ' x constraint ' a _types = < toplevel_phrase : ' x ; . . > |
type ' a get_core_type = ' x constraint ' a _types = < core_type : ' x ; . . > |
type ' a get_expression = ' x constraint ' a _types = < expression : ' x ; . . > |
type ' a get_pattern = ' x constraint ' a _types = < pattern : ' x ; . . > |
type ' a get_case = ' x constraint ' a _types = < case : ' x ; . . > |
type ' a get_type_declaration = ' x constraint ' a _types = < type_declaration : ' x ; . . > |
type ' a get_type_extension = ' x constraint ' a _types = < type_extension : ' x ; . . > |
type ' a get_extension_constructor = ' x constraint ' a _types = < extension_constructor : ' x ; . . > |
module type OCaml_version = sig module Ast : Ast val version : int val string_version : string type types = < structure : Ast . Parsetree . structure ; signature : Ast . Parsetree . signature ; toplevel_phrase : Ast . Parsetree . toplevel_phrase ; core_type : Ast . Parsetree . core_type ; expression : Ast . Parsetree . expression ; pattern : Ast . Parsetree . pattern ; case : Ast . Parsetree . case ; type_declaration : Ast . Parsetree . type_declaration ; type_extension : Ast . Parsetree . type_extension ; extension_constructor : Ast . Parsetree . extension_constructor ; > _types type _ witnesses += Version : types witnesses val migration_info : types migration_info end |
module Make_witness ( Ast : Ast ) = struct type types = < structure : Ast . Parsetree . structure ; signature : Ast . Parsetree . signature ; toplevel_phrase : Ast . Parsetree . toplevel_phrase ; core_type : Ast . Parsetree . core_type ; expression : Ast . Parsetree . expression ; pattern : Ast . Parsetree . pattern ; case : Ast . Parsetree . case ; type_declaration : Ast . Parsetree . type_declaration ; type_extension : Ast . Parsetree . type_extension ; extension_constructor : Ast . Parsetree . extension_constructor ; > _types type _ witnesses += Version : types witnesses let migration_info : types migration_info = { next_version = Undefined ; previous_version = Undefined } end |
type ' types ocaml_version = ( module OCaml_version with type Ast . Parsetree . structure = ' types get_structure and type Ast . Parsetree . signature = ' types get_signature and type Ast . Parsetree . toplevel_phrase = ' types get_toplevel_phrase and type Ast . Parsetree . core_type = ' types get_core_type and type Ast . Parsetree . expression = ' types get_expression and type Ast . Parsetree . pattern = ' types get_pattern and type Ast . Parsetree . case = ' types get_case and type Ast . Parsetree . type_declaration = ' types get_type_declaration and type Ast . Parsetree . type_extension = ' types get_type_extension and type Ast . Parsetree . extension_constructor = ' types get_extension_constructor ) |
type ( ' from , ' to_ ) migration_functions = { copy_structure : ' from get_structure -> ' to_ get_structure ; copy_signature : ' from get_signature -> ' to_ get_signature ; copy_toplevel_phrase : ' from get_toplevel_phrase -> ' to_ get_toplevel_phrase ; copy_core_type : ' from get_core_type -> ' to_ get_core_type ; copy_expression : ' from get_expression -> ' to_ get_expression ; copy_pattern : ' from get_pattern -> ' to_ get_pattern ; copy_case : ' from get_case -> ' to_ get_case ; copy_type_declaration : ' from get_type_declaration -> ' to_ get_type_declaration ; copy_type_extension : ' from get_type_extension -> ' to_ get_type_extension ; copy_extension_constructor : ' from get_extension_constructor -> ' to_ get_extension_constructor ; } |
let id x = x |
let migration_identity : ( ' a , ' a ) migration_functions = { copy_structure = id ; copy_signature = id ; copy_toplevel_phrase = id ; copy_core_type = id ; copy_expression = id ; copy_pattern = id ; copy_case = id ; copy_type_declaration = id ; copy_type_extension = id ; copy_extension_constructor = id ; } |
let compose f g x = f ( g x ) |
let migration_compose ( ab : ( ' a , ' b ) migration_functions ) ( bc : ( ' b , ' c ) migration_functions ) : ( ' a , ' c ) migration_functions = { copy_structure = compose bc . copy_structure ab . copy_structure ; copy_signature = compose bc . copy_signature ab . copy_signature ; copy_toplevel_phrase = compose bc . copy_toplevel_phrase ab . copy_toplevel_phrase ; copy_core_type = compose bc . copy_core_type ab . copy_core_type ; copy_expression = compose bc . copy_expression ab . copy_expression ; copy_pattern = compose bc . copy_pattern ab . copy_pattern ; copy_case = compose bc . copy_case ab . copy_case ; copy_type_declaration = compose bc . copy_type_declaration ab . copy_type_declaration ; copy_type_extension = compose bc . copy_type_extension ab . copy_type_extension ; copy_extension_constructor = compose bc . copy_extension_constructor ab . copy_extension_constructor ; } |
type _ migration += Migration : ' from ocaml_version * ( ' from , ' to_ ) migration_functions * ' to_ ocaml_version -> ' from migration |
module type Migrate_module = sig module From : Ast module To : Ast val copy_structure : From . Parsetree . structure -> To . Parsetree . structure val copy_signature : From . Parsetree . signature -> To . Parsetree . signature val copy_toplevel_phrase : From . Parsetree . toplevel_phrase -> To . Parsetree . toplevel_phrase val copy_core_type : From . Parsetree . core_type -> To . Parsetree . core_type val copy_expression : From . Parsetree . expression -> To . Parsetree . expression val copy_pattern : From . Parsetree . pattern -> To . Parsetree . pattern val copy_case : From . Parsetree . case -> To . Parsetree . case val copy_type_declaration : From . Parsetree . type_declaration -> To . Parsetree . type_declaration val copy_type_extension : From . Parsetree . type_extension -> To . Parsetree . type_extension val copy_extension_constructor : From . Parsetree . extension_constructor -> To . Parsetree . extension_constructor end |
module Migration_functions ( A : OCaml_version ) ( B : OCaml_version ) ( A_to_B : Migrate_module with module From = A . Ast and module To = B . Ast ) = struct let migration_functions : ( A . types , B . types ) migration_functions = let open A_to_B in { copy_structure ; copy_signature ; copy_toplevel_phrase ; copy_core_type ; copy_expression ; copy_pattern ; copy_case ; copy_type_declaration ; copy_type_extension ; copy_extension_constructor ; } end |
module Register_migration ( A : OCaml_version ) ( B : OCaml_version ) ( A_to_B : Migrate_module with module From = A . Ast and module To = B . Ast ) ( B_to_A : Migrate_module with module From = B . Ast and module To = A . Ast ) = struct let ( ) = ( let is_undefined : type a . a migration -> bool = function | Undefined -> true | _ -> false in assert ( A . version < B . version ) ; assert ( is_undefined A . migration_info . next_version ) ; assert ( is_undefined B . migration_info . previous_version ) ; let module A_to_B_fun = Migration_functions ( A ) ( B ) ( A_to_B ) in let module B_to_A_fun = Migration_functions ( B ) ( A ) ( B_to_A ) in A . migration_info . next_version <- Migration ( ( module A ) , A_to_B_fun . migration_functions , ( module B ) ) ; B . migration_info . previous_version <- Migration ( ( module B ) , B_to_A_fun . migration_functions , ( module A ) ) ; ) end |
type ' from immediate_migration = | No_migration : ' from immediate_migration | Immediate_migration : ( ' from , ' to_ ) migration_functions * ' to_ ocaml_version -> ' from immediate_migration |
let immediate_migration ( type structure ) ( type signature ) ( type toplevel_phrase ) ( type core_type ) ( type expression ) ( type pattern ) ( type case ) ( type type_declaration ) ( type type_extension ) ( type extension_constructor ) ( ( module A ) : < structure : structure ; signature : signature ; toplevel_phrase : toplevel_phrase ; core_type : core_type ; expression : expression ; pattern : pattern ; case : case ; type_declaration : type_declaration ; type_extension : type_extension ; extension_constructor : extension_constructor ; > ocaml_version ) direction = let version = match direction with | ` Next -> A . migration_info . next_version | ` Previous -> A . migration_info . previous_version in match version with | Undefined -> No_migration | Migration ( _ , funs , to_ ) -> Immediate_migration ( funs , to_ ) | _ -> assert false |
let migrate ( type structure1 ) ( type structure2 ) ( type signature1 ) ( type signature2 ) ( type toplevel_phrase1 ) ( type toplevel_phrase2 ) ( type core_type1 ) ( type core_type2 ) ( type expression1 ) ( type expression2 ) ( type pattern1 ) ( type pattern2 ) ( type case1 ) ( type case2 ) ( type type_declaration1 ) ( type type_declaration2 ) ( type type_extension1 ) ( type type_extension2 ) ( type extension_constructor1 ) ( type extension_constructor2 ) ( ( module A ) : < structure : structure1 ; signature : signature1 ; toplevel_phrase : toplevel_phrase1 ; core_type : core_type1 ; expression : expression1 ; pattern : pattern1 ; case : case1 ; type_declaration : type_declaration1 ; type_extension : type_extension1 ; extension_constructor : extension_constructor1 ; > ocaml_version ) ( ( module B ) : < structure : structure2 ; signature : signature2 ; toplevel_phrase : toplevel_phrase2 ; core_type : core_type2 ; expression : expression2 ; pattern : pattern2 ; case : case2 ; type_declaration : type_declaration2 ; type_extension : type_extension2 ; extension_constructor : extension_constructor2 ; > ocaml_version ) : ( A . types , B . types ) migration_functions = match A . Version with | B . Version -> migration_identity | _ -> let direction = if A . version < B . version then ` Next else ` Previous in let rec migrate ( m : A . types immediate_migration ) : ( A . types , B . types ) migration_functions = match m with | No_migration -> assert false | Immediate_migration ( f , ( module To ) ) -> match To . Version with | B . Version -> f | _ -> match immediate_migration ( module To ) direction with | No_migration -> assert false | Immediate_migration ( g , to2 ) -> migrate ( Immediate_migration ( migration_compose f g , to2 ) ) in migrate ( immediate_migration ( module A ) direction ) |
module Convert ( A : OCaml_version ) ( B : OCaml_version ) = struct let { copy_structure ; copy_signature ; copy_toplevel_phrase ; copy_core_type ; copy_expression ; copy_pattern ; copy_case ; copy_type_declaration ; copy_type_extension ; copy_extension_constructor ; } : ( A . types , B . types ) migration_functions = migrate ( module A ) ( module B ) end |
module OCaml_402 = struct module Ast = Astlib . Ast_402 include Make_witness ( Astlib . Ast_402 ) let version = 402 let string_version = " 4 . 02 " end |
let ocaml_402 : OCaml_402 . types ocaml_version = ( module OCaml_402 ) |
module OCaml_403 = struct module Ast = Astlib . Ast_403 include Make_witness ( Astlib . Ast_403 ) let version = 403 let string_version = " 4 . 03 " end |
let ocaml_403 : OCaml_403 . types ocaml_version = ( module OCaml_403 ) |
module OCaml_404 = struct module Ast = Astlib . Ast_404 include Make_witness ( Astlib . Ast_404 ) let version = 404 let string_version = " 4 . 04 " end |
let ocaml_404 : OCaml_404 . types ocaml_version = ( module OCaml_404 ) |
module OCaml_405 = struct module Ast = Astlib . Ast_405 include Make_witness ( Astlib . Ast_405 ) let version = 405 let string_version = " 4 . 05 " end |
let ocaml_405 : OCaml_405 . types ocaml_version = ( module OCaml_405 ) |
module OCaml_406 = struct module Ast = Astlib . Ast_406 include Make_witness ( Astlib . Ast_406 ) let version = 406 let string_version = " 4 . 06 " end |
let ocaml_406 : OCaml_406 . types ocaml_version = ( module OCaml_406 ) |
module OCaml_407 = struct module Ast = Astlib . Ast_407 include Make_witness ( Astlib . Ast_407 ) let version = 407 let string_version = " 4 . 07 " end |
let ocaml_407 : OCaml_407 . types ocaml_version = ( module OCaml_407 ) |
module OCaml_408 = struct module Ast = Astlib . Ast_408 include Make_witness ( Astlib . Ast_408 ) let version = 408 let string_version = " 4 . 08 " end |
let ocaml_408 : OCaml_408 . types ocaml_version = ( module OCaml_408 ) |
module OCaml_409 = struct module Ast = Astlib . Ast_409 include Make_witness ( Astlib . Ast_409 ) let version = 409 let string_version = " 4 . 09 " end |
let ocaml_409 : OCaml_409 . types ocaml_version = ( module OCaml_409 ) |
module OCaml_410 = struct module Ast = Astlib . Ast_410 include Make_witness ( Astlib . Ast_410 ) let version = 410 let string_version = " 4 . 10 " end |
let ocaml_410 : OCaml_410 . types ocaml_version = ( module OCaml_410 ) |
module OCaml_411 = struct module Ast = Astlib . Ast_411 include Make_witness ( Astlib . Ast_411 ) let version = 411 let string_version = " 4 . 11 " end |
let ocaml_411 : OCaml_411 . types ocaml_version = ( module OCaml_411 ) |
module OCaml_412 = struct module Ast = Astlib . Ast_412 include Make_witness ( Astlib . Ast_412 ) let version = 412 let string_version = " 4 . 12 " end |
let ocaml_412 : OCaml_412 . types ocaml_version = ( module OCaml_412 ) |
module OCaml_413 = struct module Ast = Astlib . Ast_413 include Make_witness ( Astlib . Ast_413 ) let version = 413 let string_version = " 4 . 13 " end |
let ocaml_413 : OCaml_413 . types ocaml_version = ( module OCaml_413 ) |
module OCaml_414 = struct module Ast = Astlib . Ast_414 include Make_witness ( Astlib . Ast_414 ) let version = 414 let string_version = " 4 . 14 " end |
let ocaml_414 : OCaml_414 . types ocaml_version = ( module OCaml_414 ) |
let all_versions : ( module OCaml_version ) list = [ ] ( Astlib . Migrate_402_403 ) ( Astlib . Migrate_403_402 ) ( Astlib . Migrate_403_404 ) ( Astlib . Migrate_404_403 ) ( Astlib . Migrate_404_405 ) ( Astlib . Migrate_405_404 ) ( Astlib . Migrate_405_406 ) ( Astlib . Migrate_406_405 ) ( Astlib . Migrate_406_407 ) ( Astlib . Migrate_407_406 ) ( Astlib . Migrate_407_408 ) ( Astlib . Migrate_408_407 ) ( Astlib . Migrate_408_409 ) ( Astlib . Migrate_409_408 ) ( Astlib . Migrate_409_410 ) ( Astlib . Migrate_410_409 ) ( Astlib . Migrate_410_411 ) ( Astlib . Migrate_411_410 ) ( Astlib . Migrate_411_412 ) ( Astlib . Migrate_412_411 ) ( Astlib . Migrate_412_413 ) ( Astlib . Migrate_413_412 ) ( Astlib . Migrate_413_414 ) ( Astlib . Migrate_414_413 ) |
module Find_version = struct type t = Impl of ( module OCaml_version ) | Intf of ( module OCaml_version ) | Unknown let from_magic magic = let rec loop = function | [ ] -> Unknown | ( module Version : OCaml_version ) :: tail -> if Version . Ast . Config . ast_impl_magic_number = magic then Impl ( module Version ) else if Version . Ast . Config . ast_intf_magic_number = magic then Intf ( module Version ) else loop tail in loop all_versions end |
let coinbase : t = ' \ x01 ' |
let secret_box_byteswr : t = ' \ x02 ' |
let fee_transfer_single : t = ' \ x03 ' |
let frontier_hash : t = ' \ x04 ' |
let ledger_hash : t = ' \ x05 ' |
let lite_precomputed : t = ' \ x06 ' |
let proof : t = ' \ x0A ' |
let random_oracle_base : t = ' \ x0B ' |
let receipt_chain_hash : t = ' \ x0C ' |
let epoch_seed : t = ' \ x0D ' |
let staged_ledger_hash_aux_hash : t = ' \ x0E ' |
let staged_ledger_hash_pending_coinbase_aux : t = ' \ x0F ' |
let state_hash : t = ' \ x10 ' |
let state_body_hash : t = ' \ x11 ' |
let transaction_hash : t = ' \ x12 ' |
let user_command : t = ' \ x13 ' |
let user_command_memo : t = ' \ x14 ' |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.