{- |
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
(/.) = 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
(./) = 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) = a -> b -> T a b -> T a b
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 = b -> T a b -> T a b
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 = T a b -> T b a -> T b a
forall a b. T a b -> T b a -> T b a
appendUniformUniform T a b
xs (T b a -> T b a) -> (a -> T b a) -> a -> T b a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> T b a
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 = T b a -> T a b -> T a b
forall b a. T b a -> T a b -> T a b
appendDisparateUniform T b a
xs (T a b -> T a b) -> (b -> T a b) -> b -> T a b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. b -> T a b
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 = (T a b -> Maybe (a, T a b)) -> (b, T a b) -> (b, Maybe (a, T a b))
forall b c a. (b -> c) -> (a, b) -> (a, c)
mapSnd T a b -> Maybe (a, T a b)
forall a b. T a b -> Maybe (a, T a b)
viewFirstL ((b, T a b) -> (b, Maybe (a, T a b)))
-> (T a b -> (b, T a b)) -> T a b -> (b, Maybe (a, T a b))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T a b -> (b, T a b)
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 =
   (((a, b), T a b) -> (a, T a b))
-> Maybe ((a, b), T a b) -> Maybe (a, T a b)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
Monad.liftM (\((a
a,b
b), T a b
xs) -> (a
a, b -> T a b -> T a b
forall b a. b -> T a b -> T a b
consSecond b
b T a b
xs)) (Maybe ((a, b), T a b) -> Maybe (a, T a b))
-> (T a b -> Maybe ((a, b), T a b)) -> T a b -> Maybe (a, T a b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T a b -> Maybe ((a, b), T a b)
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) =
   (Maybe (T a b, a), b)
