-- |
--   Module      :  Data.Edison.Seq.Defaults
--   Copyright   :  Copyright (c) 1998, 2008 Chris Okasaki
--   License     :  MIT; see COPYRIGHT file for terms and conditions
--
--   Maintainer  :  robdockins AT fastmail DOT fm
--   Stability   :  internal (unstable)
--   Portability :  GHC, Hugs (MPTC and FD)
--
--   This module provides default implementations of many of
--   the sequence operations.  It is used to fill in implementations
--   and is not intended for end users.

module Data.Edison.Seq.Defaults where

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.Monad.Fail as Fail
import Control.Monad
import Data.Char (isSpace)

import Data.Edison.Prelude ( runFail_ )
import Data.Edison.Seq
import qualified Data.Edison.Seq.ListSeq as L

rconsUsingAppend :: Sequence s => a -> s a -> s a
rconsUsingAppend :: forall (s :: * -> *) a. Sequence s => a -> s a -> s a
rconsUsingAppend a
x s a
s = s a -> s a -> s a
forall (s :: * -> *) a. Sequence s => s a -> s a -> s a
append s a
s (a -> s a
forall (s :: * -> *) a. Sequence s => a -> s a
singleton a
x)

rconsUsingFoldr :: Sequence s => a -> s a -> s a
rconsUsingFoldr :: forall (s :: * -> *) a. Sequence s => a -> s a -> s a
rconsUsingFoldr a
x s a
s = (a -> s a -> s a) -> s a -> s a -> s a
forall a b. (a -> b -> b) -> b -> s a -> b
forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
foldr a -> s a -> s a
forall a. a -> s a -> s a
forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons (a -> s a
forall (s :: * -> *) a. Sequence s => a -> s a
singleton a
x) s a
s

appendUsingFoldr :: Sequence s => s a -> s a -> s a
appendUsingFoldr :: forall (s :: * -> *) a. Sequence s => s a -> s a -> s a
appendUsingFoldr s a
s s a
t | s a -> Bool
forall a. s a -> Bool
forall (s :: * -> *) a. Sequence s => s a -> Bool
null s a
t = s a
s
                            | Bool
otherwise = (a -> s a -> s a) -> s a -> s a -> s a
forall a b. (a -> b -> b) -> b -> s a -> b
forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
foldr a -> s a -> s a
forall a. a -> s a -> s a
forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons s a
t s a
s

rviewDefault :: (Fail.MonadFail m, Sequence s) => s a -> m (a, s a)
rviewDefault :: forall (m :: * -> *) (s :: * -> *) a.
(MonadFail m, Sequence s) =>
s a -> m (a, s a)
rviewDefault s a
xs
  | s a -> Bool
forall a. s a -> Bool
forall (s :: * -> *) a. Sequence s => s a -> Bool
null s a
xs   = String -> m (a, s a)
forall a. String -> m a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> m (a, s a)) -> String -> m (a, s a)
forall a b. (a -> b) -> a -> b
$ s a -> String
forall a. s a -> String
forall (s :: * -> *) a. Sequence s => s a -> String
instanceName s a
xs String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
".rview: empty sequence"
  | Bool
otherwise = (a, s a) -> m (a, s a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (s a -> a
forall a. s a -> a
forall (s :: * -> *) a. Sequence s => s a -> a
rhead s a
xs, s a -> s a
forall a. s a -> s a
forall (s :: * -> *) a. Sequence s => s a -> s a
rtail s a
xs)


rtailUsingLview :: (Sequence s) => s a -> s a
rtailUsingLview :: forall (s :: * -> *) a. Sequence s => s a -> s a
rtailUsingLview s a
xs =
    case s a -> Maybe (a, s a)
forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
forall (m :: * -> *) a. MonadFail m => s a -> m (a, s a)
lview s a
xs of
      Maybe (a, s a)
Nothing      -> String -> s a
forall a. HasCallStack => String -> a
error (String -> s a) -> String -> s a
forall a b. (a -> b) -> a -> b
$ s a -> String
forall a. s a -> String
forall (s :: * -> *) a. Sequence s => s a -> String
instanceName s a
xs String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
".rtail: empty sequence"
      Just (a
x, s a
xs) -> a -> s a -> s a
forall {s :: * -> *} {s :: * -> *} {t}.
(Sequence s, Sequence s) =>
t -> s t -> s t
rt a
x s a
xs
  where rt :: t -> s t -> s t
rt t
x s t
xs =
          case s t -> Maybe (t, s t)
forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
forall (m :: * -> *) a. MonadFail m => s a -> m (a, s a)
lview s t
xs of
            Maybe (t, s t)
Nothing      -> s t
forall (s :: * -> *) a. Sequence s => s a
empty
            Just (t
y, s t
ys) -> t -> s t -> s t
forall a. a -> s a -> s a
forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons t
x (t -> s t -> s t
rt t
y s t
ys)

rtailMUsingLview :: (Fail.MonadFail m, Sequence s) => s a -> m (s a)
rtailMUsingLview :: forall (m :: * -> *) (s :: * -> *) a.
(MonadFail m, Sequence s) =>
s a -> m (s a)
rtailMUsingLview s a
xs =
    case s a -> Maybe (a, s a)
forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
forall (m :: * -> *) a. MonadFail m => s a -> m (a, s a)
lview s a
xs of
      Maybe (a, s a)
Nothing      -> String -> m (s a)
forall a. String -> m a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> m (s a)) -> String -> m (s a)
forall a b. (a -> b) -> a -> b
$ s a -> String
forall a. s a -> String
forall (s :: * -> *) a. Sequence s => s a -> String
instanceName s a
xs String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
".rtailM: empty sequence"
      Just (a
x, s a
xs) -> s a -> m (s a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> s a -> s a
forall {s :: * -> *} {s :: * -> *} {t}.
(Sequence s, Sequence s) =>
t -> s t -> s t
rt a
x s a
xs)
  where rt :: t -> s t -> s t
rt t
x s t
xs =
          case s t -> Maybe (t, s t)
forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
forall (m :: * -> *) a. MonadFail m => s a -> m (a, s a)
lview s t
xs of
            Maybe (t, s t)
Nothing      -> s t
forall (s :: * -> *) a. Sequence s => s a
empty
            Just (t
y, s t
ys) -> t -> s t -> s t
forall a. a -> s a -> s a
forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons t
x (t -> s t -> s t
rt t
y s t
ys)



concatUsingFoldr :: Sequence s => s (s a) -> s a
concatUsingFoldr :: forall (s :: * -> *) a. Sequence s => s (s a) -> s a
concatUsingFoldr = (s a -> s a -> s a) -> s a -> s (s a) -> s a
forall a b. (a -> b -> b) -> b -> s a -> b
forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
foldr s a -> s a -> s a
forall (s :: * -> *) a. Sequence s => s a -> s a -> s a
append s a
forall (s :: * -> *) a. Sequence s => s a
empty

reverseUsingReverseOnto :: Sequence s => s a -> s a
reverseUsingReverseOnto :: forall (s :: * -> *) a. Sequence s => s a -> s a
reverseUsingReverseOnto s a
s = s a -> s a -> s a
forall a. s a -> s a -> s a
forall (s :: * -> *) a. Sequence s => s a -> s a -> s a
reverseOnto s a
s s a
forall (s :: * -> *) a. Sequence s => s a
empty

reverseUsingLists :: Sequence s => s a -> s a
reverseUsingLists :: forall (s :: * -> *) a. Sequence s => s a -> s a
reverseUsingLists = [a] -> s a
forall a. [a] -> s a
forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList ([a] -> s a) -> (s a -> [a]) -> s a -> s a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> [a]
forall a. [a] -> [a]
L.reverse ([a] -> [a]) -> (s a -> [a]) -> s a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. s a -> [a]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList

reverseOntoUsingFoldl :: Sequence s => s a -> s a -> s a
reverseOntoUsingFoldl :: forall (s :: * -> *) a. Sequence s => s a -> s a -> s a
reverseOntoUsingFoldl s a
xs s a
ys = (s a -> a -> s a) -> s a -> s a -> s a
forall b a. (b -> a -> b) -> b -> s a -> b
forall (s :: * -> *) b a.
Sequence s =>
(b -> a -> b) -> b -> s a -> b
foldl ((a -> s a -> s a) -> s a -> a -> s a
forall a b c. (a -> b -> c) -> b -> a -> c
flip a -> s a -> s a
forall a. a -> s a -> s a
forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons) s a
ys s a
xs

reverseOntoUsingReverse :: Sequence s => s a -> s a -> s a
reverseOntoUsingReverse :: forall (s :: * -> *) a. Sequence s => s a -> s a -> s a
reverseOntoUsingReverse = s a -> s a -> s a
forall (s :: * -> *) a. Sequence s => s a -> s a -> s a
append (s a -> s a -> s a) -> (s a -> s a) -> s a -> s a -> s a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. s a -> s a
forall a. s a -> s a
forall (s :: * -> *) a. Sequence s => s a -> s a
reverse

fromListUsingCons :: Sequence s => [a] -> s a
fromListUsingCons :: forall (s :: * -> *) a. Sequence s => [a] -> s a
fromListUsingCons = (a -> s a -> s a) -> s a -> [a] -> s a
forall a b. (a -> b -> b) -> b -> [a] -> b
L.foldr a -> s a -> s a
forall a. a -> s a -> s a
forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons s a
forall (s :: * -> *) a. Sequence s => s a
empty

