2 Deques

8.17.0.4

2 Deques🔗ℹ

Double ended queues (or deque) are queues where elements can be added or removed from either end. The deque data structures provided by this library implement and provide the following operations: deque, empty?, enqueue, enqueue-front, head, tail, last, init and deque->list.

2.1 Bankers Deque

2.2 Implicit Deque

2.3 Real-Time Deque

2.1 Bankers Deque🔗ℹ

(require pfds/deque/bankers)

package: pfds

Bankers deques are amortized double ended deques developed using the Bankers method. They provide an amortized running time of O(1) for the operations head, tail, last, init, enqueue-front and enqueue. They use lazy evaluation and memoization to achieve the amortized running time.

syntax
(Deque A)

A banker’s deque of type A.

procedure
(deque a ...) → (Deque A)
a : A

Function deque creates a Bankers Deque with the given inputs.

Example:

> (deque 1 2 3 4 5 6)
- : #(struct:Deque
      ((Rec
        g298183
        (U (Pairof Positive-Byte g298183) (Promiseof g298183) Null))
       Integer
       (Rec
        g298185
        (U (Pairof Positive-Byte g298185) (Promiseof g298185) Null))
       Integer))
#<Deque>

In the above example, the deque obtained will have 1 as its head element.

procedure
(empty t) → (Deque A)
t : A

An empty deque of type t.

Examples:

> (empty Nothing)
- : (Deque Nothing)
#<Deque>
> (empty Integer)
- : (Deque Integer)
#<Deque>

procedure
(empty? dq) → Boolean
dq : (Deque A)

Function empty? checks if the given deque is empty.

Examples:

> (empty? (empty Natural))
- : Boolean
#t
> (empty? (deque 1 2))
- : Boolean
#f

procedure
(enqueue a deq) → (Deque A)
a : A
deq : (Deque A)

Function enqueue takes an element and a deque and enqueues the given element in the deque.

Example:

> (enqueue 10 (deque 3 2 4))
- : #(struct:Deque
      ((Rec
        g298255
        (U (Pairof Positive-Byte g298255) (Promiseof g298255) Null))
       Integer
       (Rec
        g298257
        (U (Pairof Positive-Byte g298257) (Promiseof g298257) Null))
       Integer))
#<Deque>

In the above example, (enqueue 10 deq) adds the element 10 to (deque 3 2 4). 10 will be the last element in the deque.

procedure
(enqueue-front a deq) → (Deque A)
a : A
deq : (Deque A)

Function enqueue-front takes an element and a deque and puts the given element to the front of the given deque.

Example:

> (enqueue-front 10 (deque 5 6 3 4))
- : #(struct:Deque
      ((Rec
        g298276
        (U (Pairof Positive-Byte g298276) (Promiseof g298276) Null))
       Integer
       (Rec
        g298278
        (U (Pairof Positive-Byte g298278) (Promiseof g298278) Null))
       Integer))
#<Deque>

In the above example, (enqueue-front 10 (deque 5 6 3 4)) adds 10 to the front of the (deque 5 6 3 4). 10 will be the head element.

procedure
(head deq) → A
deq : (Deque A)

Function head takes a deque and gives the first element in the deque if deque is not empty else throws an error.

Examples:

> (head (deque 5 2 3))
- : Integer [more precisely: Positive-Byte]
5
> (head (empty Integer))
head: given deque is empty

In the above example, (head (empty Integer)) throws an error since the given deque is empty.

procedure
(last deq) → A
deq : (Deque A)

Function last takes a deque and gives the last element in the deque if deque is not empty else throws an error.

Examples:

> (last (deque 1 2 3 4 5 6))
- : Integer [more precisely: Positive-Byte]
6
> (last (empty Integer))
last: given deque is empty

In the above example, (last (empty Integer))throws an error since the given deque is empty.

procedure
(tail deq) → (Deque A)
deq : (Deque A)

Function tail takes a deque and returns the given deque without the first element if the given deque is non empty else throws an error.

Examples:

> (tail (deque 1 2 3 4 5 6))
- : #(struct:Deque
      ((Rec
        g298370
        (U (Pairof Positive-Byte g298370) (Promiseof g298370) Null))
       Integer
       (Rec
        g298372
        (U (Pairof Positive-Byte g298372) (Promiseof g298372) Null))
       Integer))
#<Deque>
> (tail (empty Integer))
tail: given deque is empty

In the above example, (tail (deque 1 2 3 4 5 6)), removes the head of the given deque returns (deque 2 3 4 5 6).

procedure
(init deq) → (Deque A)
deq : (Deque A)

