{- |
Copyright   :  (c) Henning Thielemann 2007-2009

Maintainer  :  haskell@henning-thielemann.de
Stability   :  stable
Portability :  Haskell 98

Functions that combine both data types,
'Data.AlternatingList.List.Disparate.T' and
'Data.AlternatingList.List.Uniform.T'
-}
module Data.AlternatingList.List.Mixed (
    consFirst, consSecond, (./), (/.),
    snocFirst, snocSecond,
    viewL, viewFirstL, viewSecondL,
    viewR, viewFirstR, viewSecondR,
    switchL, switchFirstL, switchSecondL,
    switchR, switchFirstR, switchSecondR,
    mapFirstL,  mapFirstHead,  mapFirstTail,
    mapSecondL, mapSecondHead, mapSecondTail,
    mapFirstR,  mapFirstLast,  mapFirstInit,
    mapSecondR, mapSecondLast, mapSecondInit,
    appendUniformUniform, appendDisparateUniform, appendUniformDisparate,
    concatUniform, concatDisparate,
    reverseUniform, reverseDisparate,
    splitAtDisparateUniform, splitAtUniformDisparate, splitAtUniformUniform,
    takeDisparate, takeUniform, dropDisparate, dropUniform,
    {- spanFirst, spanSecond, spanDisparate, -}
   ) where


import qualified Data.AlternatingList.List.Disparate as Disp
import qualified Data.AlternatingList.List.Uniform as Uniform

import Data.AlternatingList.List.Uniform (mapSecondHead)

import qualified Control.Monad as Monad

import Data.Tuple.HT (mapFst, mapSnd, mapPair, )

import Prelude hiding
   (null, foldr, map, concat, sequence, sequence_, )


infixr 5 ./, /.

(/.) :: a -> Uniform.T a b -> Disp.T a b
/. :: forall a b. a -> T a b -> T a b
(/.) = forall a b. a -> T a b -> T a b
consFirst

(./) :: b -> Disp.T a b -> Uniform.T a b
./ :: forall b a. b -> T a b -> T a b
(./) = forall b a. b -> T a b -> T a b
consSecond


consFirst :: a -> Uniform.T a b -> Disp.T a b
consFirst :: forall a b. a -> T a b -> T a b
consFirst a
a ~(Uniform.Cons b
b T a b
xs) = forall a b. a -> b -> T a b -> T a b
Disp.cons a
a b
b T a b
xs

consSecond :: b -> Disp.T a b -> Uniform.T a b
consSecond :: forall b a. b -> T a b -> T a b
consSecond = forall a b. b -> T a b -> T a b
Uniform.Cons


snocFirst :: Uniform.T a b -> a -> Disp.T b a
snocFirst :: forall a b. T a b -> a -> T b a
snocFirst T a b
xs = forall a b. T a b -> T b a -> T b a
appendUniformUniform T a b
xs forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall b a. b -> T a b
Uniform.singleton
-- snocFirst xs a = Uniform.foldr consSecond consFirst (Uniform.singleton a) xs

snocSecond :: Disp.T b a -> b -> Uniform.T a b
snocSecond :: forall b a. T b a -> b -> T a b
snocSecond T b a
xs = forall b a. T b a -> T a b -> T a b
appendDisparateUniform T b a
xs forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall b a. b -> T a b
Uniform.singleton
-- snocSecond xs b = Disp.foldr consSecond consFirst (Uniform.singleton b) xs


viewL :: Uniform.T a b -> (b, Maybe (a, Uniform.T a b))
viewL :: forall a b. T a b -> (b, Maybe (a, T a b))
viewL = forall b c a. (b -> c) -> (a, b) -> (a, c)
mapSnd forall a b. T a b -> Maybe (a, T a b)
viewFirstL forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. T a b -> (b, T a b)
viewSecondL

viewFirstL :: Disp.T a b -> Maybe (a, Uniform.T a b)
viewFirstL :: forall a b. T a b -> Maybe (a, T a b)
viewFirstL =
   forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