toListUsingFoldr :: Sequence s => s a -> [a]
toListUsingFoldr :: forall (s :: * -> *) a. Sequence s => s a -> [a]
toListUsingFoldr = (a -> [a] -> [a]) -> [a] -> s a -> [a]
forall a b. (a -> b -> b) -> b -> s a -> b
forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
foldr (:) []

mapUsingFoldr :: Sequence s => (a -> b) -> s a -> s b
mapUsingFoldr :: forall (s :: * -> *) a b. Sequence s => (a -> b) -> s a -> s b
mapUsingFoldr a -> b
f = (a -> s b -> s b) -> s b -> s a -> s b
forall a b. (a -> b -> b) -> b -> s a -> b
forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
foldr (b -> s b -> s b
forall a. a -> s a -> s a
forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons (b -> s b -> s b) -> (a -> b) -> a -> s b -> s b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> b
f) s b
forall (s :: * -> *) a. Sequence s => s a
empty

concatMapUsingFoldr :: Sequence s => (a -> s b) -> s a -> s b
concatMapUsingFoldr :: forall (s :: * -> *) a b. Sequence s => (a -> s b) -> s a -> s b
concatMapUsingFoldr a -> s b
f = (a -> s b -> s b) -> s b -> s a -> s b
forall a b. (a -> b -> b) -> b -> s a -> b
forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
foldr (s b -> s b -> s b
forall (s :: * -> *) a. Sequence s => s a -> s a -> s a
append (s b -> s b -> s b) -> (a -> s b) -> a -> s b -> s b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> s b
f) s b
forall (s :: * -> *) a. Sequence s => s a
empty

foldrUsingLists :: Sequence s => (a -> b -> b) -> b -> s a -> b
foldrUsingLists :: forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
foldrUsingLists a -> b -> b
f b
e s a
xs = (a -> b -> b) -> b -> [a] -> b
forall a b. (a -> b -> b) -> b -> [a] -> b
L.foldr a -> b -> b
f b
e (s a -> [a]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
xs)

foldr'UsingLists :: Sequence s => (a -> b -> b) -> b -> s a -> b
foldr'UsingLists :: forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
foldr'UsingLists a -> b -> b
f b
e s a
xs = (a -> b -> b) -> b -> [a] -> b
forall a b. (a -> b -> b) -> b -> [a] -> b
L.foldr' a -> b -> b
f b
e (s a -> [a]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
xs)

foldlUsingLists :: Sequence s => (b -> a -> b) -> b -> s a -> b
foldlUsingLists :: forall (s :: * -> *) b a.
Sequence s =>
(b -> a -> b) -> b -> s a -> b
foldlUsingLists b -> a -> b
f b
e s a
xs = (b -> a -> b) -> b -> [a] -> b
forall b a. (b -> a -> b) -> b -> [a] -> b
L.foldl b -> a -> b
f b
e (s a -> [a]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
xs)

foldl'UsingLists :: Sequence s => (b -> a -> b) -> b -> s a -> b
foldl'UsingLists :: forall (s :: * -> *) b a.
Sequence s =>
(b -> a -> b) -> b -> s a -> b
foldl'UsingLists b -> a -> b
f b
e s a
xs = (b -> a -> b) -> b -> [a] -> b
forall b a. (b -> a -> b) -> b -> [a] -> b
L.foldl' b -> a -> b
f b
e (s a -> [a]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
xs)

foldr1UsingLists :: Sequence s => (a -> a -> a) -> s a -> a
foldr1UsingLists :: forall (s :: * -> *) a. Sequence s => (a -> a -> a) -> s a -> a
foldr1UsingLists a -> a -> a
f s a
xs = (a -> a -> a) -> [a] -> a
forall a. (a -> a -> a) -> [a] -> a
L.foldr1 a -> a -> a
f (s a -> [a]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
xs)

foldr1'UsingLists :: Sequence s => (a -> a -> a) -> s a -> a
foldr1'UsingLists :: forall (s :: * -> *) a. Sequence s => (a -> a -> a) -> s a -> a
foldr1'UsingLists a -> a -> a
f s a
xs = (a -> a -> a) -> [a] -> a
forall a. (a -> a -> a) -> [a] -> a
L.foldr1' a -> a -> a
f (s a -> [a]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
xs)

foldl1UsingLists :: Sequence s => (a -> a -> a) -> s a -> a
foldl1UsingLists :: forall (s :: * -> *) a. Sequence s => (a -> a -> a) -> s a -> a
foldl1UsingLists a -> a -> a
f s a
xs = (a -> a -> a) -> [a] -> a
forall a. (a -> a -> a) -> [a] -> a
L.foldl1 a -> a -> a
f (s a -> [a]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
xs)

foldl1'UsingLists :: Sequence s => (a -> a -> a) -> s a -> a
foldl1'UsingLists :: forall (s :: * -> *) a. Sequence s => (a -> a -> a) -> s a -> a
foldl1'UsingLists a -> a -> a
f s a
xs = (a -> a -> a) -> [a] -> a
forall a. (a -> a -> a) -> [a] -> a
L.foldl1' a -> a -> a
f (s a -> [a]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
xs)

fold1UsingFold :: Sequence s => (a -> a -> a) -> s a -> a
fold1UsingFold :: forall (s :: * -> *) a. Sequence s => (a -> a -> a) -> s a -> a
fold1UsingFold a -> a -> a
f s a
xs =
    case s a -> Maybe (a, s a)
forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
forall (m :: * -> *) a. MonadFail m => s a -> m (a, s a)
lview s a
xs of
      Maybe (a, s a)
Nothing      -> String -> a
forall a. HasCallStack => String -> a
error (String -> a) -> String -> a
forall a b. (a -> b) -> a -> b
$ s a -> String
forall a. s a -> String
forall (s :: * -> *) a. Sequence s => s a -> String
instanceName s a
xs String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
".fold1: empty sequence"
      Just (a
x, s a
xs) -> (a -> a -> a) -> a -> s a -> a
forall a b. (a -> b -> b) -> b -> s a -> b
forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
fold a -> a -> a
f a
x s a
xs

fold1'UsingFold' :: Sequence s => (a -> a -> a) -> s a -> a
fold1'UsingFold' :: forall (s :: * -> *) a. Sequence s => (a -> a -> a) -> s a -> a
fold1'UsingFold' a -> a -> a
f s a
xs =
    case s a -> Maybe (a, s a)
forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
forall (m :: * -> *) a. MonadFail m => s a -> m (a, s a)
lview s a
xs of
      Maybe (a, s a)
Nothing      -> String -> a
forall a. HasCallStack => String -> a
error (String -> a) -> String -> a
forall a b. (a -> b) -> a -> b
$ s a -> String
forall a. s a -> String
forall (s :: * -> *) a. Sequence s => s a -> String
instanceName s a
xs String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
".fold1': empty sequence"
      Just (a
x, s a
xs) -> (a -> a -> a) -> a -> s a -> a
forall a b. (a -> b -> b) -> b -> s a -> b
forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
fold' a -> a -> a
f a
x s a
xs

foldr1UsingLview :: Sequence s => (a -> a -> a) -> s a -> a
foldr1UsingLview :: forall (s :: * -> *) a. Sequence s => (a -> a -> a) -> s a -> a
foldr1UsingLview a -> a -> a
f s a
xs =
    case s a -> Maybe (a, s a)
forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
forall (m :: * -> *) a. MonadFail m => s a -> m (a, s a)
lview s a
xs of
      Maybe (a, s a)
Nothing      -> String -> a
forall a. HasCallStack => String -> a
error (String -> a) -> String -> a
forall a b. (a -> b) -> a -> b
$ s a -> String
forall a. s a -> String
forall (s :: * -> *) a. Sequence s => s a -> String
instanceName s a
xs String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
".foldr1: empty sequence"
      Just (a
x, s a
xs) -> a -> s a -> a
forall {s :: * -> *}. Sequence s => a -> s a -> a
fr1 a
x s a
xs
  where fr1 :: a -> s a -> a
fr1 a
x s a
xs =
          case s a -> Maybe (a, s a)
forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
forall (m :: * -> *) a. MonadFail m => s a -> m (a, s a)
lview s a
xs of
            Maybe (a, s a)
Nothing     -> a
x
            Just (a
y,s a
ys) -> a -> a -> a
f a
x (a -> s a -> a
fr1 a
y s a
ys)

foldr1'UsingLview :: Sequence s => (a -> a -> a) -> s a -> a
foldr1'UsingLview :: forall (s :: * -> *) a. Sequence s => (a -> a -> a) -> s a -> a
foldr1'UsingLview a -> a -> a
f s a
xs =
     case s a -> Maybe (a, s a)
forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
forall (m :: * -> *) a. MonadFail m => s a -> m (a, s a)
lview s a
xs of
        Maybe (a, s a)
