This document describes a BankersQueue data structure for Haskell. It consists of a front list, rear list, and lengths. Functions like head, tail, and snoc are provided to access or modify the queue in constant time by rotating or appending the two lists. The snoc function adds an element to the rear by potentially rotating to balance the lengths, maintaining the queue's structure.

1. (car (cdr ))

2. about me
• wat-aro
• @wat-aro
• GitHub wat-aro
•
• Haskell

4. • SML
• SML OCaml
• Haskell
•

5. •
•
•

6. •
• (
)
•

7. •
•

8. d
b
a c
g
f h
e

9. e
d
b
a c
g
f h
e

10. d
b
a c
g
f h
e

11. xs
d
b
a c
g
f h
d
g
f
e
ys
xs ys

12. xs
d
b
a c
g
f h
d
g
f
e
ys

13. •
•
•

14. ai i ti i
m
mX
i=1
ai
mX
i=1
ti

15. •
•
•
•

16. •
• head
• tail
• snoc

17. • f, r
• head f
• (snoc) f r
rotate
• tail f head f
r rotate
• rotate: r reverse f append

18. • f, r
data BankersQueue a = BQ Int [a] Int [a]
deriving Show

19. • head
Maybe
head :: BankersQueue a -> Maybe a
head (BQ _ [] _ _) = Nothing
head (BQ _ (x : f') _ _) = Just x

20. • (snoc) r
f r rotate
• rotate: r reverse f append

21. snoc
a
b
f
d
c
r
e
a
b
f
c
d
r
e
a
b
f
e
d
r
c
f < r
append

22. snoc :: BankersQueue a -> a -> BankersQueue a
snoc (BQ lenf f lenr r) x = check (BQ lenf f (lenr + 1) (x : r))
check :: BankersQueue a -> BankersQueue a
check q@(BQ lenf f lenr r)
| lenr <= lenf = q
| otherwise = BQ (lenf + lenr) (f ++ reverse r) 0 []

23. • tail f cdr f r
rotate
• f r 1 r
rotate |r|
tail :: BankersQueue a -> Maybe (BankersQueue a)
tail (BQ _ [] _ _) = Nothing
tail (BQ lenf (x : f') lenr r) = Just $ check $ BQ (lenf - 1) f' lenr r

24. • reverse |r|
• reverse tail |f|
• rotate snoc 2 reverse
1 (rotate
snoc 1)
• reverse 1
O(1)

25. •
•
•