-- |
--   Module      :  Data.Edison.Seq.RevSeq
--   Copyright   :  Copyright (c) 1998-1999, 2008 Chris Okasaki
--   License     :  MIT; see COPYRIGHT file for terms and conditions
--
--   Maintainer  :  robdockins AT fastmail DOT fm
--   Stability   :  stable
--   Portability :  GHC, Hugs (MPTC and FD)
--
--   This module defines a sequence adaptor @Rev s@.
--   If @s@ is a sequence type constructor, then @Rev s@
--   is a sequence type constructor that is identical to @s@,
--   except that it is kept in the opposite order.
--   Also keeps explicit track of the size of the sequence,
--   similar to the @Sized@ adaptor in "Data.Edison.Seq.SizedSeq".
--
--   This module is most useful when s is a sequence type
--   that offers fast access to the front but slow access
--   to the rear, and your application needs the opposite
--   (i.e., fast access to the rear but slow access to the
--   front).
--
--   All time complexities are determined by the underlying
--   sequence, except that the complexities for accessing
--   the left and right sides of the sequence are exchanged,
--   and size becomes @O( 1 )@.

module Data.Edison.Seq.RevSeq (
    -- * Rev Sequence Type
    Rev, -- Rev s 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,foldrWithIndex',foldlWithIndex,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,instanceName,

    -- * Other supported operations
    fromSeq,toSeq

) where

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 qualified Data.Edison.Seq as S
import qualified Data.Edison.Seq.ListSeq as L
import Data.Edison.Seq.Defaults -- only used by concatMap
import Control.Monad
import qualified Control.Monad.Fail as Fail
import Data.Monoid
import Data.Semigroup as SG
import Test.QuickCheck


-- signatures for exported functions
moduleName     :: String
instanceName   :: S.Sequence s => Rev s a -> String
empty          :: S.Sequence s => Rev s a
singleton      :: S.Sequence s => a -> Rev s a
lcons          :: S.Sequence s => a -> Rev s a -> Rev s a
rcons          :: S.Sequence s => a -> Rev s a -> Rev s a
append         :: S.Sequence s => Rev s a -> Rev s a -> Rev s a
lview          :: (S.Sequence s, Fail.MonadFail m) => Rev s a -> m (a, Rev s a)
lhead          :: S.Sequence s => Rev s a -> a
lheadM         :: (S.Sequence s, Fail.MonadFail m) => Rev s a -> m a
ltail          :: S.Sequence s => Rev s a -> Rev s a
ltailM         :: (S.Sequence s, Fail.MonadFail m) => Rev s a -> m (Rev s a)
rview          :: (S.Sequence s, Fail.MonadFail m) => Rev s a -> m (a, Rev s a)
rhead          :: S.Sequence s => Rev s a -> a
rheadM         :: (S.Sequence s, Fail.MonadFail m) => Rev s a -> m a
rtail          :: S.Sequence s => Rev s a -> Rev s a
rtailM         :: (S.Sequence s, Fail.MonadFail m) => Rev s a -> m (Rev s a)
null           :: S.Sequence s => Rev s a -> Bool
size           :: S.Sequence s => Rev s a -> Int
concat         :: S.Sequence s => Rev s (Rev s a) -> Rev s a
reverse        :: S.Sequence s => Rev s a -> Rev s a
reverseOnto    :: S.Sequence s => Rev s a -> Rev s a -> Rev s a
fromList       :: S.Sequence s => [a] -> Rev s a
toList         :: S.Sequence s => Rev s a -> [a]
map            :: S.Sequence s => (a -> b) -> Rev s a -> Rev s b
concatMap      :: S.Sequence s => (a -> Rev s b) -> Rev s a -> Rev s b
fold           :: S.Sequence s => (a -> b -> b) -> b -> Rev s a -> b
fold'          :: S.Sequence s => (a -> b -> b) -> b -> Rev s a -> b
fold1          :: S.Sequence s => (a -> a -> a) -> Rev s a -> a
fold1'         :: S.Sequence s => (a -> a -> a) -> Rev s a -> a
foldr          :: S.Sequence s => (a -> b -> b) -> b -> Rev s a -> b
foldl          :: S.Sequence s => (b -> a -> b) -> b -> Rev s a -> b
foldr1         :: S.Sequence s => (a -> a -> a) -> Rev s a -> a
foldl1         :: S.Sequence s => (a -> a -> a) -> Rev s a -> a
reducer        :: S.Sequence s => (a -> a -> a) -> a -> Rev s a -> a
reducel        :: S.Sequence s => (a -> a -> a) -> a -> Rev s a -> a
reduce1        :: S.Sequence s => (a -> a -> a) -> Rev s a -> a
foldr'         :: S.Sequence s => (a -> b -> b) -> b -> Rev s a -> b
foldl'         :: S.Sequence s => (b -> a -> b) -> b -> Rev s a -> b
foldr1'        :: S.Sequence s => (a -> a -> a) -> Rev s a -> a
foldl1'        :: S.Sequence s => (a -> a -> a) -> Rev s a -> a
reducer'       :: S.Sequence s => (a -> a -> a) -> a -> Rev s a -> a
reducel'       :: S.Sequence s => (a -> a -> a) -> a -> Rev s a -> a
reduce1'       :: S.Sequence s => (a -> a -> a) -> Rev s a -> a
copy           :: S.Sequence s => Int -> a -> Rev s a
inBounds       :: S.Sequence s => Int -> Rev s a -> Bool
lookup         :: S.Sequence s => Int -> Rev s a -> a
lookupM        :: (S.Sequence s, Fail.MonadFail m) => Int -> Rev s a -> m a
lookupWithDefault :: S.Sequence s => a -> Int -> Rev s a -> a
update         :: S.Sequence s => Int -> a -> Rev s a -> Rev s a
adjust         :: S.Sequence s => (a -> a) -> Int -> Rev s a -> Rev s a
mapWithIndex   :: S.Sequence s => (Int -> a -> b) -> Rev s a -> Rev s b
foldrWithIndex :: S.Sequence s => (Int -> a -> b -> b) -> b -> Rev s a -> b
foldlWithIndex :: S.Sequence s => (b -> Int -> a -> b) -> b -> Rev s a -> b
foldrWithIndex' :: S.Sequence s => (Int -> a -> b -> b) -> b -> Rev s a -> b
foldlWithIndex' :: S.Sequence s => (b -> Int -> a -> b) -> b -> Rev s a -> b
take           :: S.Sequence s => Int -> Rev s a -> Rev s a
drop           :: S.Sequence s => Int -> Rev s a -> Rev s a
splitAt        :: S.Sequence s => Int -> Rev s a -> (Rev s a, Rev s a)
subseq         :: S.Sequence s => Int -> Int -> Rev s a -> Rev s a
filter         :: S.Sequence s => (a -> Bool) -> Rev s a -> Rev s a
partition      :: S.Sequence s => (a -> Bool) -> Rev s a -> (Rev s a, Rev s a)
takeWhile      :: S.Sequence s => (a -> Bool) -> Rev s a -> Rev s a
dropWhile      :: S.Sequence s => (a -> Bool) -> Rev s a -> Rev s a
splitWhile     :: S.Sequence s => (a -> Bool) -> Rev s a -> (Rev s a, Rev s a)
zip            :: S.Sequence s => Rev s a -> Rev s b -> Rev s (a,b)
zip3           :: S.Sequence s => Rev s a -> Rev s b -> Rev s c -> Rev s (a,b,c)
zipWith        :: S.Sequence s => (a -> b -> c) -> Rev s a -> Rev s b -> Rev s c
zipWith3       :: S.Sequence s => (a -> b -> c -> d) -> Rev s a -> Rev s b -> Rev s c -> Rev s d
unzip          :: S.Sequence s => Rev s (a,b) -> (Rev s a, Rev s b)
unzip3         :: S.Sequence s => Rev s (a,b,c) -> (Rev s a, Rev s b, Rev s c)
unzipWith      :: S.Sequence s => (a -> b) -> (a -> c) -> Rev s a -> (Rev s b, Rev s c)
unzipWith3     :: S.Sequence s => (a -> b) -> (a -> c) -> (a -> d) -> Rev s a -> (Rev s b, Rev s c, Rev s d)
strict         :: S.Sequence s => Rev s a -> Rev s a
strictWith     :: S.Sequence s => (a -> b) -> Rev s a -> Rev s a
structuralInvariant :: S.Sequence s => Rev s a -> Bool

