{-# LANGUAGE Safe #-}
{-# OPTIONS_GHC -Wno-orphans #-}

module Yaya.Containers.Pattern.Set
  ( SetF (BinF, TipF),
  )
where

import "base" Control.Category (Category ((.)))
import "base" Data.Bool (Bool (False, True), (&&))
import "base" Data.Eq (Eq ((==)))
import "base" Data.Foldable (Foldable)
import "base" Data.Function (($))
import "base" Data.Functor (Functor (fmap))
import "base" Data.Functor.Classes
  ( Eq1 (liftEq),
    Eq2 (liftEq2),
    Ord1 (liftCompare),
    Ord2 (liftCompare2),
    Show1 (liftShowsPrec),
    Show2 (liftShowsPrec2),
  )
import "base" Data.Ord (Ord (compare, (<=)), Ordering (EQ, GT, LT))
import "base" Data.Semigroup ((<>))
import "base" Data.Traversable (Traversable)
import qualified "base" Data.Tuple as Tuple
import "base" GHC.Generics (Generic, Generic1)
import "base" Text.Show (Show (showList, showsPrec), showParen, showString)
import qualified "containers" Data.Set.Internal as Set
import "yaya" Yaya.Fold
  ( Projectable (project),
    Recursive (cata),
    Steppable (embed),
  )
import "base" Prelude (Num ((+)))

data SetF a r = TipF | BinF Set.Size a r r
  deriving stock
    ( SetF a r -> SetF a r -> Bool
(SetF a r -> SetF a r -> Bool)
-> (SetF a r -> SetF a r -> Bool) -> Eq (SetF a r)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall a r. (Eq a, Eq r) => SetF a r -> SetF a r -> Bool
$c== :: forall a r. (Eq a, Eq r) => SetF a r -> SetF a r -> Bool
== :: SetF a r -> SetF a r -> Bool
$c/= :: forall a r. (Eq a, Eq r) => SetF a r -> SetF a r -> Bool
/= :: SetF a r -> SetF a r -> Bool
Eq,
      Eq (SetF a r)
Eq (SetF a r) =>
(SetF a r -> SetF a r -> Ordering)
-> (SetF a r -> SetF a r -> Bool)
-> (SetF a r -> SetF a r -> Bool)
-> (SetF a r -> SetF a r -> Bool)
-> (SetF a r -> SetF a r -> Bool)
-> (SetF a r -> SetF a r -> SetF a r)
-> (SetF a r -> SetF a r -> SetF a r)
-> Ord (SetF a r)
SetF a r -> SetF a r -> Bool
SetF a r -> SetF a r -> Ordering
SetF a r -> SetF a r -> SetF a r
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 r. (Ord a, Ord r) => Eq (SetF a r)
forall a r. (Ord a, Ord r) => SetF a r -> SetF a r -> Bool
forall a r. (Ord a, Ord r) => SetF a r -> SetF a r -> Ordering
forall a r. (Ord a, Ord r) => SetF a r -> SetF a r -> SetF a r
$ccompare :: forall a r. (Ord a, Ord r) => SetF a r -> SetF a r -> Ordering
compare :: SetF a r -> SetF a r -> Ordering
$c< :: forall a r. (Ord a, Ord r) => SetF a r -> SetF a r -> Bool
< :: SetF a r -> SetF a r -> Bool
$c<= :: forall a r. (Ord a, Ord r) => SetF a r -> SetF a r -> Bool
<= :: SetF a r -> SetF a r -> Bool
$c> :: forall a r. (Ord a, Ord r) => SetF a r -> SetF a r -> Bool
> :: SetF a r -> SetF a r -> Bool
$c>= :: forall a r. (Ord a, Ord r) => SetF a r -> SetF a r -> Bool
>= :: SetF a r -> SetF a r -> Bool
$cmax :: forall a r. (Ord a, Ord r) => SetF a r -> SetF a r -> SetF a r
max :: SetF a r -> SetF a r -> SetF a r
$cmin :: forall a r. (Ord a, Ord r) => SetF a r -> SetF a r -> SetF a r
min :: SetF a r -> SetF a r -> SetF a r
Ord,
      (forall x. SetF a r -> Rep (SetF a r) x)
-> (forall x. Rep (SetF a r) x -> SetF a r) -> Generic (SetF a r)
forall x. Rep (SetF a r) x -> SetF a r
forall x. SetF a r -> Rep (SetF a r) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a r x. Rep (SetF a r) x -> SetF a r
forall a r x. SetF a r -> Rep (SetF a r) x
$cfrom :: forall a r x. SetF a r -> Rep (SetF a r) x
from :: forall x. SetF a r -> Rep (SetF a r) x
$cto :: forall a r x. Rep (SetF a r) x -> SetF a r
to :: forall x. Rep (SetF a r) x -> SetF a r
Generic,
      Size -> SetF a r -> ShowS
[SetF a r] -> ShowS
SetF a r -> String
(Size -> SetF a r -> ShowS)
-> (SetF a r -> String) -> ([SetF a r] -> ShowS) -> Show (SetF a r)
forall a.
(Size -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall a r. (Show a, Show r) => Size -> SetF a r -> ShowS
forall a r. (Show a, Show r) => [SetF a r] -> ShowS
forall a r. (Show a, Show r) => SetF a r -> String
$cshowsPrec :: forall a r. (Show a, Show r) => Size -> SetF a r -> ShowS
showsPrec :: Size -> SetF a r -> ShowS
$cshow :: forall a r. (Show a, Show r) => SetF a r -> String
show :: SetF a r -> String
$cshowList :: forall a r. (Show a, Show r) => [SetF a r] -> ShowS
showList :: [SetF a r] -> ShowS
Show,
      (forall m. Monoid m => SetF a m -> m)
-> (forall m a. Monoid m => (a -> m) -> SetF a a -> m)
-> (forall m a. Monoid m => (a -> m) -> SetF a a -> m)
-> (forall a b. (a -> b -> b) -> b -> SetF a a -> b)
-> (forall a b. (a -> b -> b) -> b -> SetF a a -> b)
-> (forall b a. (b -> a -> b) -> b -> SetF a a -> b)
-> (forall b a. (b -> a -> b) -> b -> SetF a a -> b)
-> (forall a. (a -> a -> a) -> SetF a a -> a)
-> (forall a. (a -> a -> a) -> SetF a a -> a)
-> (forall a. SetF a a -> [a])
-> (forall a. SetF a a -> Bool)
-> (forall a. SetF a a -> Size)
-> (forall a. Eq a => a -> SetF a a -> Bool)
-> (forall a. Ord a => SetF a a -> a)
-> (forall a. Ord a => SetF a a -> a)
-> (forall a. Num a => SetF a a -> a)
-> (forall a. Num a => SetF a a -> a)
-> Foldable (SetF a)
forall a. Eq a => a -> SetF a a -> Bool
forall a. Num a => SetF a a -> a
forall a. Ord a => SetF a a -> a
forall m. Monoid m => SetF a m -> m
forall a. SetF a a -> Bool
forall a. SetF a a -> Size
forall a. SetF a a -> [a]
forall a. (a -> a -> a) -> SetF a a -> a
forall a a. Eq a => a -> SetF a a -> Bool
forall a a. Num a => SetF a a -> a
forall a a. Ord a => SetF a a -> a
forall m a. Monoid m => (a -> m) -> SetF a a -> m
forall a m. Monoid m => SetF a m -> m
forall a a. SetF a a -> Bool
forall a a. SetF a a -> Size
forall a a. SetF a a -> [a]
forall b a. (b -> a -> b) -> b -> SetF a a -> b
forall a b. (a -> b -> b) -> b -> SetF a a -> b
forall a a. (a -> a -> a) -> SetF a a -> a
forall a m a. Monoid m => (a -> m) -> SetF a a -> m
forall a b a. (b -> a -> b) -> b -> SetF a a -> b
forall a a b. (a -> b -> b) -> b -> SetF a 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 -> Size)
-> (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 a m. Monoid m => SetF a m -> m
fold :: forall m. Monoid m => SetF a m -> m
$cfoldMap :: forall a m a. Monoid m => (a -> m) -> SetF a a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> SetF a a -> m
$cfoldMap' :: forall a m a. Monoid m => (a -> m) -> SetF a a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> SetF a a -> m
$cfoldr :: forall a a b. (a -> b -> b) -> b -> SetF a a -> b
foldr :: forall a b. (a -> b -> b) -> b -> SetF a a -> b
$cfoldr' :: forall a a b. (a -> b -> b) -> b -> SetF a a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> SetF a a -> b
$cfoldl :: forall a b a. (b -> a -> b) -> b -> SetF a a -> b
foldl :: forall b a. (b -> a -> b) -> b -> SetF a a -> b
$cfoldl' :: forall a b a. (b -> a -> b) -> b -> SetF a a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> SetF a a -> b
$cfoldr1 :: forall a a. (a -> a -> a) -> SetF a a -> a
foldr1 :: forall a. (a -> a -> a) -> SetF a a -> a
$cfoldl1 :: forall a a. (a -> a -> a) -> SetF a a -> a
foldl1 :: forall a. (a -> a -> a) -> SetF a a -> a
$ctoList :: forall a a. SetF a a -> [a]
toList :: forall a. SetF a a -> [a]
$cnull :: forall a a. SetF a a -> Bool
null :: forall a. SetF a a -> Bool
$clength :: forall a a. SetF a a -> Size
length :: forall a. SetF a a -> Size
$celem :: forall a a. Eq a => a -> SetF a a -> Bool
elem :: forall a. Eq a => a -> SetF a a -> Bool
$cmaximum :: forall a a. Ord a => SetF a a -> a
maximum :: forall a. Ord a => SetF a a -> a
$cminimum :: forall a a. Ord a => SetF a a -> a
minimum :: forall a. Ord a => SetF a a -> a
$csum :: forall a a. Num a => SetF a a -> a
sum :: forall a. Num a => SetF a a -> a
$cproduct :: forall a a. Num a => SetF a a -> a
product :: forall a. Num a => SetF a a -> a
Foldable,
      (forall a b. (a -> b) -> SetF a a -> SetF a b)
-> (forall a b. a -> SetF a b -> SetF a a) -> Functor (SetF a)
forall a b. a -> SetF a b -> SetF a a
forall a b. (a -> b) -> SetF a a -> SetF a b
forall a a b. a -> SetF a b -> SetF a a
forall a a b. (a -> b) -> SetF a a -> SetF a 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 a b. (a -> b) -> SetF a a -> SetF a b
fmap :: forall a b. (a -> b) -> SetF a a -> SetF a b
$c<$ :: forall a a b. a -> SetF a b -> SetF a a
<$ :: forall a b. a -> SetF a b -> SetF a a
Functor,
      (forall a. SetF a a -> Rep1 (SetF a) a)
-> (forall a. Rep1 (SetF a) a -> SetF a a) -> Generic1 (SetF a)
forall a. Rep1 (SetF a) a -> SetF a a
forall a. SetF a a -> Rep1 (SetF a) a
forall a a. Rep1 (SetF a) a -> SetF a a
forall a a. SetF a a -> Rep1 (SetF a) a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cfrom1 :: forall a a. SetF a a -> Rep1 (SetF a) a
from1 :: forall a. SetF a a -> Rep1 (SetF a) a
$cto1 :: forall a a. Rep1 (SetF a) a -> SetF a a
to1 :: forall a. Rep1 (SetF a) a -> SetF a a
Generic1,
      Functor (SetF a)
Foldable (SetF a)
(Functor (SetF a), Foldable (SetF a)) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> SetF a a -> f (SetF a b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    SetF a (f a) -> f (SetF a a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> SetF a a -> m (SetF a b))
-> (forall (m :: * -> *) a.
    Monad m =>
    SetF a (m a) -> m (SetF a a))
-> Traversable (SetF a)
forall a. Functor (SetF a)
forall a. Foldable (SetF a)
forall a (m :: * -> *) a. Monad m => SetF a (m a) -> m (SetF a a)
forall a (f :: * -> *) a.
Applicative f =>
SetF a (f a) -> f (SetF a a)
forall a (m :: * -> *) a b.
Monad m =>
(a -> m b) -> SetF a a -> m (SetF a b)
forall a (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> SetF a a -> f (SetF a b)
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 => SetF a (m a) -> m (SetF a a)
forall (f :: * -> *) a.
Applicative f =>
SetF a (f a) -> f (SetF a a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> SetF a a -> m (SetF a b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> SetF a a -> f (SetF a b)
$ctraverse :: forall a (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> SetF a a -> f (SetF a b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> SetF a a -> f (SetF a b)
$csequenceA :: forall a (f :: * -> *) a.
Applicative f =>
SetF a (f a) -> f (SetF a a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
SetF a (f a) -> f (SetF a a)
$cmapM :: forall a (m :: * -> *) a b.
Monad m =>
(a -> m b) -> SetF a a -> m (SetF a b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> SetF a a -> m (SetF a b)
$csequence :: forall a (m :: * -> *) a. Monad m => SetF a (m a) -> m (SetF a a)
sequence :: forall (m :: * -> *) a. Monad m => SetF a (m a) -> m (SetF a a)
Traversable
    )

instance Projectable (->) (Set.Set a) (SetF a) where
  project :: Coalgebra (->) (SetF a) (Set a)
project Set a
Set.Tip = SetF a (Set a)
forall a r. SetF a r
TipF
  project (Set.Bin Size
size a
a Set a
l Set a
r) = Size -> a -> Set a -> Coalgebra (->) (SetF a) (Set a)
forall a r. Size -> a -> r -> r -> SetF a r
BinF Size
size a
a Set a
l Set a
r

instance Recursive (->) (Set.Set a) (SetF a) where
  cata :: forall a. Algebra (->) (SetF a) a -> Set a -> a
cata Algebra (->) (SetF a) a
φ = Algebra (->) (SetF a) a
φ Algebra (->) (SetF a) a -> (Set a -> SetF a a) -> Set a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. (Set a -> a) -> SetF a (Set a) -> SetF a a
forall a b. (a -> b) -> SetF a a -> SetF a b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Algebra (->) (SetF a) a -> Set a -> a
forall a. Algebra (->) (SetF a) a -> Set a -> a
forall {k} {k1} (c :: k -> k1 -> *) (t :: k) (f :: k1 -> k)
       (a :: k1).
Recursive c t f =>
Algebra c f a -> c t a
cata Algebra (->) (SetF a) a
φ) (SetF a (Set a) -> SetF a a)
-> (Set a -> SetF a (Set a)) -> Set a -> SetF a a
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Set a -> SetF a (Set a)
forall {k} {k1} (c :: k -> k1 -> *) (t :: k) (f :: k -> k1).
Projectable c t f =>
Coalgebra c f t
project

instance Steppable (->) (Set.Set a) (SetF a) where
  embed :: Algebra (->) (SetF a) (Set a)
embed SetF a (Set a)
TipF = Set a
forall a. Set a
Set.Tip
  embed (BinF Size
size a
a Set a
l Set a
r) = Size -> a -> Set a -> Set a -> Set a
forall a. Size -> a -> Set a -> Set a -> Set a
Set.Bin Size
size a
a Set a
l Set a
r

instance (Eq a) => Eq1 (SetF a) where
  -- TODO: Remove this once base-4.18 is the oldest supported verson, as it’s
  --       the default impl.
  liftEq :: forall a b. (a -> b -> Bool) -> SetF a a -> SetF a b -> Bool
liftEq = (a -> a -> Bool)
-> (a -> b -> Bool) -> SetF a a -> SetF a b -> Bool
forall a b c d.
(a -> b -> Bool)
-> (c -> d -> Bool) -> SetF a c -> SetF b d -> Bool
forall (f :: * -> * -> *) a b c d.
Eq2 f =>
(a -> b -> Bool) -> (c -> d -> Bool) -> f a c -> f b d -> Bool
liftEq2 a -> a -> Bool
forall a. Eq a => a -> a -> Bool
(==)

instance Eq2 SetF where
  liftEq2 :: forall a b c d.
(a -> b -> Bool)
-> (c -> d -> Bool) -> SetF a c -> SetF b d -> Bool
liftEq2 a -> b -> Bool
f c -> d -> Bool
g = ((SetF a c, SetF b d) -> Bool) -> SetF a c -> SetF b d -> Bool
forall a b c. ((a, b) -> c) -> a -> b -> c
Tuple.curry (((SetF a c, SetF b d) -> Bool) -> SetF a c -> SetF b d -> Bool)
-> ((SetF a c, SetF b d) -> Bool) -> SetF a c -> SetF b d -> Bool
forall a b. (a -> b) -> a -> b
$ \case
    (SetF a c
TipF, SetF b d
TipF) -> Bool
True
    (BinF Size
size a
a c
l c
r, BinF Size
size' b
a' d
l' d
r') ->
      Size
size Size -> Size -> Bool
forall a. Eq a => a -> a -> Bool
== Size
size' Bool -> Bool -> Bool
&& a -> b -> Bool
f a
a b
a' Bool -> Bool -> Bool
&& c -> d -> Bool
g c
l d
l' Bool -> Bool -> Bool
&& c -> d -> Bool
g c
r d
r'
    (SetF a c
_, SetF b d
_) -> Bool
False

instance (Ord a) => Ord1 (SetF a) where
  -- TODO: Remove this once base-4.18 is the oldest supported verson, as it’s
  --       the default impl.
  liftCompare :: forall a b.
(a -> b -> Ordering) -> SetF a a -> SetF a b -> Ordering
liftCompare = (a -> a -> Ordering)
-> (a -> b -> Ordering) -> SetF a a -> SetF a b -> Ordering
forall a b c d.
(a -> b -> Ordering)
-> (c -> d -> Ordering) -> SetF a c -> SetF b d -> Ordering
forall (f :: * -> * -> *) a b c d.
Ord2 f =>
(a -> b -> Ordering)
-> (c -> d -> Ordering) -> f a c -> f b d -> Ordering
liftCompare2 a -> a -> Ordering
forall a. Ord a => a -> a -> Ordering
compare

instance Ord2 SetF where
  liftCompare2 :: forall a b c d.
(a -> b -> Ordering)
-> (c -> d -> Ordering) -> SetF a c -> SetF b d -> Ordering
liftCompare2 a -> b -> Ordering
f c -> d -> Ordering
g = ((SetF a c, SetF b d) -> Ordering)
-> SetF a c -> SetF b d -> Ordering
forall a b c. ((a, b) -> c) -> a -> b -> c
Tuple.curry (((SetF a c, SetF b d) -> Ordering)
 -> SetF a c -> SetF b d -> Ordering)
-> ((SetF a c, SetF b d) -> Ordering)
-> SetF a c
-> SetF b d
-> Ordering
forall a b. (a -> b) -> a -> b
$ \case
    (SetF a c
TipF, SetF b d
TipF) -> Ordering
EQ
    (SetF a c
TipF, BinF {}) -> Ordering
LT
    (BinF {}, SetF b d
TipF) -> Ordering
GT
    (BinF Size
size a
a c
l c
r, BinF Size
size' b
a' d
l' d
r') ->
      Size -> Size -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Size
size Size
size' Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> a -> b -> Ordering
f a
a b
a' Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> c -> d -> Ordering
g c
l d
l' Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> c -> d -> Ordering
g c
r d
r'

instance (Show a) => Show1 (SetF a) where
  -- TODO: Remove this once base-4.18 is the oldest supported verson, as it’s
  --       the default impl.
  liftShowsPrec :: forall a.
(Size -> a -> ShowS) -> ([a] -> ShowS) -> Size -> SetF a a -> ShowS
liftShowsPrec = (Size -> a -> ShowS)
-> ([a] -> ShowS)
-> (Size -> a -> ShowS)
-> ([a] -> ShowS)
-> Size
-> SetF a a
-> ShowS
forall a b.
(Size -> a -> ShowS)
-> ([a] -> ShowS)
-> (Size -> b -> ShowS)
-> ([b] -> ShowS)
-> Size
-> SetF a b
-> ShowS
forall (f :: * -> * -> *) a b.
Show2 f =>
(Size -> a -> ShowS)
-> ([a] -> ShowS)
-> (Size -> b -> ShowS)
-> ([b] -> ShowS)
-> Size
-> f a b
-> ShowS
liftShowsPrec2 Size -> a -> ShowS
forall a. Show a => Size -> a -> ShowS
showsPrec [a] -> ShowS
forall a. Show a => [a] -> ShowS
showList

instance Show2 SetF where
  liftShowsPrec2 :: forall a b.
(Size -> a -> ShowS)
-> ([a] -> ShowS)
-> (Size -> b -> ShowS)
-> ([b] -> ShowS)
-> Size
-> SetF a b
-> ShowS
liftShowsPrec2 Size -> a -> ShowS
showsPrecA [a] -> ShowS
_showListA Size -> b -> ShowS
showsPrecR [b] -> ShowS
_showListR Size
prec =
    let appPrec :: a
appPrec = a
10
        nextPrec :: a
nextPrec = a
forall {a}. Num a => a
appPrec a -> a -> a
forall a. Num a => a -> a -> a
+ a
1
     in \case
          SetF a b
TipF -> String -> ShowS
showString String
"TipF"
          BinF Size
size a
a b
l b
r ->
            Bool -> ShowS -> ShowS
showParen (Size
forall {a}. Num a => a
nextPrec Size -> Size -> Bool
forall a. Ord a => a -> a -> Bool
<= Size
prec) (ShowS -> ShowS) -> ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$
              String -> ShowS
showString String
"BinF "
                ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Size -> Size -> ShowS
forall a. Show a => Size -> a -> ShowS
showsPrec Size
forall {a}. Num a => a
nextPrec Size
size
                ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. String -> ShowS
showString String
" "
                ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Size -> a -> ShowS
showsPrecA Size
forall {a}. Num a => a
nextPrec a
a
                ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. String -> ShowS
showString String
" "
                ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Size -> b -> ShowS
showsPrecR Size
forall {a}. Num a => a
nextPrec b
l
                ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. String -> ShowS
showString String
" "
                ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Size -> b -> ShowS
showsPrecR Size
forall {a}. Num a => a
nextPrec b
r