Function init takes a deque and returns the given deque without the last element if the given deque is not empty else throws an error.

Examples:

> (init (deque 1 2 3 4 5 6))
- : #(struct:Deque
      ((Rec
        g298413
        (U (Pairof Positive-Byte g298413) (Promiseof g298413) Null))
       Integer
       (Rec
        g298415
        (U (Pairof Positive-Byte g298415) (Promiseof g298415) Null))
       Integer))
#<Deque>
> (init (empty Integer))
init: given deque is empty

In the above example, (init (deque 1 2 3 4 5 6)), removes the last element 6 and returns (deque 1 2 3 4 5).

procedure
(deque->list deq) → (Listof A)
deq : (Deque A)

Function deque->list takes a deque and returns a list of elements. The list will have head of the given deque as its first element. If the given deque is empty, then it returns an empty list.

Examples:

> (deque->list (deque 10 2 34 4 15 6))
- : (Listof Positive-Byte)
'(10 2 34 4 15 6)
> (deque->list (empty Integer))
- : (Listof Integer)
'()

procedure
(map func deq1 deq2 ...) → (Deque A)
  func : (A B ... B -> C)
  deq1 : (Deque A)
  deq2 : (Deque B)

Function map is similar to map for lists.

Examples:

> (deque->list (map add1 (deque 1 2 3 4 5 6)))
- : (Listof Positive-Index)
'(2 3 4 5 6 7)
> (deque->list (map * (deque 1 2 3 4 5 6) (deque 1 2 3 4 5 6)))
- : (Listof Positive-Index)
'(1 4 9 16 25 36)

procedure
(foldl func init deq1 deq2 ...) → C
  func : (C A B ... B -> C)
  init : C
  deq1 : (Deque A)
  deq2 : (Deque B)

Function foldl is similar to foldl

foldl currently does not produce correct results when the given function is non-commutative.

Examples:

> (foldl + 0 (deque 1 2 3 4 5 6))
- : Integer [more precisely: Nonnegative-Integer]
21
> (foldl * 1 (deque 1 2 3 4 5 6) (deque 1 2 3 4 5 6))
- : Integer [more precisely: Positive-Integer]
518400

procedure
(foldr func init deq1 deq2 ...) → C
  func : (C A B ... B -> C)
  init : C
  deq1 : (Deque A)
  deq2 : (Deque B)

Function foldr is similar to foldr

foldr currently does not produce correct results when the given function is non-commutative.

Examples:

> (foldr + 0 (deque 1 2 3 4 5 6))
- : Integer [more precisely: Nonnegative-Integer]
21
> (foldr * 1 (deque 1 2 3 4 5 6) (deque 1 2 3 4 5 6))
- : Integer [more precisely: Positive-Integer]
518400

procedure
(filter func que) → (Deque A)
func : (A -> Boolean)
que : (Deque A)

Function filter is similar to filter.

Examples:

> (define que (deque 1 2 3 4 5 6))
> (deque->list (filter (λ: ([x : Integer]) (> x 5)) que))
- : (Listof Positive-Byte)
'(6)
> (deque->list (filter (λ: ([x : Integer]) (< x 5)) que))
- : (Listof Positive-Byte)
'(1 2 3 4)
> (deque->list (filter (λ: ([x : Integer]) (<= x 5)) que))
- : (Listof Positive-Byte)
'(1 2 3 4 5)

procedure
(remove func que) → (Deque A)
func : (A -> Boolean)
que : (Deque A)

Function remove is similar to filter but remove removes the elements which match the predicate.

Examples:

> (deque->list (remove (λ: ([x : Integer]) (> x 5))
                       (deque 1 2 3 4 5 6)))
- : (Listof Positive-Byte)
'(1 2 3 4 5)
> (deque->list (remove (λ: ([x : Integer]) (< x 5))
                       (deque 1 2 3 4 5 6)))
- : (Listof Positive-Byte)
'(5 6)
> (deque->list (remove (λ: ([x : Integer]) (<= x 5))
                       (deque 1 2 3 4 5 6)))
- : (Listof Positive-Byte)
'(6)

procedure
(andmap func deq1 deq2 ...) → Boolean
  func : (A B ... B -> Boolean)
  deq1 : (Deque A)
  deq2 : (Deque B)

Function andmap is similar to andmap.

Examples:

> (andmap even? (deque 1 2 3 4 5 6))
- : Boolean
#f
> (andmap odd? (deque 1 2 3 4 5 6))
- : Boolean
#f
> (andmap positive? (deque 1 2 3 4 5 6))
- : Boolean
#t
> (andmap negative? (deque -1 -2))
- : Boolean
#t

