package core

  1. Overview
  2. Docs
package core
Legend:
Library
Module
Module type
Parameter
Class
Class type

Conversions between units of measure that are based on bytes (like kilobytes, megabytes, gigabytes, and words).

t's are created with of_bytes_float_exn, of_words_float_exn, of_kilobytes, of_megabytes, etc.

Note: in this module, kilobytes, Megabytes, etc. are defined as powers of 1024:

  • 1 kilobyte: 2^10 = 1024 bytes
  • 1 Megabyte: 2^20 = 1024^2 bytes
  • 1 Gigabyte: 2^30 = 1024^3 bytes
  • 1 Terabyte: 2^40 = 1024^4 bytes
  • 1 Petabyte: 2^50 = 1024^5 bytes
  • 1 Exabyte: 2^60 = 1024^6 bytes
type t
val sexp_of_t : t -> Sexplib0.Sexp.t
val create : [ `Bytes | `Kilobytes | `Megabytes | `Gigabytes | `Words ] -> Base.Float.t -> t
  • deprecated [since 2019-01] Use [of_bytes], [of_kilobytes], [of_megabytes], etc as appropriate.
include Comparable.S_plain with type t := t
include Base.Comparable.S with type t := t
val (>=) : t -> t -> bool
val (<=) : t -> t -> bool
val (=) : t -> t -> bool
val (>) : t -> t -> bool
val (<) : t -> t -> bool
val (<>) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val comparator : (t, comparator_witness) Base__.Comparator.comparator
val validate_lbound : min:t Maybe_bound.t -> t Validate.check
val validate_ubound : max:t Maybe_bound.t -> t Validate.check
val validate_bound : min:t Maybe_bound.t -> max:t Maybe_bound.t -> t Validate.check
module Replace_polymorphic_compare : sig ... end
include Hashable.S_plain with type t := t
include Ppx_compare_lib.Comparable.S with type t := t
val compare : t Base__Ppx_compare_lib.compare
include Ppx_hash_lib.Hashable.S with type t := t
val hash_fold_t : t Base__Ppx_hash_lib.hash_fold
val hash : t -> Base__Ppx_hash_lib.Std.Hash.hash_value
val hashable : t Core__.Hashtbl.Hashable.t
module Table : Hashtbl.S_plain with type key = t
module Hash_set : Hash_set.S_plain with type elt = t
module Hash_queue : Hash_queue.S with type key = t
val of_string : string -> t
val to_string : t -> string
val of_bytes : Base.Float.t -> t

This is a deprecated alias for of_bytes_float_exn.

  • deprecated [since 2019-01] Use [of_bytes_int], [of_bytes_int63], [of_bytes_int64_exn] or [of_bytes_float_exn] as appropriate.
val of_bytes_int : Base.Int.t -> t
val of_bytes_int63 : Int63.t -> t
val of_bytes_int64_exn : Int64.t -> t

This will raise if and only if the argument can not be represented as a Byte_units.t. Specifically this is if the argument is outside of [-2^62,2^62).

val of_bytes_float_exn : Base.Float.t -> t

This will raise if and only if the argument can not be represented as a Byte_units.t. Specifically this is if the argument is outside of [-2^62,2^62),

val of_kilobytes : Base.Float.t -> t

create of Byte_units based on the number of kilobytes. N.B. This will raise if the value is outside of [-2^52,2^52).

val of_megabytes : Base.Float.t -> t

create of Byte_units based on the number of Megabytes. N.B. This will raise if the value is outside of [-2^42,2^42).

val of_gigabytes : Base.Float.t -> t

create of Byte_units based on the number of Gigabytes. N.B. This will raise if the value is outside of [-2^32,2^32).

val of_terabytes : Base.Float.t -> t

create of Byte_units based on the number of Terabytes. N.B. This will raise if the value is outside of [-2^22,2^22).

val of_petabytes : Base.Float.t -> t

create of Byte_units based on the number of Petabytes. N.B. This will raise if the value is outside of [-2^12,2^12).

val of_exabytes : Base.Float.t -> t

create of Byte_units based on the number of Exabytes. N.B. This will raise if the value is outside of [-4,4).

val of_words : Base.Float.t -> t

Do not use, consider using of_words_int instead. Alias for of_words_float_exn.

  • deprecated [since 2019-01] Use [of_words_int] or [of_words_float_exn] instead.
val of_words_int : Base.Int.t -> t

create of Byte_units based on the number of machine words.

val of_words_float_exn : Base.Float.t -> t

Create of Byte_units based on the number of machine words. On 64-bit platforms this will raise if the value is outside of [-2^59,2^59). On 32-bit platforms (including JS) this will raise if the value is outside of [-2^60,2^60).

val to_string_hum : t -> Base.String.t

to_string_hum t returns a string representation of t. This will use the largest unit that will not make the translated value be below 1.

For example Byte_units.to_string_hum (Byte_units.of_bytes_int 1000) gives 1000B, but Byte_units.to_string_hum (Byte_units.of_bytes_int 1500) gives 1.46484K.

val to_string_short : t -> Base.String.t
  • deprecated [since 2020-06] Use [Short.to_string] instead.
module Short : sig ... end
val bytes : t -> Base.Float.t

This is a deprecated alias for bytes_float.

  • deprecated [since 2019-01] Use [bytes_int_exn], [bytes_int63], [bytes_int64] or [bytes_float] as appropriate.
val bytes_int_exn : t -> Base.Int.t

This will raise if and only if the value of this Byte_units.t can not be represented as an int. This can only happen on platforms where int is less than 63 bits, specifically JS and 32-bit OCaml where this will raise if the number of bytes is outside of [-2^30,2^30).

val bytes_int63 : t -> Int63.t
val bytes_int64 : t -> Int64.t
val bytes_float : t -> Base.Float.t
val kilobytes : t -> Base.Float.t
val megabytes : t -> Base.Float.t
val gigabytes : t -> Base.Float.t
val terabytes : t -> Base.Float.t
val petabytes : t -> Base.Float.t
val exabytes : t -> Base.Float.t
val words : t -> Base.Float.t

Do not use, consider using words_int_exn instead. Alias for words_float

  • deprecated [since 2019-01] Use [words_int_exn] or [words_float] instead.
val words_int_exn : t -> Base.Int.t

In JS and on 32-bit OCaml this will raise if and only if the number of bytes is outside of [-2^32,2^32).

val words_float : t -> Base.Float.t
val zero : t
val min_value : t
val max_value : t
val scale : t -> Base.Float.t -> t

scale t mul scale the measure t by mul

val arg_type : t Command.Arg_type.t
module Infix : sig ... end
include module type of Infix
val (-) : t -> t -> t
val (+) : t -> t -> t
val (/) : t -> Base.Float.t -> t

( / ) t mul scales t by 1/mul

val (//) : t -> t -> Base.Float.t

( // ) t1 t2 returns the ratio of t1 to t2

include Quickcheckable.S with type t := t
val quickcheck_generator : t Base_quickcheck.Generator.t
val quickcheck_observer : t Base_quickcheck.Observer.t
val quickcheck_shrinker : t Base_quickcheck.Shrinker.t
module Stable : sig ... end
OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct