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

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

import "base" Control.Applicative
  ( Alternative ((<|>)),
    Applicative ((<*>)),
    (*>),
  )
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.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" GHC.Read (Read (readListPrec, readPrec), expectP, parens)
import "base" Text.ParserCombinators.ReadPrec (prec, step)
import qualified "base" Text.Read.Lex as Lex
import qualified "containers" Data.Set.Internal as Set
import "yaya" Yaya.Fold
  ( Projectable (project),
    Recursive (cata),
    Steppable (embed),
  )
import "base" Prelude (Num ((+)))
#if MIN_VERSION_base(4, 18, 0)
import "base" Data.Functor.Classes
  ( Eq1,
    Eq2 (liftEq2),
    Ord1,
    Ord2 (liftCompare2),
    Read1 (liftReadPrec),
    Read2 (liftReadPrec2),
    Show1,
    Show2 (liftShowsPrec2),
  )
import "base" Text.Show (Show (showsPrec), showParen, showString)
#else
import "base" Data.Functor.Classes
  ( Eq1 (liftEq),
    Eq2 (liftEq2),
    Ord1 (liftCompare),
    Ord2 (liftCompare2),
    Read1 (liftReadPrec),
    Read2 (liftReadPrec2),
    Show1 (liftShowsPrec),
    Show2 (liftShowsPrec2),
  )
import "base" Text.Show (Show (showList, showsPrec), showParen, showString)
#endif

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,
      -- | @since 0.1.2.0
      ReadPrec [SetF a r]