procedure
(ormap func deq1 deq2 ...) → Boolean
  func : (A B ... B -> Boolean)
  deq1 : (Deque A)
  deq2 : (Deque B)

Function ormap is similar to ormap.

Examples:

> (ormap even? (deque 1 2 3 4 5 6))
- : Boolean
#t
> (ormap odd? (deque 1 2 3 4 5 6))
- : Boolean
#t
> (ormap positive? (deque -1 -2 3 4 -5 6))
- : Boolean
#t
> (ormap negative? (deque 1 -2))
- : Boolean
#t

procedure
(build-deque size func) → (Deque A)
size : Natural
func : (Natural -> A)

Function build-deque is similar to build-list.

Examples:

> (deque->list (build-deque 5 (λ:([x : Integer]) (add1 x))))
- : (Listof Integer)
'(1 2 3 4 5)
> (deque->list (build-deque 5 (λ:([x : Integer]) (* x x))))
- : (Listof Integer)
'(0 1 4 9 16)

procedure
(head+tail deq) → (Pair A (Deque A))
deq : (Deque A)

Function head+tail returns a pair containing the head and the tail of the given deque.

Examples:

> (head+tail (deque 1 2 3 4 5))
- : (Pairof
     Positive-Byte
     #(struct:Deque
       ((Rec
         g299087
         (U (Pairof Positive-Byte g299087) (Promiseof g299087) Null))
        Integer
        (Rec
         g299089
         (U (Pairof Positive-Byte g299089) (Promiseof g299089) Null))
        Integer)))
'(1 . #<Deque>)
> (head+tail (build-deque 5 (λ:([x : Integer]) (* x x))))
- : (Pairof
     Integer
     #(struct:Deque
       ((Rec g299113 (U (Pairof Integer g299113) (Promiseof g299113) Null))
        Integer
        (Rec g299115 (U (Pairof Integer g299115) (Promiseof g299115) Null))
        Integer)))
'(0 . #<Deque>)
> (head+tail (empty Integer))
head+tail: given deque is empty

procedure
(last+init deq) → (Pair A (Deque A))
deq : (Deque A)

Function last+init returns a pair containing the last element and the init of the given deque.

Examples:

> (last+init (deque 1 2 3 4 5))
- : (Pairof
     Positive-Byte
     #(struct:Deque
       ((Rec
         g299156
         (U (Pairof Positive-Byte g299156) (Promiseof g299156) Null))
        Integer
        (Rec
         g299158
         (U (Pairof Positive-Byte g299158) (Promiseof g299158) Null))
        Integer)))
'(5 . #<Deque>)
> (last+init (build-deque 5 (λ:([x : Integer]) (* x x))))
- : (Pairof
     Integer
     #(struct:Deque
       ((Rec g299182 (U (Pairof Integer g299182) (Promiseof g299182) Null))
        Integer
        (Rec g299184 (U (Pairof Integer g299184) (Promiseof g299184) Null))
        Integer)))
'(16 . #<Deque>)
> (last+init (empty Integer))
last+init: given deque is empty

2.2 Implicit Deque🔗ℹ

(require pfds/deque/implicit)

package: pfds

Deques obtained by applying Implicit Recursive Slowdown. Provides amortized running time of O(1) for the operations head, tail, last, init, enqueue-front and enqueue. Implicit Recursive Slowdown combines laziness and technique called Recursive Slow-Down developed by Kaplan and Tarjan in their paper Persistant Lists with Catenation via Recursive Slow-Down.

syntax
(Deque A)

Implicit double ended queue of type A.

procedure
(deque a ...) → (Deque A)
a : A

Function deque creates a Implicit Deque with the given inputs.

Example:

> (deque 1 2 3 4 5 6)
- : (U (Deep Positive-Byte) (Shallow Positive-Byte))
#<Deep>

In the above example, the deque obtained will have 1 as its head element.

value
empty : (Deque Nothing)

An empty deque

procedure
(empty? dq) → Boolean
dq : (Deque A)

Function empty? checks if the given deque is empty or not.

Examples:

> (empty? (deque 1 2 3 4 5 6))
- : Boolean
#f
> (empty? empty)
- : Boolean
#t

procedure
(enqueue a deq) → (Deque A)
a : A
deq : (Deque A)

Function enqueue takes an element and a deque and enqueues the given element into the deque.

Example:

> (enqueue 10 (deque 1 2 3 4 5 6))
- : (U (Deep Positive-Byte) (Shallow Positive-Byte))
#<Deep>

