{-# LANGUAGE DeriveTraversable #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE LambdaCase #-}
module Data.Profunctor.UniconEncoding(
  Unicon(..),
  Encoding(..),
  encodeId
) where

import Data.Functor.Classes
import Data.Profunctor (Profunctor(..))
import Data.Profunctor.Cartesian
import Data.Bifunctor (Bifunctor(..))

-- | Universal container. Any container type with finite maximum length and
--   finite number of possible shapes can be encoded into @Unicon@.
data Unicon a = MkUnicon !Int [a]
    deriving stock (Unicon a -> Unicon a -> Bool
(Unicon a -> Unicon a -> Bool)
-> (Unicon a -> Unicon a -> Bool) -> Eq (Unicon a)
forall a. Eq a => Unicon a -> Unicon a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Unicon a -> Unicon a -> Bool
== :: Unicon a -> Unicon a -> Bool
$c/= :: forall a. Eq a => Unicon a -> Unicon a -> Bool
/= :: Unicon a -> Unicon a -> Bool
Eq, Eq (Unicon a)
Eq (Unicon a) =>
(Unicon a -> Unicon a -> Ordering)
-> (Unicon a -> Unicon a -> Bool)
-> (Unicon a -> Unicon a -> Bool)
-> (Unicon a -> Unicon a -> Bool)
-> (Unicon a -> Unicon a -> Bool)
-> (Unicon a -> Unicon a -> Unicon a)
-> (Unicon a -> Unicon a -> Unicon a)
-> Ord (Unicon a)
Unicon a -> Unicon a -> Bool
Unicon a -> Unicon a -> Ordering
Unicon a -> Unicon a -> Unicon a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Unicon a)
forall a. Ord a => Unicon a -> Unicon a -> Bool
forall a. Ord a => Unicon a -> Unicon a -> Ordering
forall a. Ord a => Unicon a -> Unicon a -> Unicon a
$ccompare :: forall a. Ord a => Unicon a -> Unicon a -> Ordering
compare :: Unicon a -> Unicon a -> Ordering
$c< :: forall a. Ord a => Unicon a -> Unicon a -> Bool
< :: Unicon a -> Unicon a -> Bool
$c<= :: forall a. Ord a => Unicon a -> Unicon a -> Bool
<= :: Unicon a -> Unicon a -> Bool
$c> :: forall a. Ord a => Unicon a -> Unicon a -> Bool
> :: Unicon a -> Unicon a -> Bool
$c>= :: forall a. Ord a => Unicon a -> Unicon a -> Bool
>= :: Unicon a -> Unicon a -> Bool
$cmax :: forall a. Ord a => Unicon a -> Unicon a -> Unicon a
max :: Unicon a -> Unicon a -> Unicon a
$cmin :: forall a. Ord a => Unicon a -> Unicon a -> Unicon a
min :: Unicon a -> Unicon a -> Unicon a
Ord, Int -> Unicon a -> ShowS
[Unicon a] -> ShowS
Unicon a -> String
(Int -> Unicon a -> ShowS)
-> (Unicon a -> String) -> ([Unicon a] -> ShowS) -> Show (Unicon a)
forall a. Show a => Int -> Unicon a -> ShowS
forall a. Show a => [Unicon a] -> ShowS
forall a. Show a => Unicon a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> Unicon a -> ShowS
showsPrec :: Int -> Unicon a -> ShowS
$cshow :: forall a. Show a => Unicon a -> String
show :: Unicon a -> String
$cshowList :: forall a. Show a => [Unicon a] -> ShowS
showList :: [Unicon a] -> ShowS
Show, ReadPrec [Unicon a]
ReadPrec (Unicon a)
Int -> ReadS (Unicon a)
ReadS [Unicon a]
(Int -> ReadS (Unicon a))
-> ReadS [Unicon a]
-> ReadPrec (Unicon a)
-> ReadPrec [Unicon a]
-> Read (Unicon a)
forall a. Read a => ReadPrec [Unicon a]
forall a. Read a => ReadPrec (Unicon a)
forall a. Read a => Int -> ReadS (Unicon a)
forall a. Read a => ReadS [Unicon a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: forall a. Read a => Int -> ReadS (Unicon a)
readsPrec :: Int -> ReadS (Unicon a)
$creadList :: forall a. Read a => ReadS [Unicon a]
readList :: ReadS [Unicon a]
$creadPrec :: forall a. Read a => ReadPrec (Unicon a)
readPrec :: ReadPrec (Unicon a)
$creadListPrec :: forall a. Read a => ReadPrec [Unicon a]
readListPrec :: ReadPrec [Unicon a]
Read, (forall a b. (a -> b) -> Unicon a -> Unicon b)
-> (forall a b. a -> Unicon b -> Unicon a) -> Functor Unicon
forall a b. a -> Unicon b -> Unicon a
forall a b. (a -> b) -> Unicon a -> Unicon b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Unicon a -> Unicon b
fmap :: forall a b. (a -> b) -> Unicon a -> Unicon b
$c<$ :: forall a b. a -> Unicon b -> Unicon a
<$ :: forall a b. a -> Unicon b -> Unicon a
Functor, (forall m. Monoid m => Unicon m -> m)
-> (forall m a. Monoid m => (a -> m) -> Unicon a -> m)
-> (forall m a. Monoid m => (a -> m) -> Unicon a -> m)
-> (forall a b. (a -> b -> b) -> b -> Unicon a -> b)
-> (forall a b. (a -> b -> b) -> b -> Unicon a -> b)
-> (forall b a. (b -> a -> b) -> b -> Unicon a -> b)
-> (forall b a. (b -> a -> b) -> b -> Unicon a -> b)
-> (forall a. (a -> a -> a) -> Unicon a -> a)
-> (forall a. (a -> a -> a) -> Unicon a -> a)
-> (forall a. Unicon a -> [a])
-> (forall a. Unicon a -> Bool)
-> (forall a. Unicon a -> Int)
-> (forall a. Eq a => a -> Unicon a -> Bool)
-> (forall a. Ord a => Unicon a -> a)
-> (forall a. Ord a => Unicon a -> a)
-> (forall a. Num a => Unicon a -> a)
-> (forall a. Num a => Unicon a -> a)
-> Foldable Unicon
forall a. Eq a => a -> Unicon a -> Bool
forall a. Num a => Unicon a -> a
forall a. Ord a => Unicon a -> a
forall m. Monoid m => Unicon m -> m
forall a. Unicon a -> Bool
forall a. Unicon a -> Int
forall a. Unicon a -> [a]
forall a. (a -> a -> a) -> Unicon a -> a
forall m a. Monoid m => (a -> m) -> Unicon a -> m
forall b a. (b -> a -> b) -> b -> Unicon a -> b
forall a b. (a -> b -> b) -> b -> Unicon a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Unicon m -> m
fold :: forall m. Monoid m => Unicon m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Unicon a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Unicon a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Unicon a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Unicon a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Unicon a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Unicon a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Unicon a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Unicon a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Unicon a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Unicon a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Unicon a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Unicon a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Unicon a -> a
foldr1 :: forall a. (a -> a -> a) -> Unicon a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Unicon a -> a
foldl1 :: forall a. (a -> a -> a) -> Unicon a -> a
$ctoList :: forall a. Unicon a -> [a]
toList :: forall a. Unicon a -> [a]
$cnull :: forall a. Unicon a -> Bool
null :: forall a. Unicon a -> Bool
$clength :: forall a. Unicon a -> Int
length :: forall a. Unicon a -> Int
$celem :: forall a. Eq a => a -> Unicon a -> Bool
elem :: forall a. Eq a => a -> Unicon a -> Bool
$cmaximum :: forall a. Ord a => Unicon a -> a
maximum :: forall a. Ord a => Unicon a -> a
$cminimum :: forall a. Ord a => Unicon a -> a
minimum :: forall a. Ord a => Unicon a -> a
$csum :: forall a. Num a => Unicon a -> a
sum :: forall a. Num a => Unicon a -> a
$cproduct :: forall a. Num a => Unicon a -> a
product :: forall a. Num a => Unicon a -> a
Foldable, Functor Unicon
Foldable Unicon
(Functor Unicon, Foldable Unicon) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Unicon a -> f (Unicon b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Unicon (f a) -> f (Unicon a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Unicon a -> m (Unicon b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Unicon (m a) -> m (Unicon a))
-> Traversable Unicon
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Unicon (m a) -> m (Unicon a)
forall (f :: * -> *) a.
Applicative f =>
Unicon (f a) -> f (Unicon a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Unicon a -> m (Unicon b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Unicon a -> f (Unicon b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Unicon a -> f (Unicon b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Unicon a -> f (Unicon b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Unicon (f a) -> f (Unicon a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Unicon (f a) -> f (Unicon a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Unicon a -> m (Unicon b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Unicon a -> m (Unicon b)
$csequence :: forall (m :: * -> *) a. Monad m => Unicon (m a) -> m (Unicon a)
sequence :: forall (m :: * -> *) a. Monad m => Unicon (m a) -> m (Unicon a)
Traversable)

instance Eq1 Unicon where
  liftEq :: forall a b. (a -> b -> Bool) -> Unicon a -> Unicon b -> Bool
liftEq a -> b -> Bool
eq (MkUnicon Int
j [a]
as) (MkUnicon Int
k [b]
bs) = Int
j Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
k Bool -> Bool -> Bool
&& (a -> b -> Bool) -> [a] -> [b] -> Bool
forall a b. (a -> b -> Bool) -> [a] -> [b] -> Bool
forall (f :: * -> *) a b.
Eq1 f =>
(a -> b -> Bool) -> f a -> f b -> Bool
liftEq a -> b -> Bool
eq [a]
as [b]
bs

instance Ord1 Unicon where
  liftCompare :: forall a b.
(a -> b -> Ordering) -> Unicon a -> Unicon b -> Ordering
liftCompare a -> b -> Ordering
cmp (MkUnicon Int
j [a]
as) (MkUnicon Int
k [b]
bs) = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Int
j Int
k Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> (a -> b -> Ordering) -> [a] -> [b] -> Ordering
forall a b. (a -> b -> Ordering) -> [a] -> [b] -> Ordering
forall (f :: * -> *) a b.
Ord1 f =>
(a -> b -> Ordering) -> f a -> f b -> Ordering
liftCompare a -> b -> Ordering
cmp [a]
as [b]
bs

-- instance Matchable Unicon

-- | Encoding into @Unicon a@ with partial decoding function.
data Encoding a s t = Encoding Int (s -> Unicon a) (Unicon a -> Maybe (t, [a]))
  deriving stock ((forall a b. (a -> b) -> Encoding a s a -> Encoding a s b)
-> (forall a b. a -> Encoding a s b -> Encoding a s a)
-> Functor (Encoding a s)
forall a b. a -> Encoding a s b -> Encoding a s a
forall a b. (a -> b) -> Encoding a s a -> Encoding a s b
forall a s a b. a -> Encoding a s b -> Encoding a s a
forall a s a b. (a -> b) -> Encoding a s a -> Encoding a s b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a s a b. (a -> b) -> Encoding a s a -> Encoding a s b
fmap :: forall a b. (a -> b) -> Encoding a s a -> Encoding a s b
$c<$ :: forall a s a b. a -> Encoding a s b -> Encoding a s a
<$ :: forall a b. a -> Encoding a s b -> Encoding a s a
Functor)

encodeId :: Encoding a a a
encodeId :: forall a. Encoding a a a
encodeId = Int
-> (a -> Unicon a)
-> (Unicon a -> Maybe (a, [a]))
-> Encoding a a a
forall a s t.
Int
-> (s -> Unicon a)
-> (Unicon a -> Maybe (t, [a]))
-> Encoding a s t
Encoding Int
1 (\a
a -> Int -> [a] -> Unicon a
forall a. Int -> [a] -> Unicon a
MkUnicon Int
0 [a
a]) ((Unicon a -> Maybe (a, [a])) -> Encoding a a a)
-> (Unicon a -> Maybe (a, [a])) -> Encoding a a a
forall a b. (a -> b) -> a -> b
$ \case
    MkUnicon Int
0 (a
a : [a]
as) -> (a, [a]) -> Maybe (a, [a])
forall a. a -> Maybe a
Just (a
a, [a]
as)
    Unicon a
_ -> Maybe (a, [a])
forall a. Maybe a
Nothing

instance Profunctor (Encoding a) where
  dimap :: forall a b c d.
(a -> b) -> (c -> d) -> Encoding a b c -> Encoding a a d
dimap a -> b
f c -> d
g (Encoding Int
n b -> Unicon a
enc Unicon a -> Maybe (c, [a])
dec) = Int
-> (a -> Unicon a)
-> (Unicon a -> Maybe (d, [a]))
-> Encoding a a d
forall a s t.
Int
-> (s -> Unicon a)
-> (Unicon a -> Maybe (t, [a]))
-> Encoding a s t
Encoding Int
n (b -> Unicon a
enc (b -> Unicon a) -> (a -> b) -> a -> Unicon a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> b
f) (((c, [a]) -> (d, [a])) -> Maybe (c, [a]) -> Maybe (d, [a])
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((c -> d) -> (c, [a]) -> (d, [a])
forall a b c. (a -> b) -> (a, c) -> (b, c)
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first c -> d
g) (Maybe (c, [a]) -> Maybe (d, [a]))
-> (Unicon a -> Maybe (c, [a])) -> Unicon a -> Maybe (d, [a])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Unicon a -> Maybe (c, [a])
dec)

instance Cartesian (Encoding a) where
  proUnit :: forall a. Encoding a a ()
proUnit = Int
-> (a -> Unicon a)
-> (Unicon a -> Maybe ((), [a]))
-> Encoding a a ()
forall a s t.
Int
-> (s -> Unicon a)
-> (Unicon a -> Maybe (t, [a]))
-> Encoding a s t
Encoding Int
1 (Unicon a -> a -> Unicon a
forall a b. a -> b -> a
const Unicon a
forall {a}. Unicon a
one) Unicon a -> Maybe ((), [a])
forall {a}. Unicon a -> Maybe ((), [a])
matchOne
    where
      one :: Unicon a
one = Int -> [a] -> Unicon a
forall a. Int -> [a] -> Unicon a
MkUnicon Int
0 []
      matchOne :: Unicon a -> Maybe ((), [a])
matchOne (MkUnicon Int
0 [a]
as) = ((), [a]) -> Maybe ((), [a])
forall a. a -> Maybe a
Just ((), [a]
as)
      matchOne Unicon a
_ = Maybe ((), [a])
forall a. Maybe a
Nothing

  Encoding Int
m a -> Unicon a
enc Unicon a -> Maybe (b, [a])
dec *** :: forall a b a' b'.
Encoding a a b -> Encoding a a' b' -> Encoding a (a, a') (b, b')
*** Encoding Int
n a' -> Unicon a
enc' Unicon a -> Maybe (b', [a])
dec' = Int
-> ((a, a') -> Unicon a)
-> (Unicon a -> Maybe ((b, b'), [a]))
-> Encoding a (a, a') (b, b')
forall a s t.
Int
-> (s -> Unicon a)
-> (Unicon a -> Maybe (t, [a]))
-> Encoding a s t
Encoding (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
m) (a, a') -> Unicon a
encPair Unicon a -> Maybe ((b, b'), [a])
decPair
    where
      encPair :: (a, a') -> Unicon a
encPair (a
s,a'
s') = case (a -> Unicon a
enc a
s, a' -> Unicon a
enc' a'
s') of
        (MkUnicon Int
j [a]
as, MkUnicon Int
k [a]
as') -> Int -> [a] -> Unicon a
forall a. Int -> [a] -> Unicon a
MkUnicon (Int
j Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
k) ([a]
as [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++ [a]
as')
      decPair :: Unicon a -> Maybe ((b, b'), [a])
decPair (MkUnicon Int
i [a]
as)
        | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0      = Maybe ((b, b'), [a])
forall a. Maybe a
Nothing
        | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
m Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
n = Maybe ((b, b'), [a])
forall a. Maybe a
Nothing
        | Bool
otherwise  = do
              let (Int
j,Int
k) = Int -> Int -> (Int, Int)
forall a. Integral a => a -> a -> (a, a)
quotRem Int
i Int
n
              (b
t1, [a]
as') <- Unicon a -> Maybe (b, [a])
dec (Int -> [a] -> Unicon a
forall a. Int -> [a] -> Unicon a
MkUnicon Int
j [a]
as)
              (b'
t2, [a]
as'') <- Unicon a -> Maybe (b', [a])
dec' (Int -> [a] -> Unicon a
forall a. Int -> [a] -> Unicon a
MkUnicon Int
k [a]
as')
              ((b, b'), [a]) -> Maybe ((b, b'), [a])
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((b
t1, b'
t2), [a]
as'')

instance Cocartesian (Encoding a) where
  proEmpty :: forall b. Encoding a Void b
proEmpty = Int
-> (Void -> Unicon a)
-> (Unicon a -> Maybe (b, [a]))
-> Encoding a Void b
forall a s t.
Int
-> (s -> Unicon a)
-> (Unicon a -> Maybe (t, [a]))
-> Encoding a s t
Encoding Int
0 Void -> Unicon a
forall b. Void -> b
forall (p :: * -> * -> *) b. Cocartesian p => p Void b
proEmpty (Maybe (b, [a]) -> Unicon a -> Maybe (b, [a])
forall a b. a -> b -> a
const Maybe (b, [a])
forall a. Maybe a
Nothing)
  Encoding Int
m a -> Unicon a
enc Unicon a -> Maybe (b, [a])
dec +++ :: forall a b a' b'.
Encoding a a b
-> Encoding a a' b' -> Encoding a (Either a a') (Either b b')
+++ Encoding Int
n a' -> Unicon a
enc' Unicon a -> Maybe (b', [a])
dec' = Int
-> (Either a a' -> Unicon a)
-> (Unicon a -> Maybe (Either b b', [a]))
-> Encoding a (Either a a') (Either b b')
forall a s t.
Int
-> (s -> Unicon a)
-> (Unicon a -> Maybe (t, [a]))
-> Encoding a s t
Encoding (Int
m Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
n) Either a a' -> Unicon a
encSum Unicon a -> Maybe (Either b b', [a])
decSum
    where
      encSum :: Either a a' -> Unicon a
encSum (Left a
s) = a -> Unicon a
enc a
s
      encSum (Right a'
s') = case a' -> Unicon a
enc' a'
s' of
        MkUnicon Int
k [a]
as' -> Int -> [a] -> Unicon a
forall a. Int -> [a] -> Unicon a
MkUnicon (Int
m Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
k) [a]
as'

      decSum :: Unicon a -> Maybe (Either b b', [a])
decSum (MkUnicon Int
i [a]
as)
        | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0 = Maybe (Either b b', [a])
forall a. Maybe a
Nothing
        | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
m = (b -> Either b b') -> (b, [a]) -> (Either b b', [a])
forall a b c. (a -> b) -> (a, c) -> (b, c)
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first b -> Either b b'
forall a b. a -> Either a b
Left ((b, [a]) -> (Either b b', [a]))
-> Maybe (b, [a]) -> Maybe (Either b b', [a])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Unicon a -> Maybe (b, [a])
dec (Int -> [a] -> Unicon a
forall a. Int -> [a] -> Unicon a
MkUnicon Int
i [a]
as)
        | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
m Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
n = (b' -> Either b b') -> (b', [a]) -> (Either b b', [a])
forall a b c. (a -> b) -> (a, c) -> (b, c)
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first b' -> Either b b'
forall a b. b -> Either a b
Right ((b', [a]) -> (Either b b', [a]))
-> Maybe (b', [a]) -> Maybe (Either b b', [a])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Unicon a -> Maybe (b', [a])
dec' (Int -> [a] -> Unicon a
forall a. Int -> [a] -> Unicon a
MkUnicon (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
m) [a]
as)
        | Bool
otherwise = Maybe (Either b b', [a])
forall a. Maybe a
Nothing