package core

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

A simple polymorphic functional queue. Use this data structure for strictly first-in, first-out access to a sequence of values. For a similar data structure with enqueue and dequeue accessors on both ends of a sequence, see Core.Fdeque.

Amortized running times assume that enqueue/dequeue are used sequentially, threading the changing Fqueue through the calls.

type 'a t
include Bin_prot.Binable.S1 with type 'a t := 'a t
val bin_shape_t : Bin_prot__.Shape.t -> Bin_prot__.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot__.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot__.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot__.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot__.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot__.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot__.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot__.Type_class.S1.t
include Ppx_compare_lib.Comparable.S1 with type 'a t := 'a t
val compare : 'a Base__Ppx_compare_lib.compare -> 'a t Base__Ppx_compare_lib.compare
include Ppx_compare_lib.Equal.S1 with type 'a t := 'a t
val equal : 'a Base__Ppx_compare_lib.equal -> 'a t Base__Ppx_compare_lib.equal
include Ppx_hash_lib.Hashable.S1 with type 'a t := 'a t
val hash_fold_t : 'a Base__Ppx_hash_lib.hash_fold -> 'a t Base__Ppx_hash_lib.hash_fold
include Sexplib0.Sexpable.S1 with type 'a t := 'a t
val t_of_sexp : (Sexplib0__.Sexp.t -> 'a) -> Sexplib0__.Sexp.t -> 'a t
val sexp_of_t : ('a -> Sexplib0__.Sexp.t) -> 'a t -> Sexplib0__.Sexp.t
val mem : 'a t -> 'a -> equal:('a -> 'a -> bool) -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold : 'a t -> init:'acc -> f:('acc -> 'a -> 'acc) -> 'acc
val fold_result : 'a t -> init:'acc -> f:('acc -> 'a -> ('acc, 'e) Base__.Result.t) -> ('acc, 'e) Base__.Result.t
val fold_until : 'a t -> init:'acc -> f:('acc -> 'a -> ('acc, 'final) Base__Container_intf.Continue_or_stop.t) -> finish:('acc -> 'final) -> 'final
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum : (module Base__Container_intf.Summable with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_array : 'a t -> 'a array
val min_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
val invariant : 'a Base__Invariant_intf.inv -> 'a t Base__Invariant_intf.inv
val (>>=) : 'a t -> ('a -> 'b t) -> 'b t
val (>>|) : 'a t -> ('a -> 'b) -> 'b t
module Monad_infix : sig ... end
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val return : 'a -> 'a t
val map : 'a t -> f:('a -> 'b) -> 'b t
val join : 'a t t -> 'a t
val ignore_m : 'a t -> unit t
val all : 'a t list -> 'a list t
val all_unit : unit t list -> unit t
module Let_syntax : sig ... end
val empty : 'a t

The empty queue.

val enqueue : 'a t -> 'a -> 'a t

enqueue t x returns a queue with adds x to the end of t. Complexity: O(1).

val peek_exn : 'a t -> 'a

Returns the front (least recently enqueued) element. Raises Empty if no element is found. Complexity: O(1).

val top_exn : 'a t -> 'a
  • deprecated [since 2019-11] Use [peek_exn] instead.
val peek : 'a t -> 'a Base.Option.t

Like peek_exn, but returns its result optionally, without exception. Complexity: O(1).

val top : 'a t -> 'a Base.Option.t
  • deprecated [since 2019-11] Use [peek] instead.
val dequeue_exn : 'a t -> 'a * 'a t

dequeue_exn t removes and returns the front of t, raising Empty if t is empty. Complexity: amortized O(1).

val dequeue : 'a t -> ('a * 'a t) Base.Option.t

Like dequeue_exn, but returns result optionally, without exception. Complexity: amortized O(1).

val drop_exn : 'a t -> 'a t

Returns version of queue with front element removed. Complexity: amortized O(1).

val discard_exn : 'a t -> 'a t
  • deprecated [since 2019-11] Use [drop_exn] instead.
val to_list : 'a t -> 'a Base.List.t

to_list t returns a list of the elements in t in order from least-recently-added (at the head) to most-recently-added (at the tail). Complexity: O(n).

val of_list : 'a Base.List.t -> 'a t

of_list is the inverse of to_list. Complexity: O(n).

val to_sequence : 'a t -> 'a Sequence.t

to_sequence returns a Sequence.t of the elements in t in order from from least-recently-added (at the head) to most-recently-added (at the tail). Complexity (if the sequence is fully traversed): O(n).

to_list t = Sequence.to_list (to_sequence t)
val of_sequence : 'a Sequence.t -> 'a t

of_sequence is the inverse of to_sequence. Complexity (if the sequence is fully traversed): O(n).

val length : 'a t -> Base.Int.t

Complexity: O(1).

val is_empty : 'a t -> Base.Bool.t

Complexity: O(1).

val singleton : 'a -> 'a 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