package core

  1. Overview
  2. Docs
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.