Monad.liftM (\((a
a,b
b), T a b
xs) -> (a
a, forall b a. b -> T a b -> T a b
consSecond b
b T a b
xs)) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. T a b -> Maybe ((a, b), T a b)
Disp.viewL

viewSecondL :: Uniform.T a b -> (b, Disp.T a b)
viewSecondL :: forall a b. T a b -> (b, T a b)
viewSecondL (Uniform.Cons b
b T a b
xs) = (b
b,T a b
xs)


viewR :: Uniform.T a b -> (Maybe (Uniform.T a b, a), b)
viewR :: forall a b. T a b -> (Maybe (T a b, a), b)
viewR (Uniform.Cons b
b0 T a b
xs0) =
   forall c a b. c -> (T a b -> a -> b -> c) -> T a b -> c
Disp.switchR
      (forall a. Maybe a
Nothing, b
b0)
      (\ T a b
xs a
a b
b -> (forall a. a -> Maybe a
Just (forall b a. b -> T a b -> T a b
consSecond b
b0 T a b
xs, a
a), b
b))
      T a b
xs0

viewFirstR :: Disp.T b a -> Maybe (Uniform.T a b, a)
viewFirstR :: forall b a. T b a -> Maybe (T a b, a)
viewFirstR =
   forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
Monad.liftM (\ (T b a
xs, ~(b
a,a
b)) -> (forall b a. T b a -> b -> T a b
snocSecond T b a
xs b
a, a
b)) forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   forall a b. T a b -> Maybe (T a b, (a, b))
Disp.viewR

{-
TODO:
Must be more lazy in case of
@viewSecondR (2 /. 'a' ./ 3 /. 'b' ./ 4 /. undefined)@.
It must also return the @'b'@ but it does not.
-}
viewSecondR :: Uniform.T a b -> (Disp.T b a, b)
viewSecondR :: forall a b. T a b -> (T b a, b)
viewSecondR (Uniform.Cons b
b0 T a b
xs0) =
   forall c a b. c -> (T a b -> a -> b -> c) -> T a b -> c
Disp.switchR
      (forall a b. T a b
Disp.empty, b
b0)
      (\ T a b
xs a
a b
b -> (forall a b. a -> T a b -> T a b
consFirst b
b0 (forall b a. T b a -> b -> T a b
snocSecond T a b
xs a
a), b
b))
      T a b
xs0


