-- |
--   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,
    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,foldl',
                       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(), runFail_)
import qualified Data.Edison.Seq as S
import Data.Edison.Seq.Defaults
import qualified Control.Monad.Fail as Fail
import Control.Monad
import Data.Monoid
import Data.Semigroup as SG
import Test.QuickCheck

#ifdef __GLASGOW_HASKELL__
import GHC.Exts (unsafeCoerce#)
#endif


import qualified Data.Edison.Concrete.FingerTree as FT

moduleName     :: String
moduleName :: String
moduleName = String
"Data.Edison.Seq.FingerSeq"


newtype SizeM = SizeM Int deriving (SizeM -> SizeM -> Bool
(SizeM -> SizeM -> Bool) -> (SizeM -> SizeM -> Bool) -> Eq SizeM
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SizeM -> SizeM -> Bool
== :: SizeM -> SizeM -> Bool
$c/= :: SizeM -> SizeM -> Bool
/= :: SizeM -> SizeM -> Bool
Eq,Eq SizeM
Eq SizeM =>
(SizeM -> SizeM -> Ordering)
-> (SizeM -> SizeM -> Bool)
-> (SizeM -> SizeM -> Bool)
-> (SizeM -> SizeM -> Bool)
-> (SizeM -> SizeM -> Bool)
-> (SizeM -> SizeM -> SizeM)
-> (SizeM -> SizeM -> SizeM)
-> Ord SizeM
SizeM -> SizeM -> Bool
SizeM -> SizeM -> Ordering
SizeM -> SizeM -> SizeM
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SizeM -> SizeM -> Ordering
compare :: SizeM -> SizeM -> Ordering
$c< :: SizeM -> SizeM -> Bool
< :: SizeM -> SizeM -> Bool
$c<= :: SizeM -> SizeM -> Bool
<= :: SizeM -> SizeM -> Bool
$c> :: SizeM -> SizeM -> Bool
> :: SizeM -> SizeM -> Bool
$c>= :: SizeM -> SizeM -> Bool
>= :: SizeM -> SizeM -> Bool
$cmax :: SizeM -> SizeM -> SizeM
max :: SizeM -> SizeM -> SizeM
$cmin :: SizeM -> SizeM -> SizeM
min :: SizeM -> SizeM -> SizeM
Ord,Integer -> SizeM
SizeM -> SizeM
SizeM -> SizeM -> SizeM
(SizeM -> SizeM -> SizeM)
-> (SizeM -> SizeM -> SizeM)
-> (SizeM -> SizeM -> SizeM)
-> (SizeM -> SizeM)
-> (SizeM -> SizeM)
-> (SizeM -> SizeM)
-> (Integer -> SizeM)
-> Num SizeM
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: SizeM -> SizeM -> SizeM
+ :: SizeM -> SizeM -> SizeM
$c- :: SizeM -> SizeM -> SizeM
- :: SizeM -> SizeM -> SizeM
$c* :: SizeM -> SizeM -> SizeM
* :: SizeM -> SizeM -> SizeM
$cnegate :: SizeM -> SizeM
negate :: SizeM -> SizeM
$cabs :: SizeM -> SizeM
abs :: SizeM -> SizeM
$csignum :: SizeM -> SizeM
signum :: SizeM -> SizeM
$cfromInteger :: Integer -> SizeM
fromInteger :: Integer -> SizeM
Num,Int -> SizeM
SizeM -> Int
SizeM -> [SizeM]
SizeM -> SizeM
SizeM -> SizeM -> [SizeM]
SizeM -> SizeM -> SizeM -> [SizeM]
(SizeM -> SizeM)
-> (SizeM -> SizeM)
-> (Int -> SizeM)
-> (SizeM -> Int)
-> (SizeM -> [SizeM])
-> (SizeM -> SizeM -> [SizeM])
-> (SizeM -> SizeM -> [SizeM])
-> (SizeM -> SizeM -> SizeM -> [SizeM])
-> Enum SizeM
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: SizeM -> SizeM
succ :: SizeM -> SizeM
$cpred :: SizeM -> SizeM
pred :: SizeM -> SizeM
$ctoEnum :: Int -> SizeM
toEnum :: Int -> SizeM
$cfromEnum :: SizeM -> Int
fromEnum :: SizeM -> Int
$cenumFrom :: SizeM -> [SizeM]
enumFrom :: SizeM -> [SizeM]
$cenumFromThen :: SizeM -> SizeM -> [SizeM]
enumFromThen :: SizeM -> SizeM -> [SizeM]
$cenumFromTo :: SizeM -> SizeM -> [SizeM]
enumFromTo :: SizeM -> SizeM -> [SizeM]
$cenumFromThenTo :: SizeM -> SizeM -> SizeM -> [SizeM]
enumFromThenTo :: SizeM -> SizeM -> SizeM -> [SizeM]
Enum,Int -> SizeM -> ShowS
[SizeM] -> ShowS
SizeM -> String
(Int -> SizeM -> ShowS)
-> (SizeM -> String) -> ([SizeM] -> ShowS) -> Show SizeM
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SizeM -> ShowS
showsPrec :: Int -> SizeM -> ShowS
$cshow :: SizeM -> String
show :: SizeM -> String
$cshowList :: [SizeM] -> ShowS
showList :: [SizeM] -> ShowS
Show)

unSizeM :: SizeM -> Int
unSizeM :: SizeM -> Int
unSizeM (SizeM Int
x) = Int
x

instance Semigroup SizeM where
   <> :: SizeM -> SizeM -> SizeM
(<>) = SizeM -> SizeM -> SizeM
forall a. Num a => a -> a -> a
(+)
instance Monoid SizeM where
   mempty :: SizeM
mempty  = SizeM
0
   mappend :: SizeM -> SizeM -> SizeM
mappend = SizeM -> SizeM -> SizeM
forall a. Semigroup a => a -> a -> a
(SG.<>)

newtype Elem a = Elem a

unElem :: Elem t -> t
unElem :: forall t. Elem t -> t
unElem (Elem t
x) = t
x

instance Measured SizeM (Elem a) where
   measure :: Elem a -> SizeM
measure Elem a
_ = SizeM
1

newtype Seq a = Seq (FT.FingerTree SizeM (Elem a))

unSeq :: Seq t -> FT.FingerTree SizeM (Elem t)
unSeq :: forall t. Seq t -> FingerTree SizeM (Elem t)
unSeq (Seq FingerTree SizeM (Elem t)
ft) = FingerTree SizeM (Elem t)
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          :: (Fail.MonadFail m) => Seq a -> m (a, Seq a)
lhead          :: Seq a -> a
lheadM         :: (Fail.MonadFail m) => Seq a -> m a
ltail          :: Seq a -> Seq a
ltailM         :: (Fail.MonadFail m) => Seq a -> m (Seq a)
rview          :: (Fail.MonadFail m) => Seq a -> m (a, Seq a)
rhead          :: Seq a -> a
rheadM         :: (Fail.MonadFail m) => Seq a -> m a
rtail          :: Seq a -> Seq a
rtailM         :: (Fail.MonadFail 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
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        :: (Fail.MonadFail m) => Int -> Seq a -> m a
lookupWithDefault :: a -> Int -> Seq a -> a
update         :: Int -> a -> Seq a -> Seq a
adjust         :: (a -> a) -> Int -> Seq a -> Seq a
mapWithIndex   :: (Int -> a -> b) -> Seq a -> Seq b
foldrWithIndex :: (Int -> a -> b -> b) -> b -> Seq a -> b
foldlWithIndex :: (b -> Int -> a -> b) -> b -> Seq a -> b
foldrWithIndex' :: (Int -> a -> b -> b) -> b -> Seq a -> b
foldlWithIndex' :: (b -> Int -> a -> b) -> b -> Seq a -> b
take           :: Int -> Seq a -> Seq a
drop           :: Int -> Seq a -> Seq a
splitAt        :: Int -> Seq a -> (Seq a, Seq a)
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__

mapElem, mapUnElem :: t -> b
mapElem :: forall t b. t -> b
mapElem   = t -> b
forall a b. a -> b
unsafeCoerce#
mapUnElem :: forall t b. t -> b
mapUnElem = t -> b
forall a b. a -> b
unsafeCoerce#

#else

mapElem   = Prelude.map Elem
mapUnElem = Prelude.map unElem

#endif

null :: forall a. Seq a -> Bool
null         = FingerTree SizeM (Elem a) -> Bool
forall v a. Measured v a => FingerTree v a -> Bool
FT.null (FingerTree SizeM (Elem a) -> Bool)
-> (Seq a -> FingerTree SizeM (Elem a)) -> Seq a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Seq a -> FingerTree SizeM (Elem a)
forall t. Seq t -> FingerTree SizeM (Elem t)
unSeq
empty :: forall a. Seq a
empty        = FingerTree SizeM (Elem a) -> Seq a
forall a. FingerTree SizeM (Elem a) -> Seq a
Seq FingerTree SizeM (Elem a)
forall v a. Measured v a => FingerTree v a
FT.empty
singleton :: forall a. a -> Seq a
singleton    = FingerTree SizeM (Elem a) -> Seq a
forall a. FingerTree SizeM (Elem a) -> Seq a
Seq (FingerTree SizeM (Elem a) -> Seq a)
-> (a -> FingerTree SizeM (Elem a)) -> a -> Seq a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Elem a -> FingerTree SizeM (Elem a)
forall v a. Measured v a => a -> FingerTree v a
FT.singleton (Elem a -> FingerTree SizeM (Elem a))
-> (a -> Elem a) -> a -> FingerTree SizeM (Elem a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Elem a
forall a. a -> Elem a
Elem
lcons :: forall a. a -> Seq a -> Seq a
lcons a
x      = FingerTree SizeM (Elem a) -> Seq a
forall a. FingerTree SizeM (Elem a) -> Seq a
Seq (FingerTree SizeM (Elem a) -> Seq a)
-> (Seq a -> FingerTree SizeM (Elem a)) -> Seq a -> Seq a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Elem a -> FingerTree SizeM (Elem a) -> FingerTree SizeM (Elem a)
forall v a. Measured v a => a -> FingerTree v a -> FingerTree v a
FT.lcons (a -> Elem a
forall a. a -> Elem a
Elem a
x) (FingerTree SizeM (Elem a) -> FingerTree SizeM (Elem a))
-> (Seq a -> FingerTree SizeM (Elem a))
-> Seq a
-> FingerTree SizeM (Elem a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Seq a -> FingerTree SizeM (Elem a)
forall t. Seq t -> FingerTree SizeM (Elem t)
unSeq
rcons :: forall a. a -> Seq a -> Seq a
rcons a
x      = FingerTree SizeM (Elem a) -> Seq a
forall a. FingerTree SizeM (Elem a) -> Seq a
Seq (FingerTree SizeM (Elem a) -> Seq a)
-> (Seq a -> FingerTree SizeM (Elem a)) -> Seq a -> Seq a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Elem a -> FingerTree SizeM (Elem a) -> FingerTree SizeM (Elem a)
forall v a. Measured v a => a -> FingerTree v a -> FingerTree v a
FT.rcons (a -> Elem a
forall a. a -> Elem a
Elem a
x) (FingerTree SizeM (Elem a) -> FingerTree SizeM (Elem a))
-> (Seq a -> FingerTree SizeM (Elem a))
-> Seq a
-> FingerTree SizeM (Elem a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Seq a -> FingerTree SizeM (Elem a)
forall t. Seq t -> FingerTree SizeM (Elem t)
unSeq
append :: forall a. Seq a -> Seq a -> Seq a
append Seq a
p Seq a
q   = FingerTree SizeM (Elem a) -> Seq a
forall a. FingerTree SizeM (Elem a) -> Seq a
Seq (FingerTree SizeM (Elem a) -> Seq a)
-> FingerTree SizeM (Elem a) -> Seq a
forall a b. (a -> b) -> a -> b
$ FingerTree SizeM (Elem a)
-> FingerTree SizeM (Elem a) -> FingerTree SizeM (Elem a)
forall v a.
Measured v a =>
FingerTree v a -> FingerTree v a -> FingerTree v a
FT.append (Seq a -> FingerTree SizeM (Elem a)
forall t. Seq t -> FingerTree SizeM (Elem t)
unSeq Seq a
p) (Seq a -> FingerTree SizeM (Elem a)
forall t. Seq t -> FingerTree SizeM (Elem t)
unSeq Seq a
q)
fromList :: forall a. [a] -> Seq a
fromList     = FingerTree SizeM (Elem a) -> Seq a
forall a. FingerTree SizeM (Elem a) -> Seq a
Seq (FingerTree SizeM (Elem a) -> Seq a)
-> ([a] -> FingerTree SizeM (Elem a)) -> [a] -> Seq a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Elem a] -> FingerTree SizeM (Elem a)
forall v a. Measured v a => [a] -> FingerTree v a
FT.fromList ([Elem a] -> FingerTree SizeM (Elem a))
-> ([a] -> [Elem a]) -> [a] -> FingerTree SizeM (Elem a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> [Elem a]
forall t b. t -> b
mapElem
toList :: forall a. Seq a -> [a]
toList       = [Elem a] -> [a]
forall t b. t -> b
mapUnElem ([Elem a] -> [a]) -> (Seq a -> [Elem a]) -> Seq a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FingerTree SizeM (Elem a) -> [Elem a]
forall v a. FingerTree v a -> [a]
FT.toList (FingerTree SizeM (Elem a) -> [Elem a])
-> (Seq a -> FingerTree SizeM (Elem a)) -> Seq a -> [Elem a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Seq a -> FingerTree SizeM (Elem a)
forall t. Seq t -> FingerTree SizeM (Elem t)
unSeq
reverse :: forall a. Seq a -> Seq a
reverse      = FingerTree SizeM (Elem a) -> Seq a
forall a. FingerTree SizeM (Elem a) -> Seq a
Seq (FingerTree SizeM (Elem a) -> Seq a)
-> (Seq a -> FingerTree SizeM (Elem a)) -> Seq a -> Seq a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FingerTree SizeM (Elem a) -> FingerTree SizeM (Elem a)
forall v a. Measured v a => FingerTree v a -> FingerTree v a
FT.reverse (FingerTree SizeM (Elem a) -> FingerTree SizeM (Elem a))
-> (Seq a -> FingerTree SizeM (Elem a))
-> Seq a
-> FingerTree SizeM (Elem a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Seq a -> FingerTree SizeM (Elem a)
forall t. Seq t -> FingerTree SizeM (Elem t)
unSeq
size :: forall a. Seq a -> Int
size         = SizeM -> Int
unSizeM (SizeM -> Int) -> (Seq a -> SizeM) -> Seq a -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FingerTree SizeM (Elem a) -> SizeM
forall v a. Measured v a => a -> v
measure (FingerTree SizeM (Elem a) -> SizeM)
-> (Seq a -> FingerTree SizeM (Elem a)) -> Seq a -> SizeM
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Seq a -> FingerTree SizeM (Elem a)
forall t. Seq t -> FingerTree SizeM (Elem t)
unSeq
strict :: forall a. Seq a -> Seq a
strict       = FingerTree SizeM (Elem a) -> Seq a
forall a. FingerTree SizeM (Elem a) -> Seq a
Seq (FingerTree SizeM (Elem a) -> Seq a)
-> (Seq a -> FingerTree SizeM (Elem a)) -> Seq a -> Seq a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FingerTree SizeM (Elem a) -> FingerTree SizeM (Elem a)
forall v a. FingerTree v a -> FingerTree v a
FT.strict (FingerTree SizeM (Elem a) -> FingerTree SizeM (Elem a))
-> (Seq a -> FingerTree SizeM (Elem a))
-> Seq a
-> FingerTree SizeM (Elem a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Seq a -> FingerTree SizeM (Elem a)
forall t. Seq t -> FingerTree SizeM (Elem t)
unSeq
strictWith :: forall a b. (a -> b) -> Seq a -> Seq a
strictWith a -> b
f = FingerTree SizeM (Elem a) -> Seq a
forall a. FingerTree SizeM (Elem a) -> Seq a
Seq (FingerTree SizeM (Elem a) -> Seq a)
-> (Seq a -> FingerTree SizeM (Elem a)) -> Seq a -> Seq a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Elem a -> b)
-> FingerTree SizeM (Elem a) -> FingerTree SizeM (Elem a)
forall a b v. (a -> b) -> FingerTree v a -> FingerTree v a
FT.strictWith (a -> b
f (a -> b) -> (Elem a -> a) -> Elem a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Elem a -> a
forall t. Elem t -> t
unElem) (FingerTree SizeM (Elem a) -> FingerTree SizeM (Elem a))
-> (Seq a -> FingerTree SizeM (Elem a))
-> Seq a
-> FingerTree SizeM (Elem a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Seq a -> FingerTree SizeM (Elem a)
forall t. Seq t -> FingerTree SizeM (Elem t)
unSeq
structuralInvariant :: forall a. Seq a -> Bool
structuralInvariant = FingerTree SizeM (Elem a) -> Bool
forall v a. (Eq v, Measured v a) => FingerTree v a -> Bool
FT.structuralInvariant (FingerTree SizeM (Elem a) -> Bool)
-> (Seq a -> FingerTree SizeM (Elem a)) -> Seq a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Seq a -> FingerTree SizeM (Elem a)
forall t. Seq t -> FingerTree SizeM (Elem t)
unSeq

#ifdef __GLASGOW_HASKELL__

lview :: forall (m :: * -> *) a. MonadFail m => Seq a -> m (a, Seq a)
lview (Seq FingerTree SizeM (Elem a)
xs) =
  let f :: m (Elem a, FingerTree SizeM (Elem a)) -> m (a, Seq a)
f = m (Elem a, FingerTree SizeM (Elem a)) -> m (a, Seq a)
forall a b. a -> b
forall {m :: * -> *} {a}.
Monad m =>
m (Elem a, FingerTree SizeM (Elem a)) -> m (a, Seq a)
unsafeCoerce# :: Monad m => m (Elem a,FT.FingerTree SizeM (Elem a)) -> m (a,Seq a)
  in  m (Elem a, FingerTree SizeM (Elem a)) -> m (a, Seq a)
forall {a}. m (Elem a, FingerTree SizeM (Elem a)) -> m (a, Seq a)
f (FingerTree SizeM (Elem a) -> m (Elem a, FingerTree SizeM (Elem a))
forall v a (m :: * -> *).
(Measured v a, MonadFail m) =>
FingerTree v a -> m (a, FingerTree v a)
FT.lview FingerTree SizeM (Elem a)
xs)

rview :: forall (m :: * -> *) a. MonadFail m => Seq a -> m (a, Seq a)
rview (Seq FingerTree SizeM (Elem a)
xs) =
  let f :: m (Elem a, FingerTree SizeM (Elem a)) -> m (a, Seq a)
f = m (Elem a, FingerTree SizeM (Elem a)) -> m (a, Seq a)
forall a b. a -> b
forall {m :: * -> *} {a}.
Monad m =>
m (Elem a, FingerTree SizeM (Elem a)) -> m (a, Seq a)
unsafeCoerce# :: Monad m => m (Elem a,FT.FingerTree SizeM (Elem a)) -> m (a,Seq a)
  in  m (Elem a, FingerTree SizeM (Elem a)) -> m (a, Seq a)
forall {a}. m (Elem a, FingerTree SizeM (Elem a)) -> m (a, Seq a)
f (FingerTree SizeM (Elem a) -> m (Elem a, FingerTree SizeM (Elem a))
forall v a (m :: * -> *).
(Measured v a, MonadFail m) =>
FingerTree v a -> m (a, FingerTree v a)
FT.rview FingerTree SizeM (Elem a)
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 :: forall (m :: * -> *) a. MonadFail m => Seq a -> m a
lheadM Seq a
xs = Seq a -> m (a, Seq a)
forall (m :: * -> *) a. MonadFail m => Seq a -> m (a, Seq a)
lview Seq a
xs m (a, Seq a) -> ((a, Seq a) -> m a) -> m a
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> m a
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> m a) -> ((a, Seq a) -> a) -> (a, Seq a) -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a, Seq a) -> a
forall a b. (a, b) -> a
fst
ltailM :: forall (m :: * -> *) a. MonadFail m => Seq a -> m (Seq a)
ltailM Seq a
xs = Seq a -> m (a, Seq a)
forall (m :: * -> *) a. MonadFail m => Seq a -> m (a, Seq a)
lview Seq a
xs m (a, Seq a) -> ((a, Seq a) -> m (Seq a)) -> m (Seq a)
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Seq a -> m (Seq a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Seq a -> m (Seq a))
-> ((a, Seq a) -> Seq a) -> (a, Seq a) -> m (Seq a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a, Seq a) -> Seq a
forall a b. (a, b) -> b
snd
rheadM :: forall (m :: * -> *) a. MonadFail m => Seq a -> m a
rheadM Seq a
xs = Seq a -> m (a, Seq a)
forall (m :: * -> *) a. MonadFail m => Seq a -> m (a, Seq a)
rview Seq a
xs m (a, Seq a) -> ((a, Seq a) -> m a) -> m a
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> m a
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> m a) -> ((a, Seq a) -> a) -> (a, Seq a) -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a, Seq a) -> a
forall a b. (a, b) -> a
fst
rtailM :: forall (m :: * -> *) a. MonadFail m => Seq a -> m (Seq a)
rtailM Seq a
xs = Seq a -> m (a, Seq a)
forall (m :: * -> *) a. MonadFail m => Seq a -> m (a, Seq a)
rview Seq a
xs m (a, Seq a) -> ((a, Seq a) -> m (Seq a)) -> m (Seq a)
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Seq a -> m (Seq a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Seq a -> m (Seq a))
-> ((a, Seq a) -> Seq a) -> (a, Seq a) -> m (Seq a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a, Seq a) -> Seq a
forall a b. (a, b) -> b
snd
lhead :: forall a. Seq a -> a
lhead = Fail a -> a
forall a. Fail a -> a
runFail_ (Fail a -> a) -> (Seq a -> Fail a) -> Seq a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Seq a -> Fail a
forall (m :: * -> *) a. MonadFail m => Seq a -> m a
lheadM
ltail :: forall a. Seq a -> Seq a
ltail = Fail (Seq a) -> Seq a
forall a. Fail a -> a
runFail_ (Fail (Seq a) -> Seq a)
-> (Seq a -> Fail (Seq a)) -> Seq a -> Seq a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Seq a -> Fail (Seq a)
forall (m :: * -> *) a. MonadFail m => Seq a -> m (Seq a)
ltailM
rhead :: forall a. Seq a -> a
rhead = Fail a -> a
forall a. Fail a -> a
runFail_ (Fail a -> a) -> (Seq a -> Fail a) -> Seq a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Seq a -> Fail a
forall (m :: * -> *) a. MonadFail m => Seq a -> m a
rheadM
rtail :: forall a. Seq a -> Seq a
rtail = Fail (Seq a) -> Seq a
forall a. Fail a -> a
runFail_ (Fail (Seq a) -> Seq a)
-> (Seq a -> Fail (Seq a)) -> Seq a -> Seq a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Seq a -> Fail (Seq a)
forall (m :: * -> *) a. MonadFail m => Seq a -> m (Seq a)
rtailM

fold :: forall a b. (a -> b -> b) -> b -> Seq a -> b
fold     = (a -> b -> b) -> b -> Seq a -> b
forall a b. (a -> b -> b) -> b -> Seq a -> b
foldr
fold' :: forall a b. (a -> b -> b) -> b -> Seq a -> b
fold'    = (a -> b -> b) -> b -> Seq a -> b
forall a b. (a -> b -> b) -> b -> Seq a -> b
foldr'
fold1 :: forall a. (a -> a -> a) -> Seq a -> a
fold1    = (a -> a -> a) -> Seq a -> a
forall a. (a -> a -> a) -> Seq a -> a
foldr1
fold1' :: forall a. (a -> a -> a) -> Seq a -> a
fold1'   = (a -> a -> a) -> Seq a -> a
forall a. (a -> a -> a) -> Seq a -> a
foldr1'

#ifdef __GLASGOW_HASKELL__

foldr :: forall a b. (a -> b -> b) -> b -> Seq a -> b
foldr  a -> b -> b
f b
z (Seq FingerTree SizeM (Elem a)
xs) = Elem b -> b
forall t. Elem t -> t
unElem (Elem b -> b) -> Elem b -> b
forall a b. (a -> b) -> a -> b
$ (Elem b -> Elem b)
-> ((Elem b -> Elem b) -> (Elem b -> Elem b) -> Elem b -> Elem b)
-> (Elem a -> Elem b -> Elem b)
-> FingerTree SizeM (Elem a)
-> Elem b
-> Elem b
forall b a v. b -> (b -> b -> b) -> (a -> b) -> FingerTree v a -> b
FT.foldFT Elem b -> Elem b
forall a. a -> a
id (Elem b -> Elem b) -> (Elem b -> Elem b) -> Elem b -> Elem b
forall b c a. (b -> c) -> (a -> b) -> a -> c
(.) ((a -> b -> b) -> Elem a -> Elem b -> Elem b
forall a b. a -> b
unsafeCoerce# a -> b -> b
f) FingerTree SizeM (Elem a)
xs (b -> Elem b
forall a. a -> Elem a
Elem b
z)
foldr' :: forall a b. (a -> b -> b) -> b -> Seq a -> b
foldr' a -> b -> b
f b
z (Seq FingerTree SizeM (Elem a)
xs) = Elem b -> b
forall t. Elem t -> t
unElem (Elem b -> b) -> Elem b -> b
forall a b. (a -> b) -> a -> b
$ (Elem b -> Elem b)
-> ((Elem b -> Elem b) -> (Elem b -> Elem b) -> Elem b -> Elem b)
-> (Elem a -> Elem b -> Elem b)
-> FingerTree SizeM (Elem a)
-> Elem b
-> Elem b
forall b a v. b -> (b -> b -> b) -> (a -> b) -> FingerTree v a -> b
FT.foldFT Elem b -> Elem b
forall a. a -> a
id (Elem b -> Elem b) -> (Elem b -> Elem b) -> Elem b -> Elem b
forall b c a. (b -> c) -> (a -> b) -> a -> c
(.) ((a -> b -> b) -> Elem a -> Elem b -> Elem b
forall a b. a -> b
unsafeCoerce# a -> b -> b
f) FingerTree SizeM (Elem a)
xs (b -> Elem b
forall a. a -> Elem a
Elem b
z)

reduce1 :: forall a. (a -> a -> a) -> Seq a -> a
reduce1  a -> a -> a
f (Seq FingerTree SizeM (Elem a)
xs) = Elem a -> a
forall t. Elem t -> t
unElem (Elem a -> a) -> Elem a -> a
forall a b. (a -> b) -> a -> b
$ (Elem a -> Elem a -> Elem a) -> FingerTree SizeM (Elem a) -> Elem a
forall a v. (a -> a -> a) -> FingerTree v a -> a
FT.reduce1  ((a -> a -> a) -> Elem a -> Elem a -> Elem a
forall a b. a -> b
unsafeCoerce# a -> a -> a
f) FingerTree SizeM (Elem a)
xs
reduce1' :: forall a. (a -> a -> a) -> Seq a -> a
reduce1' a -> a -> a
f (Seq FingerTree SizeM (Elem a)
xs) = Elem a -> a
forall t. Elem t -> t
unElem (Elem a -> a) -> Elem a -> a
forall a b. (a -> b) -> a -> b
$ (Elem a -> Elem a -> Elem a) -> FingerTree SizeM (Elem a) -> Elem a
forall a v. (a -> a -> a) -> FingerTree v a -> a
FT.reduce1' ((a -> a -> a) -> Elem a -> Elem a -> Elem a
forall a b. a -> b
unsafeCoerce# a -> a -> a
f) FingerTree SizeM (Elem a)
xs

map :: forall a b. (a -> b) -> Seq a -> Seq b
map a -> b
f (Seq FingerTree SizeM (Elem a)
xs) = FingerTree SizeM (Elem b) -> Seq b
forall a. FingerTree SizeM (Elem a) -> Seq a
Seq (FingerTree SizeM (Elem b) -> Seq b)
-> FingerTree SizeM (Elem b) -> Seq b
forall a b. (a -> b) -> a -> b
$ (Elem a -> Elem b)
-> FingerTree SizeM (Elem a) -> FingerTree SizeM (Elem b)
forall v2 a2 a1 v1.
Measured v2 a2 =>
(a1 -> a2) -> FingerTree v1 a1 -> FingerTree v2 a2
FT.mapTree ((a -> b) -> Elem a -> Elem b
forall a b. a -> b
unsafeCoerce# a -> b
f) FingerTree SizeM (Elem a)
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 :: forall (m :: * -> *) a. MonadFail m => Int -> Seq a -> m a
lookupM Int
i (Seq FingerTree SizeM (Elem a)
xs)
    | Int -> Seq a -> Bool
forall a. Int -> Seq a -> Bool
inBounds Int
i (FingerTree SizeM (Elem a) -> Seq a
forall a. FingerTree SizeM (Elem a) -> Seq a
Seq FingerTree SizeM (Elem a)
xs) =
        case (SizeM -> Bool)
-> SizeM
-> FingerTree SizeM (Elem a)
-> Split (FingerTree SizeM (Elem a)) (Elem a)
forall v a.
Measured v a =>
(v -> Bool) -> v -> FingerTree v a -> Split (FingerTree v a) a
FT.splitTree (SizeM -> SizeM -> Bool
forall a. Ord a => a -> a -> Bool
> (Int -> SizeM
SizeM Int
i)) (Int -> SizeM
SizeM Int
0) FingerTree SizeM (Elem a)
xs of
           FT.Split FingerTree SizeM (Elem a)
_ (Elem a
x) FingerTree SizeM (Elem a)
_ -> a -> m a
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return a
x

    | Bool
otherwise = String -> m a
forall a. String -> m a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"FingerSeq.lookupM: index out of bounds"

lookupWithDefault :: forall a. a -> Int -> Seq a -> a
lookupWithDefault a
d Int
i (Seq FingerTree SizeM (Elem a)
xs)
    | Int -> Seq a -> Bool
forall a. Int -> Seq a -> Bool
inBounds Int
i (FingerTree SizeM (Elem a) -> Seq a
forall a. FingerTree SizeM (Elem a) -> Seq a
Seq FingerTree SizeM (Elem a)
xs) =
        case (SizeM -> Bool)
-> SizeM
-> FingerTree SizeM (Elem a)
-> Split (FingerTree SizeM (Elem a)) (Elem a)
forall v a.
Measured v a =>
(v -> Bool) -> v -> FingerTree v a -> Split (FingerTree v a) a
FT.splitTree (SizeM -> SizeM -> Bool
forall a. Ord a => a -> a -> Bool
> (Int -> SizeM
SizeM Int
i)) (Int -> SizeM
SizeM Int
0) FingerTree SizeM (Elem a)
xs of
           FT.Split FingerTree SizeM (Elem a)
_ (Elem a
x) FingerTree SizeM (Elem a)
_ -> a
x

    | Bool
otherwise = a
d

update :: forall a. Int -> a -> Seq a -> Seq a
update Int
i a
x (Seq FingerTree SizeM (Elem a)
xs)
    | Int -> Seq a -> Bool
forall a. Int -> Seq a -> Bool
inBounds Int
i (FingerTree SizeM (Elem a) -> Seq a
forall a. FingerTree SizeM (Elem a) -> Seq a
Seq FingerTree SizeM (Elem a)
xs) =
        case (SizeM -> Bool)
-> SizeM
-> FingerTree SizeM (Elem a)
-> Split (FingerTree SizeM (Elem a)) (Elem a)
forall v a.
Measured v a =>
(v -> Bool) -> v -> FingerTree v a -> Split (FingerTree v a) a
FT.splitTree (SizeM -> SizeM -> Bool
forall a. Ord a => a -> a -> Bool
> (Int -> SizeM
SizeM Int
i)) (Int -> SizeM
SizeM Int
0) FingerTree SizeM (Elem a)
xs of
           FT.Split FingerTree SizeM (Elem a)
l Elem a
_ FingerTree SizeM (Elem a)
r -> FingerTree SizeM (Elem a) -> Seq a
forall a. FingerTree SizeM (Elem a) -> Seq a
Seq (FingerTree SizeM (Elem a) -> Seq a)
-> FingerTree SizeM (Elem a) -> Seq a
forall a b. (a -> b) -> a -> b
$ FingerTree SizeM (Elem a)
-> FingerTree SizeM (Elem a) -> FingerTree SizeM (Elem a)
forall v a.
Measured v a =>
FingerTree v a -> FingerTree v a -> FingerTree v a
FT.append FingerTree SizeM (Elem a)
l (FingerTree SizeM (Elem a) -> FingerTree SizeM (Elem a))
-> FingerTree SizeM (Elem a) -> FingerTree SizeM (Elem a)
forall a b. (a -> b) -> a -> b
$ Elem a -> FingerTree SizeM (Elem a) -> FingerTree SizeM (Elem a)
forall v a. Measured v a => a -> FingerTree v a -> FingerTree v a
FT.lcons (a -> Elem a
forall a. a -> Elem a
Elem a
x) (FingerTree SizeM (Elem a) -> FingerTree SizeM (Elem a))
-> FingerTree SizeM (Elem a) -> FingerTree SizeM (Elem a)
forall a b. (a -> b) -> a -> b
$ FingerTree SizeM (Elem a)
r

    | Bool
otherwise = FingerTree SizeM (Elem a) -> Seq a
forall a. FingerTree SizeM (Elem a) -> Seq a
Seq FingerTree SizeM (Elem a)
xs

adjust :: forall a. (a -> a) -> Int -> Seq a -> Seq a
adjust a -> a
f Int
i (Seq FingerTree SizeM (Elem a)
xs)
    | Int -> Seq a -> Bool
forall a. Int -> Seq a -> Bool
inBounds Int
i (FingerTree SizeM (Elem a) -> Seq a
forall a. FingerTree SizeM (Elem a) -> Seq a
Seq FingerTree SizeM (Elem a)
xs) =
        case (SizeM -> Bool)
-> SizeM
-> FingerTree SizeM (Elem a)
-> Split (FingerTree SizeM (Elem a)) (Elem a)
forall v a.
Measured v a =>
(v -> Bool) -> v -> FingerTree v a -> Split (FingerTree v a) a
FT.splitTree (SizeM -> SizeM -> Bool
forall a. Ord a => a -> a -> Bool
> (Int -> SizeM
SizeM Int
i)) (Int -> SizeM
SizeM Int
0) FingerTree SizeM (Elem a)
xs of
           FT.Split FingerTree SizeM (Elem a)
l Elem a
x FingerTree SizeM (Elem a)
r -> FingerTree SizeM (Elem a) -> Seq a
forall a. FingerTree SizeM (Elem a) -> Seq a
Seq (FingerTree SizeM (Elem a) -> Seq a)
-> FingerTree SizeM (Elem a) -> Seq a
forall a b. (a -> b) -> a -> b
$ FingerTree SizeM (Elem a)
-> FingerTree SizeM (Elem a) -> FingerTree SizeM (Elem a)
forall v a.
Measured v a =>
FingerTree v a -> FingerTree v a -> FingerTree v a
FT.append FingerTree SizeM (Elem a)
l (FingerTree SizeM (Elem a) -> FingerTree SizeM (Elem a))
-> FingerTree SizeM (Elem a) -> FingerTree SizeM (Elem a)
forall a b. (a -> b) -> a -> b
$ Elem a -> FingerTree SizeM (Elem a) -> FingerTree SizeM (Elem a)
forall v a. Measured v a => a -> FingerTree v a -> FingerTree v a
FT.lcons (a -> Elem a
forall a. a -> Elem a
Elem (a -> a
f (Elem a -> a
forall t. Elem t -> t
unElem Elem a
x))) (FingerTree SizeM (Elem a) -> FingerTree SizeM (Elem a))
-> FingerTree SizeM (Elem a) -> FingerTree SizeM (Elem a)
forall a b. (a -> b) -> a -> b
$ FingerTree SizeM (Elem a)
r

    | Bool
otherwise = FingerTree SizeM (Elem a) -> Seq a
forall a. FingerTree SizeM (Elem a) -> Seq a
Seq FingerTree SizeM (Elem a)
xs

take :: forall a. Int -> Seq a -> Seq a
take Int
i (Seq FingerTree SizeM (Elem a)
xs) = FingerTree SizeM (Elem a) -> Seq a
forall a. FingerTree SizeM (Elem a) -> Seq a
Seq (FingerTree SizeM (Elem a) -> Seq a)
-> FingerTree SizeM (Elem a) -> Seq a
forall a b. (a -> b) -> a -> b
$ (SizeM -> Bool)
-> FingerTree SizeM (Elem a) -> FingerTree SizeM (Elem a)
forall v a.
Measured v a =>
(v -> Bool) -> FingerTree v a -> FingerTree v a
FT.takeUntil (SizeM -> SizeM -> Bool
forall a. Ord a => a -> a -> Bool
> (Int -> SizeM
SizeM Int
i)) FingerTree SizeM (Elem a)
xs
drop :: forall a. Int -> Seq a -> Seq a
drop Int
i (Seq FingerTree SizeM (Elem a)
xs) = FingerTree SizeM (Elem a) -> Seq a
forall a. FingerTree SizeM (Elem a) -> Seq a
Seq (FingerTree SizeM (Elem a) -> Seq a)
-> FingerTree SizeM (Elem a) -> Seq a
forall a b. (a -> b) -> a -> b
$ (SizeM -> Bool)
-> FingerTree SizeM (Elem a) -> FingerTree SizeM (Elem a)
forall v a.
Measured v a =>
(v -> Bool) -> FingerTree v a -> FingerTree v a
FT.dropUntil (SizeM -> SizeM -> Bool
forall a. Ord a => a -> a -> Bool
> (Int -> SizeM
SizeM Int
i)) FingerTree SizeM (Elem a)
xs
splitAt :: forall a. Int -> Seq a -> (Seq a, Seq a)
splitAt Int
i (Seq FingerTree SizeM (Elem a)
xs) = let (FingerTree SizeM (Elem a)
a,FingerTree SizeM (Elem a)
b) = (SizeM -> Bool)
-> FingerTree SizeM (Elem a)
-> (FingerTree SizeM (Elem a), FingerTree SizeM (Elem a))
forall v a.
Measured v a =>
(v -> Bool) -> FingerTree v a -> (FingerTree v a, FingerTree v a)
FT.split (SizeM -> SizeM -> Bool
forall a. Ord a => a -> a -> Bool
> (Int -> SizeM
SizeM Int
i)) FingerTree SizeM (Elem a)
xs in (FingerTree SizeM (Elem a) -> Seq a
forall a. FingerTree SizeM (Elem a) -> Seq a
Seq FingerTree SizeM (Elem a)
a, FingerTree SizeM (Elem a) -> Seq a
forall a. FingerTree SizeM (Elem a) -> Seq a
Seq FingerTree SizeM (Elem a)
b)


inBounds :: forall a. Int -> Seq a -> Bool
inBounds = Int -> Seq a -> Bool
forall (s :: * -> *) a. Sequence s => Int -> s a -> Bool
inBoundsUsingSize
lookup :: forall a. Int -> Seq a -> a
lookup   = Int -> Seq a -> a
forall (s :: * -> *) a. Sequence s => Int -> s a -> a
lookupUsingLookupM

foldr1 :: forall a. (a -> a -> a) -> Seq a -> a
foldr1 a -> a -> a
f Seq a
xs =
   case Seq a -> Maybe (a, Seq a)
forall (m :: * -> *) a. MonadFail m => Seq a -> m (a, Seq a)
rview Seq a
xs of
      Maybe (a, Seq a)
Nothing      -> String -> a
forall a. HasCallStack => String -> a
error String
"FingerSeq.foldr1: empty sequence"
      Just (a
x,Seq a
xs') -> (a -> a -> a) -> a -> Seq a -> a
forall a b. (a -> b -> b) -> b -> Seq a -> b
foldr a -> a -> a
f a
x Seq a
xs'

foldr1' :: forall a. (a -> a -> a) -> Seq a -> a
foldr1' a -> a -> a
f Seq a
xs =
   case Seq a -> Maybe (a, Seq a)
forall (m :: * -> *) a. MonadFail m => Seq a -> m (a, Seq a)
rview Seq a
xs of
      Maybe (a, Seq a)
Nothing      -> String -> a
forall a. HasCallStack => String -> a
error String
"FingerSeq.foldr1': empty sequence"
      Just (a
x,Seq a
xs') -> (a -> a -> a) -> a -> Seq a -> a
forall a b. (a -> b -> b) -> b -> Seq a -> b
foldr' a -> a -> a
f a
x Seq a
xs'

foldl :: forall b a. (b -> a -> b) -> b -> Seq a -> b
foldl    = (b -> a -> b) -> b -> Seq a -> b
forall (s :: * -> *) b a.
Sequence s =>
(b -> a -> b) -> b -> s a -> b
foldlUsingLists
foldl' :: forall b a. (b -> a -> b) -> b -> Seq a -> b
foldl'   = (b -> a -> b) -> b -> Seq a -> b
forall (s :: * -> *) b a.
Sequence s =>
(b -> a -> b) -> b -> s a -> b
foldl'UsingLists
foldl1 :: forall a. (a -> a -> a) -> Seq a -> a
foldl1   = (a -> a -> a) -> Seq a -> a
forall (s :: * -> *) a. Sequence s => (a -> a -> a) -> s a -> a
foldl1UsingLists
foldl1' :: forall a. (a -> a -> a) -> Seq a -> a
foldl1'  = (a -> a -> a) -> Seq a -> a
forall (s :: * -> *) a. Sequence s => (a -> a -> a) -> s a -> a
foldl1'UsingLists

reducer :: forall a. (a -> a -> a) -> a -> Seq a -> a
reducer  = (a -> a -> a) -> a -> Seq a -> a
forall (s :: * -> *) a.
Sequence s =>
(a -> a -> a) -> a -> s a -> a
reducerUsingReduce1
reducer' :: forall a. (a -> a -> a) -> a -> Seq a -> a
reducer' = (a -> a -> a) -> a -> Seq a -> a
forall (s :: * -> *) a.
Sequence s =>
(a -> a -> a) -> a -> s a -> a
reducer'UsingReduce1'
reducel :: forall a. (a -> a -> a) -> a -> Seq a -> a
reducel  = (a -> a -> a) -> a -> Seq a -> a
forall (s :: * -> *) a.
Sequence s =>
(a -> a -> a) -> a -> s a -> a
reducelUsingReduce1
reducel' :: forall a. (a -> a -> a) -> a -> Seq a -> a
reducel' = (a -> a -> a) -> a -> Seq a -> a
forall (s :: * -> *) a.
Sequence s =>
(a -> a -> a) -> a -> s a -> a
reducel'UsingReduce1'

copy :: forall a. Int -> a -> Seq a
copy        = Int -> a -> Seq a
forall (s :: * -> *) a. Sequence s => Int -> a -> s a
copyUsingLists
concat :: forall a. Seq (Seq a) -> Seq a
concat      = Seq (Seq a) -> Seq a
forall (s :: * -> *) a. Sequence s => s (s a) -> s a
concatUsingFoldr
reverseOnto :: forall a. Seq a -> Seq a -> Seq a
reverseOnto = Seq a -> Seq a -> Seq a
forall (s :: * -> *) a. Sequence s => s a -> s a -> s a
reverseOntoUsingReverse
concatMap :: forall a b. (a -> Seq b) -> Seq a -> Seq b
concatMap   = (a -> Seq b) -> Seq a -> Seq b
forall (s :: * -> *) a b. Sequence s => (a -> s b) -> s a -> s b
concatMapUsingFoldr
subseq :: forall a. Int -> Int -> Seq a -> Seq a
subseq      = Int -> Int -> Seq a -> Seq a
forall (s :: * -> *) a. Sequence s => Int -> Int -> s a -> s a
subseqDefault
filter :: forall a. (a -> Bool) -> Seq a -> Seq a
filter      = (a -> Bool) -> Seq a -> Seq a
forall (s :: * -> *) a. Sequence s => (a -> Bool) -> s a -> s a
filterUsingLview
partition :: forall a. (a -> Bool) -> Seq a -> (Seq a, Seq a)
partition   = (a -> Bool) -> Seq a -> (Seq a, Seq a)
forall (s :: * -> *) a.
Sequence s =>
(a -> Bool) -> s a -> (s a, s a)
partitionUsingFoldr
takeWhile :: forall a. (a -> Bool) -> Seq a -> Seq a
takeWhile   = (a -> Bool) -> Seq a -> Seq a
forall (s :: * -> *) a. Sequence s => (a -> Bool) -> s a -> s a
takeWhileUsingLview
dropWhile :: forall a. (a -> Bool) -> Seq a -> Seq a
dropWhile   = (a -> Bool) -> Seq a -> Seq a
forall (s :: * -> *) a. Sequence s => (a -> Bool) -> s a -> s a
dropWhileUsingLview
splitWhile :: forall a. (a -> Bool) -> Seq a -> (Seq a, Seq a)
splitWhile  = (a -> Bool) -> Seq a -> (Seq a, Seq a)
forall (s :: * -> *) a.
Sequence s =>
(a -> Bool) -> s a -> (s a, s a)
splitWhileUsingLview

mapWithIndex :: forall a b. (Int -> a -> b) -> Seq a -> Seq b
mapWithIndex    = (Int -> a -> b) -> Seq a -> Seq b
forall (s :: * -> *) a b.
Sequence s =>
(Int -> a -> b) -> s a -> s b
mapWithIndexUsingLists
foldrWithIndex :: forall a b. (Int -> a -> b -> b) -> b -> Seq a -> b
foldrWithIndex  = (Int -> a -> b -> b) -> b -> Seq a -> b
forall (s :: * -> *) a b.
Sequence s =>
(Int -> a -> b -> b) -> b -> s a -> b
foldrWithIndexUsingLists
foldrWithIndex' :: forall a b. (Int -> a -> b -> b) -> b -> Seq a -> b
foldrWithIndex' = (Int -> a -> b -> b) -> b -> Seq a -> b
forall (s :: * -> *) a b.
Sequence s =>
(Int -> a -> b -> b) -> b -> s a -> b
foldrWithIndex'UsingLists
foldlWithIndex :: forall b a. (b -> Int -> a -> b) -> b -> Seq a -> b
foldlWithIndex  = (b -> Int -> a -> b) -> b -> Seq a -> b
forall (s :: * -> *) b a.
Sequence s =>
(b -> Int -> a -> b) -> b -> s a -> b
foldlWithIndexUsingLists
foldlWithIndex' :: forall b a. (b -> Int -> a -> b) -> b -> Seq a -> b
foldlWithIndex' = (b -> Int -> a -> b) -> b -> Seq a -> b
forall (s :: * -> *) b a.
Sequence s =>
(b -> Int -> a -> b) -> b -> s a -> b
foldlWithIndex'UsingLists

zip :: forall a b. Seq a -> Seq b -> Seq (a, b)
zip = Seq a -> Seq b -> Seq (a, b)
forall (s :: * -> *) a b. Sequence s => s a -> s b -> s (a, b)
zipUsingLview
zip3 :: forall a b c. Seq a -> Seq b -> Seq c -> Seq (a, b, c)
zip3 = Seq a -> Seq b -> Seq c -> Seq (a, b, c)
forall (s :: * -> *) a b c.
Sequence s =>
s a -> s b -> s c -> s (a, b, c)
zip3UsingLview
zipWith :: forall a b c. (a -> b -> c) -> Seq a -> Seq b -> Seq c
zipWith = (a -> b -> c) -> Seq a -> Seq b -> Seq c
forall (s :: * -> *) a b c.
Sequence s =>
(a -> b -> c) -> s a -> s b -> s c
zipWithUsingLview
zipWith3 :: forall a b c d.
(a -> b -> c -> d) -> Seq a -> Seq b -> Seq c -> Seq d
zipWith3 = (a -> b -> c -> d) -> Seq a -> Seq b -> Seq c -> Seq d
forall (s :: * -> *) a b c d.
Sequence s =>
(a -> b -> c -> d) -> s a -> s b -> s c -> s d
zipWith3UsingLview

unzip :: forall a b. Seq (a, b) -> (Seq a, Seq b)
unzip = Seq (a, b) -> (Seq a, Seq b)
forall (s :: * -> *) a b. Sequence s => s (a, b) -> (s a, s b)
unzipUsingFoldr
unzip3 :: forall a b c. Seq (a, b, c) -> (Seq a, Seq b, Seq c)
unzip3 = Seq (a, b, c) -> (Seq a, Seq b, Seq c)
forall (s :: * -> *) a b c.
Sequence s =>
s (a, b, c) -> (s a, s b, s c)
unzip3UsingFoldr
unzipWith :: forall a b c. (a -> b) -> (a -> c) -> Seq a -> (Seq b, Seq c)
unzipWith = (a -> b) -> (a -> c) -> Seq a -> (Seq b, Seq c)
forall (s :: * -> *) a b c.
Sequence s =>
(a -> b) -> (a -> c) -> s a -> (s b, s c)
unzipWithUsingFoldr
unzipWith3 :: forall a b c d.
(a -> b) -> (a -> c) -> (a -> d) -> Seq a -> (Seq b, Seq c, Seq d)
unzipWith3 = (a -> b) -> (a -> c) -> (a -> d) -> Seq a -> (Seq b, Seq c, Seq d)
forall (s :: * -> *) a b c d.
Sequence s =>
(a -> b) -> (a -> c) -> (a -> d) -> s a -> (s b, s c, s d)
unzipWith3UsingFoldr

-- instances

instance S.Sequence Seq where
  {lcons :: forall a. a -> Seq a -> Seq a
lcons = a -> Seq a -> Seq a
forall a. a -> Seq a -> Seq a
lcons; rcons :: forall a. a -> Seq a -> Seq a
rcons = a -> Seq a -> Seq a
forall a. a -> Seq a -> Seq a
rcons;
   lview :: forall (m :: * -> *) a. MonadFail m => Seq a -> m (a, Seq a)
lview = Seq a -> m (a, Seq a)
forall (m :: * -> *) a. MonadFail m => Seq a -> m (a, Seq a)
lview; lhead :: forall a. Seq a -> a
lhead = Seq a -> a
forall a. Seq a -> a
lhead; ltail :: forall a. Seq a -> Seq a
ltail = Seq a -> Seq a
forall a. Seq a -> Seq a
ltail;
   lheadM :: forall (m :: * -> *) a. MonadFail m => Seq a -> m a
lheadM = Seq a -> m a
forall (m :: * -> *) a. MonadFail m => Seq a -> m a
lheadM; ltailM :: forall (m :: * -> *) a. MonadFail m => Seq a -> m (Seq a)
ltailM = Seq a -> m (Seq a)
forall (m :: * -> *) a. MonadFail m => Seq a -> m (Seq a)
ltailM; rheadM :: forall (m :: * -> *) a. MonadFail m => Seq a -> m a
rheadM = Seq a -> m a
forall (m :: * -> *) a. MonadFail m => Seq a -> m a
rheadM; rtailM :: forall (m :: * -> *) a. MonadFail m => Seq a -> m (Seq a)
rtailM = Seq a -> m (Seq a)
forall (m :: * -> *) a. MonadFail m => Seq a -> m (Seq a)
rtailM;
   rview :: forall (m :: * -> *) a. MonadFail m => Seq a -> m (a, Seq a)
rview = Seq a -> m (a, Seq a)
forall (m :: * -> *) a. MonadFail m => Seq a -> m (a, Seq a)
rview; rhead :: forall a. Seq a -> a
rhead = Seq a -> a
forall a. Seq a -> a
rhead; rtail :: forall a. Seq a -> Seq a
rtail = Seq a -> Seq a
forall a. Seq a -> Seq a
rtail; null :: forall a. Seq a -> Bool
null = Seq a -> Bool
forall a. Seq a -> Bool
null;
   size :: forall a. Seq a -> Int
size = Seq a -> Int
forall a. Seq a -> Int
size; concat :: forall a. Seq (Seq a) -> Seq a
concat = Seq (Seq a) -> Seq a
forall a. Seq (Seq a) -> Seq a
concat; reverse :: forall a. Seq a -> Seq a
reverse = Seq a -> Seq a
forall a. Seq a -> Seq a
reverse;
   reverseOnto :: forall a. Seq a -> Seq a -> Seq a
reverseOnto = Seq a -> Seq a -> Seq a
forall a. Seq a -> Seq a -> Seq a
reverseOnto; fromList :: forall a. [a] -> Seq a
fromList = [a] -> Seq a
forall a. [a] -> Seq a
fromList; toList :: forall a. Seq a -> [a]
toList = Seq a -> [a]
forall a. Seq a -> [a]
toList;
   fold :: forall a b. (a -> b -> b) -> b -> Seq a -> b
fold = (a -> b -> b) -> b -> Seq a -> b
forall a b. (a -> b -> b) -> b -> Seq a -> b
fold; fold' :: forall a b. (a -> b -> b) -> b -> Seq a -> b
fold' = (a -> b -> b) -> b -> Seq a -> b
forall a b. (a -> b -> b) -> b -> Seq a -> b
fold'; fold1 :: forall a. (a -> a -> a) -> Seq a -> a
fold1 = (a -> a -> a) -> Seq a -> a
forall a. (a -> a -> a) -> Seq a -> a
fold1; fold1' :: forall a. (a -> a -> a) -> Seq a -> a
fold1' = (a -> a -> a) -> Seq a -> a
forall a. (a -> a -> a) -> Seq a -> a
fold1';
   foldr :: forall a b. (a -> b -> b) -> b -> Seq a -> b
foldr = (a -> b -> b) -> b -> Seq a -> b
forall a b. (a -> b -> b) -> b -> Seq a -> b
foldr; foldr' :: forall a b. (a -> b -> b) -> b -> Seq a -> b
foldr' = (a -> b -> b) -> b -> Seq a -> b
forall a b. (a -> b -> b) -> b -> Seq a -> b
foldr'; foldl :: forall b a. (b -> a -> b) -> b -> Seq a -> b
foldl = (b -> a -> b) -> b -> Seq a -> b
forall b a. (b -> a -> b) -> b -> Seq a -> b
foldl; foldl' :: forall b a. (b -> a -> b) -> b -> Seq a -> b
foldl' = (b -> a -> b) -> b -> Seq a -> b
forall b a. (b -> a -> b) -> b -> Seq a -> b
foldl';
   foldr1 :: forall a. (a -> a -> a) -> Seq a -> a
foldr1 = (a -> a -> a) -> Seq a -> a
forall a. (a -> a -> a) -> Seq a -> a
foldr1; foldr1' :: forall a. (a -> a -> a) -> Seq a -> a
foldr1' = (a -> a -> a) -> Seq a -> a
forall a. (a -> a -> a) -> Seq a -> a
foldr1'; foldl1 :: forall a. (a -> a -> a) -> Seq a -> a
foldl1 = (a -> a -> a) -> Seq a -> a
forall a. (a -> a -> a) -> Seq a -> a
foldl1; foldl1' :: forall a. (a -> a -> a) -> Seq a -> a
foldl1' = (a -> a -> a) -> Seq a -> a
forall a. (a -> a -> a) -> Seq a -> a
foldl1';
   reducer :: forall a. (a -> a -> a) -> a -> Seq a -> a
reducer = (a -> a -> a) -> a -> Seq a -> a
forall a. (a -> a -> a) -> a -> Seq a -> a
reducer; reducer' :: forall a. (a -> a -> a) -> a -> Seq a -> a
reducer' = (a -> a -> a) -> a -> Seq a -> a
forall a. (a -> a -> a) -> a -> Seq a -> a
reducer'; reducel :: forall a. (a -> a -> a) -> a -> Seq a -> a
reducel = (a -> a -> a) -> a -> Seq a -> a
forall a. (a -> a -> a) -> a -> Seq a -> a
reducel;
   reducel' :: forall a. (a -> a -> a) -> a -> Seq a -> a
reducel' = (a -> a -> a) -> a -> Seq a -> a
forall a. (a -> a -> a) -> a -> Seq a -> a
reducel'; reduce1 :: forall a. (a -> a -> a) -> Seq a -> a
reduce1 = (a -> a -> a) -> Seq a -> a
forall a. (a -> a -> a) -> Seq a -> a
reduce1;  reduce1' :: forall a. (a -> a -> a) -> Seq a -> a
reduce1' = (a -> a -> a) -> Seq a -> a
forall a. (a -> a -> a) -> Seq a -> a
reduce1';
   copy :: forall a. Int -> a -> Seq a
copy = Int -> a -> Seq a
forall a. Int -> a -> Seq a
copy; inBounds :: forall a. Int -> Seq a -> Bool
inBounds = Int -> Seq a -> Bool
forall a. Int -> Seq a -> Bool
inBounds; lookup :: forall a. Int -> Seq a -> a
lookup = Int -> Seq a -> a
forall a. Int -> Seq a -> a
lookup;
   lookupM :: forall (m :: * -> *) a. MonadFail m => Int -> Seq a -> m a
lookupM = Int -> Seq a -> m a
forall (m :: * -> *) a. MonadFail m => Int -> Seq a -> m a
lookupM; lookupWithDefault :: forall a. a -> Int -> Seq a -> a
lookupWithDefault = a -> Int -> Seq a -> a
forall a. a -> Int -> Seq a -> a
lookupWithDefault;
   update :: forall a. Int -> a -> Seq a -> Seq a
update = Int -> a -> Seq a -> Seq a
forall a. Int -> a -> Seq a -> Seq a
update; adjust :: forall a. (a -> a) -> Int -> Seq a -> Seq a
adjust = (a -> a) -> Int -> Seq a -> Seq a
forall a. (a -> a) -> Int -> Seq a -> Seq a
adjust; mapWithIndex :: forall a b. (Int -> a -> b) -> Seq a -> Seq b
mapWithIndex = (Int -> a -> b) -> Seq a -> Seq b
forall a b. (Int -> a -> b) -> Seq a -> Seq b
mapWithIndex;
   foldrWithIndex :: forall a b. (Int -> a -> b -> b) -> b -> Seq a -> b
foldrWithIndex = (Int -> a -> b -> b) -> b -> Seq a -> b
forall a b. (Int -> a -> b -> b) -> b -> Seq a -> b
foldrWithIndex; foldlWithIndex :: forall b a. (b -> Int -> a -> b) -> b -> Seq a -> b
foldlWithIndex = (b -> Int -> a -> b) -> b -> Seq a -> b
forall b a. (b -> Int -> a -> b) -> b -> Seq a -> b
foldlWithIndex;
   foldrWithIndex' :: forall a b. (Int -> a -> b -> b) -> b -> Seq a -> b
foldrWithIndex' = (Int -> a -> b -> b) -> b -> Seq a -> b
forall a b. (Int -> a -> b -> b) -> b -> Seq a -> b
foldrWithIndex'; foldlWithIndex' :: forall b a. (b -> Int -> a -> b) -> b -> Seq a -> b
foldlWithIndex' = (b -> Int -> a -> b) -> b -> Seq a -> b
forall b a. (b -> Int -> a -> b) -> b -> Seq a -> b
foldlWithIndex';
   take :: forall a. Int -> Seq a -> Seq a
take = Int -> Seq a -> Seq a
forall a. Int -> Seq a -> Seq a
take; drop :: forall a. Int -> Seq a -> Seq a
drop = Int -> Seq a -> Seq a
forall a. Int -> Seq a -> Seq a
drop; splitAt :: forall a. Int -> Seq a -> (Seq a, Seq a)
splitAt = Int -> Seq a -> (Seq a, Seq a)
forall a. Int -> Seq a -> (Seq a, Seq a)
splitAt; subseq :: forall a. Int -> Int -> Seq a -> Seq a
subseq = Int -> Int -> Seq a -> Seq a
forall a. Int -> Int -> Seq a -> Seq a
subseq;
   filter :: forall a. (a -> Bool) -> Seq a -> Seq a
filter = (a -> Bool) -> Seq a -> Seq a
forall a. (a -> Bool) -> Seq a -> Seq a
filter; partition :: forall a. (a -> Bool) -> Seq a -> (Seq a, Seq a)
partition = (a -> Bool) -> Seq a -> (Seq a, Seq a)
forall a. (a -> Bool) -> Seq a -> (Seq a, Seq a)
partition; takeWhile :: forall a. (a -> Bool) -> Seq a -> Seq a
takeWhile = (a -> Bool) -> Seq a -> Seq a
forall a. (a -> Bool) -> Seq a -> Seq a
takeWhile;
   dropWhile :: forall a. (a -> Bool) -> Seq a -> Seq a
dropWhile = (a -> Bool) -> Seq a -> Seq a
forall a. (a -> Bool) -> Seq a -> Seq a
dropWhile; splitWhile :: forall a. (a -> Bool) -> Seq a -> (Seq a, Seq a)
splitWhile = (a -> Bool) -> Seq a -> (Seq a, Seq a)
forall a. (a -> Bool) -> Seq a -> (Seq a, Seq a)
splitWhile; zip :: forall a b. Seq a -> Seq b -> Seq (a, b)
zip = Seq a -> Seq b -> Seq (a, b)
forall a b. Seq a -> Seq b -> Seq (a, b)
zip;
   zip3 :: forall a b c. Seq a -> Seq b -> Seq c -> Seq (a, b, c)
zip3 = Seq a -> Seq b -> Seq c -> Seq (a, b, c)
forall a b c. Seq a -> Seq b -> Seq c -> Seq (a, b, c)
zip3; zipWith :: forall a b c. (a -> b -> c) -> Seq a -> Seq b -> Seq c
zipWith = (a -> b -> c) -> Seq a -> Seq b -> Seq c
forall a b c. (a -> b -> c) -> Seq a -> Seq b -> Seq c
zipWith; zipWith3 :: forall a b c d.
(a -> b -> c -> d) -> Seq a -> Seq b -> Seq c -> Seq d
zipWith3 = (a -> b -> c -> d) -> Seq a -> Seq b -> Seq c -> Seq d
forall a b c d.
(a -> b -> c -> d) -> Seq a -> Seq b -> Seq c -> Seq d
zipWith3; unzip :: forall a b. Seq (a, b) -> (Seq a, Seq b)
unzip = Seq (a, b) -> (Seq a, Seq b)
forall a b. Seq (a, b) -> (Seq a, Seq b)
unzip;
   unzip3 :: forall a b c. Seq (a, b, c) -> (Seq a, Seq b, Seq c)
unzip3 = Seq (a, b, c) -> (Seq a, Seq b, Seq c)
forall a b c. Seq (a, b, c) -> (Seq a, Seq b, Seq c)
unzip3; unzipWith :: forall a b c. (a -> b) -> (a -> c) -> Seq a -> (Seq b, Seq c)
unzipWith = (a -> b) -> (a -> c) -> Seq a -> (Seq b, Seq c)
forall a b c. (a -> b) -> (a -> c) -> Seq a -> (Seq b, Seq c)
unzipWith; unzipWith3 :: forall a b c d.
(a -> b) -> (a -> c) -> (a -> d) -> Seq a -> (Seq b, Seq c, Seq d)
unzipWith3 = (a -> b) -> (a -> c) -> (a -> d) -> Seq a -> (Seq b, Seq c, Seq d)
forall a b c d.
(a -> b) -> (a -> c) -> (a -> d) -> Seq a -> (Seq b, Seq c, Seq d)
unzipWith3;
   strict :: forall a. Seq a -> Seq a
strict = Seq a -> Seq a
forall a. Seq a -> Seq a
strict; strictWith :: forall a b. (a -> b) -> Seq a -> Seq a
strictWith = (a -> b) -> Seq a -> Seq a
forall a b. (a -> b) -> Seq a -> Seq a
strictWith;
   structuralInvariant :: forall a. Seq a -> Bool
structuralInvariant = Seq a -> Bool
forall a. Seq a -> Bool
structuralInvariant; instanceName :: forall a. Seq a -> String
instanceName Seq a
_ = String
moduleName}

instance Functor Seq where
  fmap :: forall a b. (a -> b) -> Seq a -> Seq b
fmap = (a -> b) -> Seq a -> Seq b
forall a b. (a -> b) -> Seq a -> Seq b
map

instance App.Alternative Seq where
  empty :: forall a. Seq a
empty = Seq a
forall a. Seq a
empty
  <|> :: forall a. Seq a -> Seq a -> Seq a
(<|>) = Seq a -> Seq a -> Seq a
forall a. Seq a -> Seq a -> Seq a
append

instance App.Applicative Seq where
  pure :: forall a. a -> Seq a
pure = a -> Seq a
forall a. a -> Seq a
forall (m :: * -> *) a. Monad m => a -> m a
return
  Seq (a -> b)
x <*> :: forall a b. Seq (a -> b) -> Seq a -> Seq b
<*> Seq a
y = do
     a -> b
x' <- Seq (a -> b)
x
     a
y' <- Seq a
y
     b -> Seq b
forall a. a -> Seq a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> b
x' a
y')

instance Monad Seq where
  return :: forall a. a -> Seq a
return = a -> Seq a
forall a. a -> Seq a
singleton
  Seq a
xs >>= :: forall a b. Seq a -> (a -> Seq b) -> Seq b
>>= a -> Seq b
k = (a -> Seq b) -> Seq a -> Seq b
forall a b. (a -> Seq b) -> Seq a -> Seq b
concatMap a -> Seq b
k Seq a
xs

instance MonadPlus Seq where
  mplus :: forall a. Seq a -> Seq a -> Seq a
mplus = Seq a -> Seq a -> Seq a
forall a. Seq a -> Seq a -> Seq a
append
  mzero :: forall a. Seq a
mzero = Seq a
forall a. Seq a
empty

instance Eq a => Eq (Seq a) where
  Seq a
xs == :: Seq a -> Seq a -> Bool
== Seq a
ys = Seq a -> [a]
forall a. Seq a -> [a]
toList Seq a
xs [a] -> [a] -> Bool
forall a. Eq a => a -> a -> Bool
== Seq a -> [a]
forall a. Seq a -> [a]
toList Seq a
ys

instance Ord a => Ord (Seq a) where
  compare :: Seq a -> Seq a -> Ordering
compare = Seq a -> Seq a -> Ordering
forall a (s :: * -> *).
(Ord a, Sequence s) =>
s a -> s a -> Ordering
defaultCompare

instance Show a => Show (Seq a) where
  showsPrec :: Int -> Seq a -> ShowS
showsPrec = Int -> Seq a -> ShowS
forall a (s :: * -> *). (Show a, Sequence s) => Int -> s a -> ShowS
showsPrecUsingToList

instance Read a => Read (Seq a) where
  readsPrec :: Int -> ReadS (Seq a)
readsPrec = Int -> ReadS (Seq a)
forall a (s :: * -> *). (Read a, Sequence s) => Int -> ReadS (s a)
readsPrecUsingFromList

instance Arbitrary a => Arbitrary (Elem a) where
   arbitrary :: Gen (Elem a)
arbitrary   = Gen a
forall a. Arbitrary a => Gen a
arbitrary Gen a -> (a -> Gen (Elem a)) -> Gen (Elem a)
forall a b. Gen a -> (a -> Gen b) -> Gen b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Elem a -> Gen (Elem a)
forall a. a -> Gen a
forall (m :: * -> *) a. Monad m => a -> m a
return (Elem a -> Gen (Elem a)) -> (a -> Elem a) -> a -> Gen (Elem a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Elem a
forall a. a -> Elem a
Elem

instance CoArbitrary a => CoArbitrary (Elem a) where
   coarbitrary :: forall b. Elem a -> Gen b -> Gen b
coarbitrary = a -> Gen b -> Gen b
forall b. a -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary (a -> Gen b -> Gen b) -> (Elem a -> a) -> Elem a -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Elem a -> a
forall t. Elem t -> t
unElem

instance Arbitrary a => Arbitrary (Seq a) where
   arbitrary :: Gen (Seq a)
arbitrary   = Gen (FingerTree SizeM (Elem a))
forall a. Arbitrary a => Gen a
arbitrary Gen (FingerTree SizeM (Elem a))
-> (FingerTree SizeM (Elem a) -> Gen (Seq a)) -> Gen (Seq a)
forall a b. Gen a -> (a -> Gen b) -> Gen b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Seq a -> Gen (Seq a)
forall a. a -> Gen a
forall (m :: * -> *) a. Monad m => a -> m a
return (Seq a -> Gen (Seq a))
-> (FingerTree SizeM (Elem a) -> Seq a)
-> FingerTree SizeM (Elem a)
-> Gen (Seq a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FingerTree SizeM (Elem a) -> Seq a
forall a. FingerTree SizeM (Elem a) -> Seq a
Seq

instance CoArbitrary a => CoArbitrary (Seq a) where
   coarbitrary :: forall b. Seq a -> Gen b -> Gen b
coarbitrary = FingerTree SizeM (Elem a) -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
forall b. FingerTree SizeM (Elem a) -> Gen b -> Gen b
coarbitrary (FingerTree SizeM (Elem a) -> Gen b -> Gen b)
-> (Seq a -> FingerTree SizeM (Elem a)) -> Seq a -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Seq a -> FingerTree SizeM (Elem a)
forall t. Seq t -> FingerTree SizeM (Elem t)
unSeq

instance Semigroup (Seq a) where
  <> :: Seq a -> Seq a -> Seq a
(<>) = Seq a -> Seq a -> Seq a
forall a. Seq a -> Seq a -> Seq a
append
instance Monoid (Seq a) where
  mempty :: Seq a
mempty  = Seq a
forall a. Seq a
empty
  mappend :: Seq a -> Seq a -> Seq a
mappend = Seq a -> Seq a -> Seq a
forall a. Semigroup a => a -> a -> a
(SG.<>)