add 2-3 fingertree implementation.

"very, very slow", says daniel spiewak. we'll find out why later.

hs/DataStructures.hs

@@ -162,9 +162,89 @@ instance Seq BankersQueue where
    isEmpty (BankersQueue _ Nil _ Nil) = True
    isEmpty _ = False
data FingerTree a =
      Empty
    | Single a
    | Deep {
          ftPrefix :: Digit a,
          ftTree :: FingerTree (Node a),
          ftSuffix :: Digit a
      } deriving (Show)
data Digit a = One a | Two a a | Three a a a | Four a a a a deriving Show
data Node a = Node2 a a | Node3 a a a deriving Show
instance Seq Digit where
    first (One x) = Just x
    first (Two x _) = Just x
    first (Three x _ _) = Just x
    first (Four x _ _ _) = Just x
    last (One x) = Just x
    last (Two _ x) = Just x
    last (Three _ _ x) = Just x
    last (Four _ _ _ x) = Just x
    cons x (One a) = Two x a
    cons x (Two a b) = Three x a b
    cons x (Three a b c) = Four x a b c
    nil = error "can't be empty"
    rest (Two _ a) = One a
    rest (Three _ a b) = Two a b
    rest (Four _ a b c) = Three a b c
    isEmpty _ = False
    append x (One a) = Two a x
    append x (Two a b) = Three a b x
    append x (Three a b c) = Four a b c x
instance Seq FingerTree where
    first Empty = Nothing
    first (Single x) = Just x
    first (Deep p _ _) = first p
    last Empty = Nothing
    last (Single x) = Just x
    last (Deep _ _ s) = last s
    cons x Empty = Single x
    cons x (Single y) = Deep (One x) Empty (One y)
    cons x (Deep (Four a b c d) t s) =
        Deep (Two x a) (cons (Node3 b c d) t) s
    cons x (Deep p t s) = Deep (cons x p) t s
    nil = Empty
    rest Empty = Empty
    rest (Single _) = Empty
    rest (Deep (One _) t s) =
        case first t of
            Nothing ->
                case s of
                    One x -> Single x
                    Two x y -> Deep (One x) Empty (One y)
                    Three x y z -> Deep (Two x y) Empty (One z)
                    Four x y z w -> Deep (Three x y z) Empty (One w)
            Just (Node2 x y) -> Deep (Two x y) (rest t) s
            Just (Node3 x y z) -> Deep (Three x y z) (rest t) s
    rest (Deep p t s) = Deep (rest p) t s
    isEmpty Empty = True
    isEmpty _ = False
    append x Empty = Single x
    append x (Single y) = Deep (One x) Empty (One y)
    append x (Deep p t (Four a b c d)) =
        Deep p (append (Node3 a b c) t) (Two d x)
    append x (Deep p t s) = Deep p t (append x s)
-- examples
sl = fromList [1..10] :: List Integer
bq = fromList [1..10] :: BankersQueue Integer
ft = fromList [1..10] :: FingerTree Integer
-- properties