zipper type

zipper.hs

module Data.Zipper where

data ZipperList a = ZL {
        prev :: [a]
      , next :: [a]
      }

-- it's an efficient list traversal, so we should be able to map over it
instance Functor ZipperList where
    fmap foo (ZL p n) = ZL (fmap foo p) (fmap foo n)

-- create a Zipper out of a list
mkZipperList :: [a] -> ZipperList a
mkZipperList xs = ZL [] xs

-- insert an element at the current index
zInsertAt :: a -> ZipperList a -> ZipperList a
zInsertAt x (ZL p n) = ZL (head n:p) (tail n)

-- delete element at current index
zDeleteAt :: ZipperList a -> ZipperList a
zDeleteAt (ZL p n) = ZL p (tail n)

-- element at current index
zCurrent :: ZipperList a -> a
zCurrent (ZL p n) = head n

-- move the index forward one
zForward :: ZipperList a -> ZipperList a
zForward z@(ZL p []) = z
zForward (ZL p n)    = ZL (head n:p) (tail n)

-- move the index backwards one
zBackward :: ZipperList a -> ZipperList a
zBackward z@(ZL [] n) = z
zBackward (ZL p n)    = ZL (tail p) (head p:n)