module Data.Sequence.Lens
( at, viewL, viewR
, traverseHead, traverseTail
, traverseLast, traverseInit
, traverseTo, traverseFrom
, traverseSlice
) where
import Control.Applicative
import Control.Lens
import Data.Monoid
import Data.Sequence as Seq
at :: Int -> Simple Lens (Seq a) a
at i f m = (\a -> update i a m) <$> f (Seq.index m i)
viewL :: Iso (Seq a) (Seq b) (ViewL a) (ViewL b)
viewL = isos viewl unviewl viewl unviewl where
unviewl :: ViewL a -> Seq a
unviewl EmptyL = mempty
unviewl (a :< as) = a <| as
viewR :: Iso (Seq a) (Seq b) (ViewR a) (ViewR b)
viewR = isos viewr unviewr viewr unviewr where
unviewr :: ViewR a -> Seq a
unviewr EmptyR = mempty
unviewr (as :> a) = as |> a
traverseHead :: Simple Traversal (Seq a) a
traverseHead f m = case viewl m of
a :< as -> (<| as) <$> f a
EmptyL -> pure m
traverseTail :: Simple Traversal (Seq a) a
traverseTail f m = case viewl m of
a :< as -> (a <|) <$> traverse f as
EmptyL -> pure m
traverseLast :: Simple Traversal (Seq a) a
traverseLast f m = case viewr m of
as :> a -> (as |>) <$> f a
EmptyR -> pure m
traverseInit :: Simple Traversal (Seq a) a
traverseInit f m = case viewr m of
as :> a -> (|> a) <$> traverse f as
EmptyR -> pure m
traverseTo :: Int -> Simple Traversal (Seq a) a
traverseTo n f m = case Seq.splitAt n m of
(l,r) -> (>< r) <$> traverse f l
traverseFrom :: Int -> Simple Traversal (Seq a) a
traverseFrom n f m = case Seq.splitAt n m of
(l,r) -> (l ><) <$> traverse f r
traverseSlice :: Int -> Int -> Simple Traversal (Seq a) a
traverseSlice i j f s = case Seq.splitAt i s of
(l,mr) -> case Seq.splitAt (ji) mr of
(m, r) -> (\n -> l >< n >< r) <$> traverse f m