Nothing     -> String -> a
forall a. HasCallStack => String -> a
error (String -> a) -> String -> a
forall a b. (a -> b) -> a -> b
$ s a -> String
forall a. s a -> String
forall (s :: * -> *) a. Sequence s => s a -> String
instanceName s a
xs String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
".foldr1': empty sequence"
        Just (a
x,s a
xs) -> a -> s a -> a
forall {s :: * -> *}. Sequence s => a -> s a -> a
fr1 a
x s a
xs
  where fr1 :: a -> s a -> a
fr1 a
x s a
xs =
          case s a -> Maybe (a, s a)
forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
forall (m :: * -> *) a. MonadFail m => s a -> m (a, s a)
lview s a
xs of
             Maybe (a, s a)
Nothing     -> a
x
             Just (a
y,s a
ys) -> a -> a -> a
f a
x (a -> a) -> a -> a
forall a b. (a -> b) -> a -> b
$! (a -> s a -> a
fr1 a
y s a
ys)

foldl1UsingFoldl :: Sequence s => (a -> a -> a) -> s a -> a
foldl1UsingFoldl :: forall (s :: * -> *) a. Sequence s => (a -> a -> a) -> s a -> a
foldl1UsingFoldl a -> a -> a
f s a
xs =
    case s a -> Maybe (a, s a)
forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
forall (m :: * -> *) a. MonadFail m => s a -> m (a, s a)
lview s a
xs of
      Maybe (a, s a)
Nothing     -> String -> a
forall a. HasCallStack => String -> a
error (String -> a) -> String -> a
forall a b. (a -> b) -> a -> b
$ s a -> String
forall a. s a -> String
forall (s :: * -> *) a. Sequence s => s a -> String
instanceName s a
xs String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
".foldl1: empty sequence"
      Just (a
x,s a
xs) -> (a -> a -> a) -> a -> s a -> a
forall b a. (b -> a -> b) -> b -> s a -> b
forall (s :: * -> *) b a.
Sequence s =>
(b -> a -> b) -> b -> s a -> b
foldl a -> a -> a
f a
x s a
xs

foldl1'UsingFoldl' :: Sequence s => (a -> a -> a) -> s a -> a
foldl1'UsingFoldl' :: forall (s :: * -> *) a. Sequence s => (a -> a -> a) -> s a -> a
foldl1'UsingFoldl' a -> a -> a
f s a
xs =
    case s a -> Maybe (a, s a)
forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
forall (m :: * -> *) a. MonadFail m => s a -> m (a, s a)
lview s a
xs of
      Maybe (a, s a)
Nothing     -> String -> a
forall a. HasCallStack => String -> a
error (String -> a) -> String -> a
forall a b. (a -> b) -> a -> b
$ s a -> String
forall a. s a -> String
forall (s :: * -> *) a. Sequence s => s a -> String
instanceName s a
xs String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
".foldl1': empty sequence"
      Just (a
x,s a
xs) -> (a -> a -> a) -> a -> s a -> a
forall b a. (b -> a -> b) -> b -> s a -> b
forall (s :: * -> *) b a.
Sequence s =>
(b -> a -> b) -> b -> s a -> b
foldl' a -> a -> a
f a
x s a
xs

reducerUsingReduce1 :: Sequence s => (a -> a -> a) -> a -> s a -> a
reducerUsingReduce1 :: forall (s :: * -> *) a.
Sequence s =>
(a -> a -> a) -> a -> s a -> a
reducerUsingReduce1 a -> a -> a
f a
e s a
s
  | s a -> Bool
forall a. s a -> Bool
forall (s :: * -> *) a. Sequence s => s a -> Bool
null s a
s = a
e
  | Bool
otherwise = a -> a -> a
f ((a -> a -> a) -> s a -> a
forall a. (a -> a -> a) -> s a -> a
forall (s :: * -> *) a. Sequence s => (a -> a -> a) -> s a -> a
reduce1 a -> a -> a
f s a
s) a
e

reducer'UsingReduce1' :: Sequence s => (a -> a -> a) -> a -> s a -> a
reducer'UsingReduce1' :: forall (s :: * -> *) a.
Sequence s =>
(a -> a -> a) -> a -> s a -> a
reducer'UsingReduce1' a -> a -> a
f a
e s a
s
  | s a -> Bool
forall a. s a -> Bool
forall (s :: * -> *) a. Sequence s => s a -> Bool
null s a
s = a
e
  | Bool
otherwise = a -> a -> a
f ((a -> a -> a) -> s a -> a
forall a. (a -> a -> a) -> s a -> a
forall (s :: * -> *) a. Sequence s => (a -> a -> a) -> s a -> a
reduce1' a -> a -> a
f s a
s) a
e

reducelUsingReduce1 :: Sequence s => (a -> a -> a) -> a -> s a -> a
reducelUsingReduce1 :: forall (s :: * -> *) a.
Sequence s =>
(a -> a -> a) -> a -> s a -> a
reducelUsingReduce1 a -> a -> a
f a
e s a
s
  | s a -> Bool
forall a. s a -> Bool
forall (s :: * -> *) a. Sequence s => s a -> Bool
null s a
s = a
e
  | Bool
otherwise = a -> a -> a
f a
e ((a -> a -> a) -> s a -> a
forall a. (a -> a -> a) -> s a -> a
forall (s :: * -> *) a. Sequence s => (a -> a -> a) -> s a -> a
reduce1 a -> a -> a
f s a
s)

reducel'UsingReduce1' :: Sequence s => (a -> a -> a) -> a -> s a -> a
reducel'UsingReduce1' :: forall (s :: * -> *) a.
Sequence s =>
(a -> a -> a) -> a -> s a -> a
reducel'UsingReduce1' a -> a -> a
f a
e s a
s
  | s a -> Bool
forall a. s a -> Bool
forall (s :: * -> *) a. Sequence s => s a -> Bool
null s a
s = a
e
  | Bool
otherwise = a -> a -> a
f a
e ((a -> a -> a) -> s a -> a
forall a. (a -> a -> a) -> s a -> a
forall (s :: * -> *) a. Sequence s => (a -> a -> a) -> s a -> a
reduce1' a -> a -> a
f s a
s)

reduce1UsingLists :: Sequence s => (a -> a -> a) -> s a -> a
reduce1UsingLists :: forall (s :: * -> *) a. Sequence s => (a -> a -> a) -> s a -> a
reduce1UsingLists a -> a -> a
f s a
s = (a -> a -> a) -> [a] -> a
forall a. (a -> a -> a) -> [a] -> a
L.reduce1 a -> a -> a
f (s a -> [a]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
s)

reduce1'UsingLists :: Sequence s => (a -> a -> a) -> s a -> a
reduce1'UsingLists :: forall (s :: * -> *) a. Sequence s => (a -> a -> a) -> s a -> a
reduce1'UsingLists a -> a -> a
f s a
s = (a -> a -> a) -> [a] -> a
forall a. (a -> a -> a) -> [a] -> a
L.reduce1' a -> a -> a
f (s a -> [a]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
s)

copyUsingLists :: Sequence s => Int -> a -> s a
copyUsingLists :: forall (s :: * -> *) a. Sequence s => Int -> a -> s a
copyUsingLists Int
n a
x = [a] -> s a
forall a. [a] -> s a
forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList (Int -> a -> [a]
forall a. Int -> a -> [a]
L.copy Int
n a
x)


inBoundsUsingDrop :: Sequence s => Int -> s a -> Bool
inBoundsUsingDrop :: forall (s :: * -> *) a. Sequence s => Int -> s a -> Bool
inBoundsUsingDrop Int
i s a
s =
  Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Bool -> Bool
not (s a -> Bool
forall a. s a -> Bool
forall (s :: * -> *) a. Sequence s => s a -> Bool
null (Int -> s a -> s a
forall a. Int -> s a -> s a
forall (s :: * -> *) a. Sequence s => Int -> s a -> s a
drop Int
i s a
s))

inBoundsUsingLookupM :: Sequence s => Int -> s a -> Bool
inBoundsUsingLookupM :: forall (s :: * -> *) a. Sequence s => Int -> s a -> Bool
inBoundsUsingLookupM Int
i s a
s =
  case Int -> s a -> Maybe a
forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
Int -> s a -> m a
forall (m :: * -> *) a. MonadFail m => Int -> s a -> m a
lookupM Int
i s a
s of
    Just a
_  -> Bool
True
    Maybe a
Nothing -> Bool
False

inBoundsUsingSize :: Sequence s => Int -> s a -> Bool
inBoundsUsingSize :: forall (s :: * -> *) a. Sequence s => Int -> s a -> Bool
inBoundsUsingSize Int
i s a
s = Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< s a -> Int
forall a. s a -> Int
forall (s :: * -> *) a. Sequence s => s a -> Int
size s a
s

lookupUsingLookupM :: Sequence s => Int -> s a -> a
lookupUsingLookupM :: forall (s :: * -> *) a. Sequence s => Int -> s a -> a
lookupUsingLookupM Int
i s a
s = Fail a -> a
forall a. Fail a -> a
runFail_ (Int -> s a -> Fail a
forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
Int -> s a -> m a
forall (m :: * -> *) a. MonadFail m => Int -> s a -> m a
lookupM Int
i s a
s)

lookupUsingDrop :: Sequence s => Int -> s a -> a
lookupUsingDrop :: forall (s :: * -> *) a. Sequence s => Int -> s a -> a
lookupUsingDrop Int
i s a
s
  | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0 Bool -> Bool -> Bool