-> (T a b -> a -> b -> (Maybe (T a b, a), b))
-> T a b
-> (Maybe (T a b, a), b)
forall c a b. c -> (T a b -> a -> b -> c) -> T a b -> c
Disp.switchR
      (Maybe (T a b, a)
forall a. Maybe a
Nothing, b
b0)
      (\ T a b
xs a
a b
b -> ((T a b, a) -> Maybe (T a b, a)
forall a. a -> Maybe a
Just (b -> T a b -> T a b
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 =
   ((T b a, (b, a)) -> (T a b, a))
-> Maybe (T b a, (b, a)) -> Maybe (T a b, a)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
Monad.liftM (\ (T b a
xs, ~(b
a,a
b)) -> (T b a -> b -> T a b
forall b a. T b a -> b -> T a b
snocSecond T b a
xs b
a, a
b)) (Maybe (T b a, (b, a)) -> Maybe (T a b, a))
-> (T b a -> Maybe (T b a, (b, a))) -> T b a -> Maybe (T a b, a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   T b a -> Maybe (T b a, (b, a))
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) =
   (T b a, b)
-> (T a b -> a -> b -> (T b a, b)) -> T a b -> (T b a, b)
forall c a b. c -> (T a b -> a -> b -> c) -> T a b -> c
Disp.switchR
      (T b a
forall a b. T a b
Disp.empty, b
b0)
      (\ T a b
xs a
a b
b -> (b -> T b a -> T b a
forall a b. a -> T a b -> T a b
consFirst b
b0 (T a b -> a -> T b a
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 =
   (b -> T a b -> c) -> T a b -> c
forall b a c. (b -> T a b -> c) -> T a b -> c
switchSecondL (\b
x -> c -> (a -> T a b -> c) -> T a b -> c
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 =
   c -> (a -> b -> T a b -> c) -> T a b -> c
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 (b -> T a b -> T a b
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 =
   (T b a -> b -> c) -> T a b -> c
forall b a c. (T b a -> b -> c) -> T a b -> c
switchSecondR (\T b a
xs b
b -> c -> (T a b -> a -> c) -> T b a -> c
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 =
   c -> ((T a b, a) -> c) -> Maybe (T a b, a) -> c
forall b a. b -> (a -> b) -> Maybe a -> b
maybe c
f ((T a b -> a -> c) -> (T a b, a) -> c
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry T a b -> a -> c
g) (Maybe (T a b, a) -> c)
-> (T b a -> Maybe (T a b, a)) -> T b a -> c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T b a -> Maybe (T a b, a)
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 = (T b a -> b -> c) -> (T b a, b) -> c
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry T b a -> b -> c
f ((T b a, b) -> c) -> (T a b -> (T b a, b)) -> T a b -> c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T a b -> (T b a, b)
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 =
   T a b1 -> ((a, T a b0) -> T a b1) -> Maybe (a, T a b0) -> T a b1
forall b a. b -> (a -> b) -> Maybe a -> b
maybe T a b1
forall a b. T a b
Disp.empty ((a -> T a b1 -> T a b1) -> (a, T a b1) -> T a b1
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry a -> T a b1 -> T a b1
forall a b. a -> T a b -> T a b
consFirst ((a, T a b1) -> T a b1)
-> ((a, T a b0) -> (a, T a b1)) -> (a, T a b0) -> T a b1
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> a, T a b0 -> T a b1) -> (a, T a b0) -> (a, T a b1)
forall a c b d. (a -> c, b -> d) -> (a, b) -> (c, d)
mapPair (a -> a, T a b0 -> T a b1)
f) (Maybe (a, T a b0) -> T a b1)
-> (T a b0 -> Maybe (a, T a b0)) -> T a b0 -> T a b1
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T a b0 -> Maybe (a, T a b0)
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 = (a -> a, T a b -> T a b) -> T a b -> T a b
forall a b0 b1. (a -> a, T a b0 -> T a b1) -> T a b0 -> T a b1
mapFirstL (a -> a
f,T a b -> T a b
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 = (a -> a, T a b0 -> T a b1) -> T a b0 -> T a b1
forall a b0 b1. (a -> a, T a b0 -> T a b1) -> T a b0 -> T a b1
mapFirstL (a -> a
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 = (b -> T a1 b -> T a1 b) -> (b, T a1 b) -> T a1 b
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry b -> T a1 b -> T a1 b
forall b a. b -> T a b -> T a b
consSecond ((b, T a1 b) -> T a1 b)
-> (T a0 b -> (b, T a1 b)) -> T a0 b -> T a1 b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (b -> b, T a0 b -> T a1 b) -> (b, T a0 b) -> (b, T a1 b)
forall a c b d. (a -> c, b -> d) -> (a, b) -> (c, d)
mapPair (b -> b, T a0 b -> T a1 b)
f ((b, T a0 b) -> (b, T a1 b))
-> (T a0 b -> (b, T a0 b)) -> T a0 b -> (b, T a1 b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T a0 b -> (b, T a0 b)
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 = (b -> b, T a0 b -> T a1 b) -> T a0 b -> T a1 b
forall b a0 a1. (b -> b, T a0 b -> T a1 b) -> T a0 b -> T a1 b
mapSecondL (b -> b
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 =
   T b1 a -> ((T a b0, a) -> T b1 a) -> Maybe (T a b0, a) -> T b1 a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe T b1 a
forall a b. T a b
Disp.empty ((T a b1 -> a -> T b1 a) -> (T a b1, a) -> T b1 a
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry T a b1 -> a -> T b1 a
forall a b. T a b -> a -> T b a
snocFirst ((T a b1, a) -> T b1 a)
-> ((T a b0, a) -> (T a b1, a)) -> (T a b0, a) -> T b1 a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (T a b0 -> T a b1, a -> a) -> (T a b0, a) -> (T a b1, a)
forall a c b d. (a -> c, b -> d) -> (a, b) -> (c, d)
mapPair (T a b0 -> T a b1, a -> a)
f) (Maybe (T a b0, a) -> T b1 a)
-> (T b0 a -> Maybe (T a b0, a)) -> T b0 a -> T b1 a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T b0 a -> Maybe (T a b0, a)
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 = (T a b -> T a b, a -> a) -> T b a -> T b a
forall a b0 b1. (T a b0 -> T a b1, a -> a) -> T b0 a -> T b1 a
mapFirstR (T a b -> T a b
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 = (T a b0 -> T a b1, a -> a) -> T b0 a -> T b1 a
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,a -> a
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 = (T b a1 -> b -> T a1 b) -> (T b a1, b) -> T a1 b
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry T b a1 -> b -> T a1 b
forall b a. T b a -> b -> T a b
snocSecond ((T b a1, b) -> T a1 b)
-> (T a0 b -> (T b a1, b)) -> T a0 b -> T a1 b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (T b a0 -> T b a1, b -> b) -> (T b a0, b) -> (T b a1, b)
forall a c b d. (a -> c, b -> d) -> (a, b) -> (c, d)
mapPair (T b a0 -> T b a1, b -> b)
f ((T b a0, b) -> (T b a1, b))
-> (T a0 b -> (T b a0, b)) -> T a0 b -> (T b a1, b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T a0 b -> (T b a0, b)
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 = (T b a -> T b a, b -> b) -> T a b -> T a b
forall b a0 a1. (T b a0 -> T b a1, b -> b) -> T a0 b -> T a1 b
mapSecondR (T b a -> T b a
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 = (T b a0 -> T b a1, b -> b) -> T a0 b -> T a1 b
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,b -> b
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 =
   (T a b -> a -> T a b)
-> (T a b -> b -> T a b) -> T a b -> T a b -> T a b
forall c a d b. (c -> a -> d) -> (d -> b -> c) -> d -> T a b -> c
Uniform.foldl ((a -> T a b -> T a b) -> T a b -> a -> T a b
forall a b c. (a -> b -> c) -> b -> a -> c
flip a -> T a b -> T a b
forall a b. a -> T a b -> T a b
consFirst) ((b -> T a b -> T a b) -> T a b -> b -> T a b
forall a b c. (a -> b -> c) -> b -> a -> c
flip b -> T a b -> T a b
forall b a. b -> T a b -> T a b
consSecond) T a b
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 =
   (T b a -> a -> T b a)
-> (T b a -> b -> T b a) -> T b a -> T a b -> T b a
forall c a d b. (c -> a -> d) -> (d -> b -> c) -> c -> T a b -> c
Disp.foldl ((a -> T b a -> T b a) -> T b a -> a -> T b a
forall a b c. (a -> b -> c) -> b -> a -> c
flip a -> T b a -> T b a
forall b a. b -> T a b -> T a b
consSecond) ((b -> T b a -> T b a) -> T b a -> b -> T b a
forall a b c. (a -> b -> c) -> b -> a -> c
flip b -> T b a -> T b a
forall a b. a -> T a b -> T a b
consFirst) T b a
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 =
   (a -> T b a -> T b a)
-> (b -> T b a -> T b a) -> T b a -> T a b -> T b a
forall a c d b. (a -> c -> d) -> (b -> d -> c) -> d -> T a b -> c
Uniform.foldr a -> T b a -> T b a
forall b a. b -> T a b -> T a b
consSecond b -> T b a -> T b a
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 =
   (b -> T a b -> T a b)
-> (a -> T a b -> T a b) -> T a b -> T b a -> T a b
forall a c d b. (a -> c -> d) -> (b -> d -> c) -> d -> T a b -> d
Disp.foldr b -> T a b -> T a b
forall b a. b -> T a b -> T a b
consSecond a -> T a b -> T a b
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 =
   (T a b -> T a b) -> T a b -> T a b
forall a0 b a1. (T a0 b -> T a1 b) -> T a0 b -> T a1 b
mapSecondTail ((T a b -> T a b -> T a b) -> T a b -> T a b -> T a b
forall a b c. (a -> b -> c) -> b -> a -> c
flip T a b -> T a b -> T a b
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 =
   (T b a -> T a b -> T a b)
-> (T a b -> T a b -> T a b) -> T a b -> T (T b a) (T a b) -> T a b
forall a c d b. (a -> c -> d) -> (b -> d -> c) -> d -> T a b -> d
Disp.foldr T b a -> T a b -> T a b
forall a b. T a b -> T b a -> T b a
appendUniformUniform T a b -> T a b -> T a b
forall a b. T a b -> T a b -> T a b
appendUniformDisparate T a b
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 =
   (T a b -> T (T b a) (T a b) -> T a b) -> T (T b a) (T a b) -> T a b
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 -> T a b -> T a b -> T a b
forall a b. T a b -> T a b -> T a b
appendUniformDisparate T a b
b (T (T b a) (T a b) -> T a 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 = (,) T b a
forall a b. T a b
Disp.empty
splitAtDisparateUniform Int
n =
   (\ ~(T a b
prefix,T a b
suffix) ->
       (T b a, T a b)
-> ((a, T a b) -> (T b a, T a b))
-> Maybe (a, T a b)
-> (T b a, T a b)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
          ([Char] -> (T b a, T a b)
forall a. HasCallStack => [Char] -> a
error [Char]
"splitAtDisparateUniform: empty list")
          ((a -> T b a) -> (a, T a b) -> (T b a, T a b)
forall a c b. (a -> c) -> (a, b) -> (c, b)
mapFst (T a b -> a -> T b a
forall a b. T a b -> a -> T b a
snocFirst T a b
prefix))
          (T a b -> Maybe (a, T a b)
forall a b. T a b -> Maybe (a, T a b)
viewFirstL T a b
suffix)) ((T a b, T a b) -> (T b a, T a b))
-> (T a b -> (T a b, T a b)) -> T a b -> (T b a, T a b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   Int -> T a b -> (T a b, T a b)
forall a b. Int -> T a b -> (T a b, T a b)
splitAtUniformDisparate (Int -> Int
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) =
   (T a b -> T a b) -> (T a b, T a b) -> (T a b, T a b)
forall a c b. (a -> c) -> (a, b) -> (c, b)
mapFst (b -> T a b -> T a b
forall b a. b -> T a b -> T a b
consSecond b
b) ((T a b, T a b) -> (T a b, T a b))
-> (T a b, T a b) -> (T a b, T a b)
forall a b. (a -> b) -> a -> b
$ Int -> T a b -> (T a b, T 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) ->
        ((b, T b a) -> (T a b, T b a))
-> Maybe (b, T b a) -> Maybe (T a b, T b a)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
           ((b -> T a b) -> (b, T b a) -> (T a b, T b a)
forall a c b. (a -> c) -> (a, b) -> (c, b)
mapFst (T b a -> b -> T a b
forall b a. T b a -> b -> T a b
snocSecond T b a
xs))
           (T b a -> Maybe (b, T b a)
forall a b. T a b -> Maybe (a, T a b)
viewFirstL T b a
ys)) ((T b a, T b a) -> Maybe (T a b, T b a))
-> (T b a -> (T b a, T b a)) -> T b a -> Maybe (T a b, T b a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   Int -> T b a -> (T b a, T b a)
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 =
   (T b a, b) -> T b a
forall a b. (a, b) -> a
fst ((T b a, b) -> T b a) -> (T a b -> (T b a, b)) -> T a b -> T b a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T a b -> (T b a, b)
forall a b. T a b -> (T b a, b)
viewSecondR (T a b -> (T b a, b)) -> (T a b -> T a b) -> T a b -> (T b a, b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> T a b -> T a b
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) =
   b -> T a b -> T a b
forall b a. b -> T a b -> T a b
consSecond b
b (T a b -> T a b) -> T a b -> T a b
forall a b. (a -> b) -> a -> b
$ Int -> T a b -> T 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 = Int -> T a b -> T a b
forall a b. Int -> T a b -> T a b
Disp.drop Int
n (T a b -> T a b) -> (T a b -> T a b) -> T a b -> T a b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (b, T a b) -> T a b
forall a b. (a, b) -> b
snd ((b, T a b) -> T a b) -> (T a b -> (b, T a b)) -> T a b -> T a b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T a b -> (b, T a b)
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 = T a b -> T a b
forall a. a -> a
id
dropUniform Int
n =
   T a b -> (a -> T a b -> T a b) -> T a b -> T a b
forall c a b. c -> (a -> T a b -> c) -> T a b -> c
switchFirstL ([Char] -> T a b
forall a. HasCallStack => [Char] -> a
error [Char]
"dropUniform: empty list") ((T a b -> a -> T a b) -> a -> T a b -> T a b
forall a b c. (a -> b -> c) -> b -> a -> c
flip T a b -> a -> T a b
forall a b. a -> b -> a
const) (T a b -> T a b) -> (T a b -> T a b) -> T a b -> T a b
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   Int -> T a b -> T a b
forall a b. Int -> T a b -> T a b
dropDisparate (Int -> Int
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
-}