-- |
--   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,
                       filter,takeWhile,dropWhile,lookup,take,drop,splitAt,
                       zip,zip3,zipWith,zipWith3,unzip,unzip3,null)

import qualified Control.Monad.Fail as Fail
import Control.Monad.Identity
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 = forall (s :: * -> *) a. Sequence s => s a -> s a -> s a
append s a
s (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 = forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
foldr forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons (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 | forall (s :: * -> *) a. Sequence s => s a -> Bool
null s a
t = s a
s
                            | Bool
otherwise = forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
foldr 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
  | forall (s :: * -> *) a. Sequence s => s a -> Bool
null s a
xs   = forall (m :: * -> *) a. MonadFail m => String -> m a
fail forall a b. (a -> b) -> a -> b
$ forall (s :: * -> *) a. Sequence s => s a -> String
instanceName s a
xs forall a. [a] -> [a] -> [a]
++ String
".rview: empty sequence"
  | Bool
otherwise = forall (m :: * -> *) a. Monad m => a -> m a
return (forall (s :: * -> *) a. Sequence s => s a -> a
rhead s a
xs, 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 forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
lview s a
xs of
      Maybe (a, s a)
Nothing      -> forall a. HasCallStack => String -> a
error forall a b. (a -> b) -> a -> b
$ forall (s :: * -> *) a. Sequence s => s a -> String
instanceName s a
xs forall a. [a] -> [a] -> [a]
++ String
".rtail: empty sequence"
      Just (a
x, s a
xs) -> 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 forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
lview s t
xs of
            Maybe (t, s t)
Nothing      -> forall (s :: * -> *) a. Sequence s => s a
empty
            Just (t
y, s t
ys) -> 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 forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
lview s a
xs of
      Maybe (a, s a)
Nothing      -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail forall a b. (a -> b) -> a -> b
$ forall (s :: * -> *) a. Sequence s => s a -> String
instanceName s a
xs forall a. [a] -> [a] -> [a]
++ String
".rtailM: empty sequence"
      Just (a
x, s a
xs) -> forall (m :: * -> *) a. Monad m => a -> m a
return (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 forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
lview s t
xs of
            Maybe (t, s t)
Nothing      -> forall (s :: * -> *) a. Sequence s => s a
empty
            Just (t
y, s t
ys) -> 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 = forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
foldr forall (s :: * -> *) a. Sequence s => s a -> s a -> s a
append 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 = forall (s :: * -> *) a. Sequence s => s a -> s a -> s a
reverseOnto s a
s 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 = forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> [a]
L.reverse forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 = forall (s :: * -> *) b a.
Sequence s =>
(b -> a -> b) -> b -> s a -> b
foldl (forall a b c. (a -> b -> c) -> b -> a -> c
flip 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 = forall (s :: * -> *) a. Sequence s => s a -> s a -> s a
append forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 = forall a b. (a -> b -> b) -> b -> [a] -> b
L.foldr forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons forall (s :: * -> *) a. Sequence s => s a
empty

toListUsingFoldr :: Sequence s => s a -> [a]
toListUsingFoldr :: forall (s :: * -> *) a. Sequence s => s a -> [a]
toListUsingFoldr = 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 = forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
foldr (forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> b
f) 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 = forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
foldr (forall (s :: * -> *) a. Sequence s => s a -> s a -> s a
append forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> s b
f) 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 = forall a b. (a -> b -> b) -> b -> [a] -> b
L.foldr a -> b -> b
f b
e (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 = forall a b. (a -> b -> b) -> b -> [a] -> b
L.foldr' a -> b -> b
f b
e (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 = forall b a. (b -> a -> b) -> b -> [a] -> b
L.foldl b -> a -> b
f b
e (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 = forall b a. (b -> a -> b) -> b -> [a] -> b
L.foldl' b -> a -> b
f b
e (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 = forall a. (a -> a -> a) -> [a] -> a
L.foldr1 a -> a -> a
f (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 = forall a. (a -> a -> a) -> [a] -> a
L.foldr1' a -> a -> a
f (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 = forall a. (a -> a -> a) -> [a] -> a
L.foldl1 a -> a -> a
f (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 = forall a. (a -> a -> a) -> [a] -> a
L.foldl1' a -> a -> a
f (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 forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
lview s a
xs of
      Maybe (a, s a)
Nothing      -> forall a. HasCallStack => String -> a
error forall a b. (a -> b) -> a -> b
$ forall (s :: * -> *) a. Sequence s => s a -> String
instanceName s a
xs forall a. [a] -> [a] -> [a]
++ String
".fold1: empty sequence"
      Just (a
x, s a
xs) -> 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 forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
lview s a
xs of
      Maybe (a, s a)
Nothing      -> forall a. HasCallStack => String -> a
error forall a b. (a -> b) -> a -> b
$ forall (s :: * -> *) a. Sequence s => s a -> String
instanceName s a
xs forall a. [a] -> [a] -> [a]
++ String
".fold1': empty sequence"
      Just (a
x, s a
xs) -> 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 forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
lview s a
xs of
      Maybe (a, s a)
Nothing      -> forall a. HasCallStack => String -> a
error forall a b. (a -> b) -> a -> b
$ forall (s :: * -> *) a. Sequence s => s a -> String
instanceName s a
xs forall a. [a] -> [a] -> [a]
++ String
".foldr1: empty sequence"
      Just (a
x, s a
xs) -> 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 forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, 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 forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
lview s a
xs of
        Maybe (a, s a)
Nothing     -> forall a. HasCallStack => String -> a
error forall a b. (a -> b) -> a -> b
$ forall (s :: * -> *) a. Sequence s => s a -> String
instanceName s a
xs forall a. [a] -> [a] -> [a]
++ String
".foldr1': empty sequence"
        Just (a
x,s a
xs) -> 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 forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, 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 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 forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
lview s a
xs of
      Maybe (a, s a)
Nothing     -> forall a. HasCallStack => String -> a
error forall a b. (a -> b) -> a -> b
$ forall (s :: * -> *) a. Sequence s => s a -> String
instanceName s a
xs forall a. [a] -> [a] -> [a]
++ String
".foldl1: empty sequence"
      Just (a
x,s a
xs) -> 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 forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
lview s a
xs of
      Maybe (a, s a)
Nothing     -> forall a. HasCallStack => String -> a
error forall a b. (a -> b) -> a -> b
$ forall (s :: * -> *) a. Sequence s => s a -> String
instanceName s a
xs forall a. [a] -> [a] -> [a]
++ String
".foldl1': empty sequence"
      Just (a
x,s a
xs) -> 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
  | forall (s :: * -> *) a. Sequence s => s a -> Bool
null s a
s = a
e
  | Bool
otherwise = a -> a -> a
f (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
  | forall (s :: * -> *) a. Sequence s => s a -> Bool
null s a
s = a
e
  | Bool
otherwise = a -> a -> a
f (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
  | forall (s :: * -> *) a. Sequence s => s a -> Bool
null s a
s = a
e
  | Bool
otherwise = a -> a -> a
f a
e (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
  | forall (s :: * -> *) a. Sequence s => s a -> Bool
null s a
s = a
e
  | Bool
otherwise = a -> a -> a
f a
e (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 = forall a. (a -> a -> a) -> [a] -> a
L.reduce1 a -> a -> a
f (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 = forall a. (a -> a -> a) -> [a] -> a
L.reduce1' a -> a -> a
f (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 = forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList (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 forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Bool -> Bool
not (forall (s :: * -> *) a. Sequence s => s a -> Bool
null (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 forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, 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 forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
i forall a. Ord a => a -> a -> Bool
< 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 = forall a. Fail a -> a
runFail_ (forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, 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 forall a. Ord a => a -> a -> Bool
< Int
0 Bool -> Bool -> Bool
|| forall (s :: * -> *) a. Sequence s => s a -> Bool
null s a
s' = forall a. HasCallStack => String -> a
error forall a b. (a -> b) -> a -> b
$ forall (s :: * -> *) a. Sequence s => s a -> String
instanceName s a
s forall a. [a] -> [a] -> [a]
++ String
".lookup: bad subscript"
  | Bool
otherwise = forall (s :: * -> *) a. Sequence s => s a -> a
lhead s a
s'
  where s' :: s a
s' = 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 forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, 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 forall a. Ord a => a -> a -> Bool
< Int
0 Bool -> Bool -> Bool
|| forall (s :: * -> *) a. Sequence s => s a -> Bool
null s a
s' = a
d
  | Bool
otherwise = forall (s :: * -> *) a. Sequence s => s a -> a
lhead s a
s'
  where s' :: s a
s' = 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 forall a. Ord a => a -> a -> Bool
< Int
0 Bool -> Bool -> Bool
|| forall (s :: * -> *) a. Sequence s => s a -> Bool
null s a
s' = forall (m :: * -> *) a. MonadFail m => String -> m a
fail forall a b. (a -> b) -> a -> b
$ forall (s :: * -> *) a. Sequence s => s a -> String
instanceName s a
s
                        forall a. [a] -> [a] -> [a]
++ String
".lookupMUsingDrop: empty sequence"
  | Bool
otherwise        = forall (m :: * -> *) a. Monad m => a -> m a
return (forall (s :: * -> *) a. Sequence s => s a -> a
lhead s a
s')
  where s' :: s a
s' = 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 forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
lview s a
xs of
    Maybe (a, s a)
Nothing     -> forall (s :: * -> *) a. Sequence s => s a
empty
    Just (a
x,s a
xs) -> if a -> Bool
p a
x then forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons a
x (forall (s :: * -> *) a. Sequence s => (a -> Bool) -> s a -> s a
filter a -> Bool
p s a
xs) else 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 =
  forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList (forall a. (a -> Bool) -> [a] -> [a]
L.filter a -> Bool
p (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 = forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
foldr forall {s :: * -> *}. Sequence s => a -> s a -> s a
pcons 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 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) = forall a. (a -> Bool) -> [a] -> ([a], [a])
L.partition a -> Bool
p (forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
xs)
  in (forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList [a]
ys, 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 = forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
foldr forall {s :: * -> *} {s :: * -> *}.
(Sequence s, Sequence s) =>
a -> (s a, s a) -> (s a, s a)
pcons (forall (s :: * -> *) a. Sequence s => s a
empty, 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 (forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons a
x s a
xs, s a
xs') else (s a
xs, 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 = forall (s :: * -> *) a. Sequence s => (a -> a) -> Int -> s a -> s a
adjust (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 forall a. Ord a => a -> a -> Bool
< Int
0 = s a
xs
  | Bool
otherwise = let (s a
ys,s a
zs) = forall (s :: * -> *) a. Sequence s => Int -> s a -> (s a, s a)
splitAt Int
i s a
xs
                in if forall (s :: * -> *) a. Sequence s => s a -> Bool
null s a
zs then s a
xs else forall (s :: * -> *) a. Sequence s => s a -> s a -> s a
append s a
ys (forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons a
x (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 = forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList (forall a. (a -> a) -> Int -> [a] -> [a]
L.adjust a -> a
f Int
i (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 forall a. Ord a => a -> a -> Bool
< Int
0 = s a
xs
  | Bool
otherwise = let (s a
ys,s a
zs) = forall (s :: * -> *) a. Sequence s => Int -> s a -> (s a, s a)
splitAt Int
i s a
xs
                in case forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, 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') -> forall (s :: * -> *) a. Sequence s => s a -> s a -> s a
append s a
ys (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 = forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList (forall a b. (Int -> a -> b) -> [a] -> [b]
L.mapWithIndex Int -> a -> b
f (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 = forall a b. (Int -> a -> b -> b) -> b -> [a] -> b
L.foldrWithIndex Int -> a -> b -> b
f b
e (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 = forall {t1} {t2} {a}.
(Num t1, Enum t1) =>
(t1 -> t2 -> a -> a) -> a -> [t2] -> a
L.foldrWithIndex' Int -> a -> b -> b
f b
e (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 = forall b a. (b -> Int -> a -> b) -> b -> [a] -> b
L.foldlWithIndex b -> Int -> a -> b
f b
e (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 = forall b a. (b -> Int -> a -> b) -> b -> [a] -> b
L.foldlWithIndex' b -> Int -> a -> b
f b
e (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 = forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList (forall a. Int -> [a] -> [a]
L.take Int
i (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 forall a. Ord a => a -> a -> Bool
<= Int
0 = forall (s :: * -> *) a. Sequence s => s a
empty
  | Bool
otherwise = case forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
lview s a
xs of
                  Maybe (a, s a)
Nothing -> forall (s :: * -> *) a. Sequence s => s a
empty
                  Just (a
x,s a
xs') -> forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons a
x (forall (s :: * -> *) a. Sequence s => Int -> s a -> s a
take (Int
iforall 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 = forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList (forall a. Int -> [a] -> [a]
L.drop Int
i (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 forall a. Ord a => a -> a -> Bool
<= Int
0 Bool -> Bool -> Bool
|| forall (s :: * -> *) a. Sequence s => s a -> Bool
null s a
xs = s a
xs
  | Bool
otherwise = forall (s :: * -> *) a. Sequence s => Int -> s a -> s a
dropUsingLtail (Int
iforall a. Num a => a -> a -> a
-Int
1) (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 = (forall (s :: * -> *) a. Sequence s => Int -> s a -> s a
take Int
i s a
s, 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 forall a. Ord a => a -> a -> Bool
<= Int
0 = (forall (s :: * -> *) a. Sequence s => s a
empty,s a
xs)
  | Bool
otherwise = case forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
lview s a
xs of
                  Maybe (a, s a)
Nothing      -> (forall (s :: * -> *) a. Sequence s => s a
empty,forall (s :: * -> *) a. Sequence s => s a
empty)
                  Just (a
x,s a
xs') -> (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) = forall (s :: * -> *) a. Sequence s => Int -> s a -> (s a, s a)
splitAtUsingLview (Int
iforall 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 = forall (s :: * -> *) a. Sequence s => Int -> s a -> s a
take Int
len (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 forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
lview s a
xs of
    Just (a
x,s a
xs') | a -> Bool
p a
x -> forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons a
x (forall (s :: * -> *) a. Sequence s => (a -> Bool) -> s a -> s a
takeWhileUsingLview a -> Bool
p s a
xs')
    Maybe (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 forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
lview s a
xs of
    Just (a
x,s a
xs') | a -> Bool
p a
x -> 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 forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, 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) = forall (s :: * -> *) a.
Sequence s =>
(a -> Bool) -> s a -> (s a, s a)
splitWhileUsingLview a -> Bool
p s a
xs'
                          in (forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons a
x s a
front, s a
back)
    Maybe (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 forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
lview s a
xs of
    Maybe (a, s a)
Nothing -> forall (s :: * -> *) a. Sequence s => s a
empty
    Just (a
x,s a
xs') ->
      case forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
lview s b
ys of
        Maybe (b, s b)
Nothing -> forall (s :: * -> *) a. Sequence s => s a
empty
        Just (b
y,s b
ys') -> forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons (a
x,b
y) (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 forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
lview s a
xs of
    Maybe (a, s a)
Nothing -> forall (s :: * -> *) a. Sequence s => s a
empty
    Just (a
x,s a
xs') ->
      case forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
lview s b
ys of
        Maybe (b, s b)
Nothing -> forall (s :: * -> *) a. Sequence s => s a
empty
        Just (b
y,s b
ys') ->
          case forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
lview s c
zs of
            Maybe (c, s c)
Nothing -> forall (s :: * -> *) a. Sequence s => s a
empty
            Just (c
z,s c
zs') -> forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons (a
x,b
y,c
z) (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 forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
lview s a
xs of
    Maybe (a, s a)
Nothing -> forall (s :: * -> *) a. Sequence s => s a
empty
    Just (a
x,s a
xs') ->
      case forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
lview s b
ys of
        Maybe (b, s b)
Nothing -> forall (s :: * -> *) a. Sequence s => s a
empty
        Just (b
y,s b
ys') -> forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons (a -> b -> c
f a
x b
y) (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 forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
lview s a
xs of
    Maybe (a, s a)
Nothing -> forall (s :: * -> *) a. Sequence s => s a
empty
    Just (a
x,s a
xs') ->
      case forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
lview s b
ys of
        Maybe (b, s b)
Nothing -> forall (s :: * -> *) a. Sequence s => s a
empty
        Just (b
y,s b
ys') ->
          case forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
lview s c
zs of
            Maybe (c, s c)
Nothing -> forall (s :: * -> *) a. Sequence s => s a
empty
            Just (c
z,s c
zs') -> forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons (a -> b -> c -> d
f a
x b
y c
z) (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 = forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList (forall a b. [a] -> [b] -> [(a, b)]
L.zip (forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
xs) (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 =
  forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList (forall a b c. [a] -> [b] -> [c] -> [(a, b, c)]
L.zip3 (forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
xs) (forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s b
ys) (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 =
  forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList (forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
L.zipWith a -> b -> c
f (forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
xs) (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 =
  forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList (forall a b c d. (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
L.zipWith3 a -> b -> c -> d
f (forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
xs) (forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s b
ys) (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 forall a b. [(a, b)] -> ([a], [b])
L.unzip (forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s (a, b)
xys) of
    ([a]
xs, [b]
ys) -> (forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList [a]
xs, 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 = forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
foldr forall {s :: * -> *} {s :: * -> *} {a} {a}.
(Sequence s, Sequence s) =>
(a, a) -> (s a, s a) -> (s a, s a)
pcons (forall (s :: * -> *) a. Sequence s => s a
empty,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) = (forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons a
x s a
xs, 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 forall a b c. [(a, b, c)] -> ([a], [b], [c])
L.unzip3 (forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s (a, b, c)
xyzs) of
    ([a]
xs, [b]
ys, [c]
zs) -> (forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList [a]
xs, forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList [b]
ys, 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 = forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
foldr 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 (forall (s :: * -> *) a. Sequence s => s a
empty,forall (s :: * -> *) a. Sequence s => s a
empty,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) = (forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons a
x s a
xs, forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons a
y s a
ys, 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 forall a b c. (a -> b) -> (a -> c) -> [a] -> ([b], [c])
L.unzipWith a -> b
f a -> c
g (forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
xys) of
    ([b]
xs, [c]
ys) -> (forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList [b]
xs, 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 = forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
foldr forall {s :: * -> *} {s :: * -> *}.
(Sequence s, Sequence s) =>
a -> (s b, s c) -> (s b, s c)
pcons (forall (s :: * -> *) a. Sequence s => s a
empty,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) = (forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons (a -> b
f a
e) s b
xs, 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 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 (forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
xyzs) of
    ([b]
xs, [c]
ys, [d]
zs) -> (forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList [b]
xs, forall (s :: * -> *) a. Sequence s => [a] -> s a
fromList [c]
ys, 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 = forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
foldr forall {s :: * -> *} {s :: * -> *} {s :: * -> *}.
(Sequence s, Sequence s, Sequence s) =>
a -> (s b, s c, s d) -> (s b, s c, s d)
tcons (forall (s :: * -> *) a. Sequence s => s a
empty,forall (s :: * -> *) a. Sequence s => s a
empty,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) = (forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons (a -> b
f a
e) s b
xs, forall (s :: * -> *) a. Sequence s => a -> s a -> s a
lcons (a -> c
g a
e) s c
ys, 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 -> ShowS
showsPrecUsingToList Int
i s a
xs String
rest
   | Int
i forall a. Eq a => a -> a -> Bool
== Int
0    = forall (s :: * -> *) a. Sequence s => s (s a) -> s a
concat [    forall (s :: * -> *) a. Sequence s => s a -> String
instanceName s a
xs,String
".fromList "] forall a. [a] -> [a] -> [a]
++ forall a. Show a => Int -> a -> ShowS
showsPrec Int
10 (forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
xs) String
rest
   | Bool
otherwise = forall (s :: * -> *) a. Sequence s => s (s a) -> s a
concat [String
"(",forall (s :: * -> *) a. Sequence s => s a -> String
instanceName s a
xs,String
".fromList "] forall a. [a] -> [a] -> [a]
++ forall a. Show a => Int -> a -> ShowS
showsPrec Int
10 (forall (s :: * -> *) a. Sequence s => s a -> [a]
toList s a
xs) (Char
')'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 = forall a. ReadS a -> ReadS a
maybeParens ReadS (s a)
p String
xs
       p :: ReadS (s a)
p String
xs = forall (m :: * -> *). MonadPlus m => String -> String -> m String
tokenMatch ((forall (s :: * -> *) a. Sequence s => s a -> String
instanceName s a
x)forall a. [a] -> [a] -> [a]
++String
".fromList") 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
>>= \([a]
l,String
rest) -> forall (m :: * -> *) a. Monad m => a -> m a
return (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 (forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, MonadFail m) =>
s a -> m (a, s a)
lview s a
a, forall (s :: * -> *) (m :: * -> *) a.
(Sequence s, 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 forall a. Ord a => a -> a -> Ordering
compare a
x a
y of
           Ordering
EQ -> 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 = forall (m :: * -> *) a. Monad m => a -> m a
return [a]
ys
dropMatch (a
x:[a]
xs) (a
y:[a]
ys)
    | a
x forall a. Eq a => a -> a -> Bool
== a
y    = forall a (m :: * -> *). (Eq a, MonadPlus m) => [a] -> [a] -> m [a]
dropMatch [a]
xs [a]
ys
    | Bool
otherwise = forall (m :: * -> *) a. MonadPlus m => m a
mzero
dropMatch [a]
_ [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 = forall a (m :: * -> *). (Eq a, MonadPlus m) => [a] -> [a] -> m [a]
dropMatch String
token (ShowS
munch String
str) forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShowS
munch
   where munch :: ShowS
munch = 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 = forall (m :: * -> *) a. Monad m => a -> m a
return String
xs
     forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). MonadPlus m => String -> String -> m String
tokenMatch String
"("
     forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ReadS a
p
     forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \(a
x,String
xs') -> forall (m :: * -> *) a. Monad m => a -> m a
return String
xs'
     forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). MonadPlus m => String -> String -> m String
tokenMatch String
")"
     forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \String
rest -> 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 = forall a. ReadS a -> ReadS a
readSParens ReadS a
p String
xs forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus` ReadS a
p String
xs