|| s a -> Bool
forall a. s a -> Bool
forall (s :: * -> *) a. Sequence s => s a -> Bool
null s a
s' = String -> a
forall a. HasCallStack => String -> a
error (String -> a) -> String -> a
forall a b. (a -> b) -> a -> b
$ s a -> String
forall a. s a -> String
forall (s :: * -> *) a. Sequence s => s a -> String
instanceName s a
s String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
".lookup: bad subscript"
  | Bool
otherwise = s a -> a
forall a. s a -> a
forall (s :: * -> *) a. Sequence s => s a -> a
lhead s a
s'
  where s' :: s a
s' = Int -> s a -> s a
forall a. Int -> s a -> s a
forall (s :: * -> *) a. Sequence s => Int -> s a -> s a
drop Int
i s a
s

lookupWithDefaultUsingLookupM :: Sequence s => a -> Int -> s a -> a
lookupWithDefaultUsingLookupM :: forall (s :: * -> *) a. Sequence s => a -> Int -> s a -> a
lookupWithDefaultUsingLookupM a
d Int
i s a
s =
  case Int -> s a -> Maybe a
forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
Int -> s a -> m a
forall (m :: * -> *) a. MonadFail m => Int -> s a -> m a
lookupM Int
i s a
s of
    Maybe a
Nothing -> a
d
    Just a
x  -> a
x

lookupWithDefaultUsingDrop :: Sequence s => a -> Int -> s a -> a
lookupWithDefaultUsingDrop :: forall (s :: * -> *) a. Sequence s => a -> Int -> s a -> a
lookupWithDefaultUsingDrop a
d Int
i s a
s
  | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0 Bool -> Bool -> Bool
|| s a -> Bool
forall a. s a -> Bool
forall (s :: * -> *) a. Sequence s => s a -> Bool
null s a
s' = a
d
  | Bool
otherwise = s a -> a
forall a. s a -> a
forall (s :: * -> *) a. Sequence s => s a -> a
lhead s a
s'
  where s' :: s a
s' = Int -> s a -> s a
forall a. Int -> s a -> s a
forall (s :: * -> *) a. Sequence s => Int -> s a -> s a
drop Int
i s a
s

lookupMUsingDrop :: (Fail.MonadFail m, Sequence s) => Int -> s a -> m a
lookupMUsingDrop :: forall (m :: * -> *) (s :: * -> *) a.
(MonadFail m, Sequence s) =>
Int -> s a -> m a
lookupMUsingDrop Int
i s a
s
  -- XXX better error message!
  | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0 Bool -> Bool -> Bool
|| s a -> Bool
forall a. s a -> Bool
forall (s :: * -> *) a. Sequence s => s a -> Bool
null s a
s' = String -> m a
forall a. String -> m a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> m a) -> String -> m a
forall a b. (a -> b) -> a -> b
$ s a -> String
forall a. s a -> String
forall (s :: * -> *) a. Sequence s => s a -> String
instanceName s a
s
                        String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
".lookupMUsingDrop: empty sequence"
  | Bool