In the above example, enqueue adds the element 10 to (deque 1 2 3 4 5 6 10).

procedure
(enqueue-front a deq) → (Deque A)
a : A
deq : (Deque A)

Function enqueue-front takes an element and a deque and puts the given element to the front of the given deque.

Example:

> (enqueue-front 10 (deque 5 6 3 4))
- : (U (Deep Positive-Byte) (Shallow Positive-Byte))
#<Deep>

In the above example, (enqueue-front 10 (deque 5 6 3 4)) adds 10 to the front of the (deque 5 6 3 4). 10 will be the head element.

procedure
(head deq) → A
deq : (Deque A)

Function head takes a deque and gives the first element in the deque if deque is not empty else throws an error.

Examples:

> (head (deque 1 2 3 4 5 6))
- : Integer [more precisely: Positive-Byte]
1
> (head empty)
head: given deque is empty

procedure
(last deq) → A
deq : (Deque A)

Function last takes a deque and gives the last element in the queue if deque is not empty else throws an error.

Examples:

> (last (deque 1 2 3 4 5 6))
- : Integer [more precisely: Positive-Byte]
6
> (last empty)
last: given deque is empty

procedure
(tail deq) → (Deque A)
deq : (Deque A)

Function tail takes a deque and returns a deque with rest elements if its a non empty deque else throws an error.

Examples:

> (tail (deque 1 2 3 4 5 6))
- : (U (Deep Positive-Byte) (Shallow Positive-Byte))
#<Deep>
> (tail empty)
tail: given deque is empty

In the above example, (tail (deque 1 2 3 4 5 6)), removes 1 and returns (tail (deque 2 3 4 5 6)).

procedure
(init deq) → (Deque A)
deq : (Deque A)

Function init takes a deque and returns a deque without the last element if its a non empty deque else throws an error.

Examples:

> (init (deque 1 2 3 4 5 6))
- : (U (Deep Positive-Byte) (Shallow Positive-Byte))
#<Deep>
> (init empty)
init: given deque is empty

In the above example, (init (deque 1 2 3 4 5 6)), removes the last element 6 and returns (deque 1 2 3 4 5)

procedure
(deque->list deq) → (Listof A)
deq : (Deque A)

Function deque->list takes a deque and returns a list of elements. The list will have head of the given deque as its first element. If the given deque is empty, then it returns an empty list.

Example:

> (deque->list (deque 10 2 34 4 15 6))
- : (Listof Positive-Byte)
'(10 2 34 4 15 6)

procedure
(map func deq1 deq2 ...) → (Deque A)
  func : (A B ... B -> C)
  deq1 : (Deque A)
  deq2 : (Deque B)

Function map is similar to map for lists.

Examples:

> (deque->list (map add1 (deque 1 2 3 4 5 6)))
- : (Listof Positive-Index)
'(2 3 4 5 6 7)
> (deque->list (map * (deque 1 2 3 4 5 6) (deque 1 2 3 4 5 6)))
- : (Listof Positive-Index)
'(1 4 9 16 25 36)

procedure
(foldl func init deq1 deq2 ...) → C
  func : (C A B ... B -> C)
  init : C
  deq1 : (Deque A)
  deq2 : (Deque B)

Function foldl is similar to foldl

foldl currently does not produce correct results when the given function is non-commutative.

Examples:

> (foldl + 0 (deque 1 2 3 4 5 6))
- : Integer [more precisely: Nonnegative-Integer]
21
> (foldl * 1 (deque 1 2 3 4 5 6) (deque 1 2 3 4 5 6))
- : Integer [more precisely: Positive-Integer]
518400

procedure
(foldr func init deq1 deq2 ...) → C
  func : (C A B ... B -> C)
  init : C
  deq1 : (Deque A)
  deq2 : (Deque B)

Function foldr is similar to foldr

foldr currently does not produce correct results when the given function is non-commutative.

Examples:

> (foldr + 0 (deque 1 2 3 4 5 6))
- : Integer [more precisely: Nonnegative-Integer]
21
> (foldr * 1 (deque 1 2 3 4 5 6) (deque 1 2 3 4 5 6))
- : Integer [more precisely: Positive-Integer]
518400

procedure
(filter func que) → (Deque A)
func : (A -> Boolean)
que : (Deque A)

Function filter is similar to filter.

Examples:

> (define que (deque 1 2 3 4 5 6))
> (deque->list (filter (λ: ([x : Integer]) (> x 5)) que))
- : (Listof Positive-Byte)
'(6)
> (deque->list (filter (λ: ([x : Integer]) (< x 5)) que))
- : (Listof Positive-Byte)
'(1 2 3 4)
> (deque->list (filter (λ: ([x : Integer]) (<= x 5)) que))
- : (Listof Positive-Byte)
'(1 2 3 4 5)

procedure
(remove func que) → (Deque A)
func : (A -> Boolean)
que : (Deque A)

Function remove is similar to filter but remove removes the elements which match the predicate.

Examples:

> (deque->list (remove (λ: ([x : Integer]) (> x 5))
                       (deque 1 2 3 4 5 6)))
- : (Listof Positive-Byte)
'(1 2 3 4 5)
> (deque->list (remove (λ: ([x : Integer]) (< x 5))
                       (deque 1 2 3 4 5 6)))
- : (Listof Positive-Byte)
'(5 6)
> (deque->list (remove (λ: ([x : Integer]) (<= x 5))
                       (deque 1 2 3 4 5 6)))
- : (Listof Positive-Byte)
'(6)

procedure
(andmap func deq1 deq2 ...) → Boolean
  func : (A B ... B -> Boolean)
  deq1 : (Deque A)
  deq2 : (Deque B)

Function andmap is similar to andmap.

Examples:

> (andmap even? (deque 1 2 3 4 5 6))
- : Boolean
#f
> (andmap odd? (deque 1 2 3 4 5 6))
- : Boolean
#f
> (andmap positive? (deque 1 2 3 4 5 6))
- : Boolean
#t
> (andmap negative? (deque -1 -2))
- : Boolean
#t

procedure
(ormap func deq1 deq2 ...) → Boolean
  func : (A B ... B -> Boolean)
  deq1 : (Deque A)
  deq2 : (Deque B)

Function ormap is similar to ormap.

Examples:

> (ormap even? (deque 1 2 3 4 5 6))
- : Boolean
#t
> (ormap odd? (deque 1 2 3 4 5 6))
- : Boolean
#t
> (ormap positive? (deque -1 -2 3 4 -5 6))
- : Boolean
#t
> (ormap negative? (deque 1 -2))
- : Boolean
#t

procedure
(build-deque size func) → (Deque A)
size : Natural
func : (Natural -> A)

Function build-deque is similar to build-list.

Examples:

> (deque->list (build-deque 5 (λ:([x : Integer]) (add1 x))))
- : (Listof Integer)
'(1 2 3 4 5)
> (deque->list (build-deque 5 (λ:([x : Integer]) (* x x))))
- : (Listof Integer)
'(0 1 4 9 16)

procedure
(head+tail deq) → (Pair A (Deque A))
deq : (Deque A)

Function head+tail returns a pair containing the head and the tail of the given deque.

Examples:

> (head+tail (deque 1 2 3 4 5))
- : (Pairof Positive-Byte (U (Deep Positive-Byte) (Shallow Positive-Byte)))
'(1 . #<Deep>)
> (head+tail (build-deque 5 (λ:([x : Integer]) (* x x))))
- : (Pairof Integer (U (Deep Integer) (Shallow Integer)))
'(0 . #<Deep>)
> (head+tail empty)
head+tail: given deque is empty

procedure
(last+init deq) → (Pair A (Deque A))
deq : (Deque A)

Function last+init returns a pair containing the last element and the init of the given deque.

Examples:

> (last+init (deque 1 2 3 4 5))
- : (Pairof Positive-Byte (U (Deep Positive-Byte) (Shallow Positive-Byte)))
'(5 . #<Deep>)
> (last+init (build-deque 5 (λ:([x : Integer]) (* x x))))
- : (Pairof Integer (U (Deep Integer) (Shallow Integer)))
'(16 . #<Deep>)
> (last+init empty)
last+init: given deque is empty

2.3 Real-Time Deque🔗ℹ

(require pfds/deque/real-time)

package: pfds

Real-Time Deques eliminate the amortization by using two techniques Scheduling and a variant of Global Rebuilding called Lazy Rebuilding. The data structure gives a worst case running time of O(1) for the operations head, tail, last, init, enqueue-front and enqueue.

syntax
(Deque A)

Real-time double ended queue of type A.

procedure
(deque a ...) → (Deque A)
a : A

Function deque creates a Real-Time Deque with the given inputs.

Example:

> (deque 1 2 3 4 5 6)
- : #(struct:Deque
      ((Rec
        g302833
        (U (Boxof (U (-> (Pairof Integer g302833)) (Pairof Integer g302833)))
           Null))
       Integer
       (Rec
        g302836
        (U (Boxof (U (-> (Pairof Integer g302836)) (Pairof Integer g302836)))
           Null))
       (Rec
        g302839
        (U (Boxof (U (-> (Pairof Integer g302839)) (Pairof Integer g302839)))
           Null))
       Integer
       (Rec
        g302842
        (U (Boxof (U (-> (Pairof Integer g302842)) (Pairof Integer g302842)))
           Null))))
#<Deque>

In the above example, the deque obtained will have 1 as its head element.

procedure
(empty t) → (Deque A)
t : A

An empty deque.

procedure
(empty? dq) → Boolean
dq : (Deque A)

Function empty? checks if the given deque is empty or not.

Examples:

> (empty? (deque 1 2 3 4 5 6))
- : Boolean
#f
> (empty? (empty Integer))
- : Boolean
#t

procedure
(enqueue a deq) → (Deque A)
a : A
deq : (Deque A)

Function enqueue takes an element and a deque and enqueues the given element into the deque.

Example:

> (enqueue 10 (deque 1 2 3 4 5 6))
- : #(struct:Deque
      ((Rec
        g302874
        (U (Boxof (U (-> (Pairof Integer g302874)) (Pairof Integer g302874)))
           Null))
       Integer
       (Rec
        g302877
        (U (Boxof (U (-> (Pairof Integer g302877)) (Pairof Integer g302877)))
           Null))
       (Rec
        g302880
        (U (Boxof (U (-> (Pairof Integer g302880)) (Pairof Integer g302880)))
           Null))
       Integer
       (Rec
        g302883
        (U (Boxof (U (-> (Pairof Integer g302883)) (Pairof Integer g302883)))
           Null))))
#<Deque>

In the above example, enqueue adds the element 10 to the end of (deque 1 2 3 4 5 6).

procedure
(enqueue-front a deq) → (Deque A)
a : A
deq : (Deque A)

Functionenqueue-front takes an element and a deque and adds the given element to the front of deque.

Example:

> (enqueue-front 10 (deque 1 2 3 4 5 6))
- : #(struct:Deque
      ((Rec
        g302895
        (U (Boxof (U (-> (Pairof Integer g302895)) (Pairof Integer g302895)))
           Null))
       Integer
       (Rec
        g302898
        (U (Boxof (U (-> (Pairof Integer g302898)) (Pairof Integer g302898)))
           Null))
       (Rec
        g302901
        (U (Boxof (U (-> (Pairof Integer g302901)) (Pairof Integer g302901)))
           Null))
       Integer
       (Rec
        g302904
        (U (Boxof (U (-> (Pairof Integer g302904)) (Pairof Integer g302904)))
           Null))))
#<Deque>

In the above example, enqueue adds the element 10 to the front of (deque 1 2 3 4 5 6) and returns (deque 10 1 2 3 4 5 6).

procedure
(head deq) → A
deq : (Deque A)

Function head takes a deque and gives the first element in the deque if deque is not empty else throws an error.

Examples:

> (head (deque 1 2 3 4 5 6))
- : Integer
1
> (head (empty Integer))
head: given deque is empty

procedure
(last deq) → A
deq : (Deque A)

Function last takes a deque and gives the last element in the queue if deque is not empty else throws an error.

Examples:

> (last (deque 1 2 3 4 5 6))
- : Integer
6
> (last (empty Integer))
last: given deque is empty

procedure
(tail deq) → (Deque A)
deq : (Deque A)

Function tail takes a deque and returns a deque with rest elements if its a non empty deque else throws an error.

Examples:

> (tail (deque 1 2 3 4 5 6))
- : #(struct:Deque
      ((Rec
        g302954
        (U (Boxof (U (-> (Pairof Integer g302954)) (Pairof Integer g302954)))
           Null))
       Integer
       (Rec
        g302957
        (U (Boxof (U (-> (Pairof Integer g302957)) (Pairof Integer g302957)))
           Null))
       (Rec
        g302960
        (U (Boxof (U (-> (Pairof Integer g302960)) (Pairof Integer g302960)))
           Null))
       Integer
       (Rec
        g302963
        (U (Boxof (U (-> (Pairof Integer g302963)) (Pairof Integer g302963)))
           Null))))
#<Deque>
> (tail (empty Integer))
tail: given deque is empty

In the above example, (tail (deque 1 2 3 4 5 6)), removes the head of the given deque returns (deque 2 3 4 5 6).

procedure
(init deq) → (Deque A)
deq : (Deque A)

Function init takes a deque and returns a deque without the last element if its a non empty deque else throws an error.

Examples:

> (init (deque 1 2 3 4 5 6))
- : #(struct:Deque
      ((Rec
        g302997
        (U (Boxof (U (-> (Pairof Integer g302997)) (Pairof Integer g302997)))
           Null))
       Integer
       (Rec
        g303000
        (U (Boxof (U (-> (Pairof Integer g303000)) (Pairof Integer g303000)))
           Null))
       (Rec
        g303003
        (U (Boxof (U (-> (Pairof Integer g303003)) (Pairof Integer g303003)))
           Null))
       Integer
       (Rec
        g303006
        (U (Boxof (U (-> (Pairof Integer g303006)) (Pairof Integer g303006)))
           Null))))
#<Deque>
> (init (empty Integer))
init: given deque is empty

In the above example, (init (deque 1 2 3 4 5 6)), removes the last element 6 of the given deque and returns (deque 1 2 3 4 5).

procedure
(deque->list deq) → (Listof A)
deq : (Deque A)

Function deque->list takes a deque and returns a list of elements. The list will have head of the given deque as its first element. If the given deque is empty, then it returns an empty list.

Example:

> (deque->list (deque 10 2 34 4 15 6))
- : (Listof Integer)
'(10 2 34 4 15 6)

procedure
(map func deq1 deq2 ...) → (Deque A)
  func : (A B ... B -> C)
  deq1 : (Deque A)
  deq2 : (Deque B)

Function map is similar to map for lists.

Examples:

> (deque->list (map add1 (deque 1 2 3 4 5 6)))
- : (Listof Integer)
'(2 3 4 5 6 7)
> (deque->list (map * (deque 1 2 3 4 5 6) (deque 1 2 3 4 5 6)))
- : (Listof Integer)
'(1 4 9 16 25 36)

procedure
(foldl func init deq1 deq2 ...) → C
  func : (C A B ... B -> C)
  init : C
  deq1 : (Deque A)
  deq2 : (Deque B)

Function foldl is similar to foldl

foldl currently does not produce correct results when the given function is non-commutative.

Examples:

> (foldl + 0 (deque 1 2 3 4 5 6))
- : Integer
21
> (foldl * 1 (deque 1 2 3 4 5 6) (deque 1 2 3 4 5 6))
- : Integer
518400

procedure
(foldr func init deq1 deq2 ...) → C
  func : (C A B ... B -> C)
  init : C
  deq1 : (Deque A)
  deq2 : (Deque B)

Function foldr is similar to foldr

foldr currently does not produce correct results when the given function is non-commutative.

Examples:

> (foldr + 0 (deque 1 2 3 4 5 6))
- : Integer
21
> (foldr * 1 (deque 1 2 3 4 5 6) (deque 1 2 3 4 5 6))
- : Integer
518400

procedure
(filter func que) → (Deque A)
func : (A -> Boolean)
que : (Deque A)

Function filter is similar to filter.

Examples:

> (define que (deque 1 2 3 4 5 6))
> (deque->list (filter (λ: ([x : Integer]) (> x 5)) que))
- : (Listof Integer)
'(6)
> (deque->list (filter (λ: ([x : Integer]) (< x 5)) que))
- : (Listof Integer)
'(1 2 3 4)
> (deque->list (filter (λ: ([x : Integer]) (<= x 5)) que))
- : (Listof Integer)
'(1 2 3 4 5)

procedure
(remove func que) → (Deque A)
func : (A -> Boolean)
que : (Deque A)

Function remove is similar to filter but remove removes the elements which match the predicate.

Examples:

> (deque->list (remove (λ: ([x : Integer]) (> x 5))
                       (deque 1 2 3 4 5 6)))
- : (Listof Integer)
'(1 2 3 4 5)
> (deque->list (remove (λ: ([x : Integer]) (< x 5))
                       (deque 1 2 3 4 5 6)))
- : (Listof Integer)
'(5 6)
> (deque->list (remove (λ: ([x : Integer]) (<= x 5))
                       (deque 1 2 3 4 5 6)))
- : (Listof Integer)
'(6)

procedure
(andmap func deq1 deq2 ...) → Boolean
  func : (A B ... B -> Boolean)
  deq1 : (Deque A)
  deq2 : (Deque B)

Function andmap is similar to andmap.

Examples:

> (andmap even? (deque 1 2 3 4 5 6))
- : Boolean
#f
> (andmap odd? (deque 1 2 3 4 5 6))
- : Boolean
#f
> (andmap positive? (deque 1 2 3 4 5 6))
- : Boolean
#t
> (andmap negative? (deque -1 -2))
- : Boolean
#t

