- README

- Top Level Namespace
- ArgumentError
- Array
- Atomic
- Base64
  - Error
- Benchmark
  - BM
    - Job
    - Tms
  - IPS
    - Entry
    - Job
- BigFloat
- BigInt
- BigRational
- BitArray
- Bool
- Box
- Bytes
- Channel
  - Buffered
  - ClosedError
  - ReceiveAction
  - SelectAction
  - SendAction
  - Unbuffered
- Char
  - Reader
- Class
- Colorize
  - Object
  - ObjectExtensions
- Comparable
- Complex
- Concurrent
  - CanceledError
- Crypto
  - Bcrypt
    - Error
    - Password
  - Blowfish
  - MD5
    - Context
  - Subtle
- CSV
  - Builder
    - Row
  - Error
  - Lexer
  - MalformedCSVError
  - Parser
  - Row
  - Token
    - Kind
- Debug
  - DWARF
    - LineNumbers
      - Register
      - Row
      - Sequence
    - LNE
    - LNS
  - ELF
    - Endianness
    - Error
    - Ident
    - Klass
    - Machine
    - OSABI
    - SectionHeader
      - Flags
      - Type
    - Type
- Deque
- Digest
  - SHA1
- Dir
- DivisionByZero
- DL
- ECR
- Enum
- Enumerable
  - EmptyError
- ENV
- Errno
- Exception
- Fiber
- File
  - Stat
- FileUtils
- Float
  - Primitive
- Float32
- Float64
- GC
  - Stats
- Hash
- HTML
- HTTP
  - Client
    - BodyType
    - Response
  - ComputedContentTypeHeader
  - Cookie
  - Cookies
  - DeflateHandler
  - ErrorHandler
  - Handler
    - Proc
  - Headers
  - LogHandler
  - Params
    - Builder
  - Request
  - Server
    - Context
    - RequestProcessor
    - Response
  - StaticFileHandler
    - DirectoryListing
  - WebSocket
  - WebSocketHandler
- Indexable
- IndexError
- INI
- Int
  - Primitive
  - Signed
  - Unsigned
- Int16
- Int32
- Int64
- Int8
- InvalidByteSequenceError
- IO
  - Buffered
  - ByteFormat
    - BigEndian
    - LittleEndian
    - NetworkEndian
    - SystemEndian
  - Delimited
  - EncodingOptions
  - EOFError
  - Error
  - FileDescriptor
  - Hexdump
  - Memory
  - MultiWriter
  - Seek
  - Sized
  - Timeout
- IPSocket
- Iterable
- Iterator
  - IteratorWrapper
  - Stop
- JSON
  - Any
  - ArrayBuilder
  - Builder
  - Error
  - Lexer
  - ObjectBuilder
  - ParseException
  - Parser
  - PrettyWriter
  - PullParser
  - Token
  - Type
- KeyError
- Levenshtein
  - Finder
- LLVM
  - ABI
    - AArch64
    - ArgKind
    - ArgType
    - ARM
    - FunctionType
    - X86
    - X86_64
      - RegClass
  - AtomicOrdering
  - AtomicRMWBinOp
  - Attribute
  - BasicBlock
  - BasicBlockCollection
  - Builder
  - CallConvention
  - CodeGenFileType
  - CodeGenOptLevel
  - CodeModel
  - Context
  - DIBuilder
  - DwarfTag
  - DwarfTypeEncoding
  - Function
  - FunctionCollection
  - FunctionPassManager
    - Runner
  - GenericValue
  - GlobalCollection
  - InstructionCollection
  - IntPredicate
  - JITCompiler
  - Linkage
  - MemoryBuffer
  - Module
  - ModulePassManager
  - ParameterCollection
  - PassManagerBuilder
  - PassRegistry
  - PhiTable
  - RealPredicate
  - RelocMode
  - Target
  - TargetData
  - TargetMachine
  - Type
    - Kind
  - Value
  - ValueMethods
  - VerifierFailureAction
- Logger
  - Formatter
  - Severity
- Markdown
  - HTMLRenderer
  - Parser
    - PrefixHeader
    - UnorderedList
  - Renderer
- Math
- MemoryIO
- Mutex
- NamedTuple
- Nil
- Number
  - Primitive
- OAuth
  - AccessToken
  - Consumer
  - Error
  - RequestToken
- OAuth2
  - AccessToken
    - Bearer
    - Mac
  - Client
  - Error
  - Session
- Object
- OpenSSL
  - Digest
    - Error
    - UnsupportedError
  - DigestBase
  - Error
  - HMAC
  - MD5
  - SHA1
  - SSL
    - Context
      - Client
      - Server
    - Error
    - ErrorType
    - Modes
    - Options
    - Socket
      - Client
      - Server
    - VerifyMode
    - X509VerifyFlags
  - X509
    - Certificate
    - Extension
    - Name
- OptionParser
  - Exception
  - InvalidOption
  - MissingOption
- PartialComparable
- Pointer
  - Appender
- PrettyPrint
- Proc
- Process
  - Env
  - Status
  - Stdio
  - Tms
- Random
  - MT19937
- Range
- Readline
  - CompletionProc
  - KeyBindingProc
- Reference
- Regex
  - MatchData
  - Options
- SecureRandom
- Set
- Signal
- Slice
- Socket
  - Address
  - Addrinfo
  - Error
  - Family
  - IPAddress
  - Protocol
  - Server
  - Type
  - UNIXAddress
- Spec
  - Expectations
  - Methods
  - ObjectExtensions
- StaticArray
- String
  - Builder
  - RawConverter
- StringPool
- StringScanner
- Struct
- Symbol
- System
- TCPServer
- TCPSocket
- Tempfile
- Termios
  - AttributeSelection
  - BaudRate
  - ControlMode
  - InputMode
  - LineControl
  - LocalMode
  - OutputMode
- Time
  - DayOfWeek
  - EpochConverter
  - EpochMillisConverter
  - Format
    - Error
  - Kind
  - MonthSpan
  - Span
- Tuple
- TypeCastError
- UDPSocket
- UInt16
- UInt32
- UInt64
- UInt8
- Unicode
  - CaseOptions
- Union
- UNIXServer
- UNIXSocket
- URI
  - Error
- Value
- XML
  - Attributes
  - AttributeType
  - Error
  - HTMLParserOptions
  - Namespace
  - Node
  - NodeSet
  - ParserOptions
  - Reader
  - SaveOptions
  - Type
  - XPathContext
- YAML
  - Any
  - Emitter
  - Error
  - EventKind
  - ParseException
  - Parser
  - PullParser
  - Type
- Zlib
  - Deflate
  - Error
  - Inflate

# 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:

## Class Method Summary

- .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)

  Equality.

- #[]=(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)

  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.

### Instance methods inherited from module `Comparable(Deque(T))`

<(other : T) <, <=(other : T) <=, <=>(other : T) <=>, ==(other : T) ==, >(other : T) >, >=(other : T) >=

### Instance methods inherited from module `Indexable(T)`

[](index : Int) [], []?(index : Int) []?, at(index : Int, &block)
at(index : Int) at, bsearch(&block) bsearch, bsearch_index(&block) bsearch_index, each(&block)
each each, each_index(&block)
each_index each_index, empty? empty?, equals?(other, &block) equals?, first(&block)
first first, first? first?, hash hash, index(object, offset : Int = 0)
index(offset : Int = 0, &block) index, last
last(&block) last, last? last?, reverse_each(&block)
reverse_each reverse_each, rindex(offset = size - 1, &block)
rindex(value, offset = size - 1) rindex, sample(random = Random::DEFAULT) sample, size size, unsafe_at(index : Int) unsafe_at, values_at(*indexes : Int) values_at, zip(other : Indexable, &block)
zip(other : Indexable(U)) forall U zip, zip?(other : Indexable, &block)
zip?(other : Indexable(U)) forall U zip?

### Instance methods inherited from module `Enumerable(T)`

all?(&block)
all? all?, any?(&block)
any? any?, chunks(&block : T -> U) forall U chunks, compact_map(&block) compact_map, count(&block)
count(item) count, cycle(n, &block)
cycle(&block) cycle, each(&block : T -> _) each, each_cons(count : Int, reuse = false, &block) each_cons, each_slice(count : Int, reuse = false, &block) each_slice, each_with_index(offset = 0, &block) each_with_index, each_with_object(obj, &block) each_with_object, find(if_none = nil, &block) find, first(count : Int)
first first, first? first?, flat_map(&block : T -> Array(U) | U) forall U flat_map, grep(pattern) grep, group_by(&block : T -> U) forall U group_by, in_groups_of(size : Int, filled_up_with : U = nil) forall U
in_groups_of(size : Int, filled_up_with : U = nil, reuse = false, &block) forall U in_groups_of, includes?(obj) includes?, index(&block)
index(obj) index, index_by(&block : T -> U) forall U index_by, join(separator, io)
join(separator = "")
join(separator, io, &block)
join(separator = "", &block) join, map(&block : T -> U) forall U map, map_with_index(&block : T, Int32 -> U) map_with_index, max max, max? max?, max_by(&block : T -> U) forall U max_by, max_by?(&block : T -> U) forall U max_by?, max_of(&block : T -> U) forall U max_of, max_of?(&block : T -> U) forall U max_of?, min min, min? min?, min_by(&block : T -> U) forall U min_by, min_by?(&block : T -> U) forall U min_by?, min_of(&block : T -> U) forall U min_of, min_of?(&block : T -> U) forall U min_of?, minmax minmax, minmax? minmax?, minmax_by(&block : T -> U) forall U minmax_by, minmax_by?(&block : T -> U) forall U minmax_by?, minmax_of(&block : T -> U) forall U minmax_of, minmax_of?(&block : T -> U) forall U minmax_of?, none?(&block)
none? none?, one?(&block) one?, partition(&block) partition, product(&block)
product(initial : Number, &block)
product
product(initial : Number) product, reduce(&block)
reduce(memo, &block) reduce, reject(&block : T -> ) reject, select(&block : T -> ) select, size size, skip(count : Int) skip, skip_while(&block) skip_while, sum(initial)
sum
sum(initial, &block)
sum(&block) sum, take_while(&block) take_while, to_a to_a, to_h to_h, to_set to_set