otherwise        = a -> m a
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (s a -> a
forall a. s a -> a
forall (s :: * -> *) a. Sequence s => s a -> a
lhead s a
s')
  where s' :: s a
s' = Int -> s a -> s a
forall a. Int -> s a -> s a
forall (s :: * -> *) a. Sequence s => Int -> s a -> s a
drop Int
i s a
s

filterUsingLview :: Sequence s => (a -> Bool) -> s a -> s a
filterUsingLview :: forall (s :: * -> *) a. Sequence s => (a -> Bool) -> s a -> s a
filterUsingLview a -> Bool
p s a
xs =
  case s a -> Maybe (a, s a)
forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
forall (m :: * -> *) a. MonadFail m => s a -> m (a, s a)
lview s a
xs of
    Maybe (a, s a)
Nothing     -> s a
forall (s :: * -> *) a. Sequence s => s a
empty
    Just (a
x,s a
xs) -> if a -> Bool
p a
x then a -> s a -> s a
forall a. a -> s a -> s a
forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons a
x ((a -> Bool) -> s a -> s a
forall a. (a -> Bool) -> s a -> s a
forall (s :: * -> *) a. Sequence s => (a -> Bool) -> s a -> s a
filter a -> Bool
p s a
xs) else (a -> Bool) -> s a -> s a
forall a. (a -> Bool) -> s a -> s a
forall (s :: * -> *) a. Sequence s => (a -> Bool) -> s a -> s a
filter a -> Bool
p s a
xs

filterUsingLists :: Sequence s => (a -> Bool) -> s a -> s a
filterUsingLists :: forall (s :: * -> *) a. Sequence s => (a -> Bool) -> s a -> s a
filterUsingLists a -> Bool
p s a
xs =
  [a] -> s a
forall a. [a] -> s a
forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList ((a -> Bool) -> [a] -> [a]
forall a. (a -> Bool) -> [a] -> [a]
L.filter a -> Bool
p (s a -> [a]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
xs))

filterUsingFoldr :: Sequence s => (a -> Bool) -> s a -> s a
filterUsingFoldr :: forall (s :: * -> *) a. Sequence s => (a -> Bool) -> s a -> s a
filterUsingFoldr a -> Bool
p = (a -> s a -> s a) -> s a -> s a -> s a
forall a b. (a -> b -> b) -> b -> s a -> b
forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
foldr a -> s a -> s a
forall {s :: * -> *}. Sequence s => a -> s a -> s a
pcons s a
forall (s :: * -> *) a. Sequence s => s a
empty
  where pcons :: a -> s a -> s a
pcons a
x s a
xs = if a -> Bool
p a
x then a -> s a -> s a
forall a. a -> s a -> s a
forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons a
x s a
xs else s a
xs

partitionUsingLists :: Sequence s => (a -> Bool) -> s a -> (s a, s a)
partitionUsingLists :: forall (s :: * -> *) a.
Sequence s =>
(a -> Bool) -> s a -> (s a, s a)
partitionUsingLists a -> Bool
p s a
xs =
  let ([a]
ys,[a]
zs) = (a -> Bool) -> [a] -> ([a], [a])
forall a. (a -> Bool) -> [a] -> ([a], [a])
L.partition a -> Bool
p (s a -> [a]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
xs)
  in ([a] -> s a
forall a. [a] -> s a
forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList [a]
ys, [a] -> s a
forall a. [a] -> s a
forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList [a]
zs)

partitionUsingFoldr :: Sequence s => (a -> Bool) -> s a -> (s a, s a)
partitionUsingFoldr :: forall (s :: * -> *) a.
Sequence s =>
(a -> Bool) -> s a -> (s a, s a)
partitionUsingFoldr a -> Bool
p = (a -> (s a, s a) -> (s a, s a)) -> (s a, s a) -> s a -> (s a, s a)
forall a b. (a -> b -> b) -> b -> s a -> b
forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
foldr a -> (s a, s a) -> (s a, s a)
forall {s :: * -> *} {s :: * -> *}.
(Sequence s, Sequence s) =>
a -> (s a, s a) -> (s a, s a)
pcons (s a
forall (s :: * -> *) a. Sequence s => s a
empty, s a
forall (s :: * -> *) a. Sequence s => s a
empty)
  where pcons :: a -> (s a, s a) -> (s a, s a)
pcons a
x (s a
xs, s a
xs') = if a -> Bool
p a
x then (a -> s a -> s a
forall a. a -> s a -> s a
forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons a
x s a
xs, s a
xs') else (s a
xs, a -> s a -> s a
forall a. a -> s a -> s a
forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons a
x s a
xs')

updateUsingAdjust :: Sequence s => Int -> a -> s a -> s a
updateUsingAdjust :: forall (s :: * -> *) a. Sequence s => Int -> a -> s a -> s a
updateUsingAdjust Int
i a
y = (a -> a) -> Int -> s a -> s a
forall a. (a -> a) -> Int -> s a -> s a
forall (s :: * -> *) a. Sequence s => (a -> a) -> Int -> s a -> s a
adjust (a -> a -> a
forall a b. a -> b -> a
const a
y) Int
i

updateUsingSplitAt :: Sequence s => Int -> a -> s a -> s a
updateUsingSplitAt :: forall (s :: * -> *) a. Sequence s => Int -> a -> s a -> s a
updateUsingSplitAt Int
i a
x s a
xs
  | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0 = s a
xs
  | Bool
otherwise = let (s a
ys,s a
zs) = Int -> s a -> (s a, s a)
forall a. Int -> s a -> (s a, s a)
forall (s :: * -> *) a. Sequence s => Int -> s a -> (s a, s a)
splitAt Int
i s a
xs
                in if s a -> Bool
forall a. s a -> Bool
forall (s :: * -> *) a. Sequence s => s a -> Bool
null s a
zs then s a
xs else s a -> s a -> s a
forall (s :: * -> *) a. Sequence s => s a -> s a -> s a
append s a
ys (a -> s a -> s a
forall a. a -> s a -> s a
forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons a
x (s a -> s a
forall a. s a -> s a
forall (s :: * -> *) a. Sequence s => s a -> s a
ltail s a
zs))

adjustUsingLists :: Sequence s => (a -> a) -> Int -> s a -> s a
adjustUsingLists :: forall (s :: * -> *) a. Sequence s => (a -> a) -> Int -> s a -> s a
adjustUsingLists a -> a
f Int
i s a
xs = [a] -> s a
forall a. [a] -> s a
forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList ((a -> a) -> Int -> [a] -> [a]
forall a. (a -> a) -> Int -> [a] -> [a]
L.adjust a -> a
f Int
i (s a -> [a]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
xs))

adjustUsingSplitAt :: Sequence s => (a -> a) -> Int -> s a -> s a
adjustUsingSplitAt :: forall (s :: * -> *) a. Sequence s => (a -> a) -> Int -> s a -> s a
adjustUsingSplitAt a -> a
f Int
i s a
xs
  | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0 = s a
xs
  | Bool
otherwise = let (s a
ys,s a
zs) = Int -> s a -> (s a, s a)
forall a. Int -> s a -> (s a, s a)
forall (s :: * -> *) a. Sequence s => Int -> s a -> (s a, s a)
splitAt Int
i s a
xs
                in case s a -> Maybe (a, s a)
forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
forall (m :: * -> *) a. MonadFail m => s a -> m (a, s a)
lview s a
zs of
                     Maybe (a, s a)
Nothing      -> s a
xs
                     Just (a
z,s a
zs') -> s a -> s a -> s a
forall (s :: * -> *) a. Sequence s => s a -> s a -> s a
append s a
ys (a -> s a -> s a
forall a. a -> s a -> s a
forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons (a -> a
f a
z) s a
zs')

{-
insertAtUsingLists :: Sequence s => Int -> a -> s a -> s a
insertAtUsingLists i x xs =
  fromList (L.insertAt i x (toList xs))

insertAtUsingSplitAt :: Sequence s => Int -> a -> s a -> s a
insertAtUsingSplitAt i x xs
  | (xs_before, xs_after) <- splitAt i xs =
      append xs_before (lcons x xs_after)

deleteAtUsingLists :: Sequence s => Int -> s a -> s a
deleteAtUsingLists i xs = fromList (L.deleteAt i (toList xs))

deleteAtUsingSplitAt :: Sequence s => Int -> s a -> s a
deleteAtUsingSplitAt i xs
  | (xs_before, xs_after) <- splitAt i xs =
      append xs_before (ltail xs_after)
-}

mapWithIndexUsingLists :: Sequence s => (Int -> a -> b) -> s a -> s b
mapWithIndexUsingLists :: forall (s :: * -> *) a b.
Sequence s =>
(Int -> a -> b) -> s a -> s b
mapWithIndexUsingLists Int -> a -> b
f s a
xs = [b] -> s b
forall a. [a] -> s a
forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList ((Int -> a -> b) -> [a] -> [b]
forall a b. (Int -> a -> b) -> [a] -> [b]
L.mapWithIndex Int -> a -> b
f (s a -> [a]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
xs))

foldrWithIndexUsingLists ::
  Sequence s => (Int -> a -> b -> b) -> b -> s a -> b
foldrWithIndexUsingLists :: forall (s :: * -> *) a b.
Sequence s =>
(Int -> a -> b -> b) -> b -> s a -> b
foldrWithIndexUsingLists Int -> a -> b -> b
f b
e s a
xs = (Int -> a -> b -> b) -> b -> [a] -> b
forall a b. (Int -> a -> b -> b) -> b -> [a] -> b
L.foldrWithIndex Int -> a -> b -> b
f b
e (s a -> [a]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
xs)

foldrWithIndex'UsingLists ::
  Sequence s => (Int -> a -> b -> b) -> b -> s a -> b
foldrWithIndex'UsingLists :: forall (s :: * -> *) a b.
Sequence s =>
(Int -> a -> b -> b) -> b -> s a -> b
foldrWithIndex'UsingLists Int -> a -> b -> b
f b
e s a
xs = (Int -> a -> b -> b) -> b -> [a] -> b
forall {t1} {t2} {a}.
(Num t1, Enum t1) =>
(t1 -> t2 -> a -> a) -> a -> [t2] -> a
L.foldrWithIndex' Int -> a -> b -> b
f b
e (s a -> [a]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
xs)

foldlWithIndexUsingLists ::
  Sequence s => (b -> Int -> a -> b) -> b -> s a -> b
foldlWithIndexUsingLists :: forall (s :: * -> *) b a.
Sequence s =>
(b -> Int -> a -> b) -> b -> s a -> b
foldlWithIndexUsingLists b -> Int -> a -> b
f b
e s a
xs = (b -> Int -> a -> b) -> b -> [a] -> b
forall b a. (b -> Int -> a -> b) -> b -> [a] -> b
L.foldlWithIndex b -> Int -> a -> b
f b
e (s a -> [a]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
xs)

foldlWithIndex'UsingLists ::
  Sequence s => (b -> Int -> a -> b) -> b -> s a -> b
foldlWithIndex'UsingLists :: forall (s :: * -> *) b a.
Sequence s =>
(b -> Int -> a -> b) -> b -> s a -> b
foldlWithIndex'UsingLists b -> Int -> a -> b
f b
e s a
xs = (b -> Int -> a -> b) -> b -> [a] -> b
forall b a. (b -> Int -> a -> b) -> b -> [a] -> b
L.foldlWithIndex' b -> Int -> a -> b
f b
e (s a -> [a]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
xs)

takeUsingLists :: Sequence s => Int -> s a -> s a
takeUsingLists :: forall (s :: * -> *) a. Sequence s => Int -> s a -> s a
takeUsingLists Int
i s a
s = [a] -> s a
forall a. [a] -> s a
forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList (Int -> [a] -> [a]
forall a. Int -> [a] -> [a]
L.take Int
i (s a -> [a]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
s))

takeUsingLview :: Sequence s => Int -> s a -> s a
takeUsingLview :: forall (s :: * -> *) a. Sequence s => Int -> s a -> s a
takeUsingLview Int
i s a
xs
  | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0 = s a
forall (s :: * -> *) a. Sequence s => s a
empty
  | Bool
otherwise = case s a -> Maybe (a, s a)
forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
forall (m :: * -> *) a. MonadFail m => s a -> m (a, s a)
lview s a
xs of
                  Maybe (a, s a)
Nothing -> s a
forall (s :: * -> *) a. Sequence s => s a
empty
                  Just (a
x,s a
xs') -> a -> s a -> s a
forall a. a -> s a -> s a
forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons a
x (Int -> s a -> s a
forall a. Int -> s a -> s a
forall (s :: * -> *) a. Sequence s => Int -> s a -> s a
take (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1) s a
xs')

dropUsingLists :: Sequence s => Int -> s a -> s a
dropUsingLists :: forall (s :: * -> *) a. Sequence s => Int -> s a -> s a
dropUsingLists Int
i s a
s = [a] -> s a
forall a. [a] -> s a
forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList (Int -> [a] -> [a]
forall a. Int -> [a] -> [a]
L.drop Int
i (s a -> [a]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
s))

dropUsingLtail :: Sequence s => Int -> s a -> s a
dropUsingLtail :: forall (s :: * -> *) a. Sequence s => Int -> s a -> s a
dropUsingLtail Int
i s a
xs
  | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0 Bool -> Bool -> Bool
|| s a -> Bool
forall a. s a -> Bool
forall (s :: * -> *) a. Sequence s => s a -> Bool
null s a
xs = s a
xs
  | Bool
otherwise = Int -> s a -> s a
forall (s :: * -> *) a. Sequence s => Int -> s a -> s a
dropUsingLtail (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1) (s a -> s a
forall a. s a -> s a
forall (s :: * -> *) a. Sequence s => s a -> s a
ltail s a
xs)

splitAtDefault :: Sequence s => Int -> s a -> (s a, s a)
splitAtDefault :: forall (s :: * -> *) a. Sequence s => Int -> s a -> (s a, s a)
splitAtDefault Int
i s a
s = (Int -> s a -> s a
forall a. Int -> s a -> s a
forall (s :: * -> *) a. Sequence s => Int -> s a -> s a
take Int
i s a
s, Int -> s a -> s a
forall a. Int -> s a -> s a
forall (s :: * -> *) a. Sequence s => Int -> s a -> s a
drop Int
i s a
s)

splitAtUsingLview :: Sequence s => Int -> s a -> (s a, s a)
splitAtUsingLview :: forall (s :: * -> *) a. Sequence s => Int -> s a -> (s a, s a)
splitAtUsingLview Int
i s a
xs
  | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0 = (s a
forall (s :: * -> *) a. Sequence s => s a
empty,s a
xs)
  | Bool
otherwise = case s a -> Maybe (a, s a)
forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
forall (m :: * -> *) a. MonadFail m => s a -> m (a, s a)
lview s a
xs of
                  Maybe (a, s a)
Nothing      -> (s a
forall (s :: * -> *) a. Sequence s => s a
empty,s a
forall (s :: * -> *) a. Sequence s => s a
empty)
                  Just (a
x,s a
xs') -> (a -> s a -> s a
forall a. a -> s a -> s a
forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons a
x s a
ys,s a
zs)
                    where (s a
ys,s a
zs) = Int -> s a -> (s a, s a)
forall (s :: * -> *) a. Sequence s => Int -> s a -> (s a, s a)
splitAtUsingLview (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1) s a
xs'

subseqDefault :: Sequence s => Int -> Int -> s a -> s a
subseqDefault :: forall (s :: * -> *) a. Sequence s => Int -> Int -> s a -> s a
subseqDefault Int
i Int
len s a
xs = Int -> s a -> s a
forall a. Int -> s a -> s a
forall (s :: * -> *) a. Sequence s => Int -> s a -> s a
take Int
len (Int -> s a -> s a
forall a. Int -> s a -> s a
forall (s :: * -> *) a. Sequence s => Int -> s a -> s a
drop Int
i s a
xs)

takeWhileUsingLview :: Sequence s => (a -> Bool) -> s a -> s a
takeWhileUsingLview :: forall (s :: * -> *) a. Sequence s => (a -> Bool) -> s a -> s a
takeWhileUsingLview a -> Bool
p s a
xs =
  case s a -> Maybe (a, s a)
forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
forall (m :: * -> *) a. MonadFail m => s a -> m (a, s a)
lview s a
xs of
    Just (a
x,s a
xs') | a -> Bool
p a
x -> a -> s a -> s a
forall a. a -> s a -> s a
forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons a
x ((a -> Bool) -> s a -> s a
forall (s :: * -> *) a. Sequence s => (a -> Bool) -> s a -> s a
takeWhileUsingLview a -> Bool
p s a
xs')
    Maybe (a, s a)
_                  -> s a
forall (s :: * -> *) a. Sequence s => s a
empty

dropWhileUsingLview :: Sequence s => (a -> Bool) -> s a -> s a
dropWhileUsingLview :: forall (s :: * -> *) a. Sequence s => (a -> Bool) -> s a -> s a
dropWhileUsingLview a -> Bool
p s a
xs =
  case s a -> Maybe (a, s a)
forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
forall (m :: * -> *) a. MonadFail m => s a -> m (a, s a)
lview s a
xs of
    Just (a
x,s a
xs') | a -> Bool
p a
x -> (a -> Bool) -> s a -> s a
forall (s :: * -> *) a. Sequence s => (a -> Bool) -> s a -> s a
dropWhileUsingLview a -> Bool
p s a
xs'
    Maybe (a, s a)
_                  -> s a
xs

splitWhileUsingLview :: Sequence s => (a -> Bool) -> s a -> (s a, s a)
splitWhileUsingLview :: forall (s :: * -> *) a.
Sequence s =>
(a -> Bool) -> s a -> (s a, s a)
splitWhileUsingLview a -> Bool
p s a
xs =
  case s a -> Maybe (a, s a)
forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
forall (m :: * -> *) a. MonadFail m => s a -> m (a, s a)
lview s a
xs of
    Just (a
x,s a
xs') | a -> Bool
p a
x -> let (s a
front, s a
back) = (a -> Bool) -> s a -> (s a, s a)
forall (s :: * -> *) a.
Sequence s =>
(a -> Bool) -> s a -> (s a, s a)
splitWhileUsingLview a -> Bool
p s a
xs'
                          in (a -> s a -> s a
forall a. a -> s a -> s a
forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons a
x s a
front, s a
back)
    Maybe (a, s a)
_                  -> (s a
forall (s :: * -> *) a. Sequence s => s a
empty, s a
xs)

zipUsingLview :: Sequence s => s a -> s b -> s (a,b)
zipUsingLview :: forall (s :: * -> *) a b. Sequence s => s a -> s b -> s (a, b)
zipUsingLview s a
xs s b
ys =
  case s a -> Maybe (a, s a)
forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
forall (m :: * -> *) a. MonadFail m => s a -> m (a, s a)
lview s a
xs of
    Maybe (a, s a)
Nothing -> s (a, b)
forall (s :: * -> *) a. Sequence s => s a
empty
    Just (a
x,s a
xs') ->
      case s b -> Maybe (b, s b)
forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
forall (m :: * -> *) a. MonadFail m => s a -> m (a, s a)
lview s b
ys of
        Maybe (b, s b)
Nothing -> s (a, b)
forall (s :: * -> *) a. Sequence s => s a
empty
        Just (b
y,s b
ys') -> (a, b) -> s (a, b) -> s (a, b)
forall a. a -> s a -> s a
forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons (a
x,b
y) (s a -> s b -> s (a, b)
forall (s :: * -> *) a b. Sequence s => s a -> s b -> s (a, b)
zipUsingLview s a
xs' s b
ys')

zip3UsingLview :: Sequence s => s a -> s b -> s c -> s (a,b,c)
zip3UsingLview :: forall (s :: * -> *) a b c.
Sequence s =>
s a -> s b -> s c -> s (a, b, c)
zip3UsingLview s a
xs s b
ys s c
zs =
  case s a -> Maybe (a, s a)
forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
forall (m :: * -> *) a. MonadFail m => s a -> m (a, s a)
lview s a
xs of
    Maybe (a, s a)
Nothing -> s (a, b, c)
forall (s :: * -> *) a. Sequence s => s a
empty
    Just (a
x,s a
xs') ->
      case s b -> Maybe (b, s b)
forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
forall (m :: * -> *) a. MonadFail m => s a -> m (a, s a)
lview s b
ys of
        Maybe (b, s b)
Nothing -> s (a, b, c)
forall (s :: * -> *) a. Sequence s => s a
empty
        Just (b
y,s b
ys') ->
          case s c -> Maybe (c, s c)
forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
forall (m :: * -> *) a. MonadFail m => s a -> m (a, s a)
lview s c
zs of
            Maybe (c, s c)
Nothing -> s (a, b, c)
forall (s :: * -> *) a. Sequence s => s a
empty
            Just (c
z,s c
zs') -> (a, b, c) -> s (a, b, c) -> s (a, b, c)
forall a. a -> s a -> s a
forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons (a
x,b
y,c
z) (s a -> s b -> s c -> s (a, b, c)
forall (s :: * -> *) a b c.
Sequence s =>
s a -> s b -> s c -> s (a, b, c)
zip3UsingLview s a
xs' s b
ys' s c
zs')

zipWithUsingLview :: Sequence s => (a -> b -> c) -> s a -> s b -> s c
zipWithUsingLview :: forall (s :: * -> *) a b c.
Sequence s =>
(a -> b -> c) -> s a -> s b -> s c
zipWithUsingLview a -> b -> c
f s a
xs s b
ys =
  case s a -> Maybe (a, s a)
forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
forall (m :: * -> *) a. MonadFail m => s a -> m (a, s a)
lview s a
xs of
    Maybe (a, s a)
Nothing -> s c
forall (s :: * -> *) a. Sequence s => s a
empty
    Just (a
x,s a
xs') ->
      case s b -> Maybe (b, s b)
forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
forall (m :: * -> *) a. MonadFail m => s a -> m (a, s a)
lview s b
ys of
        Maybe (b, s b)
Nothing -> s c
forall (s :: * -> *) a. Sequence s => s a
empty
        Just (b
y,s b
ys') -> c -> s c -> s c
forall a. a -> s a -> s a
forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons (a -> b -> c
f a
x b
y) ((a -> b -> c) -> s a -> s b -> s c
forall (s :: * -> *) a b c.
Sequence s =>
(a -> b -> c) -> s a -> s b -> s c
zipWithUsingLview a -> b -> c
f s a
xs' s b
ys')

zipWith3UsingLview ::
  Sequence s => (a -> b -> c -> d) -> s a -> s b -> s c -> s d
zipWith3UsingLview :: forall (s :: * -> *) a b c d.
Sequence s =>
(a -> b -> c -> d) -> s a -> s b -> s c -> s d
zipWith3UsingLview a -> b -> c -> d
f s a
xs s b
ys s c
zs =
  case s a -> Maybe (a, s a)
forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
forall (m :: * -> *) a. MonadFail m => s a -> m (a, s a)
lview s a
xs of
    Maybe (a, s a)
Nothing -> s d
forall (s :: * -> *) a. Sequence s => s a
empty
    Just (a
x,s a
xs') ->
      case s b -> Maybe (b, s b)
forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
forall (m :: * -> *) a. MonadFail m => s a -> m (a, s a)
lview s b
ys of
        Maybe (b, s b)
Nothing -> s d
forall (s :: * -> *) a. Sequence s => s a
empty
        Just (b
y,s b
ys') ->
          case s c -> Maybe (c, s c)
forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
forall (m :: * -> *) a. MonadFail m => s a -> m (a, s a)
lview s c
zs of
            Maybe (c, s c)
Nothing -> s d
forall (s :: * -> *) a. Sequence s => s a
empty
            Just (c
z,s c
zs') -> d -> s d -> s d
forall a. a -> s a -> s a
forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons (a -> b -> c -> d
f a
x b
y c
z) ((a -> b -> c -> d) -> s a -> s b -> s c -> s d
forall (s :: * -> *) a b c d.
Sequence s =>
(a -> b -> c -> d) -> s a -> s b -> s c -> s d
zipWith3UsingLview a -> b -> c -> d
f s a
xs' s b
ys' s c
zs')

zipUsingLists :: Sequence s => s a -> s b -> s (a,b)
zipUsingLists :: forall (s :: * -> *) a b. Sequence s => s a -> s b -> s (a, b)
zipUsingLists s a
xs s b
ys = [(a, b)] -> s (a, b)
forall a. [a] -> s a
forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList ([a] -> [b] -> [(a, b)]
forall a b. [a] -> [b] -> [(a, b)]
L.zip (s a -> [a]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
xs) (s b -> [b]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s b
ys))

zip3UsingLists :: Sequence s => s a -> s b -> s c -> s (a,b,c)
zip3UsingLists :: forall (s :: * -> *) a b c.
Sequence s =>
s a -> s b -> s c -> s (a, b, c)
zip3UsingLists s a
xs s b
ys s c
zs =
  [(a, b, c)] -> s (a, b, c)
forall a. [a] -> s a
forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList ([a] -> [b] -> [c] -> [(a, b, c)]
forall a b c. [a] -> [b] -> [c] -> [(a, b, c)]
L.zip3 (s a -> [a]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
xs) (s b -> [b]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s b
ys) (s c -> [c]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s c
zs))

zipWithUsingLists :: Sequence s => (a -> b -> c) -> s a -> s b -> s c
zipWithUsingLists :: forall (s :: * -> *) a b c.
Sequence s =>
(a -> b -> c) -> s a -> s b -> s c
zipWithUsingLists a -> b -> c
f s a
xs s b
ys =
  [c] -> s c
forall a. [a] -> s a
forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList ((a -> b -> c) -> [a] -> [b] -> [c]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
L.zipWith a -> b -> c
f (s a -> [a]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
xs) (s b -> [b]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s b
ys))

zipWith3UsingLists ::
  Sequence s => (a -> b -> c -> d) -> s a -> s b -> s c -> s d
zipWith3UsingLists :: forall (s :: * -> *) a b c d.
Sequence s =>
(a -> b -> c -> d) -> s a -> s b -> s c -> s d
zipWith3UsingLists a -> b -> c -> d
f s a
xs s b
ys s c
zs =
  [d] -> s d
forall a. [a] -> s a
forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList ((a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
forall a b c d. (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
L.zipWith3 a -> b -> c -> d
f (s a -> [a]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
xs) (s b -> [b]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s b
ys) (s c -> [c]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s c
zs))

unzipUsingLists :: Sequence s => s (a,b) -> (s a, s b)
unzipUsingLists :: forall (s :: * -> *) a b. Sequence s => s (a, b) -> (s a, s b)
unzipUsingLists s (a, b)
xys =
  case [(a, b)] -> ([a], [b])
forall a b. [(a, b)] -> ([a], [b])
L.unzip (s (a, b) -> [(a, b)]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s (a, b)
xys) of
    ([a]
xs, [b]
ys) -> ([a] -> s a
forall a. [a] -> s a
forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList [a]
xs, [b] -> s b
forall a. [a] -> s a
forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList [b]
ys)

unzipUsingFoldr :: Sequence s => s (a,b) -> (s a, s b)
unzipUsingFoldr :: forall (s :: * -> *) a b. Sequence s => s (a, b) -> (s a, s b)
unzipUsingFoldr = ((a, b) -> (s a, s b) -> (s a, s b))
-> (s a, s b) -> s (a, b) -> (s a, s b)
forall a b. (a -> b -> b) -> b -> s a -> b
forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
foldr (a, b) -> (s a, s b) -> (s a, s b)
forall {s :: * -> *} {s :: * -> *} {a} {a}.
(Sequence s, Sequence s) =>
(a, a) -> (s a, s a) -> (s a, s a)
pcons (s a
forall (s :: * -> *) a. Sequence s => s a
empty,s b
forall (s :: * -> *) a. Sequence s => s a
empty)
  where pcons :: (a, a) -> (s a, s a) -> (s a, s a)
pcons (a
x,a
y) (s a
xs,s a
ys) = (a -> s a -> s a
forall a. a -> s a -> s a
forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons a
x s a
xs, a -> s a -> s a
forall a. a -> s a -> s a
forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons a
y s a
ys)

unzip3UsingLists :: Sequence s => s (a,b,c) -> (s a, s b, s c)
unzip3UsingLists :: forall (s :: * -> *) a b c.
Sequence s =>
s (a, b, c) -> (s a, s b, s c)
unzip3UsingLists s (a, b, c)
xyzs =
  case [(a, b, c)] -> ([a], [b], [c])
forall a b c. [(a, b, c)] -> ([a], [b], [c])
L.unzip3 (s (a, b, c) -> [(a, b, c)]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s (a, b, c)
xyzs) of
    ([a]
xs, [b]
ys, [c]
zs) -> ([a] -> s a
forall a. [a] -> s a
forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList [a]
xs, [b] -> s b
forall a. [a] -> s a
forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList [b]
ys, [c] -> s c
forall a. [a] -> s a
forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList [c]
zs)

unzip3UsingFoldr :: Sequence s => s (a,b,c) -> (s a, s b, s c)
unzip3UsingFoldr :: forall (s :: * -> *) a b c.
Sequence s =>
s (a, b, c) -> (s a, s b, s c)
unzip3UsingFoldr = ((a, b, c) -> (s a, s b, s c) -> (s a, s b, s c))
-> (s a, s b, s c) -> s (a, b, c) -> (s a, s b, s c)
forall a b. (a -> b -> b) -> b -> s a -> b
forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
foldr (a, b, c) -> (s a, s b, s c) -> (s a, s b, s c)
forall {s :: * -> *} {s :: * -> *} {s :: * -> *} {a} {a} {a}.
(Sequence s, Sequence s, Sequence s) =>
(a, a, a) -> (s a, s a, s a) -> (s a, s a, s a)
tcons (s a
forall (s :: * -> *) a. Sequence s => s a
empty,s b
forall (s :: * -> *) a. Sequence s => s a
empty,s c
forall (s :: * -> *) a. Sequence s => s a
empty)
  where tcons :: (a, a, a) -> (s a, s a, s a) -> (s a, s a, s a)
tcons (a
x,a
y,a
z) (s a
xs,s a
ys,s a
zs) = (a -> s a -> s a
forall a. a -> s a -> s a
forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons a
x s a
xs, a -> s a -> s a
forall a. a -> s a -> s a
forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons a
y s a
ys, a -> s a -> s a
forall a. a -> s a -> s a
forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons a
z s a
zs)

unzipWithUsingLists ::
  Sequence s => (a -> b) -> (a -> c) -> s a -> (s b, s c)
unzipWithUsingLists :: forall (s :: * -> *) a b c.
Sequence s =>
(a -> b) -> (a -> c) -> s a -> (s b, s c)
unzipWithUsingLists a -> b
f a -> c
g s a
xys =
  case (a -> b) -> (a -> c) -> [a] -> ([b], [c])
forall a b c. (a -> b) -> (a -> c) -> [a] -> ([b], [c])
L.unzipWith a -> b
f a -> c
g (s a -> [a]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
xys) of
    ([b]
xs, [c]
ys) -> ([b] -> s b
forall a. [a] -> s a
forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList [b]
xs, [c] -> s c
forall a. [a] -> s a
forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList [c]
ys)

unzipWithUsingFoldr ::
  Sequence s => (a -> b) -> (a -> c) -> s a -> (s b, s c)
unzipWithUsingFoldr :: forall (s :: * -> *) a b c.
Sequence s =>
(a -> b) -> (a -> c) -> s a -> (s b, s c)
unzipWithUsingFoldr a -> b
f a -> c
g = (a -> (s b, s c) -> (s b, s c)) -> (s b, s c) -> s a -> (s b, s c)
forall a b. (a -> b -> b) -> b -> s a -> b
forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
foldr a -> (s b, s c) -> (s b, s c)
forall {s :: * -> *} {s :: * -> *}.
(Sequence s, Sequence s) =>
a -> (s b, s c) -> (s b, s c)
pcons (s b
forall (s :: * -> *) a. Sequence s => s a
empty,s c
forall (s :: * -> *) a. Sequence s => s a
empty)
  where pcons :: a -> (s b, s c) -> (s b, s c)
pcons a
e (s b
xs,s c
ys) = (b -> s b -> s b
forall a. a -> s a -> s a
forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons (a -> b
f a
e) s b
xs, c -> s c -> s c
forall a. a -> s a -> s a
forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons (a -> c
g a
e) s c
ys)

unzipWith3UsingLists ::
  Sequence s => (a -> b) -> (a -> c) -> (a -> d) -> s a -> (s b, s c, s d)
unzipWith3UsingLists :: forall (s :: * -> *) a b c d.
Sequence s =>
(a -> b) -> (a -> c) -> (a -> d) -> s a -> (s b, s c, s d)
unzipWith3UsingLists a -> b
f a -> c
g a -> d
h s a
xyzs =
  case (a -> b) -> (a -> c) -> (a -> d) -> [a] -> ([b], [c], [d])
forall a b c d.
(a -> b) -> (a -> c) -> (a -> d) -> [a] -> ([b], [c], [d])
L.unzipWith3 a -> b
f a -> c
g a -> d
h (s a -> [a]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
xyzs) of
    ([b]
xs, [c]
ys, [d]
zs) -> ([b] -> s b
forall a. [a] -> s a
forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList [b]
xs, [c] -> s c
forall a. [a] -> s a
forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList [c]
ys, [d] -> s d
forall a. [a] -> s a
forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList [d]
zs)

unzipWith3UsingFoldr ::
  Sequence s => (a -> b) -> (a -> c) -> (a -> d) -> s a -> (s b, s c, s d)
unzipWith3UsingFoldr :: forall (s :: * -> *) a b c d.
Sequence s =>
(a -> b) -> (a -> c) -> (a -> d) -> s a -> (s b, s c, s d)
unzipWith3UsingFoldr a -> b
f a -> c
g a -> d
h = (a -> (s b, s c, s d) -> (s b, s c, s d))
-> (s b, s c, s d) -> s a -> (s b, s c, s d)
forall a b. (a -> b -> b) -> b -> s a -> b
forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
foldr a -> (s b, s c, s d) -> (s b, s c, s d)
forall {s :: * -> *} {s :: * -> *} {s :: * -> *}.
(Sequence s, Sequence s, Sequence s) =>
a -> (s b, s c, s d) -> (s b, s c, s d)
tcons (s b
forall (s :: * -> *) a. Sequence s => s a
empty,s c
forall (s :: * -> *) a. Sequence s => s a
empty,s d
forall (s :: * -> *) a. Sequence s => s a
empty)
  where tcons :: a -> (s b, s c, s d) -> (s b, s c, s d)
tcons a
e (s b
xs,s c
ys,s d
zs) = (b -> s b -> s b
forall a. a -> s a -> s a
forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons (a -> b
f a
e) s b
xs, c -> s c -> s c
forall a. a -> s a -> s a
forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons (a -> c
g a
e) s c
ys, d -> s d -> s d
forall a. a -> s a -> s a
forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons (a -> d
h a
e) s d
zs)

showsPrecUsingToList :: (Show a,Sequence s) => Int -> s a -> ShowS
showsPrecUsingToList :: forall a (s :: * -> *).
(Show a, Sequence s) =>
Int -> s a -> String -> String
showsPrecUsingToList Int
i s a
xs String
rest
   | Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0    = [String] -> String
forall a. [[a]] -> [a]
forall (s :: * -> *) a. Sequence s => s (s a) -> s a
concat [    s a -> String
forall a. s a -> String
forall (s :: * -> *) a. Sequence s => s a -> String
instanceName s a
xs,String
".fromList "] String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> [a] -> String -> String
forall a. Show a => Int -> a -> String -> String
showsPrec Int
10 (s a -> [a]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
xs) String
rest
   | Bool
otherwise = [String] -> String
forall a. [[a]] -> [a]
forall (s :: * -> *) a. Sequence s => s (s a) -> s a
concat [String
"(",s a -> String
forall a. s a -> String
forall (s :: * -> *) a. Sequence s => s a -> String
instanceName s a
xs,String
".fromList "] String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> [a] -> String -> String
forall a. Show a => Int -> a -> String -> String
showsPrec Int
10 (s a -> [a]
forall a. s a -> [a]
forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
xs) (Char
')'Char -> String -> String
forall a. a -> [a] -> [a]
:String
rest)

readsPrecUsingFromList :: (Read a,Sequence s) => Int -> ReadS (s a)
readsPrecUsingFromList :: forall a (s :: * -> *). (Read a, Sequence s) => Int -> ReadS (s a)
readsPrecUsingFromList Int
_ String
xs =
   let result :: [(s a, String)]
result = ReadS (s a) -> ReadS (s a)
forall a. ReadS a -> ReadS a
maybeParens ReadS (s a)
p String
xs
       p :: ReadS (s a)
p String
xs = String -> String -> [String]
forall (m :: * -> *). MonadPlus m => String -> String -> m String
tokenMatch ((s a -> String
forall a. s a -> String
forall (s :: * -> *) a. Sequence s => s a -> String
instanceName s a
x)String -> String -> String
forall a. [a] -> [a] -> [a]
++String
".fromList") String
xs
                [String] -> (String -> [([a], String)]) -> [([a], String)]
forall a b. [a] -> (a -> [b]) -> [b]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Int -> String -> [([a], String)]
forall a. Read a => Int -> ReadS a
readsPrec Int
10
                [([a], String)]
-> (([a], String) -> [(s a, String)]) -> [(s a, String)]
forall a b. [a] -> (a -> [b]) -> [b]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([a]
l,String
rest) -> (s a, String) -> [(s a, String)]
forall a. a -> [a]
forall (m :: * -> *) a. Monad m => a -> m a
return ([a] -> s a
forall a. [a] -> s a
forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList [a]
l,String
rest)

       -- play games with the typechecker so we don't have to use
       -- extensions for scoped type variables
       ~[(s a
x,String
_)] = [(s a, String)]
result

   in [(s a, String)]
result

defaultCompare :: (Ord a, Sequence s) => s a -> s a -> Ordering
defaultCompare :: forall a (s :: * -> *).
(Ord a, Sequence s) =>
s a -> s a -> Ordering
defaultCompare s a
a s a
b =
   case (s a -> Maybe (a, s a)
forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
forall (m :: * -> *) a. MonadFail m => s a -> m (a, s a)
lview s a
a, s a -> Maybe (a, s a)
forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
forall (m :: * -> *) a. MonadFail m => s a -> m (a, s a)
lview s a
b) of
     (Maybe (a, s a)
Nothing, Maybe (a, s a)
Nothing) -> Ordering
EQ
     (Maybe (a, s a)
Nothing, Maybe (a, s a)
_      ) -> Ordering
LT
     (Maybe (a, s a)
_      , Maybe (a, s a)
Nothing) -> Ordering
GT
     (Just (a
x,s a
xs), Just (a
y,s a
ys)) ->
        case a -> a -> Ordering
forall a. Ord a => a -> a -> Ordering
compare a
x a
y of
           Ordering
EQ -> s a -> s a -> Ordering
forall a (s :: * -> *).
(Ord a, Sequence s) =>
s a -> s a -> Ordering
defaultCompare s a
xs s a
ys
           Ordering
c -> Ordering
c


dropMatch :: (Eq a,MonadPlus m) => [a] -> [a] -> m [a]
dropMatch :: forall a (m :: * -> *). (Eq a, MonadPlus m) => [a] -> [a] -> m [a]
dropMatch [] [a]
ys = [a] -> m [a]
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return [a]
ys
dropMatch (a
x:[a]
xs) (a
y:[a]
ys)
    | a
x a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
y    = [a] -> [a] -> m [a]
forall a (m :: * -> *). (Eq a, MonadPlus m) => [a] -> [a] -> m [a]
dropMatch [a]
xs [a]
ys
    | Bool
otherwise = m [a]
forall a. m a
forall (m :: * -> *) a. MonadPlus m => m a
mzero
dropMatch [a]
_ [a]
_   = m [a]
forall a. m a
forall (m :: * -> *) a. MonadPlus m => m a
mzero

tokenMatch :: MonadPlus m => String -> String -> m String
tokenMatch :: forall (m :: * -> *). MonadPlus m => String -> String -> m String
tokenMatch String
token String
str = String -> String -> m String
forall a (m :: * -> *). (Eq a, MonadPlus m) => [a] -> [a] -> m [a]
dropMatch String
token (String -> String
munch String
str) m String -> (String -> m String) -> m String
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= String -> m String
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> m String) -> (String -> String) -> String -> m String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> String
munch
   where munch :: String -> String
munch = (Char -> Bool) -> String -> String
forall a. (a -> Bool) -> [a] -> [a]
forall (s :: * -> *) a. Sequence s => (a -> Bool) -> s a -> s a
dropWhile Char -> Bool
isSpace

readSParens :: ReadS a -> ReadS a
readSParens :: forall a. ReadS a -> ReadS a
readSParens ReadS a
p String
xs = String -> [String]
forall a. a -> [a]
forall (m :: * -> *) a. Monad m => a -> m a
return String
xs
     [String] -> (String -> [String]) -> [String]
forall a b. [a] -> (a -> [b]) -> [b]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= String -> String -> [String]
forall (m :: * -> *). MonadPlus m => String -> String -> m String
tokenMatch String
"("
     [String] -> ReadS a -> [(a, String)]
forall a b. [a] -> (a -> [b]) -> [b]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ReadS a
p
     [(a, String)] -> ((a, String) -> [(a, String)]) -> [(a, String)]
forall a b. [a] -> (a -> [b]) -> [b]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \(a
x,String
xs') -> String -> [String]
forall a. a -> [a]
forall (m :: * -> *) a. Monad m => a -> m a
return String
xs'
     [String] -> (String -> [String]) -> [String]
forall a b. [a] -> (a -> [b]) -> [b]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= String -> String -> [String]
forall (m :: * -> *). MonadPlus m => String -> String -> m String
tokenMatch String
")"
     [String] -> ReadS a -> [(a, String)]
forall a b. [a] -> (a -> [b]) -> [b]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \String
rest -> (a, String) -> [(a, String)]
forall a. a -> [a]
forall (m :: * -> *) a. Monad m => a -> m a
return (a
x,String
rest)

maybeParens :: ReadS a -> ReadS a
maybeParens :: forall a. ReadS a -> ReadS a
maybeParens ReadS a
p String
xs = ReadS a -> ReadS a
forall a. ReadS a -> ReadS a
readSParens ReadS a
p String
xs [(a, String)] -> [(a, String)] -> [(a, String)]
forall a. [a] -> [a] -> [a]
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus` ReadS a
p String
xs