Returns the additive identity of this type.

This is an empty deque.

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

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

Creates a newDeque that copies its items from an Array.

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

Creates a new emptyDeque backed by a buffer that is initiallyinitial_capacity big.

Theinitial_capacity is useful to avoid unnecessary reallocations of the internal buffer in case of growth. If you have an estimate of the maximum number of elements a deque will hold, you should initialize it with that capacity for improved execution performance.

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

Creates a new empty Deque

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

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

Concatenation. Returns a newDeque built by concatenating two deques together to create a third. The type of the new deque is the union of the types of both the other deques.

Alias for#push.

Returnstrue if it is passed aDeque andequals? returnstrue for both deques, the caller and the argument.

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

Removes all elements fromself.

Returns a newDeque that has this deque's elements cloned. That is, it returns a deep copy of this deque.

Use#dup if you want a shallow copy.

Appends the elements ofother toself, and returnsself.

deq = Deque{"a", "b"}
deq.concat(Deque{"c", "d"})
deq # => Deque{"a", "b", "c", "d"}

Removes all items fromself that are equal toobj.

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

Deletes the item that is present at theindex. Items to the right of this one will have their indices decremented. RaisesIndexError if trying to delete an element outside the deque's range.

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

Returns a newDeque that has exactly this deque's elements. That is, it returns a shallow copy of this deque.

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

Do not modify the deque while using this variant of#each!

Insert a new item before the item atindex. Items to the right of this one will have their indices incremented.

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

Appends a String representation of this object which includes its class name, its object address and the values of all instance variables.

class Person
  def initialize(@name : String, @age : Int32)
  end
end

Person.new("John", 32).inspect # => #<Person:0x10fd31f20 @name="John", @age=32>

Removes the lastn (at most) items in the deque.

Removes and returns the last item. RaisesIndexError if empty.

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

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

Removes and returns the last item, if not empty, otherwisenil.

Adds an item to the end of the deque.

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

Modifiesself, deleting the elements in the collection for which the passed block is truthy. Returnsself.

a = Deque{1, 6, 2, 4, 8}
a.reject! { |x| x > 3 }
a # => Deque{1, 2}

See also:Deque#reject.

Modifiesself, deleting the elements in the collection for which pattern === element.

a = Deque{1, 6, 2, 4, 8}
a.reject!(3..7)
a # => Deque{1, 2, 8}

See also:Deque#reject.

Shifts all elements ofself to the leftn times. Returnsself.

a1 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
a2 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
a3 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

a1.rotate!
a2.rotate!(1)
a3.rotate!(3)

a1 # => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
a2 # => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
a3 # => [3, 4, 5, 6, 7, 8, 9, 0, 1, 2]

Modifiesself, keeping only the elements in the collection for which the passed block is truthy. Returnsself.

a = Deque{1, 6, 2, 4, 8}
a.select! { |x| x > 3 }
a # => Deque{6, 4, 8}

See also:Deque#select.

Modifiesself, keeping only the elements in the collection for which pattern === element.

ary = [1, 6, 2, 4, 8]
ary.select!(3..7)
ary # => [6, 4]

See also:Deque#select.

Removes the firstn (at most) items in the deque.

Removes and returns the first item. RaisesIndexError if empty.

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

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

Removes and returns the first item, if not empty, otherwisenil.

Returns the number of elements in the deque.

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

Appends a short String representation of this object which includes its class name and its object address.

class Person
  def initialize(@name : String, @age : Int32)
  end
end

Person.new("John", 32).to_s # => #<Person:0x10a199f20>

Returns the element at the givenindex, without doing any bounds check.

Indexable makes sure to invoke this method withindex in0...size, so converting negative indices to positive ones is not needed here.

Clients never invoke this method directly. Instead, they access elements with#[](index) and#[]?(index).

This method should only be directly invoked if you are absolutely sure the index is in bounds, to avoid a bounds check for a small boost of performance.

Sets the element at the givenindex tovalue, without doing any bounds check.

Indexable::Mutable makes sure to invoke this method withindex in 0...size, so converting negative indices to positive ones is not needed here.

Clients never invoke this method directly. Instead, they modify elements with#[]=(index, value).

This method should only be directly invoked if you are absolutely sure the index is in bounds, to avoid a bounds check for a small boost of performance.

Adds an item to the beginning of the deque.

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