{-# INLINE switchL #-}
switchL :: (b -> c) -> (b -> a -> Uniform.T a b -> c) -> Uniform.T a b -> c
switchL :: forall b c a. (b -> c) -> (b -> a -> T a b -> c) -> T a b -> c
switchL b -> c
f b -> a -> T a b -> c
g =
   forall b a c. (b -> T a b -> c) -> T a b -> c
switchSecondL (\b
x -> forall c a b. c -> (a -> T a b -> c) -> T a b -> c
switchFirstL (b -> c
f b
x) (b -> a -> T a b -> c
g b
x))

{-# INLINE switchFirstL #-}
switchFirstL :: c -> (a -> Uniform.T a b -> c) -> Disp.T a b -> c
switchFirstL :: forall c a b. c -> (a -> T a b -> c) -> T a b -> c
switchFirstL c
f a -> T a b -> c
g =
   forall c a b. c -> (a -> b -> T a b -> c) -> T a b -> c
Disp.switchL c
f (\ a
a b
b T a b
xs -> a -> T a b -> c
g a
a (forall b a. b -> T a b -> T a b
consSecond b
b T a b
xs))

{-# INLINE switchSecondL #-}
switchSecondL :: (b -> Disp.T a b -> c) -> Uniform.T a b -> c
switchSecondL :: forall b a c. (b -> T a b -> c) -> T a b -> c
switchSecondL b -> T a b -> c
f (Uniform.Cons b
b T a b
xs) = b -> T a b -> c
f b
b T a b
xs
{-
The lazy pattern match leads to a space leak in synthesizer-alsa:testArrangeSpaceLeak
I would like to reproduce this in a small test,
but I did not achieve this so far.
-}
-- switchSecondL f ~(Uniform.Cons b xs) = f b xs


{-# INLINE switchR #-}
switchR :: (b -> c) -> (Uniform.T a b -> a -> b -> c) -> Uniform.T a b -> c
switchR :: forall b c a. (b -> c) -> (T a b -> a -> b -> c) -> T a b -> c
switchR b -> c
f T a b -> a -> b -> c
g =
   forall b a c. (T b a -> b -> c) -> T a b -> c
switchSecondR (\T b a
xs b
b -> forall c a b. c -> (T a b -> a -> c) -> T b a -> c
switchFirstR (b -> c
f b
b) (\T a b
ys a
a -> T a b -> a -> b -> c
g T a b
ys a
a b
b) T b a
xs)

{-# INLINE switchFirstR #-}
switchFirstR :: c -> (Uniform.T a b -> a -> c) -> Disp.T b a -> c
switchFirstR :: forall c a b. c -> (T a b -> a -> c) -> T b a -> c
switchFirstR c
f T a b -> a -> c
g =
   forall b a. b -> (a -> b) -> Maybe a -> b
maybe c
f (forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry T a b -> a -> c
g) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall b a. T b a -> Maybe (T a b, a)
viewFirstR

{-# INLINE switchSecondR #-}
switchSecondR :: (Disp.T b a -> b -> c) -> Uniform.T a b -> c
switchSecondR :: forall b a c. (T b a -> b -> c) -> T a b -> c
switchSecondR T b a -> b -> c
f = forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry T b a -> b -> c
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. T a b -> (T b a, b)
viewSecondR


-- could also be in ListDisparate
mapFirstL ::
   (a -> a, Uniform.T a b0 -> Uniform.T a b1) ->
   Disp.T a b0 -> Disp.T a b1
mapFirstL :: forall a b0 b1. (a -> a, T a b0 -> T a b1) -> T a b0 -> T a b1
mapFirstL (a -> a, T a b0 -> T a b1)
f =
   forall b a. b -> (a -> b) -> Maybe a -> b
maybe forall a b. T a b
Disp.empty (forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry forall a b. a -> T a b -> T a b
consFirst forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a c b d. (a -> c, b -> d) -> (a, b) -> (c, d)
mapPair (a -> a, T a b0 -> T a b1)
f) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. T a b -> Maybe (a, T a b)
viewFirstL

mapFirstHead ::
   (a -> a) ->
   Disp.T a b -> Disp.T a b
mapFirstHead :: forall a b. (a -> a) -> T a b -> T a b
mapFirstHead a -> a
f = forall a b0 b1. (a -> a, T a b0 -> T a b1) -> T a b0 -> T a b1
mapFirstL (a -> a
f,forall a. a -> a
id)

mapFirstTail ::
   (Uniform.T a b0 -> Uniform.T a b1) ->
   Disp.T a b0 -> Disp.T a b1
mapFirstTail :: forall a b0 b1. (T a b0 -> T a b1) -> T a b0 -> T a b1
mapFirstTail T a b0 -> T a b1
f = forall a b0 b1. (a -> a, T a b0 -> T a b1) -> T a b0 -> T a b1
mapFirstL (forall a. a -> a
id,T a b0 -> T a b1
f)


mapSecondL ::
   (b -> b, Disp.T a0 b -> Disp.T a1 b) ->
   Uniform.T a0 b -> Uniform.T a1 b
mapSecondL :: forall b a0 a1. (b -> b, T a0 b -> T a1 b) -> T a0 b -> T a1 b
mapSecondL (b -> b, T a0 b -> T a1 b)
f = forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry forall b a. b -> T a b -> T a b
consSecond forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a c b d. (a -> c, b -> d) -> (a, b) -> (c, d)
mapPair (b -> b, T a0 b -> T a1 b)
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. T a b -> (b, T a b)
viewSecondL

{-
mapSecondHead ::
   (b -> b) ->
   Uniform.T a b -> Uniform.T a b
mapSecondHead f = mapSecondL (f,id)
-}

mapSecondTail ::
   (Disp.T a0 b -> Disp.T a1 b) ->
   Uniform.T a0 b -> Uniform.T a1 b
mapSecondTail :: forall a0 b a1. (T a0 b -> T a1 b) -> T a0 b -> T a1 b
mapSecondTail T a0 b -> T a1 b
f = forall b a0 a1. (b -> b, T a0 b -> T a1 b) -> T a0 b -> T a1 b
mapSecondL (forall a. a -> a
id,T a0 b -> T a1 b
f)


mapFirstR ::
   (Uniform.T a b0 -> Uniform.T a b1, a -> a) ->
   Disp.T b0 a -> Disp.T b1 a
mapFirstR :: forall a b0 b1. (T a b0 -> T a b1, a -> a) -> T b0 a -> T b1 a
mapFirstR (T a b0 -> T a b1, a -> a)
f =
   forall b a. b -> (a -> b) -> Maybe a -> b
maybe forall a b. T a b
Disp.empty (forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry forall a b. T a b -> a -> T b a
snocFirst forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a c b d. (a -> c, b -> d) -> (a, b) -> (c, d)
mapPair (T a b0 -> T a b1, a -> a)
f) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall b a. T b a -> Maybe (T a b, a)
viewFirstR

-- could also be in ListDisparate
mapFirstLast ::
   (a -> a) ->
   Disp.T b a -> Disp.T b a
mapFirstLast :: forall a b. (a -> a) -> T b a -> T b a
mapFirstLast a -> a
f = forall a b0 b1. (T a b0 -> T a b1, a -> a) -> T b0 a -> T b1 a
mapFirstR (forall a. a -> a
id,a -> a
f)

mapFirstInit ::
   (Uniform.T a b0 -> Uniform.T a b1) ->
   Disp.T b0 a -> Disp.T b1 a
mapFirstInit :: forall a b0 b1. (T a b0 -> T a b1) -> T b0 a -> T b1 a
mapFirstInit T a b0 -> T a b1
f = forall a b0 b1. (T a b0 -> T a b1, a -> a) -> T b0 a -> T b1 a
mapFirstR (T a b0 -> T a b1
f,forall a. a -> a
id)


mapSecondR ::
   (Disp.T b a0 -> Disp.T b a1, b -> b) ->
   Uniform.T a0 b -> Uniform.T a1 b
mapSecondR :: forall b a0 a1. (T b a0 -> T b a1, b -> b) -> T a0 b -> T a1 b
mapSecondR (T b a0 -> T b a1, b -> b)
f = forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry forall b a. T b a -> b -> T a b
snocSecond forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a c b d. (a -> c, b -> d) -> (a, b) -> (c, d)
mapPair (T b a0 -> T b a1, b -> b)
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. T a b -> (T b a, b)
viewSecondR

mapSecondLast ::
   (b -> b) ->
   Uniform.T a b -> Uniform.T a b
mapSecondLast :: forall b a. (b -> b) -> T a b -> T a b
mapSecondLast b -> b
f = forall b a0 a1. (T b a0 -> T b a1, b -> b) -> T a0 b -> T a1 b
mapSecondR (forall a. a -> a
id,b -> b
f)

mapSecondInit ::
   (Disp.T b a0 -> Disp.T b a1) ->
   Uniform.T a0 b -> Uniform.T a1 b
mapSecondInit :: forall b a0 a1. (T b a0 -> T b a1) -> T a0 b -> T a1 b
mapSecondInit T b a0 -> T b a1
f = forall b a0 a1. (T b a0 -> T b a1, b -> b) -> T a0 b -> T a1 b
mapSecondR (T b a0 -> T b a1
f,forall a. a -> a
id)



reverseUniform :: Uniform.T a b -> Uniform.T a b
reverseUniform :: forall a b. T a b -> T a b
reverseUniform =
   forall c a d b. (c -> a -> d) -> (d -> b -> c) -> d -> T a b -> c
Uniform.foldl (forall a b c. (a -> b -> c) -> b -> a -> c
flip forall a b. a -> T a b -> T a b
consFirst) (forall a b c. (a -> b -> c) -> b -> a -> c
flip forall b a. b -> T a b -> T a b
consSecond) forall a b. T a b
Disp.empty

reverseDisparate :: Disp.T a b -> Disp.T b a
reverseDisparate :: forall a b. T a b -> T b a
reverseDisparate =
   forall c a d b. (c -> a -> d) -> (d -> b -> c) -> c -> T a b -> c
Disp.foldl (forall a b c. (a -> b -> c) -> b -> a -> c
flip forall b a. b -> T a b -> T a b
consSecond) (forall a b c. (a -> b -> c) -> b -> a -> c
flip forall a b. a -> T a b -> T a b
consFirst) forall a b. T a b
Disp.empty


appendUniformUniform :: Uniform.T a b -> Uniform.T b a -> Disp.T b a
appendUniformUniform :: forall a b. T a b -> T b a -> T b a
appendUniformUniform T a b
xs T b a
ys =
   forall a c d b. (a -> c -> d) -> (b -> d -> c) -> d -> T a b -> c
Uniform.foldr forall b a. b -> T a b -> T a b
consSecond forall a b. a -> T a b -> T a b
consFirst T b a
ys T a b
xs

appendDisparateUniform :: Disp.T b a -> Uniform.T a b -> Uniform.T a b
appendDisparateUniform :: forall b a. T b a -> T a b -> T a b
appendDisparateUniform T b a
xs T a b
ys =
   forall a c d b. (a -> c -> d) -> (b -> d -> c) -> d -> T a b -> d
Disp.foldr forall b a. b -> T a b -> T a b
consSecond forall a b. a -> T a b -> T a b
consFirst T a b
ys T b a
xs

appendUniformDisparate :: Uniform.T a b -> Disp.T a b -> Uniform.T a b
appendUniformDisparate :: forall a b. T a b -> T a b -> T a b
appendUniformDisparate T a b
xs T a b
ys =
   forall a0 b a1. (T a0 b -> T a1 b) -> T a0 b -> T a1 b
mapSecondTail (forall a b c. (a -> b -> c) -> b -> a -> c
flip forall a b. T a b -> T a b -> T a b
Disp.append T a b
ys) T a b
xs


concatDisparate :: Disp.T (Uniform.T b a) (Uniform.T a b) -> Disp.T a b
concatDisparate :: forall b a. T (T b a) (T a b) -> T a b
concatDisparate =
   forall a c d b. (a -> c -> d) -> (b -> d -> c) -> d -> T a b -> d
Disp.foldr forall a b. T a b -> T b a -> T b a
appendUniformUniform forall a b. T a b -> T a b -> T a b
appendUniformDisparate forall a b. T a b
Disp.empty

concatUniform :: Uniform.T (Uniform.T b a) (Uniform.T a b) -> Uniform.T a b
concatUniform :: forall b a. T (T b a) (T a b) -> T a b
concatUniform =
   forall b a c. (b -> T a b -> c) -> T a b -> c
switchSecondL
   (\ T a b
b T (T b a) (T a b)
xs -> forall a b. T a b -> T a b -> T a b
appendUniformDisparate T a b
b (forall b a. T (T b a) (T a b) -> T a b
concatDisparate T (T b a) (T a b)
xs))



splitAtDisparateUniform :: Int -> Uniform.T a b -> (Disp.T b a, Uniform.T a b)
splitAtDisparateUniform :: forall a b. Int -> T a b -> (T b a, T a b)
splitAtDisparateUniform Int
0 = (,) forall a b. T a b
Disp.empty
splitAtDisparateUniform Int
n =
   (\ ~(T a b
prefix,T a b
suffix) ->
       forall b a. b -> (a -> b) -> Maybe a -> b
maybe
          (forall a. HasCallStack => [Char] -> a
error [Char]
"splitAtDisparateUniform: empty list")
          (forall a c b. (a -> c) -> (a, b) -> (c, b)
mapFst (forall a b. T a b -> a -> T b a
snocFirst T a b
prefix))
          (forall a b. T a b -> Maybe (a, T a b)
viewFirstL T a b
suffix)) forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   forall a b. Int -> T a b -> (T a b, T a b)
splitAtUniformDisparate (forall a. Enum a => a -> a
pred Int
n)

splitAtUniformDisparate :: Int -> Uniform.T a b -> (Uniform.T a b, Disp.T a b)
splitAtUniformDisparate :: forall a b. Int -> T a b -> (T a b, T a b)
splitAtUniformDisparate Int
n (Uniform.Cons b
b T a b
xs) =
   forall a c b. (a -> c) -> (a, b) -> (c, b)
mapFst (forall b a. b -> T a b -> T a b
consSecond b
b) forall a b. (a -> b) -> a -> b
$ forall a b. Int -> T a b -> (T a b, T a b)
Disp.splitAt Int
n T a b
xs


splitAtUniformUniform ::
   Int -> Disp.T b a -> Maybe (Uniform.T a b, Uniform.T b a)
splitAtUniformUniform :: forall b a. Int -> T b a -> Maybe (T a b, T b a)
splitAtUniformUniform Int
n =
   (\ ~(T b a
xs,T b a
ys) ->
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
           (forall a c b. (a -> c) -> (a, b) -> (c, b)
mapFst (forall b a. T b a -> b -> T a b
snocSecond T b a
xs))
           (forall a b. T a b -> Maybe (a, T a b)
viewFirstL T b a
ys)) forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   forall a b. Int -> T a b -> (T a b, T a b)
Disp.splitAt Int
n


takeDisparate :: Int -> Uniform.T a b -> Disp.T b a
takeDisparate :: forall a b. Int -> T a b -> T b a
takeDisparate Int
n =
   forall a b. (a, b) -> a
fst forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. T a b -> (T b a, b)
viewSecondR forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. Int -> T a b -> T a b
takeUniform Int
n

takeUniform :: Int -> Uniform.T a b -> Uniform.T a b
takeUniform :: forall a b. Int -> T a b -> T a b
takeUniform Int
n (Uniform.Cons b
b T a b
xs) =
   forall b a. b -> T a b -> T a b
consSecond b
b forall a b. (a -> b) -> a -> b
$ forall a b. Int -> T a b -> T a b
Disp.take Int
n T a b
xs

dropDisparate :: Int -> Uniform.T a b -> Disp.T a b
dropDisparate :: forall a b. Int -> T a b -> T a b
dropDisparate Int
n = forall a b. Int -> T a b -> T a b
Disp.drop Int
n forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> b
snd forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. T a b -> (b, T a b)
viewSecondL

dropUniform :: Int -> Uniform.T a b -> Uniform.T a b
dropUniform :: forall a b. Int -> T a b -> T a b
dropUniform Int
0 = forall a. a -> a
id
dropUniform Int
n =
   forall c a b. c -> (a -> T a b -> c) -> T a b -> c
switchFirstL (forall a. HasCallStack => [Char] -> a
error [Char]
"dropUniform: empty list") (forall a b c. (a -> b -> c) -> b -> a -> c
flip forall a b. a -> b -> a
const) forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   forall a b. Int -> T a b -> T a b
dropDisparate (forall a. Enum a => a -> a
pred Int
n)


{-
breakDisparateFirst :: (a -> Bool) ->
   Disp.T a b -> (Disp.T a b, Disp.T a b)
breakDisparateFirst p = Disp.spanFirst (not . p)

breakUniformFirst :: (a -> Bool) ->
   Uniform.T a b -> (Uniform.T a b, Disp.T a b)
breakUniformFirst p =
   let recourse xs0 =
          (\(b,xs) ->
              if p b
                then (empty, xs0)
                else
                  maybe
                     (\(a,ys) ->)
                  let (as,) = recourse  xs
                  in  ) $
          viewSecondL xs0
-}

{-
spanSecond :: (b -> Bool) -> Uniform.T a b -> (Uniform.T a b, Disp.T b a)
spanSecond p (Uniform.Cons b xs) =
   mapFst (consSecond b) (Disp.span p xs)

spanDisparate :: (b -> Bool) -> Disp.T a b -> (Uniform.T b a, Uniform.T a b)
spanDisparate p =
   mapPair (consSecond, consSecond) . List.span (p . pairFirst) . toPairList
-}