sig
  type ('key, 'value) t_
  module type S =
    sig
      type key
      type value
      type t = (key, value) t_
      val create : (key * value) list -> t Core_kernel.Std.Or_error.t
      val get : t -> key -> value
      val first_knot : t -> (key * value) option
      val last_knot : t -> (key * value) option
      val to_knots : t -> (key * value) list
      val to_knots' : t -> key array * value array
      val precache : ?density:float -> t -> unit
      val create_from_linear_combination :
        (t * float) list -> t Core_kernel.Std.Or_error.t
      val compare : t -> t -> int
      val t_of_sexp : Sexplib.Sexp.t -> t
      val sexp_of_t : t -> Sexplib.Sexp.t
      val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
    end
  module Make :
    functor
      (Key : Piecewise_linear_intf.Float_like) (Value : Piecewise_linear_intf.Float_like->
      sig
        type key = Key.t
        type value = Value.t
        type t = (key, value) t_
        val create : (key * value) list -> t Core_kernel.Std.Or_error.t
        val get : t -> key -> value
        val first_knot : t -> (key * value) option
        val last_knot : t -> (key * value) option
        val to_knots : t -> (key * value) list
        val to_knots' : t -> key array * value array
        val precache : ?density:float -> t -> unit
        val create_from_linear_combination :
          (t * float) list -> t Core_kernel.Std.Or_error.t
        val compare : t -> t -> int
        val t_of_sexp : Sexplib.Sexp.t -> t
        val sexp_of_t : t -> Sexplib.Sexp.t
        val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
        val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
        val __bin_read_t__ : (int -> t) Core_kernel.Std.Bin_prot.Read.reader
        val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
        val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
        val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
        val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
      end
  type ('key, 'value) t_invertible
  module type S_invertible =
    sig
      type key
      type value
      type t = (key, value) t_invertible
      val create : (key * value) list -> t Core_kernel.Std.Or_error.t
      val get : t -> key -> value
      val first_knot : t -> (key * value) option
      val last_knot : t -> (key * value) option
      val to_knots : t -> (key * value) list
      val to_knots' : t -> key array * value array
      val precache : ?density:float -> t -> unit
      val create_from_linear_combination :
        (t * float) list -> t Core_kernel.Std.Or_error.t
      val compare : t -> t -> int
      val t_of_sexp : Sexplib.Sexp.t -> t
      val sexp_of_t : t -> Sexplib.Sexp.t
      val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
      val get_inverse : t -> value -> key
    end
  module Make_invertible :
    functor
      (Key : Piecewise_linear_intf.Float_like) (Value : Piecewise_linear_intf.Float_like->
      sig
        type key = Key.t
        type value = Value.t
        type t = (key, value) t_invertible
        val create : (key * value) list -> t Core_kernel.Std.Or_error.t
        val get : t -> key -> value
        val first_knot : t -> (key * value) option
        val last_knot : t -> (key * value) option
        val to_knots : t -> (key * value) list
        val to_knots' : t -> key array * value array
        val precache : ?density:float -> t -> unit
        val create_from_linear_combination :
          (t * float) list -> t Core_kernel.Std.Or_error.t
        val compare : t -> t -> int
        val t_of_sexp : Sexplib.Sexp.t -> t
        val sexp_of_t : t -> Sexplib.Sexp.t
        val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
        val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
        val __bin_read_t__ : (int -> t) Core_kernel.Std.Bin_prot.Read.reader
        val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
        val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
        val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
        val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
        val get_inverse : t -> value -> key
      end
  module Time :
    sig
      type key = Time.t
      type value = float
      type t = (key, value) t_
      val create : (key * value) list -> t Core_kernel.Std.Or_error.t
      val get : t -> key -> value
      val first_knot : t -> (key * value) option
      val last_knot : t -> (key * value) option
      val to_knots : t -> (key * value) list
      val to_knots' : t -> key array * value array
      val precache : ?density:float -> t -> unit
      val create_from_linear_combination :
        (t * float) list -> t Core_kernel.Std.Or_error.t
      val compare : t -> t -> int
      val t_of_sexp : Sexplib.Sexp.t -> t
      val sexp_of_t : t -> Sexplib.Sexp.t
      val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
    end
  module Ofday :
    sig
      type key = Ofday.t
      type value = float
      type t = (key, value) t_
      val create : (key * value) list -> t Core_kernel.Std.Or_error.t
      val get : t -> key -> value
      val first_knot : t -> (key * value) option
      val last_knot : t -> (key * value) option
      val to_knots : t -> (key * value) list
      val to_knots' : t -> key array * value array
      val precache : ?density:float -> t -> unit
      val create_from_linear_combination :
        (t * float) list -> t Core_kernel.Std.Or_error.t
      val compare : t -> t -> int
      val t_of_sexp : Sexplib.Sexp.t -> t
      val sexp_of_t : t -> Sexplib.Sexp.t
      val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
    end
  module Span :
    sig
      type key = Span.t
      type value = float
      type t = (key, value) t_
      val create : (key * value) list -> t Core_kernel.Std.Or_error.t
      val get : t -> key -> value
      val first_knot : t -> (key * value) option
      val last_knot : t -> (key * value) option
      val to_knots : t -> (key * value) list
      val to_knots' : t -> key array * value array
      val precache : ?density:float -> t -> unit
      val create_from_linear_combination :
        (t * float) list -> t Core_kernel.Std.Or_error.t
      val compare : t -> t -> int
      val t_of_sexp : Sexplib.Sexp.t -> t
      val sexp_of_t : t -> Sexplib.Sexp.t
      val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
    end
  module Float :
    sig
      type key = float
      type value = float
      type t = (key, value) t_
      val create : (key * value) list -> t Core_kernel.Std.Or_error.t
      val get : t -> key -> value
      val first_knot : t -> (key * value) option
      val last_knot : t -> (key * value) option
      val to_knots : t -> (key * value) list
      val to_knots' : t -> key array * value array
      val precache : ?density:float -> t -> unit
      val create_from_linear_combination :
        (t * float) list -> t Core_kernel.Std.Or_error.t
      val compare : t -> t -> int
      val t_of_sexp : Sexplib.Sexp.t -> t
      val sexp_of_t : t -> Sexplib.Sexp.t
      val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
    end
  module Int :
    sig
      type key = int
      type value = float
      type t = (key, value) t_
      val create : (key * value) list -> t Core_kernel.Std.Or_error.t
      val get : t -> key -> value
      val first_knot : t -> (key * value) option
      val last_knot : t -> (key * value) option
      val to_knots : t -> (key * value) list
      val to_knots' : t -> key array * value array
      val precache : ?density:float -> t -> unit
      val create_from_linear_combination :
        (t * float) list -> t Core_kernel.Std.Or_error.t
      val compare : t -> t -> int
      val t_of_sexp : Sexplib.Sexp.t -> t
      val sexp_of_t : t -> Sexplib.Sexp.t
      val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
    end
  module Stable :
    sig
      module V1 :
        sig
          type ('key, 'value) t_ = ('key, 'value) t_
          module Make :
            functor
              (Key : Piecewise_linear_intf.Float_like) (Value : Piecewise_linear_intf.Float_like->
              sig
                type t = (Key.t, Value.t) Piecewise_linear.t_
                val t_of_sexp :
                  Sexplib.Sexp.t -> Piecewise_linear.Stable.V1.Make.t
                val sexp_of_t :
                  Piecewise_linear.Stable.V1.Make.t -> Sexplib.Sexp.t
                val compare :
                  Piecewise_linear.Stable.V1.Make.t ->
                  Piecewise_linear.Stable.V1.Make.t -> int
                val bin_t :
                  Piecewise_linear.Stable.V1.Make.t
                  Core_kernel.Std.Bin_prot.Type_class.t
                val bin_read_t :
                  Piecewise_linear.Stable.V1.Make.t
                  Core_kernel.Std.Bin_prot.Read.reader
                val __bin_read_t__ :
                  (int -> Piecewise_linear.Stable.V1.Make.t)
                  Core_kernel.Std.Bin_prot.Read.reader
                val bin_reader_t :
                  Piecewise_linear.Stable.V1.Make.t
                  Core_kernel.Std.Bin_prot.Type_class.reader
                val bin_size_t :
                  Piecewise_linear.Stable.V1.Make.t
                  Core_kernel.Std.Bin_prot.Size.sizer
                val bin_write_t :
                  Piecewise_linear.Stable.V1.Make.t
                  Core_kernel.Std.Bin_prot.Write.writer
                val bin_writer_t :
                  Piecewise_linear.Stable.V1.Make.t
                  Core_kernel.Std.Bin_prot.Type_class.writer
              end
          type ('key, 'value) t_invertible = ('key, 'value) t_invertible
          module Make_invertible :
            functor
              (Key : Piecewise_linear_intf.Float_like) (Value : Piecewise_linear_intf.Float_like->
              sig
                type t = (Key.t, Value.t) Piecewise_linear.t_invertible
                val t_of_sexp :
                  Sexplib.Sexp.t ->
                  Piecewise_linear.Stable.V1.Make_invertible.t
                val sexp_of_t :
                  Piecewise_linear.Stable.V1.Make_invertible.t ->
                  Sexplib.Sexp.t
                val compare :
                  Piecewise_linear.Stable.V1.Make_invertible.t ->
                  Piecewise_linear.Stable.V1.Make_invertible.t -> int
                val bin_t :
                  Piecewise_linear.Stable.V1.Make_invertible.t
                  Core_kernel.Std.Bin_prot.Type_class.t
                val bin_read_t :
                  Piecewise_linear.Stable.V1.Make_invertible.t
                  Core_kernel.Std.Bin_prot.Read.reader
                val __bin_read_t__ :
                  (int -> Piecewise_linear.Stable.V1.Make_invertible.t)
                  Core_kernel.Std.Bin_prot.Read.reader
                val bin_reader_t :
                  Piecewise_linear.Stable.V1.Make_invertible.t
                  Core_kernel.Std.Bin_prot.Type_class.reader
                val bin_size_t :
                  Piecewise_linear.Stable.V1.Make_invertible.t
                  Core_kernel.Std.Bin_prot.Size.sizer
                val bin_write_t :
                  Piecewise_linear.Stable.V1.Make_invertible.t
                  Core_kernel.Std.Bin_prot.Write.writer
                val bin_writer_t :
                  Piecewise_linear.Stable.V1.Make_invertible.t
                  Core_kernel.Std.Bin_prot.Type_class.writer
              end
        end
    end
end