-- bonus functions, not in Sequence signature
fromSeq        :: S.Sequence s => s a -> Rev s a
toSeq          :: S.Sequence s => Rev s a -> s a


moduleName :: String
moduleName = String
"Data.Edison.Seq.RevSeq"
instanceName :: forall (s :: * -> *) a. Sequence s => Rev s a -> String
instanceName (N Int
_ s a
s) = String
"RevSeq(" forall a. [a] -> [a] -> [a]
++ forall (s :: * -> *) a. Sequence s => s a -> String
S.instanceName s a
s forall a. [a] -> [a] -> [a]
++ String
")"

data Rev s a = N !Int (s a)
  -- The Int is the size minus one.  The "minus one" makes indexing
  -- calculations easier.

fromSeq :: forall (s :: * -> *) a. Sequence s => s a -> Rev s a
fromSeq s a
xs = forall (s :: * -> *) a. Int -> s a -> Rev s a
N (forall (s :: * -> *) a. Sequence s => s a -> Int
S.size s a
xs forall a. Num a => a -> a -> a
- Int
1) s a
xs
toSeq :: forall (s :: * -> *) a. Sequence s => Rev s a -> s a
toSeq (N Int
_ s a
xs) = s a
xs

empty :: forall (s :: * -> *) a. Sequence s => Rev s a
empty = forall (s :: * -> *) a. Int -> s a -> Rev s a
N (-Int
1) forall (s :: * -> *) a. Sequence s => s a
S.empty
singleton :: forall (s :: * -> *) a. Sequence s => a -> Rev s a
singleton a
x = forall (s :: * -> *) a. Int -> s a -> Rev s a
N Int
0 (forall (s :: * -> *) a. Sequence s => a -> s a
S.singleton a
x)
lcons :: forall (s :: * -> *) a. Sequence s => a -> Rev s a -> Rev s a
lcons a
x (N Int
m s a
xs) = forall (s :: * -> *) a. Int -> s a -> Rev s a
N (Int
mforall a. Num a => a -> a -> a
+Int
1) (forall (s :: * -> *) a. Sequence s => a -> s a -> s a
S.rcons a
x s a
xs)
rcons :: forall (s :: * -> *) a. Sequence s => a -> Rev s a -> Rev s a
rcons a
x (N Int
m s a
xs) = forall (s :: * -> *) a. Int -> s a -> Rev s a
N (Int
mforall a. Num a => a -> a -> a
+Int
1) (forall (s :: * -> *) a. Sequence s => a -> s a -> s a
S.lcons a
x s a
xs)
append :: forall (s :: * -> *) a. Sequence s => Rev s a -> Rev s a -> Rev s a
append (N Int
m s a
xs) (N Int
n s a
ys) = forall (s :: * -> *) a. Int -> s a -> Rev s a
N (Int
mforall a. Num a => a -> a -> a
+Int
nforall a. Num a => a -> a -> a
+Int
1) (forall (s :: * -> *) a. Sequence s => s a -> s a -> s a
S.append s a
ys s a
xs)

lview :: forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
Rev s a -> m (a, Rev s a)
lview (N Int
m s a
xs) = case forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
S.rview s a
xs of
                   Maybe (a, s a)
Nothing     -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"RevSeq.lview: empty sequence"
                   Just (a
x,s a
xs) -> forall (m :: * -> *) a. Monad m => a -> m a
return (a
x, forall (s :: * -> *) a. Int -> s a -> Rev s a
N (Int
mforall a. Num a => a -> a -> a
-Int
1) s a
xs)

lhead :: forall (s :: * -> *) a. Sequence s => Rev s a -> a
lhead (N Int
_ s a
xs) = forall (s :: * -> *) a. Sequence s => s a -> a
S.rhead s a
xs

lheadM :: forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
Rev s a -> m a
lheadM (N Int
_ s a
xs) = forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m a
S.rheadM s a
xs

ltail :: forall (s :: * -> *) a. Sequence s => Rev s a -> Rev s a
ltail (N (-1) s a
_) = forall a. HasCallStack => String -> a
error String
"RevSeq.ltail: empty sequence"
ltail (N Int
m s a
xs) = forall (s :: * -> *) a. Int -> s a -> Rev s a
N (Int
mforall a. Num a => a -> a -> a
-Int
1) (forall (s :: * -> *) a. Sequence s => s a -> s a
S.rtail s a
xs)

ltailM :: forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
Rev s a -> m (Rev s a)
ltailM (N (-1) s a
_) = forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"RevSeq.ltailM: empty sequence"
ltailM (N Int
m s a
xs) = forall (m :: * -> *) a. Monad m => a -> m a
return (forall (s :: * -> *) a. Int -> s a -> Rev s a
N (Int
mforall a. Num a => a -> a -> a
-Int
1) (forall (s :: * -> *) a. Sequence s => s a -> s a
S.rtail s a
xs))

