Data.Edison.Concrete.FingerTree: exported symbols usage examples

Symbols

  • append No usage example found for this symbol :( Collapse [-]
    dropUntil See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
        | inBounds i (Seq xs) =
            case FT.splitTree (> (SizeM i)) (SizeM 0) xs of
               FT.Split l _ r -> Seq $ FT.append l $ FT.lcons (Elem x) $ r
    
        | otherwise = Seq xs
    
    adjust f i (Seq xs)
        | inBounds i (Seq xs) =
            case FT.splitTree (> (SizeM i)) (SizeM 0) xs of
               FT.Split l x r -> Seq $ FT.append l $ FT.lcons (Elem (f (unElem x))) $ r
    
        | otherwise = Seq xs
    
    take i (Seq xs) = Seq $ FT.takeUntil (> (SizeM i)) xs
    drop i (Seq xs) = Seq $ FT.dropUntil (> (SizeM i)) xs
    splitAt i (Seq xs) = let (a,b) = FT.split (> (SizeM i)) xs in (Seq a, Seq b)
    
    
    inBounds = inBoundsUsingSize
    lookup   = lookupUsingLookupM
    

    empty See 8 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
       arbitrary   = arbitrary >>= return . Elem
    
    instance CoArbitrary a => CoArbitrary (Elem a) where
       coarbitrary = coarbitrary . unElem
    
    instance Arbitrary a => Arbitrary (Seq a) where
       arbitrary   = arbitrary >>= return . Seq
    
    instance CoArbitrary a => CoArbitrary (Seq a) where
       coarbitrary = coarbitrary . unSeq
    
    instance Semigroup (Seq a) where
      (<>) = append
    instance Monoid (Seq a) where
      mempty  = empty
      mappend = (SG.<>)
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    instance App.Applicative Seq where
      pure = return
      x <*> y = do
         x' <- x
         y' <- y
         return (x' y')
    
    instance Monad Seq where
      return = singleton
      xs >>= k = concatMap k xs
    
    instance MonadPlus Seq where
      mplus = append
      mzero = empty
    
    instance Eq a => Eq (Seq a) where
      xs == ys = toList xs == toList ys
    
    instance Ord a => Ord (Seq a) where
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
       foldrWithIndex = foldrWithIndex; foldlWithIndex = foldlWithIndex;
       foldrWithIndex' = foldrWithIndex'; foldlWithIndex' = foldlWithIndex';
       take = take; drop = drop; splitAt = splitAt; subseq = subseq;
       filter = filter; partition = partition; takeWhile = takeWhile;
       dropWhile = dropWhile; splitWhile = splitWhile; zip = zip;
       zip3 = zip3; zipWith = zipWith; zipWith3 = zipWith3; unzip = unzip;
       unzip3 = unzip3; unzipWith = unzipWith; unzipWith3 = unzipWith3;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Functor Seq where
      fmap = map
    
    instance App.Alternative Seq where
      empty = empty
      (<|>) = append
    
    instance App.Applicative Seq where
      pure = return
      x <*> y = do
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
       foldrWithIndex = foldrWithIndex; foldlWithIndex = foldlWithIndex;
       foldrWithIndex' = foldrWithIndex'; foldlWithIndex' = foldlWithIndex';
       take = take; drop = drop; splitAt = splitAt; subseq = subseq;
       filter = filter; partition = partition; takeWhile = takeWhile;
       dropWhile = dropWhile; splitWhile = splitWhile; zip = zip;
       zip3 = zip3; zipWith = zipWith; zipWith3 = zipWith3; unzip = unzip;
       unzip3 = unzip3; unzipWith = unzipWith; unzipWith3 = unzipWith3;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Functor Seq where
      fmap = map
    
    instance App.Alternative Seq where
      empty = empty
      (<|>) = append
    
    instance App.Applicative Seq where
      pure = return
      x <*> y = do
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    #ifdef __GLASGOW_HASKELL__
    
    mapElem, mapUnElem :: t -> b
    mapElem   = unsafeCoerce#
    mapUnElem = unsafeCoerce#
    
    #else
    
    mapElem   = Prelude.map Elem
    mapUnElem = Prelude.map unElem
    
    #endif
    
    null         = FT.null . unSeq
    empty        = Seq FT.empty
    singleton    = Seq . FT.singleton . Elem
    lcons x      = Seq . FT.lcons (Elem x) . unSeq
    rcons x      = Seq . FT.rcons (Elem x) . unSeq
    append p q   = Seq $ FT.append (unSeq p) (unSeq q)
    fromList     = Seq . FT.fromList . mapElem
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    #ifdef __GLASGOW_HASKELL__
    
    mapElem, mapUnElem :: t -> b
    mapElem   = unsafeCoerce#
    mapUnElem = unsafeCoerce#
    
    #else
    
    mapElem   = Prelude.map Elem
    mapUnElem = Prelude.map unElem
    
    #endif
    
    null         = FT.null . unSeq
    empty        = Seq FT.empty
    singleton    = Seq . FT.singleton . Elem
    lcons x      = Seq . FT.lcons (Elem x) . unSeq
    rcons x      = Seq . FT.rcons (Elem x) . unSeq
    append p q   = Seq $ FT.append (unSeq p) (unSeq q)
    fromList     = Seq . FT.fromList . mapElem
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    unElem :: Elem t -> t
    unElem (Elem x) = x
    
    instance Measured SizeM (Elem a) where
       measure _ = 1
    
    newtype Seq a = Seq (FT.FingerTree SizeM (Elem a))
    
    unSeq :: Seq t -> FT.FingerTree SizeM (Elem t)
    unSeq (Seq ft) = ft
    
    
    
    empty          :: Seq a
    singleton      :: a -> Seq a
    lcons          :: a -> Seq a -> Seq a
    rcons          :: a -> Seq a -> Seq a
    append         :: Seq a -> Seq a -> Seq a
    lview          :: (Monad m) => Seq a -> m (a, Seq a)
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    --   Module      :  Data.Edison.Seq.FingerSeq
    --   Copyright   :  Copyright (c) 2006, 2008 Robert Dockins
    --   License     :  MIT; see COPYRIGHT file for terms and conditions
    --
    --   Maintainer  :  robdockins AT fastmail DOT fm
    --   Stability   :  stable
    --   Portability :  GHC, Hugs (MPTC and FD)
    
    
    module Data.Edison.Seq.FingerSeq (
        -- * Sequence Type
        Seq, -- instance of Sequence, Functor, Monad, MonadPlus
    
        -- * Sequence Operations
        empty,singleton,lcons,rcons,append,lview,lhead,ltail,rview,rhead,rtail,
        lheadM,ltailM,rheadM,rtailM,
        null,size,concat,reverse,reverseOnto,fromList,toList,map,concatMap,
        fold,fold',fold1,fold1',foldr,foldr',foldl,foldl',foldr1,foldr1',foldl1,foldl1',
        reducer,reducer',reducel,reducel',reduce1,reduce1',
        copy,inBounds,lookup,lookupM,lookupWithDefault,update,adjust,
    

    foldFT See 4 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    #ifdef __GLASGOW_HASKELL__
    
    foldr  f z (Seq xs) = unElem $ FT.foldFT id (.) (unsafeCoerce# f) xs (Elem z)
    foldr' f z (Seq xs) = unElem $ FT.foldFT id (.) (unsafeCoerce# f) xs (Elem z)
    
    reduce1  f (Seq xs) = unElem $ FT.reduce1  (unsafeCoerce# f) xs
    reduce1' f (Seq xs) = unElem $ FT.reduce1' (unsafeCoerce# f) xs
    
    map f (Seq xs) = Seq $ FT.mapTree (unsafeCoerce# f) xs
    
    #else
    
    foldr  f z (Seq xs) = unElem $ FT.foldFT id (.) ( \(Elem x) (Elem y) -> Elem $ f x y) xs (Elem z)
    foldr' f z (Seq xs) = unElem $ FT.foldFT id (.) ( \(Elem x) (Elem y) -> Elem $ f x y) xs (Elem z)
    
    reduce1  f (Seq xs) = unElem $ FT.reduce1  ( \(Elem x) (Elem y) -> Elem $ f x y) xs
    reduce1' f (Seq xs) = unElem $ FT.reduce1' ( \(Elem x) (Elem y) -> Elem $ f x y) xs
    
    map f (Seq xs) = Seq $ FT.mapTree ( \(Elem x) -> Elem $ f x) xs
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    fold1'   = foldr1'
    
    #ifdef __GLASGOW_HASKELL__
    
    foldr  f z (Seq xs) = unElem $ FT.foldFT id (.) (unsafeCoerce# f) xs (Elem z)
    foldr' f z (Seq xs) = unElem $ FT.foldFT id (.) (unsafeCoerce# f) xs (Elem z)
    
    reduce1  f (Seq xs) = unElem $ FT.reduce1  (unsafeCoerce# f) xs
    reduce1' f (Seq xs) = unElem $ FT.reduce1' (unsafeCoerce# f) xs
    
    map f (Seq xs) = Seq $ FT.mapTree (unsafeCoerce# f) xs
    
    #else
    
    foldr  f z (Seq xs) = unElem $ FT.foldFT id (.) ( \(Elem x) (Elem y) -> Elem $ f x y) xs (Elem z)
    foldr' f z (Seq xs) = unElem $ FT.foldFT id (.) ( \(Elem x) (Elem y) -> Elem $ f x y) xs (Elem z)
    
    reduce1  f (Seq xs) = unElem $ FT.reduce1  ( \(Elem x) (Elem y) -> Elem $ f x y) xs
    reduce1' f (Seq xs) = unElem $ FT.reduce1' ( \(Elem x) (Elem y) -> Elem $ f x y) xs
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    rtailM xs = rview xs >>= return . snd
    lhead = runIdentity . lheadM
    ltail = runIdentity . ltailM
    rhead = runIdentity . rheadM
    rtail = runIdentity . rtailM
    
    fold     = foldr
    fold'    = foldr'
    fold1    = foldr1
    fold1'   = foldr1'
    
    #ifdef __GLASGOW_HASKELL__
    
    foldr  f z (Seq xs) = unElem $ FT.foldFT id (.) (unsafeCoerce# f) xs (Elem z)
    foldr' f z (Seq xs) = unElem $ FT.foldFT id (.) (unsafeCoerce# f) xs (Elem z)
    
    reduce1  f (Seq xs) = unElem $ FT.reduce1  (unsafeCoerce# f) xs
    reduce1' f (Seq xs) = unElem $ FT.reduce1' (unsafeCoerce# f) xs
    
    map f (Seq xs) = Seq $ FT.mapTree (unsafeCoerce# f) xs
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    rheadM xs = rview xs >>= return . fst
    rtailM xs = rview xs >>= return . snd
    lhead = runIdentity . lheadM
    ltail = runIdentity . ltailM
    rhead = runIdentity . rheadM
    rtail = runIdentity . rtailM
    
    fold     = foldr
    fold'    = foldr'
    fold1    = foldr1
    fold1'   = foldr1'
    
    #ifdef __GLASGOW_HASKELL__
    
    foldr  f z (Seq xs) = unElem $ FT.foldFT id (.) (unsafeCoerce# f) xs (Elem z)
    foldr' f z (Seq xs) = unElem $ FT.foldFT id (.) (unsafeCoerce# f) xs (Elem z)
    
    reduce1  f (Seq xs) = unElem $ FT.reduce1  (unsafeCoerce# f) xs
    reduce1' f (Seq xs) = unElem $ FT.reduce1' (unsafeCoerce# f) xs
    

    fromList See 6 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    unzip = unzipUsingFoldr
    unzip3 = unzip3UsingFoldr
    unzipWith = unzipWithUsingFoldr
    unzipWith3 = unzipWith3UsingFoldr
    
    -- instances
    
    instance S.Sequence Seq where
      {lcons = lcons; rcons = rcons;
       lview = lview; lhead = lhead; ltail = ltail;
       lheadM = lheadM; ltailM = ltailM; rheadM = rheadM; rtailM = rtailM;
       rview = rview; rhead = rhead; rtail = rtail; null = null;
       size = size; concat = concat; reverse = reverse;
       reverseOnto = reverseOnto; fromList = fromList; toList = toList;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       foldr = foldr; foldr' = foldr'; foldl = foldl; foldl' = foldl';
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
       reducer = reducer; reducer' = reducer'; reducel = reducel;
       reducel' = reducel'; reduce1 = reduce1;  reduce1' = reduce1';
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    unzip = unzipUsingFoldr
    unzip3 = unzip3UsingFoldr
    unzipWith = unzipWithUsingFoldr
    unzipWith3 = unzipWith3UsingFoldr
    
    -- instances
    
    instance S.Sequence Seq where
      {lcons = lcons; rcons = rcons;
       lview = lview; lhead = lhead; ltail = ltail;
       lheadM = lheadM; ltailM = ltailM; rheadM = rheadM; rtailM = rtailM;
       rview = rview; rhead = rhead; rtail = rtail; null = null;
       size = size; concat = concat; reverse = reverse;
       reverseOnto = reverseOnto; fromList = fromList; toList = toList;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       foldr = foldr; foldr' = foldr'; foldl = foldl; foldl' = foldl';
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
       reducer = reducer; reducer' = reducer'; reducel = reducel;
       reducel' = reducel'; reduce1 = reduce1;  reduce1' = reduce1';
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    #else
    
    mapElem   = Prelude.map Elem
    mapUnElem = Prelude.map unElem
    
    #endif
    
    null         = FT.null . unSeq
    empty        = Seq FT.empty
    singleton    = Seq . FT.singleton . Elem
    lcons x      = Seq . FT.lcons (Elem x) . unSeq
    rcons x      = Seq . FT.rcons (Elem x) . unSeq
    append p q   = Seq $ FT.append (unSeq p) (unSeq q)
    fromList     = Seq . FT.fromList . mapElem
    toList       = mapUnElem . FT.toList . unSeq
    reverse      = Seq . FT.reverse . unSeq
    size         = unSizeM . measure . unSeq
    strict       = Seq . FT.strict . unSeq
    strictWith f = Seq . FT.strictWith (f . unElem) . unSeq
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    #else
    
    mapElem   = Prelude.map Elem
    mapUnElem = Prelude.map unElem
    
    #endif
    
    null         = FT.null . unSeq
    empty        = Seq FT.empty
    singleton    = Seq . FT.singleton . Elem
    lcons x      = Seq . FT.lcons (Elem x) . unSeq
    rcons x      = Seq . FT.rcons (Elem x) . unSeq
    append p q   = Seq $ FT.append (unSeq p) (unSeq q)
    fromList     = Seq . FT.fromList . mapElem
    toList       = mapUnElem . FT.toList . unSeq
    reverse      = Seq . FT.reverse . unSeq
    size         = unSizeM . measure . unSeq
    strict       = Seq . FT.strict . unSeq
    strictWith f = Seq . FT.strictWith (f . unElem) . unSeq
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    lhead          :: Seq a -> a
    lheadM         :: (Monad m) => Seq a -> m a
    ltail          :: Seq a -> Seq a
    ltailM         :: (Monad m) => Seq a -> m (Seq a)
    rview          :: (Monad m) => Seq a -> m (a, Seq a)
    rhead          :: Seq a -> a
    rheadM         :: (Monad m) => Seq a -> m a
    rtail          :: Seq a -> Seq a
    rtailM         :: (Monad m) => Seq a -> m (Seq a)
    null           :: Seq a -> Bool
    size           :: Seq a -> Int
    concat         :: Seq (Seq a) -> Seq a
    reverse        :: Seq a -> Seq a
    reverseOnto    :: Seq a -> Seq a -> Seq a
    fromList       :: [a] -> Seq a
    toList         :: Seq a -> [a]
    map            :: (a -> b) -> Seq a -> Seq b
    concatMap      :: (a -> Seq b) -> Seq a -> Seq b
    fold           :: (a -> b -> b) -> b -> Seq a -> b
    fold'          :: (a -> b -> b) -> b -> Seq a -> b
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    --   License     :  MIT; see COPYRIGHT file for terms and conditions
    --
    --   Maintainer  :  robdockins AT fastmail DOT fm
    --   Stability   :  stable
    --   Portability :  GHC, Hugs (MPTC and FD)
    
    
    module Data.Edison.Seq.FingerSeq (
        -- * Sequence Type
        Seq, -- instance of Sequence, Functor, Monad, MonadPlus
    
        -- * Sequence Operations
        empty,singleton,lcons,rcons,append,lview,lhead,ltail,rview,rhead,rtail,
        lheadM,ltailM,rheadM,rtailM,
        null,size,concat,reverse,reverseOnto,fromList,toList,map,concatMap,
        fold,fold',fold1,fold1',foldr,foldr',foldl,foldl',foldr1,foldr1',foldl1,foldl1',
        reducer,reducer',reducel,reducel',reduce1,reduce1',
        copy,inBounds,lookup,lookupM,lookupWithDefault,update,adjust,
        mapWithIndex,foldrWithIndex,foldlWithIndex,
        take,drop,splitAt,subseq,filter,partition,takeWhile,dropWhile,splitWhile,
    

    lcons See 8 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    zip = zipUsingLview
    zip3 = zip3UsingLview
    zipWith = zipWithUsingLview
    zipWith3 = zipWith3UsingLview
    
    unzip = unzipUsingFoldr
    unzip3 = unzip3UsingFoldr
    unzipWith = unzipWithUsingFoldr
    unzipWith3 = unzipWith3UsingFoldr
    
    -- instances
    
    instance S.Sequence Seq where
      {lcons = lcons; rcons = rcons;
       lview = lview; lhead = lhead; ltail = ltail;
       lheadM = lheadM; ltailM = ltailM; rheadM = rheadM; rtailM = rtailM;
       rview = rview; rhead = rhead; rtail = rtail; null = null;
       size = size; concat = concat; reverse = reverse;
       reverseOnto = reverseOnto; fromList = fromList; toList = toList;
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    zip = zipUsingLview
    zip3 = zip3UsingLview
    zipWith = zipWithUsingLview
    zipWith3 = zipWith3UsingLview
    
    unzip = unzipUsingFoldr
    unzip3 = unzip3UsingFoldr
    unzipWith = unzipWithUsingFoldr
    unzipWith3 = unzipWith3UsingFoldr
    
    -- instances
    
    instance S.Sequence Seq where
      {lcons = lcons; rcons = rcons;
       lview = lview; lhead = lhead; ltail = ltail;
       lheadM = lheadM; ltailM = ltailM; rheadM = rheadM; rtailM = rtailM;
       rview = rview; rhead = rhead; rtail = rtail; null = null;
       size = size; concat = concat; reverse = reverse;
       reverseOnto = reverseOnto; fromList = fromList; toList = toList;
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
               FT.Split _ (Elem x) _ -> x
    
        | otherwise = d
    
    update i x (Seq xs)
        | inBounds i (Seq xs) =
            case FT.splitTree (> (SizeM i)) (SizeM 0) xs of
               FT.Split l _ r -> Seq $ FT.append l $ FT.lcons (Elem x) $ r
    
        | otherwise = Seq xs
    
    adjust f i (Seq xs)
        | inBounds i (Seq xs) =
            case FT.splitTree (> (SizeM i)) (SizeM 0) xs of
               FT.Split l x r -> Seq $ FT.append l $ FT.lcons (Elem (f (unElem x))) $ r
    
        | otherwise = Seq xs
    
    take i (Seq xs) = Seq $ FT.takeUntil (> (SizeM i)) xs
    drop i (Seq xs) = Seq $ FT.dropUntil (> (SizeM i)) xs
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
               FT.Split _ (Elem x) _ -> return x
    
        | otherwise = fail "FingerSeq.lookupM: index out of bounds"
    
    lookupWithDefault d i (Seq xs)
        | inBounds i (Seq xs) =
            case FT.splitTree (> (SizeM i)) (SizeM 0) xs of
               FT.Split _ (Elem x) _ -> x
    
        | otherwise = d
    
    update i x (Seq xs)
        | inBounds i (Seq xs) =
            case FT.splitTree (> (SizeM i)) (SizeM 0) xs of
               FT.Split l _ r -> Seq $ FT.append l $ FT.lcons (Elem x) $ r
    
        | otherwise = Seq xs
    
    adjust f i (Seq xs)
        | inBounds i (Seq xs) =
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    mapElem, mapUnElem :: t -> b
    mapElem   = unsafeCoerce#
    mapUnElem = unsafeCoerce#
    
    #else
    
    mapElem   = Prelude.map Elem
    mapUnElem = Prelude.map unElem
    
    #endif
    
    null         = FT.null . unSeq
    empty        = Seq FT.empty
    singleton    = Seq . FT.singleton . Elem
    lcons x      = Seq . FT.lcons (Elem x) . unSeq
    rcons x      = Seq . FT.rcons (Elem x) . unSeq
    append p q   = Seq $ FT.append (unSeq p) (unSeq q)
    fromList     = Seq . FT.fromList . mapElem
    toList       = mapUnElem . FT.toList . unSeq
    reverse      = Seq . FT.reverse . unSeq
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    mapElem, mapUnElem :: t -> b
    mapElem   = unsafeCoerce#
    mapUnElem = unsafeCoerce#
    
    #else
    
    mapElem   = Prelude.map Elem
    mapUnElem = Prelude.map unElem
    
    #endif
    
    null         = FT.null . unSeq
    empty        = Seq FT.empty
    singleton    = Seq . FT.singleton . Elem
    lcons x      = Seq . FT.lcons (Elem x) . unSeq
    rcons x      = Seq . FT.rcons (Elem x) . unSeq
    append p q   = Seq $ FT.append (unSeq p) (unSeq q)
    fromList     = Seq . FT.fromList . mapElem
    toList       = mapUnElem . FT.toList . unSeq
    reverse      = Seq . FT.reverse . unSeq
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    unElem (Elem x) = x
    
    instance Measured SizeM (Elem a) where
       measure _ = 1
    
    newtype Seq a = Seq (FT.FingerTree SizeM (Elem a))
    
    unSeq :: Seq t -> FT.FingerTree SizeM (Elem t)
    unSeq (Seq ft) = ft
    
    
    
    empty          :: Seq a
    singleton      :: a -> Seq a
    lcons          :: a -> Seq a -> Seq a
    rcons          :: a -> Seq a -> Seq a
    append         :: Seq a -> Seq a -> Seq a
    lview          :: (Monad m) => Seq a -> m (a, Seq a)
    lhead          :: Seq a -> a
    lheadM         :: (Monad m) => Seq a -> m a
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    --   Module      :  Data.Edison.Seq.FingerSeq
    --   Copyright   :  Copyright (c) 2006, 2008 Robert Dockins
    --   License     :  MIT; see COPYRIGHT file for terms and conditions
    --
    --   Maintainer  :  robdockins AT fastmail DOT fm
    --   Stability   :  stable
    --   Portability :  GHC, Hugs (MPTC and FD)
    
    
    module Data.Edison.Seq.FingerSeq (
        -- * Sequence Type
        Seq, -- instance of Sequence, Functor, Monad, MonadPlus
    
        -- * Sequence Operations
        empty,singleton,lcons,rcons,append,lview,lhead,ltail,rview,rhead,rtail,
        lheadM,ltailM,rheadM,rtailM,
        null,size,concat,reverse,reverseOnto,fromList,toList,map,concatMap,
        fold,fold',fold1,fold1',foldr,foldr',foldl,foldl',foldr1,foldr1',foldl1,foldl1',
        reducer,reducer',reducel,reducel',reduce1,reduce1',
        copy,inBounds,lookup,lookupM,lookupWithDefault,update,adjust,
    

    lview See 10 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    zip = zipUsingLview
    zip3 = zip3UsingLview
    zipWith = zipWithUsingLview
    zipWith3 = zipWith3UsingLview
    
    unzip = unzipUsingFoldr
    unzip3 = unzip3UsingFoldr
    unzipWith = unzipWithUsingFoldr
    unzipWith3 = unzipWith3UsingFoldr
    
    -- instances
    
    instance S.Sequence Seq where
      {lcons = lcons; rcons = rcons;
       lview = lview; lhead = lhead; ltail = ltail;
       lheadM = lheadM; ltailM = ltailM; rheadM = rheadM; rtailM = rtailM;
       rview = rview; rhead = rhead; rtail = rtail; null = null;
       size = size; concat = concat; reverse = reverse;
       reverseOnto = reverseOnto; fromList = fromList; toList = toList;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    zip = zipUsingLview
    zip3 = zip3UsingLview
    zipWith = zipWithUsingLview
    zipWith3 = zipWith3UsingLview
    
    unzip = unzipUsingFoldr
    unzip3 = unzip3UsingFoldr
    unzipWith = unzipWithUsingFoldr
    unzipWith3 = unzipWith3UsingFoldr
    
    -- instances
    
    instance S.Sequence Seq where
      {lcons = lcons; rcons = rcons;
       lview = lview; lhead = lhead; ltail = ltail;
       lheadM = lheadM; ltailM = ltailM; rheadM = rheadM; rtailM = rtailM;
       rview = rview; rhead = rhead; rtail = rtail; null = null;
       size = size; concat = concat; reverse = reverse;
       reverseOnto = reverseOnto; fromList = fromList; toList = toList;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    rview (Seq xs) =
      let f = unsafeCoerce# :: Monad m => m (Elem a,FT.FingerTree SizeM (Elem a)) -> m (a,Seq a)
      in  f (FT.rview xs)
    
    #else
    
    lview (Seq xs) = FT.lview xs >>= \(Elem a, zs) -> return (a, Seq zs)
    rview (Seq xs) = FT.rview xs >>= \(Elem a, zs) -> return (a, Seq zs)
    
    #endif
    
    
    lheadM xs = lview xs >>= return . fst
    ltailM xs = lview xs >>= return . snd
    rheadM xs = rview xs >>= return . fst
    rtailM xs = rview xs >>= return . snd
    lhead = runIdentity . lheadM
    ltail = runIdentity . ltailM
    rhead = runIdentity . rheadM
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
      in  f (FT.lview xs)
    
    rview (Seq xs) =
      let f = unsafeCoerce# :: Monad m => m (Elem a,FT.FingerTree SizeM (Elem a)) -> m (a,Seq a)
      in  f (FT.rview xs)
    
    #else
    
    lview (Seq xs) = FT.lview xs >>= \(Elem a, zs) -> return (a, Seq zs)
    rview (Seq xs) = FT.rview xs >>= \(Elem a, zs) -> return (a, Seq zs)
    
    #endif
    
    
    lheadM xs = lview xs >>= return . fst
    ltailM xs = lview xs >>= return . snd
    rheadM xs = rview xs >>= return . fst
    rtailM xs = rview xs >>= return . snd
    lhead = runIdentity . lheadM
    ltail = runIdentity . ltailM
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    structuralInvariant = FT.structuralInvariant . unSeq
    
    #ifdef __GLASGOW_HASKELL__
    
    lview (Seq xs) =
      let f = unsafeCoerce# :: Monad m => m (Elem a,FT.FingerTree SizeM (Elem a)) -> m (a,Seq a)
      in  f (FT.lview xs)
    
    rview (Seq xs) =
      let f = unsafeCoerce# :: Monad m => m (Elem a,FT.FingerTree SizeM (Elem a)) -> m (a,Seq a)
      in  f (FT.rview xs)
    
    #else
    
    lview (Seq xs) = FT.lview xs >>= \(Elem a, zs) -> return (a, Seq zs)
    rview (Seq xs) = FT.rview xs >>= \(Elem a, zs) -> return (a, Seq zs)
    
    #endif
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    structuralInvariant = FT.structuralInvariant . unSeq
    
    #ifdef __GLASGOW_HASKELL__
    
    lview (Seq xs) =
      let f = unsafeCoerce# :: Monad m => m (Elem a,FT.FingerTree SizeM (Elem a)) -> m (a,Seq a)
      in  f (FT.lview xs)
    
    rview (Seq xs) =
      let f = unsafeCoerce# :: Monad m => m (Elem a,FT.FingerTree SizeM (Elem a)) -> m (a,Seq a)
      in  f (FT.rview xs)
    
    #else
    
    lview (Seq xs) = FT.lview xs >>= \(Elem a, zs) -> return (a, Seq zs)
    rview (Seq xs) = FT.rview xs >>= \(Elem a, zs) -> return (a, Seq zs)
    
    #endif
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    rcons x      = Seq . FT.rcons (Elem x) . unSeq
    append p q   = Seq $ FT.append (unSeq p) (unSeq q)
    fromList     = Seq . FT.fromList . mapElem
    toList       = mapUnElem . FT.toList . unSeq
    reverse      = Seq . FT.reverse . unSeq
    size         = unSizeM . measure . unSeq
    strict       = Seq . FT.strict . unSeq
    strictWith f = Seq . FT.strictWith (f . unElem) . unSeq
    structuralInvariant = FT.structuralInvariant . unSeq
    
    #ifdef __GLASGOW_HASKELL__
    
    lview (Seq xs) =
      let f = unsafeCoerce# :: Monad m => m (Elem a,FT.FingerTree SizeM (Elem a)) -> m (a,Seq a)
      in  f (FT.lview xs)
    
    rview (Seq xs) =
      let f = unsafeCoerce# :: Monad m => m (Elem a,FT.FingerTree SizeM (Elem a)) -> m (a,Seq a)
      in  f (FT.rview xs)
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    singleton    = Seq . FT.singleton . Elem
    lcons x      = Seq . FT.lcons (Elem x) . unSeq
    rcons x      = Seq . FT.rcons (Elem x) . unSeq
    append p q   = Seq $ FT.append (unSeq p) (unSeq q)
    fromList     = Seq . FT.fromList . mapElem
    toList       = mapUnElem . FT.toList . unSeq
    reverse      = Seq . FT.reverse . unSeq
    size         = unSizeM . measure . unSeq
    strict       = Seq . FT.strict . unSeq
    strictWith f = Seq . FT.strictWith (f . unElem) . unSeq
    structuralInvariant = FT.structuralInvariant . unSeq
    
    #ifdef __GLASGOW_HASKELL__
    
    lview (Seq xs) =
      let f = unsafeCoerce# :: Monad m => m (Elem a,FT.FingerTree SizeM (Elem a)) -> m (a,Seq a)
      in  f (FT.lview xs)
    
    rview (Seq xs) =
      let f = unsafeCoerce# :: Monad m => m (Elem a,FT.FingerTree SizeM (Elem a)) -> m (a,Seq a)
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
       measure _ = 1
    
    newtype Seq a = Seq (FT.FingerTree SizeM (Elem a))
    
    unSeq :: Seq t -> FT.FingerTree SizeM (Elem t)
    unSeq (Seq ft) = ft
    
    
    
    empty          :: Seq a
    singleton      :: a -> Seq a
    lcons          :: a -> Seq a -> Seq a
    rcons          :: a -> Seq a -> Seq a
    append         :: Seq a -> Seq a -> Seq a
    lview          :: (Monad m) => Seq a -> m (a, Seq a)
    lhead          :: Seq a -> a
    lheadM         :: (Monad m) => Seq a -> m a
    ltail          :: Seq a -> Seq a
    ltailM         :: (Monad m) => Seq a -> m (Seq a)
    rview          :: (Monad m) => Seq a -> m (a, Seq a)
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    --   Module      :  Data.Edison.Seq.FingerSeq
    --   Copyright   :  Copyright (c) 2006, 2008 Robert Dockins
    --   License     :  MIT; see COPYRIGHT file for terms and conditions
    --
    --   Maintainer  :  robdockins AT fastmail DOT fm
    --   Stability   :  stable
    --   Portability :  GHC, Hugs (MPTC and FD)
    
    
    module Data.Edison.Seq.FingerSeq (
        -- * Sequence Type
        Seq, -- instance of Sequence, Functor, Monad, MonadPlus
    
        -- * Sequence Operations
        empty,singleton,lcons,rcons,append,lview,lhead,ltail,rview,rhead,rtail,
        lheadM,ltailM,rheadM,rtailM,
        null,size,concat,reverse,reverseOnto,fromList,toList,map,concatMap,
        fold,fold',fold1,fold1',foldr,foldr',foldl,foldl',foldr1,foldr1',foldl1,foldl1',
        reducer,reducer',reducel,reducel',reduce1,reduce1',
        copy,inBounds,lookup,lookupM,lookupWithDefault,update,adjust,
    

    mapTree See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    reduce1  f (Seq xs) = unElem $ FT.reduce1  (unsafeCoerce# f) xs
    reduce1' f (Seq xs) = unElem $ FT.reduce1' (unsafeCoerce# f) xs
    
    map f (Seq xs) = Seq $ FT.mapTree (unsafeCoerce# f) xs
    
    #else
    
    foldr  f z (Seq xs) = unElem $ FT.foldFT id (.) ( \(Elem x) (Elem y) -> Elem $ f x y) xs (Elem z)
    foldr' f z (Seq xs) = unElem $ FT.foldFT id (.) ( \(Elem x) (Elem y) -> Elem $ f x y) xs (Elem z)
    
    reduce1  f (Seq xs) = unElem $ FT.reduce1  ( \(Elem x) (Elem y) -> Elem $ f x y) xs
    reduce1' f (Seq xs) = unElem $ FT.reduce1' ( \(Elem x) (Elem y) -> Elem $ f x y) xs
    
    map f (Seq xs) = Seq $ FT.mapTree ( \(Elem x) -> Elem $ f x) xs
    
    #endif
    
    lookupM i (Seq xs)
        | inBounds i (Seq xs) =
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    fold     = foldr
    fold'    = foldr'
    fold1    = foldr1
    fold1'   = foldr1'
    
    #ifdef __GLASGOW_HASKELL__
    
    foldr  f z (Seq xs) = unElem $ FT.foldFT id (.) (unsafeCoerce# f) xs (Elem z)
    foldr' f z (Seq xs) = unElem $ FT.foldFT id (.) (unsafeCoerce# f) xs (Elem z)
    
    reduce1  f (Seq xs) = unElem $ FT.reduce1  (unsafeCoerce# f) xs
    reduce1' f (Seq xs) = unElem $ FT.reduce1' (unsafeCoerce# f) xs
    
    map f (Seq xs) = Seq $ FT.mapTree (unsafeCoerce# f) xs
    
    #else
    
    foldr  f z (Seq xs) = unElem $ FT.foldFT id (.) ( \(Elem x) (Elem y) -> Elem $ f x y) xs (Elem z)
    foldr' f z (Seq xs) = unElem $ FT.foldFT id (.) ( \(Elem x) (Elem y) -> Elem $ f x y) xs (Elem z)
    

    null See 7 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    zipWith = zipWithUsingLview
    zipWith3 = zipWith3UsingLview
    
    unzip = unzipUsingFoldr
    unzip3 = unzip3UsingFoldr
    unzipWith = unzipWithUsingFoldr
    unzipWith3 = unzipWith3UsingFoldr
    
    -- instances
    
    instance S.Sequence Seq where
      {lcons = lcons; rcons = rcons;
       lview = lview; lhead = lhead; ltail = ltail;
       lheadM = lheadM; ltailM = ltailM; rheadM = rheadM; rtailM = rtailM;
       rview = rview; rhead = rhead; rtail = rtail; null = null;
       size = size; concat = concat; reverse = reverse;
       reverseOnto = reverseOnto; fromList = fromList; toList = toList;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       foldr = foldr; foldr' = foldr'; foldl = foldl; foldl' = foldl';
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    zipWith = zipWithUsingLview
    zipWith3 = zipWith3UsingLview
    
    unzip = unzipUsingFoldr
    unzip3 = unzip3UsingFoldr
    unzipWith = unzipWithUsingFoldr
    unzipWith3 = unzipWith3UsingFoldr
    
    -- instances
    
    instance S.Sequence Seq where
      {lcons = lcons; rcons = rcons;
       lview = lview; lhead = lhead; ltail = ltail;
       lheadM = lheadM; ltailM = ltailM; rheadM = rheadM; rtailM = rtailM;
       rview = rview; rhead = rhead; rtail = rtail; null = null;
       size = size; concat = concat; reverse = reverse;
       reverseOnto = reverseOnto; fromList = fromList; toList = toList;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       foldr = foldr; foldr' = foldr'; foldl = foldl; foldl' = foldl';
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    #ifdef __GLASGOW_HASKELL__
    
    mapElem, mapUnElem :: t -> b
    mapElem   = unsafeCoerce#
    mapUnElem = unsafeCoerce#
    
    #else
    
    mapElem   = Prelude.map Elem
    mapUnElem = Prelude.map unElem
    
    #endif
    
    null         = FT.null . unSeq
    empty        = Seq FT.empty
    singleton    = Seq . FT.singleton . Elem
    lcons x      = Seq . FT.lcons (Elem x) . unSeq
    rcons x      = Seq . FT.rcons (Elem x) . unSeq
    append p q   = Seq $ FT.append (unSeq p) (unSeq q)
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    #ifdef __GLASGOW_HASKELL__
    
    mapElem, mapUnElem :: t -> b
    mapElem   = unsafeCoerce#
    mapUnElem = unsafeCoerce#
    
    #else
    
    mapElem   = Prelude.map Elem
    mapUnElem = Prelude.map unElem
    
    #endif
    
    null         = FT.null . unSeq
    empty        = Seq FT.empty
    singleton    = Seq . FT.singleton . Elem
    lcons x      = Seq . FT.lcons (Elem x) . unSeq
    rcons x      = Seq . FT.rcons (Elem x) . unSeq
    append p q   = Seq $ FT.append (unSeq p) (unSeq q)
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    singleton      :: a -> Seq a
    lcons          :: a -> Seq a -> Seq a
    rcons          :: a -> Seq a -> Seq a
    append         :: Seq a -> Seq a -> Seq a
    lview          :: (Monad m) => Seq a -> m (a, Seq a)
    lhead          :: Seq a -> a
    lheadM         :: (Monad m) => Seq a -> m a
    ltail          :: Seq a -> Seq a
    ltailM         :: (Monad m) => Seq a -> m (Seq a)
    rview          :: (Monad m) => Seq a -> m (a, Seq a)
    rhead          :: Seq a -> a
    rheadM         :: (Monad m) => Seq a -> m a
    rtail          :: Seq a -> Seq a
    rtailM         :: (Monad m) => Seq a -> m (Seq a)
    null           :: Seq a -> Bool
    size           :: Seq a -> Int
    concat         :: Seq (Seq a) -> Seq a
    reverse        :: Seq a -> Seq a
    reverseOnto    :: Seq a -> Seq a -> Seq a
    fromList       :: [a] -> Seq a
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
        take,drop,splitAt,subseq,filter,partition,takeWhile,dropWhile,splitWhile,
        zip,zip3,zipWith,zipWith3,unzip,unzip3,unzipWith,unzipWith3,
        strict, strictWith,
    
        -- * Unit testing
        structuralInvariant,
    
        -- * Documentation
        moduleName
    ) where
    
    import qualified Prelude
    import Prelude hiding (concat,reverse,map,concatMap,foldr,foldl,foldr1,foldl1,
                           filter,takeWhile,dropWhile,lookup,take,drop,splitAt,
                           zip,zip3,zipWith,zipWith3,unzip,unzip3,null)
    
    import qualified Control.Applicative as App
    import Data.Edison.Prelude (measure, Measured())
    import qualified Data.Edison.Seq as S
    import Data.Edison.Seq.Defaults
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    --   License     :  MIT; see COPYRIGHT file for terms and conditions
    --
    --   Maintainer  :  robdockins AT fastmail DOT fm
    --   Stability   :  stable
    --   Portability :  GHC, Hugs (MPTC and FD)
    
    
    module Data.Edison.Seq.FingerSeq (
        -- * Sequence Type
        Seq, -- instance of Sequence, Functor, Monad, MonadPlus
    
        -- * Sequence Operations
        empty,singleton,lcons,rcons,append,lview,lhead,ltail,rview,rhead,rtail,
        lheadM,ltailM,rheadM,rtailM,
        null,size,concat,reverse,reverseOnto,fromList,toList,map,concatMap,
        fold,fold',fold1,fold1',foldr,foldr',foldl,foldl',foldr1,foldr1',foldl1,foldl1',
        reducer,reducer',reducel,reducel',reduce1,reduce1',
        copy,inBounds,lookup,lookupM,lookupWithDefault,update,adjust,
        mapWithIndex,foldrWithIndex,foldlWithIndex,
        take,drop,splitAt,subseq,filter,partition,takeWhile,dropWhile,splitWhile,
    

    rcons See 6 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    zip = zipUsingLview
    zip3 = zip3UsingLview
    zipWith = zipWithUsingLview
    zipWith3 = zipWith3UsingLview
    
    unzip = unzipUsingFoldr
    unzip3 = unzip3UsingFoldr
    unzipWith = unzipWithUsingFoldr
    unzipWith3 = unzipWith3UsingFoldr
    
    -- instances
    
    instance S.Sequence Seq where
      {lcons = lcons; rcons = rcons;
       lview = lview; lhead = lhead; ltail = ltail;
       lheadM = lheadM; ltailM = ltailM; rheadM = rheadM; rtailM = rtailM;
       rview = rview; rhead = rhead; rtail = rtail; null = null;
       size = size; concat = concat; reverse = reverse;
       reverseOnto = reverseOnto; fromList = fromList; toList = toList;
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    zip = zipUsingLview
    zip3 = zip3UsingLview
    zipWith = zipWithUsingLview
    zipWith3 = zipWith3UsingLview
    
    unzip = unzipUsingFoldr
    unzip3 = unzip3UsingFoldr
    unzipWith = unzipWithUsingFoldr
    unzipWith3 = unzipWith3UsingFoldr
    
    -- instances
    
    instance S.Sequence Seq where
      {lcons = lcons; rcons = rcons;
       lview = lview; lhead = lhead; ltail = ltail;
       lheadM = lheadM; ltailM = ltailM; rheadM = rheadM; rtailM = rtailM;
       rview = rview; rhead = rhead; rtail = rtail; null = null;
       size = size; concat = concat; reverse = reverse;
       reverseOnto = reverseOnto; fromList = fromList; toList = toList;
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    mapElem   = unsafeCoerce#
    mapUnElem = unsafeCoerce#
    
    #else
    
    mapElem   = Prelude.map Elem
    mapUnElem = Prelude.map unElem
    
    #endif
    
    null         = FT.null . unSeq
    empty        = Seq FT.empty
    singleton    = Seq . FT.singleton . Elem
    lcons x      = Seq . FT.lcons (Elem x) . unSeq
    rcons x      = Seq . FT.rcons (Elem x) . unSeq
    append p q   = Seq $ FT.append (unSeq p) (unSeq q)
    fromList     = Seq . FT.fromList . mapElem
    toList       = mapUnElem . FT.toList . unSeq
    reverse      = Seq . FT.reverse . unSeq
    size         = unSizeM . measure . unSeq
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    mapElem   = unsafeCoerce#
    mapUnElem = unsafeCoerce#
    
    #else
    
    mapElem   = Prelude.map Elem
    mapUnElem = Prelude.map unElem
    
    #endif
    
    null         = FT.null . unSeq
    empty        = Seq FT.empty
    singleton    = Seq . FT.singleton . Elem
    lcons x      = Seq . FT.lcons (Elem x) . unSeq
    rcons x      = Seq . FT.rcons (Elem x) . unSeq
    append p q   = Seq $ FT.append (unSeq p) (unSeq q)
    fromList     = Seq . FT.fromList . mapElem
    toList       = mapUnElem . FT.toList . unSeq
    reverse      = Seq . FT.reverse . unSeq
    size         = unSizeM . measure . unSeq
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    instance Measured SizeM (Elem a) where
       measure _ = 1
    
    newtype Seq a = Seq (FT.FingerTree SizeM (Elem a))
    
    unSeq :: Seq t -> FT.FingerTree SizeM (Elem t)
    unSeq (Seq ft) = ft
    
    
    
    empty          :: Seq a
    singleton      :: a -> Seq a
    lcons          :: a -> Seq a -> Seq a
    rcons          :: a -> Seq a -> Seq a
    append         :: Seq a -> Seq a -> Seq a
    lview          :: (Monad m) => Seq a -> m (a, Seq a)
    lhead          :: Seq a -> a
    lheadM         :: (Monad m) => Seq a -> m a
    ltail          :: Seq a -> Seq a
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    --   Module      :  Data.Edison.Seq.FingerSeq
    --   Copyright   :  Copyright (c) 2006, 2008 Robert Dockins
    --   License     :  MIT; see COPYRIGHT file for terms and conditions
    --
    --   Maintainer  :  robdockins AT fastmail DOT fm
    --   Stability   :  stable
    --   Portability :  GHC, Hugs (MPTC and FD)
    
    
    module Data.Edison.Seq.FingerSeq (
        -- * Sequence Type
        Seq, -- instance of Sequence, Functor, Monad, MonadPlus
    
        -- * Sequence Operations
        empty,singleton,lcons,rcons,append,lview,lhead,ltail,rview,rhead,rtail,
        lheadM,ltailM,rheadM,rtailM,
        null,size,concat,reverse,reverseOnto,fromList,toList,map,concatMap,
        fold,fold',fold1,fold1',foldr,foldr',foldl,foldl',foldr1,foldr1',foldl1,foldl1',
        reducer,reducer',reducel,reducel',reduce1,reduce1',
        copy,inBounds,lookup,lookupM,lookupWithDefault,update,adjust,
    

    reduce1 See 8 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    -- instances
    
    instance S.Sequence Seq where
      {lcons = lcons; rcons = rcons;
       lview = lview; lhead = lhead; ltail = ltail;
       lheadM = lheadM; ltailM = ltailM; rheadM = rheadM; rtailM = rtailM;
       rview = rview; rhead = rhead; rtail = rtail; null = null;
       size = size; concat = concat; reverse = reverse;
       reverseOnto = reverseOnto; fromList = fromList; toList = toList;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       foldr = foldr; foldr' = foldr'; foldl = foldl; foldl' = foldl';
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
       reducer = reducer; reducer' = reducer'; reducel = reducel;
       reducel' = reducel'; reduce1 = reduce1;  reduce1' = reduce1';
       copy = copy; inBounds = inBounds; lookup = lookup;
       lookupM = lookupM; lookupWithDefault = lookupWithDefault;
       update = update; adjust = adjust; mapWithIndex = mapWithIndex;
       foldrWithIndex = foldrWithIndex; foldlWithIndex = foldlWithIndex;
       foldrWithIndex' = foldrWithIndex'; foldlWithIndex' = foldlWithIndex';
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    -- instances
    
    instance S.Sequence Seq where
      {lcons = lcons; rcons = rcons;
       lview = lview; lhead = lhead; ltail = ltail;
       lheadM = lheadM; ltailM = ltailM; rheadM = rheadM; rtailM = rtailM;
       rview = rview; rhead = rhead; rtail = rtail; null = null;
       size = size; concat = concat; reverse = reverse;
       reverseOnto = reverseOnto; fromList = fromList; toList = toList;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       foldr = foldr; foldr' = foldr'; foldl = foldl; foldl' = foldl';
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
       reducer = reducer; reducer' = reducer'; reducel = reducel;
       reducel' = reducel'; reduce1 = reduce1;  reduce1' = reduce1';
       copy = copy; inBounds = inBounds; lookup = lookup;
       lookupM = lookupM; lookupWithDefault = lookupWithDefault;
       update = update; adjust = adjust; mapWithIndex = mapWithIndex;
       foldrWithIndex = foldrWithIndex; foldlWithIndex = foldlWithIndex;
       foldrWithIndex' = foldrWithIndex'; foldlWithIndex' = foldlWithIndex';
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    foldr  f z (Seq xs) = unElem $ FT.foldFT id (.) (unsafeCoerce# f) xs (Elem z)
    foldr' f z (Seq xs) = unElem $ FT.foldFT id (.) (unsafeCoerce# f) xs (Elem z)
    
    reduce1  f (Seq xs) = unElem $ FT.reduce1  (unsafeCoerce# f) xs
    reduce1' f (Seq xs) = unElem $ FT.reduce1' (unsafeCoerce# f) xs
    
    map f (Seq xs) = Seq $ FT.mapTree (unsafeCoerce# f) xs
    
    #else
    
    foldr  f z (Seq xs) = unElem $ FT.foldFT id (.) ( \(Elem x) (Elem y) -> Elem $ f x y) xs (Elem z)
    foldr' f z (Seq xs) = unElem $ FT.foldFT id (.) ( \(Elem x) (Elem y) -> Elem $ f x y) xs (Elem z)
    
    reduce1  f (Seq xs) = unElem $ FT.reduce1  ( \(Elem x) (Elem y) -> Elem $ f x y) xs
    reduce1' f (Seq xs) = unElem $ FT.reduce1' ( \(Elem x) (Elem y) -> Elem $ f x y) xs
    
    map f (Seq xs) = Seq $ FT.mapTree ( \(Elem x) -> Elem $ f x) xs
    
    #endif
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    foldr  f z (Seq xs) = unElem $ FT.foldFT id (.) (unsafeCoerce# f) xs (Elem z)
    foldr' f z (Seq xs) = unElem $ FT.foldFT id (.) (unsafeCoerce# f) xs (Elem z)
    
    reduce1  f (Seq xs) = unElem $ FT.reduce1  (unsafeCoerce# f) xs
    reduce1' f (Seq xs) = unElem $ FT.reduce1' (unsafeCoerce# f) xs
    
    map f (Seq xs) = Seq $ FT.mapTree (unsafeCoerce# f) xs
    
    #else
    
    foldr  f z (Seq xs) = unElem $ FT.foldFT id (.) ( \(Elem x) (Elem y) -> Elem $ f x y) xs (Elem z)
    foldr' f z (Seq xs) = unElem $ FT.foldFT id (.) ( \(Elem x) (Elem y) -> Elem $ f x y) xs (Elem z)
    
    reduce1  f (Seq xs) = unElem $ FT.reduce1  ( \(Elem x) (Elem y) -> Elem $ f x y) xs
    reduce1' f (Seq xs) = unElem $ FT.reduce1' ( \(Elem x) (Elem y) -> Elem $ f x y) xs
    
    map f (Seq xs) = Seq $ FT.mapTree ( \(Elem x) -> Elem $ f x) xs
    
    #endif
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    ltail = runIdentity . ltailM
    rhead = runIdentity . rheadM
    rtail = runIdentity . rtailM
    
    fold     = foldr
    fold'    = foldr'
    fold1    = foldr1
    fold1'   = foldr1'
    
    #ifdef __GLASGOW_HASKELL__
    
    foldr  f z (Seq xs) = unElem $ FT.foldFT id (.) (unsafeCoerce# f) xs (Elem z)
    foldr' f z (Seq xs) = unElem $ FT.foldFT id (.) (unsafeCoerce# f) xs (Elem z)
    
    reduce1  f (Seq xs) = unElem $ FT.reduce1  (unsafeCoerce# f) xs
    reduce1' f (Seq xs) = unElem $ FT.reduce1' (unsafeCoerce# f) xs
    
    map f (Seq xs) = Seq $ FT.mapTree (unsafeCoerce# f) xs
    
    #else
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    ltail = runIdentity . ltailM
    rhead = runIdentity . rheadM
    rtail = runIdentity . rtailM
    
    fold     = foldr
    fold'    = foldr'
    fold1    = foldr1
    fold1'   = foldr1'
    
    #ifdef __GLASGOW_HASKELL__
    
    foldr  f z (Seq xs) = unElem $ FT.foldFT id (.) (unsafeCoerce# f) xs (Elem z)
    foldr' f z (Seq xs) = unElem $ FT.foldFT id (.) (unsafeCoerce# f) xs (Elem z)
    
    reduce1  f (Seq xs) = unElem $ FT.reduce1  (unsafeCoerce# f) xs
    reduce1' f (Seq xs) = unElem $ FT.reduce1' (unsafeCoerce# f) xs
    
    map f (Seq xs) = Seq $ FT.mapTree (unsafeCoerce# f) xs
    
    #else
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    fromList       :: [a] -> Seq a
    toList         :: Seq a -> [a]
    map            :: (a -> b) -> Seq a -> Seq b
    concatMap      :: (a -> Seq b) -> Seq a -> Seq b
    fold           :: (a -> b -> b) -> b -> Seq a -> b
    fold'          :: (a -> b -> b) -> b -> Seq a -> b
    fold1          :: (a -> a -> a) -> Seq a -> a
    fold1'         :: (a -> a -> a) -> Seq a -> a
    foldr          :: (a -> b -> b) -> b -> Seq a -> b
    foldl          :: (b -> a -> b) -> b -> Seq a -> b
    foldr1         :: (a -> a -> a) -> Seq a -> a
    foldl1         :: (a -> a -> a) -> Seq a -> a
    reducer        :: (a -> a -> a) -> a -> Seq a -> a
    reducel        :: (a -> a -> a) -> a -> Seq a -> a
    reduce1        :: (a -> a -> a) -> Seq a -> a
    foldr'         :: (a -> b -> b) -> b -> Seq a -> b
    foldl'         :: (b -> a -> b) -> b -> Seq a -> b
    foldr1'        :: (a -> a -> a) -> Seq a -> a
    foldl1'        :: (a -> a -> a) -> Seq a -> a
    reducer'       :: (a -> a -> a) -> a -> Seq a -> a
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    --   Maintainer  :  robdockins AT fastmail DOT fm
    --   Stability   :  stable
    --   Portability :  GHC, Hugs (MPTC and FD)
    
    
    module Data.Edison.Seq.FingerSeq (
        -- * Sequence Type
        Seq, -- instance of Sequence, Functor, Monad, MonadPlus
    
        -- * Sequence Operations
        empty,singleton,lcons,rcons,append,lview,lhead,ltail,rview,rhead,rtail,
        lheadM,ltailM,rheadM,rtailM,
        null,size,concat,reverse,reverseOnto,fromList,toList,map,concatMap,
        fold,fold',fold1,fold1',foldr,foldr',foldl,foldl',foldr1,foldr1',foldl1,foldl1',
        reducer,reducer',reducel,reducel',reduce1,reduce1',
        copy,inBounds,lookup,lookupM,lookupWithDefault,update,adjust,
        mapWithIndex,foldrWithIndex,foldlWithIndex,
        take,drop,splitAt,subseq,filter,partition,takeWhile,dropWhile,splitWhile,
        zip,zip3,zipWith,zipWith3,unzip,unzip3,unzipWith,unzipWith3,
        strict, strictWith,
    

    reduce1' See 8 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    -- instances
    
    instance S.Sequence Seq where
      {lcons = lcons; rcons = rcons;
       lview = lview; lhead = lhead; ltail = ltail;
       lheadM = lheadM; ltailM = ltailM; rheadM = rheadM; rtailM = rtailM;
       rview = rview; rhead = rhead; rtail = rtail; null = null;
       size = size; concat = concat; reverse = reverse;
       reverseOnto = reverseOnto; fromList = fromList; toList = toList;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       foldr = foldr; foldr' = foldr'; foldl = foldl; foldl' = foldl';
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
       reducer = reducer; reducer' = reducer'; reducel = reducel;
       reducel' = reducel'; reduce1 = reduce1;  reduce1' = reduce1';
       copy = copy; inBounds = inBounds; lookup = lookup;
       lookupM = lookupM; lookupWithDefault = lookupWithDefault;
       update = update; adjust = adjust; mapWithIndex = mapWithIndex;
       foldrWithIndex = foldrWithIndex; foldlWithIndex = foldlWithIndex;
       foldrWithIndex' = foldrWithIndex'; foldlWithIndex' = foldlWithIndex';
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    -- instances
    
    instance S.Sequence Seq where
      {lcons = lcons; rcons = rcons;
       lview = lview; lhead = lhead; ltail = ltail;
       lheadM = lheadM; ltailM = ltailM; rheadM = rheadM; rtailM = rtailM;
       rview = rview; rhead = rhead; rtail = rtail; null = null;
       size = size; concat = concat; reverse = reverse;
       reverseOnto = reverseOnto; fromList = fromList; toList = toList;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       foldr = foldr; foldr' = foldr'; foldl = foldl; foldl' = foldl';
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
       reducer = reducer; reducer' = reducer'; reducel = reducel;
       reducel' = reducel'; reduce1 = reduce1;  reduce1' = reduce1';
       copy = copy; inBounds = inBounds; lookup = lookup;
       lookupM = lookupM; lookupWithDefault = lookupWithDefault;
       update = update; adjust = adjust; mapWithIndex = mapWithIndex;
       foldrWithIndex = foldrWithIndex; foldlWithIndex = foldlWithIndex;
       foldrWithIndex' = foldrWithIndex'; foldlWithIndex' = foldlWithIndex';
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    foldr  f z (Seq xs) = unElem $ FT.foldFT id (.) (unsafeCoerce# f) xs (Elem z)
    foldr' f z (Seq xs) = unElem $ FT.foldFT id (.) (unsafeCoerce# f) xs (Elem z)
    
    reduce1  f (Seq xs) = unElem $ FT.reduce1  (unsafeCoerce# f) xs
    reduce1' f (Seq xs) = unElem $ FT.reduce1' (unsafeCoerce# f) xs
    
    map f (Seq xs) = Seq $ FT.mapTree (unsafeCoerce# f) xs
    
    #else
    
    foldr  f z (Seq xs) = unElem $ FT.foldFT id (.) ( \(Elem x) (Elem y) -> Elem $ f x y) xs (Elem z)
    foldr' f z (Seq xs) = unElem $ FT.foldFT id (.) ( \(Elem x) (Elem y) -> Elem $ f x y) xs (Elem z)
    
    reduce1  f (Seq xs) = unElem $ FT.reduce1  ( \(Elem x) (Elem y) -> Elem $ f x y) xs
    reduce1' f (Seq xs) = unElem $ FT.reduce1' ( \(Elem x) (Elem y) -> Elem $ f x y) xs
    
    map f (Seq xs) = Seq $ FT.mapTree ( \(Elem x) -> Elem $ f x) xs
    
    #endif
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    foldr  f z (Seq xs) = unElem $ FT.foldFT id (.) (unsafeCoerce# f) xs (Elem z)
    foldr' f z (Seq xs) = unElem $ FT.foldFT id (.) (unsafeCoerce# f) xs (Elem z)
    
    reduce1  f (Seq xs) = unElem $ FT.reduce1  (unsafeCoerce# f) xs
    reduce1' f (Seq xs) = unElem $ FT.reduce1' (unsafeCoerce# f) xs
    
    map f (Seq xs) = Seq $ FT.mapTree (unsafeCoerce# f) xs
    
    #else
    
    foldr  f z (Seq xs) = unElem $ FT.foldFT id (.) ( \(Elem x) (Elem y) -> Elem $ f x y) xs (Elem z)
    foldr' f z (Seq xs) = unElem $ FT.foldFT id (.) ( \(Elem x) (Elem y) -> Elem $ f x y) xs (Elem z)
    
    reduce1  f (Seq xs) = unElem $ FT.reduce1  ( \(Elem x) (Elem y) -> Elem $ f x y) xs
    reduce1' f (Seq xs) = unElem $ FT.reduce1' ( \(Elem x) (Elem y) -> Elem $ f x y) xs
    
    map f (Seq xs) = Seq $ FT.mapTree ( \(Elem x) -> Elem $ f x) xs
    
    #endif
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    rhead = runIdentity . rheadM
    rtail = runIdentity . rtailM
    
    fold     = foldr
    fold'    = foldr'
    fold1    = foldr1
    fold1'   = foldr1'
    
    #ifdef __GLASGOW_HASKELL__
    
    foldr  f z (Seq xs) = unElem $ FT.foldFT id (.) (unsafeCoerce# f) xs (Elem z)
    foldr' f z (Seq xs) = unElem $ FT.foldFT id (.) (unsafeCoerce# f) xs (Elem z)
    
    reduce1  f (Seq xs) = unElem $ FT.reduce1  (unsafeCoerce# f) xs
    reduce1' f (Seq xs) = unElem $ FT.reduce1' (unsafeCoerce# f) xs
    
    map f (Seq xs) = Seq $ FT.mapTree (unsafeCoerce# f) xs
    
    #else
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    rhead = runIdentity . rheadM
    rtail = runIdentity . rtailM
    
    fold     = foldr
    fold'    = foldr'
    fold1    = foldr1
    fold1'   = foldr1'
    
    #ifdef __GLASGOW_HASKELL__
    
    foldr  f z (Seq xs) = unElem $ FT.foldFT id (.) (unsafeCoerce# f) xs (Elem z)
    foldr' f z (Seq xs) = unElem $ FT.foldFT id (.) (unsafeCoerce# f) xs (Elem z)
    
    reduce1  f (Seq xs) = unElem $ FT.reduce1  (unsafeCoerce# f) xs
    reduce1' f (Seq xs) = unElem $ FT.reduce1' (unsafeCoerce# f) xs
    
    map f (Seq xs) = Seq $ FT.mapTree (unsafeCoerce# f) xs
    
    #else
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    fold1'         :: (a -> a -> a) -> Seq a -> a
    foldr          :: (a -> b -> b) -> b -> Seq a -> b
    foldl          :: (b -> a -> b) -> b -> Seq a -> b
    foldr1         :: (a -> a -> a) -> Seq a -> a
    foldl1         :: (a -> a -> a) -> Seq a -> a
    reducer        :: (a -> a -> a) -> a -> Seq a -> a
    reducel        :: (a -> a -> a) -> a -> Seq a -> a
    reduce1        :: (a -> a -> a) -> Seq a -> a
    foldr'         :: (a -> b -> b) -> b -> Seq a -> b
    foldl'         :: (b -> a -> b) -> b -> Seq a -> b
    foldr1'        :: (a -> a -> a) -> Seq a -> a
    foldl1'        :: (a -> a -> a) -> Seq a -> a
    reducer'       :: (a -> a -> a) -> a -> Seq a -> a
    reducel'       :: (a -> a -> a) -> a -> Seq a -> a
    reduce1'       :: (a -> a -> a) -> Seq a -> a
    copy           :: Int -> a -> Seq a
    inBounds       :: Int -> Seq a -> Bool
    lookup         :: Int -> Seq a -> a
    lookupM        :: (Monad m) => Int -> Seq a -> m a
    lookupWithDefault :: a -> Int -> Seq a -> a
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    --   Maintainer  :  robdockins AT fastmail DOT fm
    --   Stability   :  stable
    --   Portability :  GHC, Hugs (MPTC and FD)
    
    
    module Data.Edison.Seq.FingerSeq (
        -- * Sequence Type
        Seq, -- instance of Sequence, Functor, Monad, MonadPlus
    
        -- * Sequence Operations
        empty,singleton,lcons,rcons,append,lview,lhead,ltail,rview,rhead,rtail,
        lheadM,ltailM,rheadM,rtailM,
        null,size,concat,reverse,reverseOnto,fromList,toList,map,concatMap,
        fold,fold',fold1,fold1',foldr,foldr',foldl,foldl',foldr1,foldr1',foldl1,foldl1',
        reducer,reducer',reducel,reducel',reduce1,reduce1',
        copy,inBounds,lookup,lookupM,lookupWithDefault,update,adjust,
        mapWithIndex,foldrWithIndex,foldlWithIndex,
        take,drop,splitAt,subseq,filter,partition,takeWhile,dropWhile,splitWhile,
        zip,zip3,zipWith,zipWith3,unzip,unzip3,unzipWith,unzipWith3,
        strict, strictWith,
    

    reverse See 7 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    zipWith3 = zipWith3UsingLview
    
    unzip = unzipUsingFoldr
    unzip3 = unzip3UsingFoldr
    unzipWith = unzipWithUsingFoldr
    unzipWith3 = unzipWith3UsingFoldr
    
    -- instances
    
    instance S.Sequence Seq where
      {lcons = lcons; rcons = rcons;
       lview = lview; lhead = lhead; ltail = ltail;
       lheadM = lheadM; ltailM = ltailM; rheadM = rheadM; rtailM = rtailM;
       rview = rview; rhead = rhead; rtail = rtail; null = null;
       size = size; concat = concat; reverse = reverse;
       reverseOnto = reverseOnto; fromList = fromList; toList = toList;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       foldr = foldr; foldr' = foldr'; foldl = foldl; foldl' = foldl';
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
       reducer = reducer; reducer' = reducer'; reducel = reducel;
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    zipWith3 = zipWith3UsingLview
    
    unzip = unzipUsingFoldr
    unzip3 = unzip3UsingFoldr
    unzipWith = unzipWithUsingFoldr
    unzipWith3 = unzipWith3UsingFoldr
    
    -- instances
    
    instance S.Sequence Seq where
      {lcons = lcons; rcons = rcons;
       lview = lview; lhead = lhead; ltail = ltail;
       lheadM = lheadM; ltailM = ltailM; rheadM = rheadM; rtailM = rtailM;
       rview = rview; rhead = rhead; rtail = rtail; null = null;
       size = size; concat = concat; reverse = reverse;
       reverseOnto = reverseOnto; fromList = fromList; toList = toList;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       foldr = foldr; foldr' = foldr'; foldl = foldl; foldl' = foldl';
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
       reducer = reducer; reducer' = reducer'; reducel = reducel;
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    mapElem   = Prelude.map Elem
    mapUnElem = Prelude.map unElem
    
    #endif
    
    null         = FT.null . unSeq
    empty        = Seq FT.empty
    singleton    = Seq . FT.singleton . Elem
    lcons x      = Seq . FT.lcons (Elem x) . unSeq
    rcons x      = Seq . FT.rcons (Elem x) . unSeq
    append p q   = Seq $ FT.append (unSeq p) (unSeq q)
    fromList     = Seq . FT.fromList . mapElem
    toList       = mapUnElem . FT.toList . unSeq
    reverse      = Seq . FT.reverse . unSeq
    size         = unSizeM . measure . unSeq
    strict       = Seq . FT.strict . unSeq
    strictWith f = Seq . FT.strictWith (f . unElem) . unSeq
    structuralInvariant = FT.structuralInvariant . unSeq
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    mapElem   = Prelude.map Elem
    mapUnElem = Prelude.map unElem
    
    #endif
    
    null         = FT.null . unSeq
    empty        = Seq FT.empty
    singleton    = Seq . FT.singleton . Elem
    lcons x      = Seq . FT.lcons (Elem x) . unSeq
    rcons x      = Seq . FT.rcons (Elem x) . unSeq
    append p q   = Seq $ FT.append (unSeq p) (unSeq q)
    fromList     = Seq . FT.fromList . mapElem
    toList       = mapUnElem . FT.toList . unSeq
    reverse      = Seq . FT.reverse . unSeq
    size         = unSizeM . measure . unSeq
    strict       = Seq . FT.strict . unSeq
    strictWith f = Seq . FT.strictWith (f . unElem) . unSeq
    structuralInvariant = FT.structuralInvariant . unSeq
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    append         :: Seq a -> Seq a -> Seq a
    lview          :: (Monad m) => Seq a -> m (a, Seq a)
    lhead          :: Seq a -> a
    lheadM         :: (Monad m) => Seq a -> m a
    ltail          :: Seq a -> Seq a
    ltailM         :: (Monad m) => Seq a -> m (Seq a)
    rview          :: (Monad m) => Seq a -> m (a, Seq a)
    rhead          :: Seq a -> a
    rheadM         :: (Monad m) => Seq a -> m a
    rtail          :: Seq a -> Seq a
    rtailM         :: (Monad m) => Seq a -> m (Seq a)
    null           :: Seq a -> Bool
    size           :: Seq a -> Int
    concat         :: Seq (Seq a) -> Seq a
    reverse        :: Seq a -> Seq a
    reverseOnto    :: Seq a -> Seq a -> Seq a
    fromList       :: [a] -> Seq a
    toList         :: Seq a -> [a]
    map            :: (a -> b) -> Seq a -> Seq b
    concatMap      :: (a -> Seq b) -> Seq a -> Seq b
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
        copy,inBounds,lookup,lookupM,lookupWithDefault,update,adjust,
        mapWithIndex,foldrWithIndex,foldlWithIndex,
        take,drop,splitAt,subseq,filter,partition,takeWhile,dropWhile,splitWhile,
        zip,zip3,zipWith,zipWith3,unzip,unzip3,unzipWith,unzipWith3,
        strict, strictWith,
    
        -- * Unit testing
        structuralInvariant,
    
        -- * Documentation
        moduleName
    ) where
    
    import qualified Prelude
    import Prelude hiding (concat,reverse,map,concatMap,foldr,foldl,foldr1,foldl1,
                           filter,takeWhile,dropWhile,lookup,take,drop,splitAt,
                           zip,zip3,zipWith,zipWith3,unzip,unzip3,null)
    
    import qualified Control.Applicative as App
    import Data.Edison.Prelude (measure, Measured())
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    --   License     :  MIT; see COPYRIGHT file for terms and conditions
    --
    --   Maintainer  :  robdockins AT fastmail DOT fm
    --   Stability   :  stable
    --   Portability :  GHC, Hugs (MPTC and FD)
    
    
    module Data.Edison.Seq.FingerSeq (
        -- * Sequence Type
        Seq, -- instance of Sequence, Functor, Monad, MonadPlus
    
        -- * Sequence Operations
        empty,singleton,lcons,rcons,append,lview,lhead,ltail,rview,rhead,rtail,
        lheadM,ltailM,rheadM,rtailM,
        null,size,concat,reverse,reverseOnto,fromList,toList,map,concatMap,
        fold,fold',fold1,fold1',foldr,foldr',foldl,foldl',foldr1,foldr1',foldl1,foldl1',
        reducer,reducer',reducel,reducel',reduce1,reduce1',
        copy,inBounds,lookup,lookupM,lookupWithDefault,update,adjust,
        mapWithIndex,foldrWithIndex,foldlWithIndex,
        take,drop,splitAt,subseq,filter,partition,takeWhile,dropWhile,splitWhile,
    

    rview See 12 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    zipWith = zipWithUsingLview
    zipWith3 = zipWith3UsingLview
    
    unzip = unzipUsingFoldr
    unzip3 = unzip3UsingFoldr
    unzipWith = unzipWithUsingFoldr
    unzipWith3 = unzipWith3UsingFoldr
    
    -- instances
    
    instance S.Sequence Seq where
      {lcons = lcons; rcons = rcons;
       lview = lview; lhead = lhead; ltail = ltail;
       lheadM = lheadM; ltailM = ltailM; rheadM = rheadM; rtailM = rtailM;
       rview = rview; rhead = rhead; rtail = rtail; null = null;
       size = size; concat = concat; reverse = reverse;
       reverseOnto = reverseOnto; fromList = fromList; toList = toList;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       foldr = foldr; foldr' = foldr'; foldl = foldl; foldl' = foldl';
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    zipWith = zipWithUsingLview
    zipWith3 = zipWith3UsingLview
    
    unzip = unzipUsingFoldr
    unzip3 = unzip3UsingFoldr
    unzipWith = unzipWithUsingFoldr
    unzipWith3 = unzipWith3UsingFoldr
    
    -- instances
    
    instance S.Sequence Seq where
      {lcons = lcons; rcons = rcons;
       lview = lview; lhead = lhead; ltail = ltail;
       lheadM = lheadM; ltailM = ltailM; rheadM = rheadM; rtailM = rtailM;
       rview = rview; rhead = rhead; rtail = rtail; null = null;
       size = size; concat = concat; reverse = reverse;
       reverseOnto = reverseOnto; fromList = fromList; toList = toList;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       foldr = foldr; foldr' = foldr'; foldl = foldl; foldl' = foldl';
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    take i (Seq xs) = Seq $ FT.takeUntil (> (SizeM i)) xs
    drop i (Seq xs) = Seq $ FT.dropUntil (> (SizeM i)) xs
    splitAt i (Seq xs) = let (a,b) = FT.split (> (SizeM i)) xs in (Seq a, Seq b)
    
    
    inBounds = inBoundsUsingSize
    lookup   = lookupUsingLookupM
    
    foldr1 f xs =
       case rview xs of
          Nothing      -> error "FingerSeq.foldr1: empty sequence"
          Just (x,xs') -> foldr f x xs'
    
    foldr1' f xs =
       case rview xs of
          Nothing      -> error "FingerSeq.foldr1': empty sequence"
          Just (x,xs') -> foldr' f x xs'
    
    foldl    = foldlUsingLists
    foldl'   = foldl'UsingLists
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
            case FT.splitTree (> (SizeM i)) (SizeM 0) xs of
               FT.Split l x r -> Seq $ FT.append l $ FT.lcons (Elem (f (unElem x))) $ r
    
        | otherwise = Seq xs
    
    take i (Seq xs) = Seq $ FT.takeUntil (> (SizeM i)) xs
    drop i (Seq xs) = Seq $ FT.dropUntil (> (SizeM i)) xs
    splitAt i (Seq xs) = let (a,b) = FT.split (> (SizeM i)) xs in (Seq a, Seq b)
    
    
    inBounds = inBoundsUsingSize
    lookup   = lookupUsingLookupM
    
    foldr1 f xs =
       case rview xs of
          Nothing      -> error "FingerSeq.foldr1: empty sequence"
          Just (x,xs') -> foldr f x xs'
    
    foldr1' f xs =
       case rview xs of
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
      let f = unsafeCoerce# :: Monad m => m (Elem a,FT.FingerTree SizeM (Elem a)) -> m (a,Seq a)
      in  f (FT.rview xs)
    
    #else
    
    lview (Seq xs) = FT.lview xs >>= \(Elem a, zs) -> return (a, Seq zs)
    rview (Seq xs) = FT.rview xs >>= \(Elem a, zs) -> return (a, Seq zs)
    
    #endif
    
    
    lheadM xs = lview xs >>= return . fst
    ltailM xs = lview xs >>= return . snd
    rheadM xs = rview xs >>= return . fst
    rtailM xs = rview xs >>= return . snd
    lhead = runIdentity . lheadM
    ltail = runIdentity . ltailM
    rhead = runIdentity . rheadM
    rtail = runIdentity . rtailM
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    rview (Seq xs) =
      let f = unsafeCoerce# :: Monad m => m (Elem a,FT.FingerTree SizeM (Elem a)) -> m (a,Seq a)
      in  f (FT.rview xs)
    
    #else
    
    lview (Seq xs) = FT.lview xs >>= \(Elem a, zs) -> return (a, Seq zs)
    rview (Seq xs) = FT.rview xs >>= \(Elem a, zs) -> return (a, Seq zs)
    
    #endif
    
    
    lheadM xs = lview xs >>= return . fst
    ltailM xs = lview xs >>= return . snd
    rheadM xs = rview xs >>= return . fst
    rtailM xs = rview xs >>= return . snd
    lhead = runIdentity . lheadM
    ltail = runIdentity . ltailM
    rhead = runIdentity . rheadM
    rtail = runIdentity . rtailM
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    #ifdef __GLASGOW_HASKELL__
    
    lview (Seq xs) =
      let f = unsafeCoerce# :: Monad m => m (Elem a,FT.FingerTree SizeM (Elem a)) -> m (a,Seq a)
      in  f (FT.lview xs)
    
    rview (Seq xs) =
      let f = unsafeCoerce# :: Monad m => m (Elem a,FT.FingerTree SizeM (Elem a)) -> m (a,Seq a)
      in  f (FT.rview xs)
    
    #else
    
    lview (Seq xs) = FT.lview xs >>= \(Elem a, zs) -> return (a, Seq zs)
    rview (Seq xs) = FT.rview xs >>= \(Elem a, zs) -> return (a, Seq zs)
    
    #endif
    
    
    lheadM xs = lview xs >>= return . fst
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    #ifdef __GLASGOW_HASKELL__
    
    lview (Seq xs) =
      let f = unsafeCoerce# :: Monad m => m (Elem a,FT.FingerTree SizeM (Elem a)) -> m (a,Seq a)
      in  f (FT.lview xs)
    
    rview (Seq xs) =
      let f = unsafeCoerce# :: Monad m => m (Elem a,FT.FingerTree SizeM (Elem a)) -> m (a,Seq a)
      in  f (FT.rview xs)
    
    #else
    
    lview (Seq xs) = FT.lview xs >>= \(Elem a, zs) -> return (a, Seq zs)
    rview (Seq xs) = FT.rview xs >>= \(Elem a, zs) -> return (a, Seq zs)
    
    #endif
    
    
    lheadM xs = lview xs >>= return . fst
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    reverse      = Seq . FT.reverse . unSeq
    size         = unSizeM . measure . unSeq
    strict       = Seq . FT.strict . unSeq
    strictWith f = Seq . FT.strictWith (f . unElem) . unSeq
    structuralInvariant = FT.structuralInvariant . unSeq
    
    #ifdef __GLASGOW_HASKELL__
    
    lview (Seq xs) =
      let f = unsafeCoerce# :: Monad m => m (Elem a,FT.FingerTree SizeM (Elem a)) -> m (a,Seq a)
      in  f (FT.lview xs)
    
    rview (Seq xs) =
      let f = unsafeCoerce# :: Monad m => m (Elem a,FT.FingerTree SizeM (Elem a)) -> m (a,Seq a)
      in  f (FT.rview xs)
    
    #else
    
    lview (Seq xs) = FT.lview xs >>= \(Elem a, zs) -> return (a, Seq zs)
    rview (Seq xs) = FT.rview xs >>= \(Elem a, zs) -> return (a, Seq zs)
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    fromList     = Seq . FT.fromList . mapElem
    toList       = mapUnElem . FT.toList . unSeq
    reverse      = Seq . FT.reverse . unSeq
    size         = unSizeM . measure . unSeq
    strict       = Seq . FT.strict . unSeq
    strictWith f = Seq . FT.strictWith (f . unElem) . unSeq
    structuralInvariant = FT.structuralInvariant . unSeq
    
    #ifdef __GLASGOW_HASKELL__
    
    lview (Seq xs) =
      let f = unsafeCoerce# :: Monad m => m (Elem a,FT.FingerTree SizeM (Elem a)) -> m (a,Seq a)
      in  f (FT.lview xs)
    
    rview (Seq xs) =
      let f = unsafeCoerce# :: Monad m => m (Elem a,FT.FingerTree SizeM (Elem a)) -> m (a,Seq a)
      in  f (FT.rview xs)
    
    #else
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    unSeq (Seq ft) = ft
    
    
    
    empty          :: Seq a
    singleton      :: a -> Seq a
    lcons          :: a -> Seq a -> Seq a
    rcons          :: a -> Seq a -> Seq a
    append         :: Seq a -> Seq a -> Seq a
    lview          :: (Monad m) => Seq a -> m (a, Seq a)
    lhead          :: Seq a -> a
    lheadM         :: (Monad m) => Seq a -> m a
    ltail          :: Seq a -> Seq a
    ltailM         :: (Monad m) => Seq a -> m (Seq a)
    rview          :: (Monad m) => Seq a -> m (a, Seq a)
    rhead          :: Seq a -> a
    rheadM         :: (Monad m) => Seq a -> m a
    rtail          :: Seq a -> Seq a
    rtailM         :: (Monad m) => Seq a -> m (Seq a)
    null           :: Seq a -> Bool
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    --   Module      :  Data.Edison.Seq.FingerSeq
    --   Copyright   :  Copyright (c) 2006, 2008 Robert Dockins
    --   License     :  MIT; see COPYRIGHT file for terms and conditions
    --
    --   Maintainer  :  robdockins AT fastmail DOT fm
    --   Stability   :  stable
    --   Portability :  GHC, Hugs (MPTC and FD)
    
    
    module Data.Edison.Seq.FingerSeq (
        -- * Sequence Type
        Seq, -- instance of Sequence, Functor, Monad, MonadPlus
    
        -- * Sequence Operations
        empty,singleton,lcons,rcons,append,lview,lhead,ltail,rview,rhead,rtail,
        lheadM,ltailM,rheadM,rtailM,
        null,size,concat,reverse,reverseOnto,fromList,toList,map,concatMap,
        fold,fold',fold1,fold1',foldr,foldr',foldl,foldl',foldr1,foldr1',foldl1,foldl1',
        reducer,reducer',reducel,reducel',reduce1,reduce1',
        copy,inBounds,lookup,lookupM,lookupWithDefault,update,adjust,
    

    singleton See 5 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
      fmap = map
    
    instance App.Alternative Seq where
      empty = empty
      (<|>) = append
    
    instance App.Applicative Seq where
      pure = return
      x <*> y = do
         x' <- x
         y' <- y
         return (x' y')
    
    instance Monad Seq where
      return = singleton
      xs >>= k = concatMap k xs
    
    instance MonadPlus Seq where
      mplus = append
      mzero = empty
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    mapElem, mapUnElem :: t -> b
    mapElem   = unsafeCoerce#
    mapUnElem = unsafeCoerce#
    
    #else
    
    mapElem   = Prelude.map Elem
    mapUnElem = Prelude.map unElem
    
    #endif
    
    null         = FT.null . unSeq
    empty        = Seq FT.empty
    singleton    = Seq . FT.singleton . Elem
    lcons x      = Seq . FT.lcons (Elem x) . unSeq
    rcons x      = Seq . FT.rcons (Elem x) . unSeq
    append p q   = Seq $ FT.append (unSeq p) (unSeq q)
    fromList     = Seq . FT.fromList . mapElem
    toList       = mapUnElem . FT.toList . unSeq
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    mapElem, mapUnElem :: t -> b
    mapElem   = unsafeCoerce#
    mapUnElem = unsafeCoerce#
    
    #else
    
    mapElem   = Prelude.map Elem
    mapUnElem = Prelude.map unElem
    
    #endif
    
    null         = FT.null . unSeq
    empty        = Seq FT.empty
    singleton    = Seq . FT.singleton . Elem
    lcons x      = Seq . FT.lcons (Elem x) . unSeq
    rcons x      = Seq . FT.rcons (Elem x) . unSeq
    append p q   = Seq $ FT.append (unSeq p) (unSeq q)
    fromList     = Seq . FT.fromList . mapElem
    toList       = mapUnElem . FT.toList . unSeq
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    unElem :: Elem t -> t
    unElem (Elem x) = x
    
    instance Measured SizeM (Elem a) where
       measure _ = 1
    
    newtype Seq a = Seq (FT.FingerTree SizeM (Elem a))
    
    unSeq :: Seq t -> FT.FingerTree SizeM (Elem t)
    unSeq (Seq ft) = ft
    
    
    
    empty          :: Seq a
    singleton      :: a -> Seq a
    lcons          :: a -> Seq a -> Seq a
    rcons          :: a -> Seq a -> Seq a
    append         :: Seq a -> Seq a -> Seq a
    lview          :: (Monad m) => Seq a -> m (a, Seq a)
    lhead          :: Seq a -> a
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    --   Module      :  Data.Edison.Seq.FingerSeq
    --   Copyright   :  Copyright (c) 2006, 2008 Robert Dockins
    --   License     :  MIT; see COPYRIGHT file for terms and conditions
    --
    --   Maintainer  :  robdockins AT fastmail DOT fm
    --   Stability   :  stable
    --   Portability :  GHC, Hugs (MPTC and FD)
    
    
    module Data.Edison.Seq.FingerSeq (
        -- * Sequence Type
        Seq, -- instance of Sequence, Functor, Monad, MonadPlus
    
        -- * Sequence Operations
        empty,singleton,lcons,rcons,append,lview,lhead,ltail,rview,rhead,rtail,
        lheadM,ltailM,rheadM,rtailM,
        null,size,concat,reverse,reverseOnto,fromList,toList,map,concatMap,
        fold,fold',fold1,fold1',foldr,foldr',foldl,foldl',foldr1,foldr1',foldl1,foldl1',
        reducer,reducer',reducel,reducel',reduce1,reduce1',
        copy,inBounds,lookup,lookupM,lookupWithDefault,update,adjust,
    

    size See 5 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    zipWith3 = zipWith3UsingLview
    
    unzip = unzipUsingFoldr
    unzip3 = unzip3UsingFoldr
    unzipWith = unzipWithUsingFoldr
    unzipWith3 = unzipWith3UsingFoldr
    
    -- instances
    
    instance S.Sequence Seq where
      {lcons = lcons; rcons = rcons;
       lview = lview; lhead = lhead; ltail = ltail;
       lheadM = lheadM; ltailM = ltailM; rheadM = rheadM; rtailM = rtailM;
       rview = rview; rhead = rhead; rtail = rtail; null = null;
       size = size; concat = concat; reverse = reverse;
       reverseOnto = reverseOnto; fromList = fromList; toList = toList;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       foldr = foldr; foldr' = foldr'; foldl = foldl; foldl' = foldl';
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
       reducer = reducer; reducer' = reducer'; reducel = reducel;
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    zipWith3 = zipWith3UsingLview
    
    unzip = unzipUsingFoldr
    unzip3 = unzip3UsingFoldr
    unzipWith = unzipWithUsingFoldr
    unzipWith3 = unzipWith3UsingFoldr
    
    -- instances
    
    instance S.Sequence Seq where
      {lcons = lcons; rcons = rcons;
       lview = lview; lhead = lhead; ltail = ltail;
       lheadM = lheadM; ltailM = ltailM; rheadM = rheadM; rtailM = rtailM;
       rview = rview; rhead = rhead; rtail = rtail; null = null;
       size = size; concat = concat; reverse = reverse;
       reverseOnto = reverseOnto; fromList = fromList; toList = toList;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       foldr = foldr; foldr' = foldr'; foldl = foldl; foldl' = foldl';
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
       reducer = reducer; reducer' = reducer'; reducel = reducel;
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    mapElem   = Prelude.map Elem
    mapUnElem = Prelude.map unElem
    
    #endif
    
    null         = FT.null . unSeq
    empty        = Seq FT.empty
    singleton    = Seq . FT.singleton . Elem
    lcons x      = Seq . FT.lcons (Elem x) . unSeq
    rcons x      = Seq . FT.rcons (Elem x) . unSeq
    append p q   = Seq $ FT.append (unSeq p) (unSeq q)
    fromList     = Seq . FT.fromList . mapElem
    toList       = mapUnElem . FT.toList . unSeq
    reverse      = Seq . FT.reverse . unSeq
    size         = unSizeM . measure . unSeq
    strict       = Seq . FT.strict . unSeq
    strictWith f = Seq . FT.strictWith (f . unElem) . unSeq
    structuralInvariant = FT.structuralInvariant . unSeq
    
    #ifdef __GLASGOW_HASKELL__
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    lcons          :: a -> Seq a -> Seq a
    rcons          :: a -> Seq a -> Seq a
    append         :: Seq a -> Seq a -> Seq a
    lview          :: (Monad m) => Seq a -> m (a, Seq a)
    lhead          :: Seq a -> a
    lheadM         :: (Monad m) => Seq a -> m a
    ltail          :: Seq a -> Seq a
    ltailM         :: (Monad m) => Seq a -> m (Seq a)
    rview          :: (Monad m) => Seq a -> m (a, Seq a)
    rhead          :: Seq a -> a
    rheadM         :: (Monad m) => Seq a -> m a
    rtail          :: Seq a -> Seq a
    rtailM         :: (Monad m) => Seq a -> m (Seq a)
    null           :: Seq a -> Bool
    size           :: Seq a -> Int
    concat         :: Seq (Seq a) -> Seq a
    reverse        :: Seq a -> Seq a
    reverseOnto    :: Seq a -> Seq a -> Seq a
    fromList       :: [a] -> Seq a
    toList         :: Seq a -> [a]
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    --   License     :  MIT; see COPYRIGHT file for terms and conditions
    --
    --   Maintainer  :  robdockins AT fastmail DOT fm
    --   Stability   :  stable
    --   Portability :  GHC, Hugs (MPTC and FD)
    
    
    module Data.Edison.Seq.FingerSeq (
        -- * Sequence Type
        Seq, -- instance of Sequence, Functor, Monad, MonadPlus
    
        -- * Sequence Operations
        empty,singleton,lcons,rcons,append,lview,lhead,ltail,rview,rhead,rtail,
        lheadM,ltailM,rheadM,rtailM,
        null,size,concat,reverse,reverseOnto,fromList,toList,map,concatMap,
        fold,fold',fold1,fold1',foldr,foldr',foldl,foldl',foldr1,foldr1',foldl1,foldl1',
        reducer,reducer',reducel,reducel',reduce1,reduce1',
        copy,inBounds,lookup,lookupM,lookupWithDefault,update,adjust,
        mapWithIndex,foldrWithIndex,foldlWithIndex,
        take,drop,splitAt,subseq,filter,partition,takeWhile,dropWhile,splitWhile,
    

    split See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
            case FT.splitTree (> (SizeM i)) (SizeM 0) xs of
               FT.Split l _ r -> Seq $ FT.append l $ FT.lcons (Elem x) $ r
    
        | otherwise = Seq xs
    
    adjust f i (Seq xs)
        | inBounds i (Seq xs) =
            case FT.splitTree (> (SizeM i)) (SizeM 0) xs of
               FT.Split l x r -> Seq $ FT.append l $ FT.lcons (Elem (f (unElem x))) $ r
    
        | otherwise = Seq xs
    
    take i (Seq xs) = Seq $ FT.takeUntil (> (SizeM i)) xs
    drop i (Seq xs) = Seq $ FT.dropUntil (> (SizeM i)) xs
    splitAt i (Seq xs) = let (a,b) = FT.split (> (SizeM i)) xs in (Seq a, Seq b)
    
    
    inBounds = inBoundsUsingSize
    lookup   = lookupUsingLookupM
    

    splitTree See 4 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
            case FT.splitTree (> (SizeM i)) (SizeM 0) xs of
               FT.Split _ (Elem x) _ -> x
    
        | otherwise = d
    
    update i x (Seq xs)
        | inBounds i (Seq xs) =
            case FT.splitTree (> (SizeM i)) (SizeM 0) xs of
               FT.Split l _ r -> Seq $ FT.append l $ FT.lcons (Elem x) $ r
    
        | otherwise = Seq xs
    
    adjust f i (Seq xs)
        | inBounds i (Seq xs) =
            case FT.splitTree (> (SizeM i)) (SizeM 0) xs of
               FT.Split l x r -> Seq $ FT.append l $ FT.lcons (Elem (f (unElem x))) $ r
    
        | otherwise = Seq xs
    
    take i (Seq xs) = Seq $ FT.takeUntil (> (SizeM i)) xs
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
            case FT.splitTree (> (SizeM i)) (SizeM 0) xs of
               FT.Split _ (Elem x) _ -> return x
    
        | otherwise = fail "FingerSeq.lookupM: index out of bounds"
    
    lookupWithDefault d i (Seq xs)
        | inBounds i (Seq xs) =
            case FT.splitTree (> (SizeM i)) (SizeM 0) xs of
               FT.Split _ (Elem x) _ -> x
    
        | otherwise = d
    
    update i x (Seq xs)
        | inBounds i (Seq xs) =
            case FT.splitTree (> (SizeM i)) (SizeM 0) xs of
               FT.Split l _ r -> Seq $ FT.append l $ FT.lcons (Elem x) $ r
    
        | otherwise = Seq xs
    
    adjust f i (Seq xs)
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    map f (Seq xs) = Seq $ FT.mapTree ( \(Elem x) -> Elem $ f x) xs
    
    #endif
    
    lookupM i (Seq xs)
        | inBounds i (Seq xs) =
            case FT.splitTree (> (SizeM i)) (SizeM 0) xs of
               FT.Split _ (Elem x) _ -> return x
    
        | otherwise = fail "FingerSeq.lookupM: index out of bounds"
    
    lookupWithDefault d i (Seq xs)
        | inBounds i (Seq xs) =
            case FT.splitTree (> (SizeM i)) (SizeM 0) xs of
               FT.Split _ (Elem x) _ -> x
    
        | otherwise = d
    
    update i x (Seq xs)
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    #else
    
    foldr  f z (Seq xs) = unElem $ FT.foldFT id (.) ( \(Elem x) (Elem y) -> Elem $ f x y) xs (Elem z)
    foldr' f z (Seq xs) = unElem $ FT.foldFT id (.) ( \(Elem x) (Elem y) -> Elem $ f x y) xs (Elem z)
    
    reduce1  f (Seq xs) = unElem $ FT.reduce1  ( \(Elem x) (Elem y) -> Elem $ f x y) xs
    reduce1' f (Seq xs) = unElem $ FT.reduce1' ( \(Elem x) (Elem y) -> Elem $ f x y) xs
    
    map f (Seq xs) = Seq $ FT.mapTree ( \(Elem x) -> Elem $ f x) xs
    
    #endif
    
    lookupM i (Seq xs)
        | inBounds i (Seq xs) =
            case FT.splitTree (> (SizeM i)) (SizeM 0) xs of
               FT.Split _ (Elem x) _ -> return x
    
        | otherwise = fail "FingerSeq.lookupM: index out of bounds"
    
    lookupWithDefault d i (Seq xs)
    

    strict See 6 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
       foldr = foldr; foldr' = foldr'; foldl = foldl; foldl' = foldl';
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
       reducer = reducer; reducer' = reducer'; reducel = reducel;
       reducel' = reducel'; reduce1 = reduce1;  reduce1' = reduce1';
       copy = copy; inBounds = inBounds; lookup = lookup;
       lookupM = lookupM; lookupWithDefault = lookupWithDefault;
       update = update; adjust = adjust; mapWithIndex = mapWithIndex;
       foldrWithIndex = foldrWithIndex; foldlWithIndex = foldlWithIndex;
       foldrWithIndex' = foldrWithIndex'; foldlWithIndex' = foldlWithIndex';
       take = take; drop = drop; splitAt = splitAt; subseq = subseq;
       filter = filter; partition = partition; takeWhile = takeWhile;
       dropWhile = dropWhile; splitWhile = splitWhile; zip = zip;
       zip3 = zip3; zipWith = zipWith; zipWith3 = zipWith3; unzip = unzip;
       unzip3 = unzip3; unzipWith = unzipWith; unzipWith3 = unzipWith3;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Functor Seq where
      fmap = map
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
       foldr = foldr; foldr' = foldr'; foldl = foldl; foldl' = foldl';
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
       reducer = reducer; reducer' = reducer'; reducel = reducel;
       reducel' = reducel'; reduce1 = reduce1;  reduce1' = reduce1';
       copy = copy; inBounds = inBounds; lookup = lookup;
       lookupM = lookupM; lookupWithDefault = lookupWithDefault;
       update = update; adjust = adjust; mapWithIndex = mapWithIndex;
       foldrWithIndex = foldrWithIndex; foldlWithIndex = foldlWithIndex;
       foldrWithIndex' = foldrWithIndex'; foldlWithIndex' = foldlWithIndex';
       take = take; drop = drop; splitAt = splitAt; subseq = subseq;
       filter = filter; partition = partition; takeWhile = takeWhile;
       dropWhile = dropWhile; splitWhile = splitWhile; zip = zip;
       zip3 = zip3; zipWith = zipWith; zipWith3 = zipWith3; unzip = unzip;
       unzip3 = unzip3; unzipWith = unzipWith; unzipWith3 = unzipWith3;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Functor Seq where
      fmap = map
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    mapUnElem = Prelude.map unElem
    
    #endif
    
    null         = FT.null . unSeq
    empty        = Seq FT.empty
    singleton    = Seq . FT.singleton . Elem
    lcons x      = Seq . FT.lcons (Elem x) . unSeq
    rcons x      = Seq . FT.rcons (Elem x) . unSeq
    append p q   = Seq $ FT.append (unSeq p) (unSeq q)
    fromList     = Seq . FT.fromList . mapElem
    toList       = mapUnElem . FT.toList . unSeq
    reverse      = Seq . FT.reverse . unSeq
    size         = unSizeM . measure . unSeq
    strict       = Seq . FT.strict . unSeq
    strictWith f = Seq . FT.strictWith (f . unElem) . unSeq
    structuralInvariant = FT.structuralInvariant . unSeq
    
    #ifdef __GLASGOW_HASKELL__
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    mapUnElem = Prelude.map unElem
    
    #endif
    
    null         = FT.null . unSeq
    empty        = Seq FT.empty
    singleton    = Seq . FT.singleton . Elem
    lcons x      = Seq . FT.lcons (Elem x) . unSeq
    rcons x      = Seq . FT.rcons (Elem x) . unSeq
    append p q   = Seq $ FT.append (unSeq p) (unSeq q)
    fromList     = Seq . FT.fromList . mapElem
    toList       = mapUnElem . FT.toList . unSeq
    reverse      = Seq . FT.reverse . unSeq
    size         = unSizeM . measure . unSeq
    strict       = Seq . FT.strict . unSeq
    strictWith f = Seq . FT.strictWith (f . unElem) . unSeq
    structuralInvariant = FT.structuralInvariant . unSeq
    
    #ifdef __GLASGOW_HASKELL__
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    subseq         :: Int -> Int -> Seq a -> Seq a
    filter         :: (a -> Bool) -> Seq a -> Seq a
    partition      :: (a -> Bool) -> Seq a -> (Seq a, Seq a)
    takeWhile      :: (a -> Bool) -> Seq a -> Seq a
    dropWhile      :: (a -> Bool) -> Seq a -> Seq a
    splitWhile     :: (a -> Bool) -> Seq a -> (Seq a, Seq a)
    zip            :: Seq a -> Seq b -> Seq (a,b)
    zip3           :: Seq a -> Seq b -> Seq c -> Seq (a,b,c)
    zipWith        :: (a -> b -> c) -> Seq a -> Seq b -> Seq c
    zipWith3       :: (a -> b -> c -> d) -> Seq a -> Seq b -> Seq c -> Seq d
    unzip          :: Seq (a,b) -> (Seq a, Seq b)
    unzip3         :: Seq (a,b,c) -> (Seq a, Seq b, Seq c)
    unzipWith      :: (a -> b) -> (a -> c) -> Seq a -> (Seq b, Seq c)
    unzipWith3     :: (a -> b) -> (a -> c) -> (a -> d) -> Seq a -> (Seq b, Seq c, Seq d)
    strict         :: Seq a -> Seq a
    strictWith     :: (a -> b) -> Seq a -> Seq a
    structuralInvariant :: Seq a -> Bool
    
    #ifdef __GLASGOW_HASKELL__
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    module Data.Edison.Seq.FingerSeq (
        -- * Sequence Type
        Seq, -- instance of Sequence, Functor, Monad, MonadPlus
    
        -- * Sequence Operations
        empty,singleton,lcons,rcons,append,lview,lhead,ltail,rview,rhead,rtail,
        lheadM,ltailM,rheadM,rtailM,
        null,size,concat,reverse,reverseOnto,fromList,toList,map,concatMap,
        fold,fold',fold1,fold1',foldr,foldr',foldl,foldl',foldr1,foldr1',foldl1,foldl1',
        reducer,reducer',reducel,reducel',reduce1,reduce1',
        copy,inBounds,lookup,lookupM,lookupWithDefault,update,adjust,
        mapWithIndex,foldrWithIndex,foldlWithIndex,
        take,drop,splitAt,subseq,filter,partition,takeWhile,dropWhile,splitWhile,
        zip,zip3,zipWith,zipWith3,unzip,unzip3,unzipWith,unzipWith3,
        strict, strictWith,
    
        -- * Unit testing
        structuralInvariant,
    
        -- * Documentation
    

    strictWith See 6 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
       foldr = foldr; foldr' = foldr'; foldl = foldl; foldl' = foldl';
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
       reducer = reducer; reducer' = reducer'; reducel = reducel;
       reducel' = reducel'; reduce1 = reduce1;  reduce1' = reduce1';
       copy = copy; inBounds = inBounds; lookup = lookup;
       lookupM = lookupM; lookupWithDefault = lookupWithDefault;
       update = update; adjust = adjust; mapWithIndex = mapWithIndex;
       foldrWithIndex = foldrWithIndex; foldlWithIndex = foldlWithIndex;
       foldrWithIndex' = foldrWithIndex'; foldlWithIndex' = foldlWithIndex';
       take = take; drop = drop; splitAt = splitAt; subseq = subseq;
       filter = filter; partition = partition; takeWhile = takeWhile;
       dropWhile = dropWhile; splitWhile = splitWhile; zip = zip;
       zip3 = zip3; zipWith = zipWith; zipWith3 = zipWith3; unzip = unzip;
       unzip3 = unzip3; unzipWith = unzipWith; unzipWith3 = unzipWith3;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Functor Seq where
      fmap = map
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
       foldr = foldr; foldr' = foldr'; foldl = foldl; foldl' = foldl';
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
       reducer = reducer; reducer' = reducer'; reducel = reducel;
       reducel' = reducel'; reduce1 = reduce1;  reduce1' = reduce1';
       copy = copy; inBounds = inBounds; lookup = lookup;
       lookupM = lookupM; lookupWithDefault = lookupWithDefault;
       update = update; adjust = adjust; mapWithIndex = mapWithIndex;
       foldrWithIndex = foldrWithIndex; foldlWithIndex = foldlWithIndex;
       foldrWithIndex' = foldrWithIndex'; foldlWithIndex' = foldlWithIndex';
       take = take; drop = drop; splitAt = splitAt; subseq = subseq;
       filter = filter; partition = partition; takeWhile = takeWhile;
       dropWhile = dropWhile; splitWhile = splitWhile; zip = zip;
       zip3 = zip3; zipWith = zipWith; zipWith3 = zipWith3; unzip = unzip;
       unzip3 = unzip3; unzipWith = unzipWith; unzipWith3 = unzipWith3;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Functor Seq where
      fmap = map
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    #endif
    
    null         = FT.null . unSeq
    empty        = Seq FT.empty
    singleton    = Seq . FT.singleton . Elem
    lcons x      = Seq . FT.lcons (Elem x) . unSeq
    rcons x      = Seq . FT.rcons (Elem x) . unSeq
    append p q   = Seq $ FT.append (unSeq p) (unSeq q)
    fromList     = Seq . FT.fromList . mapElem
    toList       = mapUnElem . FT.toList . unSeq
    reverse      = Seq . FT.reverse . unSeq
    size         = unSizeM . measure . unSeq
    strict       = Seq . FT.strict . unSeq
    strictWith f = Seq . FT.strictWith (f . unElem) . unSeq
    structuralInvariant = FT.structuralInvariant . unSeq
    
    #ifdef __GLASGOW_HASKELL__
    
    lview (Seq xs) =
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    #endif
    
    null         = FT.null . unSeq
    empty        = Seq FT.empty
    singleton    = Seq . FT.singleton . Elem
    lcons x      = Seq . FT.lcons (Elem x) . unSeq
    rcons x      = Seq . FT.rcons (Elem x) . unSeq
    append p q   = Seq $ FT.append (unSeq p) (unSeq q)
    fromList     = Seq . FT.fromList . mapElem
    toList       = mapUnElem . FT.toList . unSeq
    reverse      = Seq . FT.reverse . unSeq
    size         = unSizeM . measure . unSeq
    strict       = Seq . FT.strict . unSeq
    strictWith f = Seq . FT.strictWith (f . unElem) . unSeq
    structuralInvariant = FT.structuralInvariant . unSeq
    
    #ifdef __GLASGOW_HASKELL__
    
    lview (Seq xs) =
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    filter         :: (a -> Bool) -> Seq a -> Seq a
    partition      :: (a -> Bool) -> Seq a -> (Seq a, Seq a)
    takeWhile      :: (a -> Bool) -> Seq a -> Seq a
    dropWhile      :: (a -> Bool) -> Seq a -> Seq a
    splitWhile     :: (a -> Bool) -> Seq a -> (Seq a, Seq a)
    zip            :: Seq a -> Seq b -> Seq (a,b)
    zip3           :: Seq a -> Seq b -> Seq c -> Seq (a,b,c)
    zipWith        :: (a -> b -> c) -> Seq a -> Seq b -> Seq c
    zipWith3       :: (a -> b -> c -> d) -> Seq a -> Seq b -> Seq c -> Seq d
    unzip          :: Seq (a,b) -> (Seq a, Seq b)
    unzip3         :: Seq (a,b,c) -> (Seq a, Seq b, Seq c)
    unzipWith      :: (a -> b) -> (a -> c) -> Seq a -> (Seq b, Seq c)
    unzipWith3     :: (a -> b) -> (a -> c) -> (a -> d) -> Seq a -> (Seq b, Seq c, Seq d)
    strict         :: Seq a -> Seq a
    strictWith     :: (a -> b) -> Seq a -> Seq a
    structuralInvariant :: Seq a -> Bool
    
    #ifdef __GLASGOW_HASKELL__
    
    mapElem, mapUnElem :: t -> b
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    module Data.Edison.Seq.FingerSeq (
        -- * Sequence Type
        Seq, -- instance of Sequence, Functor, Monad, MonadPlus
    
        -- * Sequence Operations
        empty,singleton,lcons,rcons,append,lview,lhead,ltail,rview,rhead,rtail,
        lheadM,ltailM,rheadM,rtailM,
        null,size,concat,reverse,reverseOnto,fromList,toList,map,concatMap,
        fold,fold',fold1,fold1',foldr,foldr',foldl,foldl',foldr1,foldr1',foldl1,foldl1',
        reducer,reducer',reducel,reducel',reduce1,reduce1',
        copy,inBounds,lookup,lookupM,lookupWithDefault,update,adjust,
        mapWithIndex,foldrWithIndex,foldlWithIndex,
        take,drop,splitAt,subseq,filter,partition,takeWhile,dropWhile,splitWhile,
        zip,zip3,zipWith,zipWith3,unzip,unzip3,unzipWith,unzipWith3,
        strict, strictWith,
    
        -- * Unit testing
        structuralInvariant,
    
        -- * Documentation
    

    structuralInvariant See 6 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
       reducer = reducer; reducer' = reducer'; reducel = reducel;
       reducel' = reducel'; reduce1 = reduce1;  reduce1' = reduce1';
       copy = copy; inBounds = inBounds; lookup = lookup;
       lookupM = lookupM; lookupWithDefault = lookupWithDefault;
       update = update; adjust = adjust; mapWithIndex = mapWithIndex;
       foldrWithIndex = foldrWithIndex; foldlWithIndex = foldlWithIndex;
       foldrWithIndex' = foldrWithIndex'; foldlWithIndex' = foldlWithIndex';
       take = take; drop = drop; splitAt = splitAt; subseq = subseq;
       filter = filter; partition = partition; takeWhile = takeWhile;
       dropWhile = dropWhile; splitWhile = splitWhile; zip = zip;
       zip3 = zip3; zipWith = zipWith; zipWith3 = zipWith3; unzip = unzip;
       unzip3 = unzip3; unzipWith = unzipWith; unzipWith3 = unzipWith3;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Functor Seq where
      fmap = map
    
    instance App.Alternative Seq where
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
       reducer = reducer; reducer' = reducer'; reducel = reducel;
       reducel' = reducel'; reduce1 = reduce1;  reduce1' = reduce1';
       copy = copy; inBounds = inBounds; lookup = lookup;
       lookupM = lookupM; lookupWithDefault = lookupWithDefault;
       update = update; adjust = adjust; mapWithIndex = mapWithIndex;
       foldrWithIndex = foldrWithIndex; foldlWithIndex = foldlWithIndex;
       foldrWithIndex' = foldrWithIndex'; foldlWithIndex' = foldlWithIndex';
       take = take; drop = drop; splitAt = splitAt; subseq = subseq;
       filter = filter; partition = partition; takeWhile = takeWhile;
       dropWhile = dropWhile; splitWhile = splitWhile; zip = zip;
       zip3 = zip3; zipWith = zipWith; zipWith3 = zipWith3; unzip = unzip;
       unzip3 = unzip3; unzipWith = unzipWith; unzipWith3 = unzipWith3;
       strict = strict; strictWith = strictWith;
       structuralInvariant = structuralInvariant; instanceName _ = moduleName}
    
    instance Functor Seq where
      fmap = map
    
    instance App.Alternative Seq where
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    #endif
    
    null         = FT.null . unSeq
    empty        = Seq FT.empty
    singleton    = Seq . FT.singleton . Elem
    lcons x      = Seq . FT.lcons (Elem x) . unSeq
    rcons x      = Seq . FT.rcons (Elem x) . unSeq
    append p q   = Seq $ FT.append (unSeq p) (unSeq q)
    fromList     = Seq . FT.fromList . mapElem
    toList       = mapUnElem . FT.toList . unSeq
    reverse      = Seq . FT.reverse . unSeq
    size         = unSizeM . measure . unSeq
    strict       = Seq . FT.strict . unSeq
    strictWith f = Seq . FT.strictWith (f . unElem) . unSeq
    structuralInvariant = FT.structuralInvariant . unSeq
    
    #ifdef __GLASGOW_HASKELL__
    
    lview (Seq xs) =
      let f = unsafeCoerce# :: Monad m => m (Elem a,FT.FingerTree SizeM (Elem a)) -> m (a,Seq a)
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    #endif
    
    null         = FT.null . unSeq
    empty        = Seq FT.empty
    singleton    = Seq . FT.singleton . Elem
    lcons x      = Seq . FT.lcons (Elem x) . unSeq
    rcons x      = Seq . FT.rcons (Elem x) . unSeq
    append p q   = Seq $ FT.append (unSeq p) (unSeq q)
    fromList     = Seq . FT.fromList . mapElem
    toList       = mapUnElem . FT.toList . unSeq
    reverse      = Seq . FT.reverse . unSeq
    size         = unSizeM . measure . unSeq
    strict       = Seq . FT.strict . unSeq
    strictWith f = Seq . FT.strictWith (f . unElem) . unSeq
    structuralInvariant = FT.structuralInvariant . unSeq
    
    #ifdef __GLASGOW_HASKELL__
    
    lview (Seq xs) =
      let f = unsafeCoerce# :: Monad m => m (Elem a,FT.FingerTree SizeM (Elem a)) -> m (a,Seq a)
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    partition      :: (a -> Bool) -> Seq a -> (Seq a, Seq a)
    takeWhile      :: (a -> Bool) -> Seq a -> Seq a
    dropWhile      :: (a -> Bool) -> Seq a -> Seq a
    splitWhile     :: (a -> Bool) -> Seq a -> (Seq a, Seq a)
    zip            :: Seq a -> Seq b -> Seq (a,b)
    zip3           :: Seq a -> Seq b -> Seq c -> Seq (a,b,c)
    zipWith        :: (a -> b -> c) -> Seq a -> Seq b -> Seq c
    zipWith3       :: (a -> b -> c -> d) -> Seq a -> Seq b -> Seq c -> Seq d
    unzip          :: Seq (a,b) -> (Seq a, Seq b)
    unzip3         :: Seq (a,b,c) -> (Seq a, Seq b, Seq c)
    unzipWith      :: (a -> b) -> (a -> c) -> Seq a -> (Seq b, Seq c)
    unzipWith3     :: (a -> b) -> (a -> c) -> (a -> d) -> Seq a -> (Seq b, Seq c, Seq d)
    strict         :: Seq a -> Seq a
    strictWith     :: (a -> b) -> Seq a -> Seq a
    structuralInvariant :: Seq a -> Bool
    
    #ifdef __GLASGOW_HASKELL__
    
    mapElem, mapUnElem :: t -> b
    mapElem   = unsafeCoerce#
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
        -- * Sequence Operations
        empty,singleton,lcons,rcons,append,lview,lhead,ltail,rview,rhead,rtail,
        lheadM,ltailM,rheadM,rtailM,
        null,size,concat,reverse,reverseOnto,fromList,toList,map,concatMap,
        fold,fold',fold1,fold1',foldr,foldr',foldl,foldl',foldr1,foldr1',foldl1,foldl1',
        reducer,reducer',reducel,reducel',reduce1,reduce1',
        copy,inBounds,lookup,lookupM,lookupWithDefault,update,adjust,
        mapWithIndex,foldrWithIndex,foldlWithIndex,
        take,drop,splitAt,subseq,filter,partition,takeWhile,dropWhile,splitWhile,
        zip,zip3,zipWith,zipWith3,unzip,unzip3,unzipWith,unzipWith3,
        strict, strictWith,
    
        -- * Unit testing
        structuralInvariant,
    
        -- * Documentation
        moduleName
    ) where
    

    takeUntil See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    update i x (Seq xs)
        | inBounds i (Seq xs) =
            case FT.splitTree (> (SizeM i)) (SizeM 0) xs of
               FT.Split l _ r -> Seq $ FT.append l $ FT.lcons (Elem x) $ r
    
        | otherwise = Seq xs
    
    adjust f i (Seq xs)
        | inBounds i (Seq xs) =
            case FT.splitTree (> (SizeM i)) (SizeM 0) xs of
               FT.Split l x r -> Seq $ FT.append l $ FT.lcons (Elem (f (unElem x))) $ r
    
        | otherwise = Seq xs
    
    take i (Seq xs) = Seq $ FT.takeUntil (> (SizeM i)) xs
    drop i (Seq xs) = Seq $ FT.dropUntil (> (SizeM i)) xs
    splitAt i (Seq xs) = let (a,b) = FT.split (> (SizeM i)) xs in (Seq a, Seq b)
    
    
    inBounds = inBoundsUsingSize
    

    toList See 8 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
      x <*> y = do
         x' <- x
         y' <- y
         return (x' y')
    
    instance Monad Seq where
      return = singleton
      xs >>= k = concatMap k xs
    
    instance MonadPlus Seq where
      mplus = append
      mzero = empty
    
    instance Eq a => Eq (Seq a) where
      xs == ys = toList xs == toList ys
    
    instance Ord a => Ord (Seq a) where
      compare = defaultCompare
    
    instance Show a => Show (Seq a) where
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
      x <*> y = do
         x' <- x
         y' <- y
         return (x' y')
    
    instance Monad Seq where
      return = singleton
      xs >>= k = concatMap k xs
    
    instance MonadPlus Seq where
      mplus = append
      mzero = empty
    
    instance Eq a => Eq (Seq a) where
      xs == ys = toList xs == toList ys
    
    instance Ord a => Ord (Seq a) where
      compare = defaultCompare
    
    instance Show a => Show (Seq a) where
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    unzip = unzipUsingFoldr
    unzip3 = unzip3UsingFoldr
    unzipWith = unzipWithUsingFoldr
    unzipWith3 = unzipWith3UsingFoldr
    
    -- instances
    
    instance S.Sequence Seq where
      {lcons = lcons; rcons = rcons;
       lview = lview; lhead = lhead; ltail = ltail;
       lheadM = lheadM; ltailM = ltailM; rheadM = rheadM; rtailM = rtailM;
       rview = rview; rhead = rhead; rtail = rtail; null = null;
       size = size; concat = concat; reverse = reverse;
       reverseOnto = reverseOnto; fromList = fromList; toList = toList;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       foldr = foldr; foldr' = foldr'; foldl = foldl; foldl' = foldl';
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
       reducer = reducer; reducer' = reducer'; reducel = reducel;
       reducel' = reducel'; reduce1 = reduce1;  reduce1' = reduce1';
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    unzip = unzipUsingFoldr
    unzip3 = unzip3UsingFoldr
    unzipWith = unzipWithUsingFoldr
    unzipWith3 = unzipWith3UsingFoldr
    
    -- instances
    
    instance S.Sequence Seq where
      {lcons = lcons; rcons = rcons;
       lview = lview; lhead = lhead; ltail = ltail;
       lheadM = lheadM; ltailM = ltailM; rheadM = rheadM; rtailM = rtailM;
       rview = rview; rhead = rhead; rtail = rtail; null = null;
       size = size; concat = concat; reverse = reverse;
       reverseOnto = reverseOnto; fromList = fromList; toList = toList;
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       foldr = foldr; foldr' = foldr'; foldl = foldl; foldl' = foldl';
       foldr1 = foldr1; foldr1' = foldr1'; foldl1 = foldl1; foldl1' = foldl1';
       reducer = reducer; reducer' = reducer'; reducel = reducel;
       reducel' = reducel'; reduce1 = reduce1;  reduce1' = reduce1';
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    #else
    
    mapElem   = Prelude.map Elem
    mapUnElem = Prelude.map unElem
    
    #endif
    
    null         = FT.null . unSeq
    empty        = Seq FT.empty
    singleton    = Seq . FT.singleton . Elem
    lcons x      = Seq . FT.lcons (Elem x) . unSeq
    rcons x      = Seq . FT.rcons (Elem x) . unSeq
    append p q   = Seq $ FT.append (unSeq p) (unSeq q)
    fromList     = Seq . FT.fromList . mapElem
    toList       = mapUnElem . FT.toList . unSeq
    reverse      = Seq . FT.reverse . unSeq
    size         = unSizeM . measure . unSeq
    strict       = Seq . FT.strict . unSeq
    strictWith f = Seq . FT.strictWith (f . unElem) . unSeq
    structuralInvariant = FT.structuralInvariant . unSeq
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    #else
    
    mapElem   = Prelude.map Elem
    mapUnElem = Prelude.map unElem
    
    #endif
    
    null         = FT.null . unSeq
    empty        = Seq FT.empty
    singleton    = Seq . FT.singleton . Elem
    lcons x      = Seq . FT.lcons (Elem x) . unSeq
    rcons x      = Seq . FT.rcons (Elem x) . unSeq
    append p q   = Seq $ FT.append (unSeq p) (unSeq q)
    fromList     = Seq . FT.fromList . mapElem
    toList       = mapUnElem . FT.toList . unSeq
    reverse      = Seq . FT.reverse . unSeq
    size         = unSizeM . measure . unSeq
    strict       = Seq . FT.strict . unSeq
    strictWith f = Seq . FT.strictWith (f . unElem) . unSeq
    structuralInvariant = FT.structuralInvariant . unSeq
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    lheadM         :: (Monad m) => Seq a -> m a
    ltail          :: Seq a -> Seq a
    ltailM         :: (Monad m) => Seq a -> m (Seq a)
    rview          :: (Monad m) => Seq a -> m (a, Seq a)
    rhead          :: Seq a -> a
    rheadM         :: (Monad m) => Seq a -> m a
    rtail          :: Seq a -> Seq a
    rtailM         :: (Monad m) => Seq a -> m (Seq a)
    null           :: Seq a -> Bool
    size           :: Seq a -> Int
    concat         :: Seq (Seq a) -> Seq a
    reverse        :: Seq a -> Seq a
    reverseOnto    :: Seq a -> Seq a -> Seq a
    fromList       :: [a] -> Seq a
    toList         :: Seq a -> [a]
    map            :: (a -> b) -> Seq a -> Seq b
    concatMap      :: (a -> Seq b) -> Seq a -> Seq b
    fold           :: (a -> b -> b) -> b -> Seq a -> b
    fold'          :: (a -> b -> b) -> b -> Seq a -> b
    fold1          :: (a -> a -> a) -> Seq a -> a
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    --   License     :  MIT; see COPYRIGHT file for terms and conditions
    --
    --   Maintainer  :  robdockins AT fastmail DOT fm
    --   Stability   :  stable
    --   Portability :  GHC, Hugs (MPTC and FD)
    
    
    module Data.Edison.Seq.FingerSeq (
        -- * Sequence Type
        Seq, -- instance of Sequence, Functor, Monad, MonadPlus
    
        -- * Sequence Operations
        empty,singleton,lcons,rcons,append,lview,lhead,ltail,rview,rhead,rtail,
        lheadM,ltailM,rheadM,rtailM,
        null,size,concat,reverse,reverseOnto,fromList,toList,map,concatMap,
        fold,fold',fold1,fold1',foldr,foldr',foldl,foldl',foldr1,foldr1',foldl1,foldl1',
        reducer,reducer',reducel,reducel',reduce1,reduce1',
        copy,inBounds,lookup,lookupM,lookupWithDefault,update,adjust,
        mapWithIndex,foldrWithIndex,foldlWithIndex,
        take,drop,splitAt,subseq,filter,partition,takeWhile,dropWhile,splitWhile,
    

    FingerTree No usage example found for this symbol :( Collapse [-]
    Split No usage example found for this symbol :( Collapse [-]