ReadPrec (SetF a r)
Size -> ReadS (SetF a r)
ReadS [SetF a r]
(Size -> ReadS (SetF a r))
-> ReadS [SetF a r]
-> ReadPrec (SetF a r)
-> ReadPrec [SetF a r]
-> Read (SetF a r)
forall a.
(Size -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
forall a r. (Read a, Read r) => ReadPrec [SetF a r]
forall a r. (Read a, Read r) => ReadPrec (SetF a r)
forall a r. (Read a, Read r) => Size -> ReadS (SetF a r)
forall a r. (Read a, Read r) => ReadS [SetF a r]
$creadsPrec :: forall a r. (Read a, Read r) => Size -> ReadS (SetF a r)
readsPrec :: Size -> ReadS (SetF a r)
$creadList :: forall a r. (Read a, Read r) => ReadS [SetF a r]
readList :: ReadS [SetF a r]
$creadPrec :: forall a r. (Read a, Read r) => ReadPrec (SetF a r)
readPrec :: ReadPrec (SetF a r)
$creadListPrec :: forall a r. (Read a, Read r) => ReadPrec [SetF a r]
readListPrec :: ReadPrec [SetF a r]
Read,
      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

#if MIN_VERSION_base(4, 18, 0)
instance (Eq a) => Eq1 (SetF a)
#else
instance (Eq a) => Eq1 (SetF a) where
  liftEq = liftEq2 (==)
#endif

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

#if MIN_VERSION_base(4, 18, 0)
instance (Ord a) => Ord1 (SetF a)
#else
instance (Ord a) => Ord1 (SetF a) where
  liftCompare = liftCompare2 compare
#endif

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'

-- | @since 0.1.2.0
instance (Read a) => Read1 (SetF a) where
  liftReadPrec :: forall a. ReadPrec a -> ReadPrec [a] -> ReadPrec (SetF a a)
liftReadPrec = ReadPrec a
-> ReadPrec [a]
-> ReadPrec a
-> ReadPrec [a]
-> ReadPrec (SetF a a)
forall a b.
ReadPrec a
-> ReadPrec [a]
-> ReadPrec b
-> ReadPrec [b]
-> ReadPrec (SetF a b)
forall (f :: * -> * -> *) a b.
Read2 f =>
ReadPrec a
-> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (f a b)
liftReadPrec2 ReadPrec a
forall a. Read a => ReadPrec a
readPrec ReadPrec [a]
forall a. Read a => ReadPrec [a]
readListPrec

-- | @since 0.1.2.0
instance Read2 SetF where
  liftReadPrec2 :: forall a b.
ReadPrec a
-> ReadPrec [a]
-> ReadPrec b
-> ReadPrec [b]
-> ReadPrec (SetF a b)
liftReadPrec2 ReadPrec a
readPrecA ReadPrec [a]
_ ReadPrec b
readPrecR ReadPrec [b]
_ =
    let appPrec :: a
appPrec = a
10
     in ReadPrec (SetF a b) -> ReadPrec (SetF a b)
forall a. ReadPrec a -> ReadPrec a
parens (ReadPrec (SetF a b) -> ReadPrec (SetF a b))
-> (ReadPrec (SetF a b) -> ReadPrec (SetF a b))
-> ReadPrec (SetF a b)
-> ReadPrec (SetF a b)
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 -> ReadPrec (SetF a b) -> ReadPrec (SetF a b)
forall a. Size -> ReadPrec a -> ReadPrec a
prec Size
forall {a}. Num a => a
appPrec (ReadPrec (SetF a b) -> ReadPrec (SetF a b))
-> ReadPrec (SetF a b) -> ReadPrec (SetF a b)
forall a b. (a -> b) -> a -> b
$
          SetF a b
forall a r. SetF a r
TipF
            SetF a b -> ReadPrec () -> ReadPrec (SetF a b)
forall a b. a -> ReadPrec b -> ReadPrec a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Lexeme -> ReadPrec ()
expectP (String -> Lexeme
Lex.Ident String
"TipF")
            ReadPrec (SetF a b) -> ReadPrec (SetF a b) -> ReadPrec (SetF a b)
forall a. ReadPrec a -> ReadPrec a -> ReadPrec a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Lexeme -> ReadPrec ()
expectP (String -> Lexeme
Lex.Ident String
"BinF")
              ReadPrec () -> ReadPrec (SetF a b) -> ReadPrec (SetF a b)
forall a b. ReadPrec a -> ReadPrec b -> ReadPrec b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ( Size -> a -> b -> b -> SetF a b
forall a r. Size -> a -> r -> r -> SetF a r
BinF
                     (Size -> a -> b -> b -> SetF a b)
-> ReadPrec Size -> ReadPrec (a -> b -> b -> SetF a b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ReadPrec Size -> ReadPrec Size
forall a. ReadPrec a -> ReadPrec a
step ReadPrec Size
forall a. Read a => ReadPrec a
readPrec
                     ReadPrec (a -> b -> b -> SetF a b)
-> ReadPrec a -> ReadPrec (b -> b -> SetF a b)
forall a b. ReadPrec (a -> b) -> ReadPrec a -> ReadPrec b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ReadPrec a -> ReadPrec a
forall a. ReadPrec a -> ReadPrec a
step ReadPrec a
readPrecA
                     ReadPrec (b -> b -> SetF a b)
-> ReadPrec b -> ReadPrec (b -> SetF a b)
forall a b. ReadPrec (a -> b) -> ReadPrec a -> ReadPrec b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ReadPrec b -> ReadPrec b
forall a. ReadPrec a -> ReadPrec a
step ReadPrec b
readPrecR
                     ReadPrec (b -> SetF a b) -> ReadPrec b -> ReadPrec (SetF a b)
forall a b. ReadPrec (a -> b) -> ReadPrec a -> ReadPrec b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ReadPrec b -> ReadPrec b
forall a. ReadPrec a -> ReadPrec a
step ReadPrec b
readPrecR
                 )

#if MIN_VERSION_base(4, 18, 0)
instance (Show a) => Show1 (SetF a)
#else
instance (Show a) => Show1 (SetF a) where
  liftShowsPrec = liftShowsPrec2 showsPrec showList
#endif

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
_ Size -> b -> ShowS
showsPrecR [b] -> ShowS
_ Size
p =
    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
p) (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