rview :: forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
Rev s a -> m (a, Rev s a)
rview (N Int
m s a
xs) = case forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
S.lview s a
xs of
                   Maybe (a, s a)
Nothing     -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"RevSeq.rview: empty sequence"
                   Just (a
x,s a
xs) -> forall (m :: * -> *) a. Monad m => a -> m a
return (a
x, forall (s :: * -> *) a. Int -> s a -> Rev s a
N (Int
mforall a. Num a => a -> a -> a
-Int
1) s a
xs)

rhead :: forall (s :: * -> *) a. Sequence s => Rev s a -> a
rhead (N Int
_ s a
xs) = forall (s :: * -> *) a. Sequence s => s a -> a
S.lhead s a
xs

rheadM :: forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
Rev s a -> m a
rheadM (N Int
_ s a
xs) = forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m a
S.lheadM s a
xs

rtail :: forall (s :: * -> *) a. Sequence s => Rev s a -> Rev s a
rtail (N (-1) s a
_) = forall a. HasCallStack => String -> a
error String
"RevSeq.rtail: empty sequence"
rtail (N Int
m s a
xs) = forall (s :: * -> *) a. Int -> s a -> Rev s a
N (Int
mforall a. Num a => a -> a -> a
-Int
1) (forall (s :: * -> *) a. Sequence s => s a -> s a
S.ltail s a
xs)

rtailM :: forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
Rev s a -> m (Rev s a)
rtailM (N (-1) s a
_) = forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"RevSeq.rtailM: empty sequence"
rtailM (N Int
m s a
xs) = forall (m :: * -> *) a. Monad m => a -> m a
return (forall (s :: * -> *) a. Int -> s a -> Rev s a
N (Int
mforall a. Num a => a -> a -> a
-Int
1) (forall (s :: * -> *) a. Sequence s => s a -> s a
S.ltail s a
xs))

null :: forall (s :: * -> *) a. Sequence s => Rev s a -> Bool
null (N Int
m s a
_) = Int
m forall a. Eq a => a -> a -> Bool
== -Int
1
size :: forall (s :: * -> *) a. Sequence s => Rev s a -> Int
size (N Int
m s a
_) = Int
mforall a. Num a => a -> a -> a
+Int
1
concat :: forall (s :: * -> *) a. Sequence s => Rev s (Rev s a) -> Rev s a
concat (N Int
_ s (Rev s a)
xss) = forall (s :: * -> *) a. Sequence s => s a -> Rev s a
fromSeq (forall (s :: * -> *) a. Sequence s => s (s a) -> s a
S.concat (forall (s :: * -> *) a b. Sequence s => (a -> b) -> s a -> s b
S.map forall (s :: * -> *) a. Sequence s => Rev s a -> s a
toSeq s (Rev s a)
xss))
reverse :: forall (s :: * -> *) a. Sequence s => Rev s a -> Rev s a
reverse (N Int
m s a
xs) = forall (s :: * -> *) a. Int -> s a -> Rev s a
N Int
m (forall (s :: * -> *) a. Sequence s => s a -> s a
S.reverse s a
xs)
reverseOnto :: forall (s :: * -> *) a. Sequence s => Rev s a -> Rev s a -> Rev s a
reverseOnto (N Int
m s a
xs) (N Int
n s a
ys) = forall (s :: * -> *) a. Int -> s a -> Rev s a
N (Int
mforall a. Num a => a -> a -> a
+Int
nforall a. Num a => a -> a -> a
+Int
1) (forall (s :: * -> *) a. Sequence s => s a -> s a -> s a
S.append s a
ys (forall (s :: * -> *) a. Sequence s => s a -> s a
S.reverse s a
xs))
fromList :: forall (s :: * -> *) a. Sequence s => [a] -> Rev s a
fromList = forall (s :: * -> *) a. Sequence s => s a -> Rev s a
fromSeq forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (s :: * -> *) a. Sequence s => [a] -> s a
S.fromList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> [a]
L.reverse
toList :: forall (s :: * -> *) a. Sequence s => Rev s a -> [a]
toList (N Int
_ s a
xs) = forall (s :: * -> *) b a.
Sequence s =>
(b -> a -> b) -> b -> s a -> b
S.foldl (forall a b c. (a -> b -> c) -> b -> a -> c
flip (:)) [] s a
xs
map :: forall (s :: * -> *) a b.
Sequence s =>
(a -> b) -> Rev s a -> Rev s b
map a -> b
f (N Int
m s a
xs) = forall (s :: * -> *) a. Int -> s a -> Rev s a
N Int
m (forall (s :: * -> *) a b. Sequence s => (a -> b) -> s a -> s b
S.map a -> b
f s a
xs)

concatMap :: forall (s :: * -> *) a b.
Sequence s =>
(a -> Rev s b) -> Rev s a -> Rev s b
concatMap = forall (s :: * -> *) a b. Sequence s => (a -> s b) -> s a -> s b
concatMapUsingFoldr -- only function that uses a default

