class Deque(T)

• Deque(T)
• Reference
• Object

Overview

A Deque ("double-ended queue") is a collection of objects of type T that behaves much like an Array.

Deque has a subset of Array's API. It performs better than an Array when there are frequent insertions or deletions of items near the beginning or the end.

The most typical use case of a Deque is a queue: use #push to add items to the end of the queue and #shift to get and remove the item at the beginning of the queue.

This Deque is implemented with a dynamic array used as a circular buffer.

Included Modules

• Comparable(Deque(T))
• Indexable(T)

Defined in:

Constructors

• .new(size : Int, value : T)

  Creates a new Deque of the given size filled with the same value in each position.

• .new(initial_capacity : Int)

  Creates a new empty Deque backed by a buffer that is initially initial_capacity big.

• .new(array : Array(T))

  Creates a new Deque that copies its items from an Array.

• .new

  Creates a new empty Deque

• .new(size : Int, &block : Int32 -> T)

  Creates a new Deque of the given size and invokes the block once for each index of the deque, assigning the block's value in that index.

Instance Method Summary

• #+(other : Deque(U)) forall U

  Concatenation.

• #<<(value : T)

  Alias for #push.

• #==(other : Deque)

  Returns true if it is passed a Deque and equals? returns true for both deques, the caller and the argument.

• #[]=(index : Int, value : T)

  Sets the given value at the given index.

• #clear

  Removes all elements from self.

• #clone

  Returns a new Deque that has this deque's elements cloned.

• #concat(other : Enumerable(T))

  Appends the elements of other to self, and returns self.

• #delete(obj)

  Removes all items from self that are equal to obj.

• #delete_at(index : Int)

  Delete the item that is present at the index.

• #dup

  Returns a new Deque that has exactly this deque's elements.

• #each(&block) : Nil

  Yields each item in this deque, from first to last.

• #insert(index : Int, value : T)

  Insert a new item before the item at index.

• #inspect(io : IO)
• #pop(n : Int)

  Removes the last n (at most) items in the deque.

• #pop

  Removes and returns the last item.

• #pop(&block)

  Removes and returns the last item, if not empty, otherwise executes the given block and returns its value.

• #pop?

  Removes and returns the last item, if not empty, otherwise nil.

• #pretty_print(pp)
• #push(value : T)

  Adds an item to the end of the deque.

• #rotate!(n : Int = 1)

  Rotates this deque in place so that the element at n becomes first.

• #shift(&block)

  Removes and returns the first item, if not empty, otherwise executes the given block and returns its value.

• #shift(n : Int)

  Removes the first n (at most) items in the deque.

• #shift

  Removes and returns the first item.

• #shift?

  Removes and returns the first item, if not empty, otherwise nil.

• #size

  Returns the number of elements in the deque.

• #swap(i, j)

  Swaps the items at the indices i and j.

• #to_a

  Returns an Array (shallow copy) that contains all the items of this deque.

• #to_s(io : IO)
• #unsafe_at(index : Int)
• #unshift(value : T)

  Adds an item to the beginning of the deque.

Constructor Detail

Deque.new(3, 'a') # => Deque{'a', 'a', 'a'}

deq = Deque(Int32).new(5)
deq.size # => 0

Deque.new([1, 2, 3]) # => Deque{1, 2, 3}

Deque.new(3) { |i| (i + 1) ** 2 } # => Deque{1, 4, 9}

Instance Method Detail

deq = Deque{2, 3}
deq.unshift 1
deq == Deque{1, 2, 3} # => true
deq == Deque{2, 3}    # => false

a = Deque{"a", "b", "b", "b", "c"}
a.delete("b") # => true
a             # => Deque{"a", "c"}

a = Deque{1, 2, 3}
a.delete_at(1) # => 2
a              # => Deque{1, 3}

a = Deque{0, 1, 2}
a.insert(1, 7) # => Deque{0, 7, 1, 2}

a = Deque{1, 2, 3}
a.pop # => 3
a     # => Deque{1, 2}

a = Deque{1, 2}
a.push 3 # => Deque{1, 2, 3}

a = Deque{1, 2, 3}
a.shift # => 1
a       # => Deque{2, 3}

Deque{:foo, :bar}.size # => 2

a = Deque{1, 2}
a.unshift 0 # => Deque{0, 1, 2}