# Module Linked_queue

    module Linked_queue: sig .. end

Linked_queue is a wrapper around OCaml's standard Queue module that follows Core idioms and adds some functions.

Differences from the standard module: `enqueue` replaces `push`, `add`, and takes the queue first. `dequeue` replaces `pop`, `take`, takes the queue first, and returns an option rather than raising `Empty`. `dequeue_exn` is available if you want to raise `Empty`. `iter` takes a labeled argument. `transfer`'s arguments are labeled.

    type 'a t

    include Container.S1

    val create : unit -> 'a t

`create ()` returns an empty queue.

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

`enqueue t x` adds `x` to the end of `t`.

    val dequeue : 'a t -> 'a option

`dequeue t` returns `None` if `t` is empty, otherwise it removes and returns the front of `t`

    val dequeue_exn : 'a t -> 'a

    val peek : 'a t -> 'a option

`peek t` returns `None` if `t` is empty, otherwise it returns `Some x` where `x` is the front of `t`.

    val peek_exn : 'a t -> 'a

    val clear : 'a t -> unit

`clear t` discards all elements from `t`.

    val copy : 'a t -> 'a t

`copy t` returns a copy of `t`.

    val filter_inplace : 'a t -> f:('a -> bool) -> unit

`filter_inplace t ~f` removes all elements of `t` that don't satisfy `f`.

    val transfer : src:'a t -> dst:'a t -> unit

`transfer ~src ~dst` adds all of the elements of `src` to the end of `dst`, then clears `src`. It is equivalent to the sequence:

          iter ~src ~f:(enqueue dst);
          clear src

but runs in constant time.

    val of_list : 'a list -> 'a t

`of_list list` returns a queue `t` with the elements of `list` in the same order as the elements of `list` (i.e. the first element of `t` is the first element of the list).

    val to_list : 'a t -> 'a list

    val partial_iter : 'a t -> f:('a -> [ `Continue | `Stop ]) -> unit

`partial_iter t ~f` iterates through t until f returns `Stop

    val map : 'a t -> f:('a -> 'b) -> 'b t

    val concat_map : 'a t -> f:('a -> 'b list) -> 'b t

    val filter_map : 'a t -> f:('a -> 'b option) -> 'b t

    val filter : 'a t -> f:('a -> bool) -> 'a t

    val of_array : 'a array -> 'a t

    val to_array : 'a t -> 'a array

    val fold : 'a t -> init:'b -> f:('b -> 'a -> 'b) -> 'b

    val singleton : 'a -> 'a t

    val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t

    val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t

    val bin_t : 'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t

    val bin_read_t : 'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader

    val __bin_read_t__ : 'a Bin_prot.Read.reader -> (int -> 'a t) Bin_prot.Read.reader

    val bin_reader_t : 'a Bin_prot.Type_class.reader -> 'a t Bin_prot.Type_class.reader

    val bin_size_t : 'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer

    val bin_write_t : 'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer

    val bin_writer_t : 'a Bin_prot.Type_class.writer -> 'a t Bin_prot.Type_class.writer

`create ()` returns an empty queue.
`enqueue t x` adds `x` to the end of `t`.
`dequeue t` returns `None` if `t` is empty, otherwise it removes and returns the front of `t`
`peek t` returns `None` if `t` is empty, otherwise it returns `Some x` where `x` is the front of `t`.
`clear t` discards all elements from `t`.
`copy t` returns a copy of `t`.
`filter_inplace t ~f` removes all elements of `t` that don't satisfy `f`.
`transfer ~src ~dst` adds all of the elements of `src` to the end of `dst`, then clears `src`. It is equivalent to the sequence:

          iter ~src ~f:(enqueue dst);
          clear src

but runs in constant time.
`of_list list` returns a queue `t` with the elements of `list` in the same order as the elements of `list` (i.e. the first element of `t` is the first element of the list).
`partial_iter t ~f` iterates through t until f returns `Stop