fold :: forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> Rev s a -> b
fold a -> b -> b
f b
e (N Int
_ s a
xs) = forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
S.fold a -> b -> b
f b
e s a
xs
fold' :: forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> Rev s a -> b
fold' a -> b -> b
f b
e (N Int
_ s a
xs) = forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
S.fold' a -> b -> b
f b
e s a
xs
fold1 :: forall (s :: * -> *) a. Sequence s => (a -> a -> a) -> Rev s a -> a
fold1 a -> a -> a
f (N Int
_ s a
xs) = forall (s :: * -> *) a. Sequence s => (a -> a -> a) -> s a -> a
S.fold1 a -> a -> a
f s a
xs
fold1' :: forall (s :: * -> *) a. Sequence s => (a -> a -> a) -> Rev s a -> a
fold1' a -> a -> a
f (N Int
_ s a
xs) = forall (s :: * -> *) a. Sequence s => (a -> a -> a) -> s a -> a
S.fold1' a -> a -> a
f s a
xs
foldr :: forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> Rev s a -> b
foldr a -> b -> b
f b
e (N Int
_ s a
xs) = forall (s :: * -> *) b a.
Sequence s =>
(b -> a -> b) -> b -> s a -> b
S.foldl (forall a b c. (a -> b -> c) -> b -> a -> c
flip a -> b -> b
f) b
e s a
xs
foldr' :: forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> Rev s a -> b
foldr' a -> b -> b
f b
e (N Int
_ s a
xs) = forall (s :: * -> *) b a.
Sequence s =>
(b -> a -> b) -> b -> s a -> b
S.foldl' (forall a b c. (a -> b -> c) -> b -> a -> c
flip a -> b -> b
f) b
e s a
xs
foldl :: forall (s :: * -> *) b a.
Sequence s =>
(b -> a -> b) -> b -> Rev s a -> b
foldl b -> a -> b
f b
e (N Int
_ s a
xs) = forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
S.foldr (forall a b c. (a -> b -> c) -> b -> a -> c
flip b -> a -> b
f) b
e s a
xs
foldl' :: forall (s :: * -> *) b a.
Sequence s =>
(b -> a -> b) -> b -> Rev s a -> b
foldl' b -> a -> b
f b
e (N Int
_ s a
xs) = forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
S.foldr' (forall a b c. (a -> b -> c) -> b -> a -> c
flip b -> a -> b
f) b
e s a
xs
foldr1 :: forall (s :: * -> *) a. Sequence s => (a -> a -> a) -> Rev s a -> a
foldr1 a -> a -> a
f (N Int
_ s a
xs) = forall (s :: * -> *) a. Sequence s => (a -> a -> a) -> s a -> a
S.foldl1 (forall a b c. (a -> b -> c) -> b -> a -> c
flip a -> a -> a
f) s a
xs
foldr1' :: forall (s :: * -> *) a. Sequence s => (a -> a -> a) -> Rev s a -> a
foldr1' a -> a -> a
f (N Int
_ s a
xs) = forall (s :: * -> *) a. Sequence s => (a -> a -> a) -> s a -> a
S.foldl1' (forall a b c. (a -> b -> c) -> b -> a -> c
flip a -> a -> a
f) s a
xs
foldl1 :: forall (s :: * -> *) a. Sequence s => (a -> a -> a) -> Rev s a -> a
foldl1 a -> a -> a
f (N Int
_ s a
xs) = forall (s :: * -> *) a. Sequence s => (a -> a -> a) -> s a -> a
S.foldr1 (forall a b c. (a -> b -> c) -> b -> a -> c
flip a -> a -> a
f) s a
xs
foldl1' :: forall (s :: * -> *) a. Sequence s => (a -> a -> a) -> Rev s a -> a
foldl1' a -> a -> a
f (N Int
_ s a
xs) = forall (s :: * -> *) a. Sequence s => (a -> a -> a) -> s a -> a
S.foldr1' (forall a b c. (a -> b -> c) -> b -> a -> c
flip a -> a -> a
f) s a
xs
reducer :: forall (s :: * -> *) a.
Sequence s =>
(a -> a -> a) -> a -> Rev s a -> a
reducer a -> a -> a
f a
e (N Int
_ s a
xs) = forall (s :: * -> *) a.
Sequence s =>
(a -> a -> a) -> a -> s a -> a
S.reducel (forall a b c. (a -> b -> c) -> b -> a -> c
flip a -> a -> a
f) a
e s a
xs
reducer' :: forall (s :: * -> *) a.
Sequence s =>
(a -> a -> a) -> a -> Rev s a -> a
reducer' a -> a -> a
f a
e (N Int
_ s a
xs) = forall (s :: * -> *) a.
Sequence s =>
(a -> a -> a) -> a -> s a -> a
S.reducel' (forall a b c. (a -> b -> c) -> b -> a -> c
flip a -> a -> a
f) a
e s a
xs
reducel :: forall (s :: * -> *) a.
Sequence s =>
(a -> a -> a) -> a -> Rev s a -> a
reducel a -> a -> a
f a
e (N Int
_ s a
xs) = forall (s :: * -> *) a.
Sequence s =>
(a -> a -> a) -> a -> s a -> a
S.reducer (forall a b c. (a -> b -> c) -> b -> a -> c
flip a -> a -> a
f) a
e s a
xs
reducel' :: forall (s :: * -> *) a.
Sequence s =>
(a -> a -> a) -> a -> Rev s a -> a
reducel' a -> a -> a
f a
e (N Int
_ s a
xs) = forall (s :: * -> *) a.
Sequence s =>
(a -> a -> a) -> a -> s a -> a
S.reducer' (forall a b c. (a -> b -> c) -> b -> a -> c
flip a -> a -> a
f) a
e s a
xs
reduce1 :: forall (s :: * -> *) a. Sequence s => (a -> a -> a) -> Rev s a -> a
reduce1 a -> a -> a
f (N Int
_ s a
xs) = forall (s :: * -> *) a. Sequence s => (a -> a -> a) -> s a -> a
S.reduce1 (forall a b c. (a -> b -> c) -> b -> a -> c
flip a -> a -> a
f) s a
xs
reduce1' :: forall (s :: * -> *) a. Sequence s => (a -> a -> a) -> Rev s a -> a
reduce1' a -> a -> a
f (N Int
_ s a
xs) = forall (s :: * -> *) a. Sequence s => (a -> a -> a) -> s a -> a
S.reduce1' (forall a b c. (a -> b -> c) -> b -> a -> c
flip a -> a -> a
f) s a
xs

copy :: forall (s :: * -> *) a. Sequence s => Int -> a -> Rev s a
copy Int
n a
x
    | Int
n forall a. Ord a => a -> a -> Bool
<= Int
0 = forall (s :: * -> *) a. Sequence s => Rev s a
empty
    | Bool
otherwise = forall (s :: * -> *) a. Int -> s a -> Rev s a
N (Int
nforall a. Num a => a -> a -> a
-Int
1) (forall (s :: * -> *) a. Sequence s => Int -> a -> s a
S.copy Int
n a
x)

inBounds :: forall (s :: * -> *) a. Sequence s => Int -> Rev s a -> Bool
inBounds Int
i (N Int
m s a
_) = (Int
i forall a. Ord a => a -> a -> Bool
>= Int
0) Bool -> Bool -> Bool
&& (Int
i forall a. Ord a => a -> a -> Bool
<= Int
m)
lookup :: forall (s :: * -> *) a. Sequence s => Int -> Rev s a -> a
lookup Int
i (N Int
m s a
xs) = forall (s :: * -> *) a. Sequence s => Int -> s a -> a
S.lookup (Int
mforall a. Num a => a -> a -> a
-Int
i) s a
xs
lookupM :: forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
Int -> Rev s a -> m a
lookupM Int
i (N Int
m s a
xs) = forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
Int -> s a -> m a
S.lookupM (Int
mforall a. Num a => a -> a -> a
-Int
i) s a
xs
lookupWithDefault :: forall (s :: * -> *) a. Sequence s => a -> Int -> Rev s a -> a
lookupWithDefault a
d Int
i (N Int
m s a
xs) = forall (s :: * -> *) a. Sequence s => a -> Int -> s a -> a
S.lookupWithDefault a
d (Int
mforall a. Num a => a -> a -> a
-Int
i) s a
xs
update :: forall (s :: * -> *) a.
Sequence s =>
Int -> a -> Rev s a -> Rev s a
update Int
i a
x (N Int
m s a
xs) = forall (s :: * -> *) a. Int -> s a -> Rev s a
N Int
m (forall (s :: * -> *) a. Sequence s => Int -> a -> s a -> s a
S.update (Int
mforall a. Num a => a -> a -> a
-Int
i) a
x s a
xs)
adjust :: forall (s :: * -> *) a.
Sequence s =>
(a -> a) -> Int -> Rev s a -> Rev s a
adjust a -> a
f Int
i (N Int
m s a
xs) = forall (s :: * -> *) a. Int -> s a -> Rev s a
N Int
m (forall (s :: * -> *) a. Sequence s => (a -> a) -> Int -> s a -> s a
S.adjust a -> a
f (Int
mforall a. Num a => a -> a -> a
-Int
i) s a
xs)
mapWithIndex :: forall (s :: * -> *) a b.
Sequence s =>
(Int -> a -> b) -> Rev s a -> Rev s b
mapWithIndex Int -> a -> b
f (N Int
m s a
xs) = forall (s :: * -> *) a. Int -> s a -> Rev s a
N Int
m (forall (s :: * -> *) a b.
Sequence s =>
(Int -> a -> b) -> s a -> s b
S.mapWithIndex (Int -> a -> b
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int
mforall a. Num a => a -> a -> a
-)) s a
xs)