### Instance methods inherited from module `Iterable(T)`

chunk(reuse = false, &block : T -> U) forall U chunk, cycle(n)
cycle cycle, each each, each_cons(count : Int, reuse = false) each_cons, each_slice(count : Int, reuse = false) each_slice, each_with_index(offset = 0) each_with_index, each_with_object(obj) each_with_object

### Instance methods inherited from class `Reference`

==(other : self)
==(other) ==, dup dup, hash hash, inspect(io : IO) : Nil inspect, object_id : UInt64 object_id, pretty_print(pp) : Nil pretty_print, same?(other : Reference)
same?(other : Nil) same?, to_s(io : IO) : Nil to_s

### Class methods inherited from class `Reference`

new new

### Instance methods inherited from class `Object`

!=(other) !=, !~(other) !~, ==(other) ==, ===(other : JSON::Any)
===(other : YAML::Any)
===(other) ===, =~(other) =~, class class, dup dup, hash hash, inspect(io : IO)
inspect inspect, itself itself, not_nil! not_nil!, pretty_inspect(width = 79, newline = "\n", indent = 0) : String pretty_inspect, pretty_print(pp : PrettyPrint) : Nil pretty_print, tap(&block) tap, to_json to_json, to_pretty_json(indent : String = " ")
to_pretty_json(io : IO, indent : String = " ") to_pretty_json, to_s
to_s(io : IO) to_s, to_yaml(io : IO)
to_yaml to_yaml, try(&block) try

### Class methods inherited from class `Object`

==(other : Class) ==, ===(other) ===, cast(other) : self cast, clone clone, dup dup, from_json(string_or_io, root : String) : self
from_json(string_or_io) : self from_json, from_yaml(string_or_io) : self from_yaml, hash hash, inspect(io) inspect, name : String name, nilable? nilable?, to_s(io) to_s, |(other : U.class) forall U |

## Class Method Detail

def self.new(size : Int, value : T) #

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

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

def self.new(initial_capacity : Int) #

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

The `initial_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

def self.new(array : Array(T)) #

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

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

def self.new #

Creates a new empty Deque

def self.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.

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

## Instance Method Detail

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

Concatenation. Returns a new Deque 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.

def <<(value : T) #

Alias for `#push`.

def ==(other : Deque) #

Equality. Returns true if it is passed a Deque and `equals?` returns true 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

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

Sets the given value at the given index.

Raises `IndexError` if the deque had no previous value at the given index.

def clear #

Removes all elements from self.

def clone #

Returns a new Deque 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.

def concat(other : Enumerable(T)) #

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

def delete(obj) #

Removes all items from `self` that are equal to obj.

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

def delete_at(index : Int) #

Delete the item that is present at the index. Items to the right of this one will have their indices decremented. Raises `IndexError` if trying to delete an element outside the deque's range.

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

def dup #

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

def each(&block) #

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

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

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

Insert a new item before the item at index. 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}

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

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

def pop #

Removes and returns the last item. Raises `IndexError` if empty.

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

def pop(&block) #

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

def pop? #

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

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

Adds an item to the end of the deque.

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

def rotate!(n : Int = 1) #

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

For positive n, equivalent to `n.times { push(shift) }`. For negative n, equivalent to `(-n).times { unshift(pop) }`.

def shift(&block) #

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

def shift(n : Int) #

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

def shift #

Removes and returns the first item. Raises `IndexError` if empty.

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

def shift? #

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

def size #

Returns the number of elements in the deque.

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

def swap(i, j) #

Swaps the items at the indices i and j.

def to_a #

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

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

Adds an item to the beginning of the deque.

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