procedure
(ormap func deq1 deq2 ...) → Boolean
  func : (A B ... B -> Boolean)
  deq1 : (Deque A)
  deq2 : (Deque B)

Function ormap is similar to ormap.

Examples:

> (ormap even? (deque 1 2 3 4 5 6))
- : Boolean
#t
> (ormap odd? (deque 1 2 3 4 5 6))
- : Boolean
#t
> (ormap positive? (deque -1 -2 3 4 -5 6))
- : Boolean
#t
> (ormap negative? (deque 1 -2))
- : Boolean
#t

procedure
(build-deque size func) → (Deque A)
size : Natural
func : (Natural -> A)

Function build-deque is similar to build-list.

Examples:

> (deque->list (build-deque 5 (λ:([x : Integer]) (add1 x))))
- : (Listof Integer)
'(1 2 3 4 5)
> (deque->list (build-deque 5 (λ:([x : Integer]) (* x x))))
- : (Listof Integer)
'(0 1 4 9 16)

procedure
(head+tail deq) → (Pair A (Deque A))
deq : (Deque A)

Function head+tail returns a pair containing the head and the tail of the given deque.

Examples:

> (head+tail (deque 1 2 3 4 5))
- : (Pairof
     Integer
     #(struct:Deque
       ((Rec
         g303380
         (U (Boxof (U (-> (Pairof Integer g303380)) (Pairof Integer g303380)))
            Null))
        Integer
        (Rec
         g303383
         (U (Boxof (U (-> (Pairof Integer g303383)) (Pairof Integer g303383)))
            Null))
        (Rec
         g303386
         (U (Boxof (U (-> (Pairof Integer g303386)) (Pairof Integer g303386)))
            Null))
        Integer
        (Rec
         g303389
         (U (Boxof (U (-> (Pairof Integer g303389)) (Pairof Integer g303389)))
            Null)))))
'(1 . #<Deque>)
> (head+tail (build-deque 5 (λ:([x : Integer]) (* x x))))
- : (Pairof
     Integer
     #(struct:Deque
       ((Rec
         g303406
         (U (Boxof (U (-> (Pairof Integer g303406)) (Pairof Integer g303406)))
            Null))
        Integer
        (Rec
         g303409
         (U (Boxof (U (-> (Pairof Integer g303409)) (Pairof Integer g303409)))
            Null))
        (Rec
         g303412
         (U (Boxof (U (-> (Pairof Integer g303412)) (Pairof Integer g303412)))
            Null))
        Integer
        (Rec
         g303415
         (U (Boxof (U (-> (Pairof Integer g303415)) (Pairof Integer g303415)))
            Null)))))
'(0 . #<Deque>)
> (head+tail (empty Integer))
head+tail: given deque is empty

procedure
(last+init deq) → (Pair A (Deque A))
deq : (Deque A)

Function last+init returns a pair containing the last element and the init of the given deque.

Examples:

> (last+init (deque 1 2 3 4 5))
- : (Pairof
     Integer
     #(struct:Deque
       ((Rec
         g303449
         (U (Boxof (U (-> (Pairof Integer g303449)) (Pairof Integer g303449)))
            Null))
        Integer
        (Rec
         g303452
         (U (Boxof (U (-> (Pairof Integer g303452)) (Pairof Integer g303452)))
            Null))
        (Rec
         g303455
         (U (Boxof (U (-> (Pairof Integer g303455)) (Pairof Integer g303455)))
            Null))
        Integer
        (Rec
         g303458
         (U (Boxof (U (-> (Pairof Integer g303458)) (Pairof Integer g303458)))
            Null)))))
'(5 . #<Deque>)
> (last+init (build-deque 5 (λ:([x : Integer]) (* x x))))
- : (Pairof
     Integer
     #(struct:Deque
       ((Rec
         g303475
         (U (Boxof (U (-> (Pairof Integer g303475)) (Pairof Integer g303475)))
            Null))
        Integer
        (Rec
         g303478
         (U (Boxof (U (-> (Pairof Integer g303478)) (Pairof Integer g303478)))
            Null))
        (Rec
         g303481
         (U (Boxof (U (-> (Pairof Integer g303481)) (Pairof Integer g303481)))
            Null))
        Integer
        (Rec
         g303484
         (U (Boxof (U (-> (Pairof Integer g303484)) (Pairof Integer g303484)))
            Null)))))
'(16 . #<Deque>)
> (last+init (empty Integer))
last+init: given deque is empty

1	Queues
2	Deques
3	Heaps
4	Random Access Lists
5	VList
6	Streams
7	Red-Black Trees
8	Tries
9	Treap