foldrWithIndex :: forall (s :: * -> *) a b.
Sequence s =>
(Int -> a -> b -> b) -> b -> Rev s a -> b
foldrWithIndex Int -> a -> b -> b
f b
e (N Int
m s a
xs) = forall (s :: * -> *) b a.
Sequence s =>
(b -> Int -> a -> b) -> b -> s a -> b
S.foldlWithIndex b -> Int -> a -> b
f' b
e s a
xs
  where f' :: b -> Int -> a -> b
f' b
xs Int
i a
x = Int -> a -> b -> b
f (Int
mforall a. Num a => a -> a -> a
-Int
i) a
x b
xs
foldrWithIndex' :: forall (s :: * -> *) a b.
Sequence s =>
(Int -> a -> b -> b) -> b -> Rev s a -> b
foldrWithIndex' Int -> a -> b -> b
f b
e (N Int
m s a
xs) = forall (s :: * -> *) b a.
Sequence s =>
(b -> Int -> a -> b) -> b -> s a -> b
S.foldlWithIndex' b -> Int -> a -> b
f' b
e s a
xs
  where f' :: b -> Int -> a -> b
f' b
xs Int
i a
x = Int -> a -> b -> b
f (Int
mforall a. Num a => a -> a -> a
-Int
i) a
x b
xs

foldlWithIndex :: forall (s :: * -> *) b a.
Sequence s =>
(b -> Int -> a -> b) -> b -> Rev s a -> b
foldlWithIndex b -> Int -> a -> b
f b
e (N Int
m s a
xs) = forall (s :: * -> *) a b.
Sequence s =>
(Int -> a -> b -> b) -> b -> s a -> b
S.foldrWithIndex Int -> a -> b -> b
f' b
e s a
xs
  where f' :: Int -> a -> b -> b
f' Int
i a
x b
xs = b -> Int -> a -> b
f b
xs (Int
mforall a. Num a => a -> a -> a
-Int
i) a
x
foldlWithIndex' :: forall (s :: * -> *) b a.
Sequence s =>
(b -> Int -> a -> b) -> b -> Rev s a -> b
foldlWithIndex' b -> Int -> a -> b
f b
e (N Int
m s a
xs) = forall (s :: * -> *) a b.
Sequence s =>
(Int -> a -> b -> b) -> b -> s a -> b
S.foldrWithIndex' Int -> a -> b -> b
f' b
e s a
xs
  where f' :: Int -> a -> b -> b
f' Int
i a
x b
xs = b -> Int -> a -> b
f b
xs (Int
mforall a. Num a => a -> a -> a
-Int
i) a
x

take :: forall (s :: * -> *) a. Sequence s => Int -> Rev s a -> Rev s a
take Int
i original :: Rev s a
original@(N Int
m s a
xs)
  | Int
i forall a. Ord a => a -> a -> Bool
<= Int
0 = forall (s :: * -> *) a. Sequence s => Rev s a
empty
  | Int
i forall a. Ord a => a -> a -> Bool
>  Int
m = Rev s a
original
  | Bool
otherwise = forall (s :: * -> *) a. Int -> s a -> Rev s a
N (Int
iforall a. Num a => a -> a -> a
-Int
1) (forall (s :: * -> *) a. Sequence s => Int -> s a -> s a
S.drop (Int
mforall a. Num a => a -> a -> a
-Int
iforall a. Num a => a -> a -> a
+Int
1) s a
xs)

drop :: forall (s :: * -> *) a. Sequence s => Int -> Rev s a -> Rev s a
drop Int
i original :: Rev s a
original@(N Int
m s a
xs)
  | Int
i forall a. Ord a => a -> a -> Bool
<= Int
0 = Rev s a
original
  | Int
i forall a. Ord a => a -> a -> Bool
>  Int
m = forall (s :: * -> *) a. Sequence s => Rev s a
empty
  | Bool
otherwise = forall (s :: * -> *) a. Int -> s a -> Rev s a
N (Int
mforall a. Num a => a -> a -> a
-Int
i) (forall (s :: * -> *) a. Sequence s => Int -> s a -> s a
S.take (Int
mforall a. Num a => a -> a -> a
-Int
iforall a. Num a => a -> a -> a
+Int
1) s a
xs)

splitAt :: forall (s :: * -> *) a.
Sequence s =>
Int -> Rev s a -> (Rev s a, Rev s a)
splitAt Int
i original :: Rev s a
original@(N Int
m s a
xs)
  | Int
i forall a. Ord a => a -> a -> Bool
<= Int
0 = (forall (s :: * -> *) a. Sequence s => Rev s a
empty, Rev s a
original)
  | Int
i forall a. Ord a => a -> a -> Bool
>  Int
m = (Rev s a
original, forall (s :: * -> *) a. Sequence s => Rev s a
empty)
  | Bool
otherwise = let (s a
ys,s a
zs) = forall (s :: * -> *) a. Sequence s => Int -> s a -> (s a, s a)
S.splitAt (Int
mforall a. Num a => a -> a -> a
-Int
iforall a. Num a => a -> a -> a
+Int
1) s a
xs
                in (forall (s :: * -> *) a. Int -> s a -> Rev s a
N (Int
iforall a. Num a => a -> a -> a
-Int
1) s a
zs, forall (s :: * -> *) a. Int -> s a -> Rev s a
N (Int
mforall a. Num a => a -> a -> a
-Int
i) s a
ys)

subseq :: forall (s :: * -> *) a.
Sequence s =>
Int -> Int -> Rev s a -> Rev s a
subseq Int
i Int
len original :: Rev s a
original@(N Int
m s a
xs)
  | Int
i forall a. Ord a => a -> a -> Bool
<= Int
0 = forall (s :: * -> *) a. Sequence s => Int -> Rev s a -> Rev s a
take Int
len Rev s a
original
  | Int
i forall a. Ord a => a -> a -> Bool
>  Int
m Bool -> Bool -> Bool
|| Int
len forall a. Ord a => a -> a -> Bool
<= Int
0 = forall (s :: * -> *) a. Sequence s => Rev s a
empty
  | Int
iforall a. Num a => a -> a -> a
+Int
len forall a. Ord a => a -> a -> Bool
> Int
m = forall (s :: * -> *) a. Int -> s a -> Rev s a
N (Int
mforall a. Num a => a -> a -> a
-Int
i) (forall (s :: * -> *) a. Sequence s => Int -> s a -> s a
S.take (Int
mforall a. Num a => a -> a -> a
-Int
iforall a. Num a => a -> a -> a
+Int
1) s a
xs)
  | Bool
otherwise = forall (s :: * -> *) a. Int -> s a -> Rev s a
N (Int
lenforall a. Num a => a -> a -> a
-Int
1) (forall (s :: * -> *) a. Sequence s => Int -> Int -> s a -> s a
S.subseq (Int
mforall a. Num a => a -> a -> a
-Int
iforall a. Num a => a -> a -> a
-Int
lenforall a. Num a => a -> a -> a
+Int
1) Int
len s a
xs)

filter :: forall (s :: * -> *) a.
Sequence s =>
(a -> Bool) -> Rev s a -> Rev s a
filter a -> Bool
p = forall (s :: * -> *) a. Sequence s => s a -> Rev s a
fromSeq forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (s :: * -> *) a. Sequence s => (a -> Bool) -> s a -> s a
S.filter a -> Bool
p forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (s :: * -> *) a. Sequence s => Rev s a -> s a
toSeq

partition :: forall (s :: * -> *) a.
Sequence s =>
(a -> Bool) -> Rev s a -> (Rev s a, Rev s a)
partition a -> Bool
p (N Int
m s a
xs) = (forall (s :: * -> *) a. Int -> s a -> Rev s a
N (Int
kforall a. Num a => a -> a -> a
-Int
1) s a
ys, forall (s :: * -> *) a. Int -> s a -> Rev s a
N (Int
mforall a. Num a => a -> a -> a
-Int
k) s a
zs)
  where (s a
ys,s a
zs) = forall (s :: * -> *) a.
Sequence s =>
(a -> Bool) -> s a -> (s a, s a)
S.partition a -> Bool
p s a
xs
        k :: Int
k = forall (s :: * -> *) a. Sequence s => s a -> Int
S.size s a
ys

takeWhile :: forall (s :: * -> *) a.
Sequence s =>
(a -> Bool) -> Rev s a -> Rev s a
takeWhile a -> Bool
p = forall (s :: * -> *) a. Sequence s => s a -> Rev s a
fromSeq forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (s :: * -> *) a. Sequence s => s a -> s a
S.reverse forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (s :: * -> *) a. Sequence s => (a -> Bool) -> s a -> s a
S.takeWhile a -> Bool
p forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (s :: * -> *) a. Sequence s => s a -> s a
S.reverse forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (s :: * -> *) a. Sequence s => Rev s a -> s a
toSeq
dropWhile :: forall (s :: * -> *) a.
Sequence s =>
(a -> Bool) -> Rev s a -> Rev s a
dropWhile a -> Bool
p = forall (s :: * -> *) a. Sequence s => s a -> Rev s a
fromSeq forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (s :: * -> *) a. Sequence s => s a -> s a
S.reverse forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (s :: * -> *) a. Sequence s => (a -> Bool) -> s a -> s a
S.dropWhile a -> Bool
p forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (s :: * -> *) a. Sequence s => s a -> s a
S.reverse forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (s :: * -> *) a. Sequence s => Rev s a -> s a
toSeq

splitWhile :: forall (s :: * -> *) a.
Sequence s =>
(a -> Bool) -> Rev s a -> (Rev s a, Rev s a)
splitWhile a -> Bool
p (N Int
m s a
xs) = (forall (s :: * -> *) a. Int -> s a -> Rev s a
N (Int
kforall a. Num a => a -> a -> a
-Int
1) (forall (s :: * -> *) a. Sequence s => s a -> s a
S.reverse s a
ys), forall (s :: * -> *) a. Int -> s a -> Rev s a
N (Int
mforall a. Num a => a -> a -> a
-Int
k) (forall (s :: * -> *) a. Sequence s => s a -> s a
S.reverse s a
zs))
  where (s a
ys,s a
zs) = forall (s :: * -> *) a.
Sequence s =>
(a -> Bool) -> s a -> (s a, s a)
S.splitWhile a -> Bool
p (forall (s :: * -> *) a. Sequence s => s a -> s a
S.reverse s a
xs)
        k :: Int
k = forall (s :: * -> *) a. Sequence s => s a -> Int
S.size s a
ys

zip :: forall (s :: * -> *) a b.
Sequence s =>
Rev s a -> Rev s b -> Rev s (a, b)
zip (N Int
m s a
xs) (N Int
n s b
ys)
  | Int
m forall a. Ord a => a -> a -> Bool
< Int
n = forall (s :: * -> *) a. Int -> s a -> Rev s a
N Int
m (forall (s :: * -> *) a b. Sequence s => s a -> s b -> s (a, b)
S.zip s a
xs (forall (s :: * -> *) a. Sequence s => Int -> s a -> s a
S.drop (Int
nforall a. Num a => a -> a -> a
-Int
m) s b
ys))
  | Int
m forall a. Ord a => a -> a -> Bool
> Int
n = forall (s :: * -> *) a. Int -> s a -> Rev s a
N Int
n (forall (s :: * -> *) a b. Sequence s => s a -> s b -> s (a, b)
S.zip (forall (s :: * -> *) a. Sequence s => Int -> s a -> s a
S.drop (Int
mforall a. Num a => a -> a -> a
-Int
n) s a
xs) s b
ys)
  | Bool
otherwise = forall (s :: * -> *) a. Int -> s a -> Rev s a
N Int
m (forall (s :: * -> *) a b. Sequence s => s a -> s b -> s (a, b)
S.zip s a
xs s b
ys)
zip3 :: forall (s :: * -> *) a b c.
Sequence s =>
Rev s a -> Rev s b -> Rev s c -> Rev s (a, b, c)
zip3 (N Int
l s a
xs) (N Int
m s b
ys) (N Int
n s c
zs) = forall (s :: * -> *) a. Int -> s a -> Rev s a
N Int
k (forall (s :: * -> *) a b c.
Sequence s =>
s a -> s b -> s c -> s (a, b, c)
S.zip3 s a
xs' s b
ys' s c
zs')
  where k :: Int
k = forall a. Ord a => a -> a -> a
min Int
l (forall a. Ord a => a -> a -> a
min Int
m Int
n)
        xs' :: s a
xs' = if Int
l forall a. Eq a => a -> a -> Bool
== Int
k then s a
xs else forall (s :: * -> *) a. Sequence s => Int -> s a -> s a
S.drop (Int
lforall a. Num a => a -> a -> a
-Int
k) s a
xs
        ys' :: s b
ys' = if Int
m forall a. Eq a => a -> a -> Bool
== Int
k then s b
ys else forall (s :: * -> *) a. Sequence s => Int -> s a -> s a
S.drop (Int
mforall a. Num a => a -> a -> a
-Int
k) s b
ys
        zs' :: s c
zs' = if Int
n forall a. Eq a => a -> a -> Bool
== Int
k then s c
zs else forall (s :: * -> *) a. Sequence s => Int -> s a -> s a
S.drop (Int
nforall a. Num a => a -> a -> a
-Int
k) s c
zs

zipWith :: forall (s :: * -> *) a b c.
Sequence s =>
(a -> b -> c) -> Rev s a -> Rev s b -> Rev s c
zipWith a -> b -> c
f (N Int
m s a
xs) (N Int
n s b
ys)
  | Int
m forall a. Ord a => a -> a -> Bool
< Int
n = forall (s :: * -> *) a. Int -> s a -> Rev s a
N Int
m (forall (s :: * -> *) a b c.
Sequence s =>
(a -> b -> c) -> s a -> s b -> s c
S.zipWith a -> b -> c
f s a
xs (forall (s :: * -> *) a. Sequence s => Int -> s a -> s a
S.drop (Int
nforall a. Num a => a -> a -> a
-Int
m) s b
ys))
  | Int
m forall a. Ord a => a -> a -> Bool
> Int
n = forall (s :: * -> *) a. Int -> s a -> Rev s a
N Int
n (forall (s :: * -> *) a b c.
Sequence s =>
(a -> b -> c) -> s a -> s b -> s c
S.zipWith a -> b -> c
f (forall (s :: * -> *) a. Sequence s => Int -> s a -> s a
S.drop (Int
mforall a. Num a => a -> a -> a
-Int
n) s a
xs) s b
ys)
  | Bool
otherwise = forall (s :: * -> *) a. Int -> s a -> Rev s a
N Int
m (forall (s :: * -> *) a b c.
Sequence s =>
(a -> b -> c) -> s a -> s b -> s c
S.zipWith a -> b -> c
f s a
xs s b
ys)
zipWith3 :: forall (s :: * -> *) a b c d.
Sequence s =>
(a -> b -> c -> d) -> Rev s a -> Rev s b -> Rev s c -> Rev s d
zipWith3 a -> b -> c -> d
f (N Int
l s a
xs) (N Int
m s b
ys) (N Int
n s c
zs) = forall (s :: * -> *) a. Int -> s a -> Rev s a
N Int
k (forall (s :: * -> *) a b c d.
Sequence s =>
(a -> b -> c -> d) -> s a -> s b -> s c -> s d
S.zipWith3 a -> b -> c -> d
f s a
xs' s b
ys' s c
zs')
  where k :: Int
k = forall a. Ord a => a -> a -> a
min Int
l (forall a. Ord a => a -> a -> a
min Int
m Int
n)
        xs' :: s a
xs' = if Int
l forall a. Eq a => a -> a -> Bool
== Int
k then s a
xs else forall (s :: * -> *) a. Sequence s => Int -> s a -> s a
S.drop (Int
lforall a. Num a => a -> a -> a
-Int
k) s a
xs
        ys' :: s b
ys' = if Int
m forall a. Eq a => a -> a -> Bool
== Int
k then s b
ys else forall (s :: * -> *) a. Sequence s => Int -> s a -> s a
S.drop (Int
mforall a. Num a => a -> a -> a
-Int
k) s b
ys
        zs' :: s c
zs' = if Int
n forall a. Eq a => a -> a -> Bool
== Int
k then s c
zs else forall (s :: * -> *) a. Sequence s => Int -> s a -> s a
S.drop (Int
nforall a. Num a => a -> a -> a
-Int
k) s c
zs

unzip :: forall (s :: * -> *) a b.
Sequence s =>
Rev s (a, b) -> (Rev s a, Rev s b)
unzip (N Int
m s (a, b)
xys) = (forall (s :: * -> *) a. Int -> s a -> Rev s a
N Int
m s a
xs, forall (s :: * -> *) a. Int -> s a -> Rev s a
N Int
m s b
ys)
  where (s a
xs,s b
ys) = forall (s :: * -> *) a b. Sequence s => s (a, b) -> (s a, s b)
S.unzip s (a, b)
xys

unzip3 :: forall (s :: * -> *) a b c.
Sequence s =>
Rev s (a, b, c) -> (Rev s a, Rev s b, Rev s c)
unzip3 (N Int
m s (a, b, c)
xyzs) = (forall (s :: * -> *) a. Int -> s a -> Rev s a
N Int
m s a
xs, forall (s :: * -> *) a. Int -> s a -> Rev s a
N Int
m s b
ys, forall (s :: * -> *) a. Int -> s a -> Rev s a
N Int
m s c
zs)
  where (s a
xs,s b
ys,s c
zs) = forall (s :: * -> *) a b c.
Sequence s =>
s (a, b, c) -> (s a, s b, s c)
S.unzip3 s (a, b, c)
xyzs

unzipWith :: forall (s :: * -> *) a b c.
Sequence s =>
(a -> b) -> (a -> c) -> Rev s a -> (Rev s b, Rev s c)
unzipWith a -> b
f a -> c
g (N Int
m s a
xys) = (forall (s :: * -> *) a. Int -> s a -> Rev s a
N Int
m s b
xs, forall (s :: * -> *) a. Int -> s a -> Rev s a
N Int
m s c
ys)
  where (s b
xs,s c
ys) = forall (s :: * -> *) a b c.
Sequence s =>
(a -> b) -> (a -> c) -> s a -> (s b, s c)
S.unzipWith a -> b
f a -> c
g s a
xys

unzipWith3 :: forall (s :: * -> *) a b c d.
Sequence s =>
(a -> b)
-> (a -> c) -> (a -> d) -> Rev s a -> (Rev s b, Rev s c, Rev s d)
unzipWith3 a -> b
f a -> c
g a -> d
h (N Int
m s a
xyzs) = (forall (s :: * -> *) a. Int -> s a -> Rev s a
N Int
m s b
xs, forall (s :: * -> *) a. Int -> s a -> Rev s a
N Int
m s c
ys, forall (s :: * -> *) a. Int -> s a -> Rev s a
N Int
m s d
zs)
  where (s b
xs,s c
ys,s d
zs) = forall (s :: * -> *) a b c d.
Sequence s =>
(a -> b) -> (a -> c) -> (a -> d) -> s a -> (s b, s c, s d)
S.unzipWith3 a -> b
f a -> c
g a -> d
h s a
xyzs

strict :: forall (s :: * -> *) a. Sequence s => Rev s a -> Rev s a
strict s :: Rev s a
s@(N Int
_ s a
s') = forall (s :: * -> *) a. Sequence s => s a -> s a
S.strict s a
s' seq :: forall a b. a -> b -> b
`seq` Rev s a
s
strictWith :: forall (s :: * -> *) a b.
Sequence s =>
(a -> b) -> Rev s a -> Rev s a
strictWith a -> b
f s :: Rev s a
s@(N Int
_ s a
s') = forall (s :: * -> *) a b. Sequence s => (a -> b) -> s a -> s a
S.strictWith a -> b
f s a
s' seq :: forall a b. a -> b -> b
`seq` Rev s a
s

structuralInvariant :: forall (s :: * -> *) a. Sequence s => Rev s a -> Bool
structuralInvariant (N Int
i s a
s) = Int
i forall a. Eq a => a -> a -> Bool
== ((forall (s :: * -> *) a. Sequence s => s a -> Int
S.size s a
s) forall a. Num a => a -> a -> a
- Int
1)

-- instances

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

instance S.Sequence s => Functor (Rev s) where
  fmap :: forall a b. (a -> b) -> Rev s a -> Rev s b
fmap = forall (s :: * -> *) a b.
Sequence s =>
(a -> b) -> Rev s a -> Rev s b
map

instance S.Sequence s => App.Alternative (Rev s) where
  empty :: forall a. Rev s a
empty = forall (s :: * -> *) a. Sequence s => Rev s a
empty
  <|> :: forall a. Rev s a -> Rev s a -> Rev s a
(<|>) = forall (s :: * -> *) a. Sequence s => Rev s a -> Rev s a -> Rev s a
append

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

instance S.Sequence s => Monad (Rev s) where
  return :: forall a. a -> Rev s a
return = forall (s :: * -> *) a. Sequence s => a -> Rev s a
singleton
  Rev s a
xs >>= :: forall a b. Rev s a -> (a -> Rev s b) -> Rev s b
>>= a -> Rev s b
k = forall (s :: * -> *) a b.
Sequence s =>
(a -> Rev s b) -> Rev s a -> Rev s b
concatMap a -> Rev s b
k Rev s a
xs

instance S.Sequence s => MonadPlus (Rev s) where
  mplus :: forall a. Rev s a -> Rev s a -> Rev s a
mplus = forall (s :: * -> *) a. Sequence s => Rev s a -> Rev s a -> Rev s a
append
  mzero :: forall a. Rev s a
mzero = forall (s :: * -> *) a. Sequence s => Rev s a
empty

instance Eq (s a) => Eq (Rev s a) where
  (N Int
m s a
xs) == :: Rev s a -> Rev s a -> Bool
== (N Int
n s a
ys) = (Int
m forall a. Eq a => a -> a -> Bool
== Int
n) Bool -> Bool -> Bool
&& (s a
xs forall a. Eq a => a -> a -> Bool
== s a
ys)

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

instance (S.Sequence s, Show (s a)) => Show (Rev s a) where
  showsPrec :: Int -> Rev s a -> ShowS
showsPrec Int
i Rev s a
xs String
rest
     | Int
i forall a. Eq a => a -> a -> Bool
== Int
0    = forall a. [[a]] -> [a]
L.concat [    String
moduleName,String
".fromSeq ",forall a. Show a => Int -> a -> ShowS
showsPrec Int
10 (forall (s :: * -> *) a. Sequence s => Rev s a -> s a
toSeq Rev s a
xs) String
rest]
     | Bool
otherwise = forall a. [[a]] -> [a]
L.concat [String
"(",String
moduleName,String
".fromSeq ",forall a. Show a => Int -> a -> ShowS
showsPrec Int
10 (forall (s :: * -> *) a. Sequence s => Rev s a -> s a
toSeq Rev s a
xs) (Char
')'forall a. a -> [a] -> [a]
:String
rest)]

instance (S.Sequence s, Read (s a)) => Read (Rev s a) where
  readsPrec :: Int -> ReadS (Rev s a)
readsPrec Int
_ String
xs = forall a. ReadS a -> ReadS a
maybeParens forall {s :: * -> *} {a}.
(Read (s a), Sequence s) =>
String -> [(Rev s a, String)]
p String
xs
      where p :: String -> [(Rev s a, String)]
p String
xs = forall (m :: * -> *). MonadPlus m => String -> String -> m String
tokenMatch (String
moduleNameforall a. [a] -> [a] -> [a]
++String
".fromSeq") String
xs
                     forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall a. Read a => Int -> ReadS a
readsPrec Int
10
                     forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \(s a
l,String
rest) -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall (s :: * -> *) a. Sequence s => s a -> Rev s a
fromSeq s a
l,String
rest)

instance (S.Sequence s, Arbitrary (s a)) => Arbitrary (Rev s a) where
  arbitrary :: Gen (Rev s a)
arbitrary = do s a
xs <- forall a. Arbitrary a => Gen a
arbitrary
                 forall (m :: * -> *) a. Monad m => a -> m a
return (forall (s :: * -> *) a. Sequence s => s a -> Rev s a
fromSeq s a
xs)

instance (S.Sequence s, CoArbitrary (s a)) => CoArbitrary (Rev s a) where
  coarbitrary :: forall b. Rev s a -> Gen b -> Gen b
coarbitrary Rev s a
xs = forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary (forall (s :: * -> *) a. Sequence s => Rev s a -> s a
toSeq Rev s a
xs)

instance S.Sequence s => Semigroup (Rev s a) where
  <> :: Rev s a -> Rev s a -> Rev s a
(<>) = forall (s :: * -> *) a. Sequence s => Rev s a -> Rev s a -> Rev s a
append
instance S.Sequence s => Monoid (Rev s a) where
  mempty :: Rev s a
mempty  = forall (s :: * -> *) a. Sequence s => Rev s a
empty
  mappend :: Rev s a -> Rev s a -> Rev s a
mappend = forall a. Semigroup a => a -> a -> a
(SG.<>)