{-# LANGUAGE CPP #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DefaultSignatures #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE InstanceSigs #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE QuantifiedConstraints #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}

module Grisette.Experimental.GenSymConstrained
  ( -- * Symbolic value generation with errors
    GenSymConstrained (..),
    GenSymSimpleConstrained (..),
    genSymConstrained,
    genSymSimpleConstrained,
    derivedFreshConstrainedNoSpec,
    derivedSimpleFreshConstrainedNoSpec,
    derivedSimpleFreshConstrainedSameShape,

    -- * Some common GenSymConstrained specifications
    SOrdUpperBound (..),
    SOrdLowerBound (..),
    SOrdBound (..),
  )
where

import Control.Monad.Except (ExceptT (ExceptT), MonadError (throwError))
import Control.Monad.Trans.Maybe (MaybeT (MaybeT))
import GHC.Generics
  ( Generic (Rep, from, to),
    K1 (K1),
    M1 (M1),
    U1 (U1),
    type (:*:) ((:*:)),
    type (:+:) (L1, R1),
  )
import Grisette.Core.Control.Monad.UnionM
  ( UnionM,
    liftToMonadUnion,
  )
import Grisette.Core.Data.Class.GenSym
  ( FreshIdent,
    GenSym (fresh),
    GenSymSimple (simpleFresh),
    ListSpec (ListSpec),
    MonadFresh,
    SimpleListSpec (SimpleListSpec),
    chooseFresh,
    chooseUnionFresh,
    runFreshT,
  )
import Grisette.Core.Data.Class.LogicalOp (LogicalOp ((.||)))
import Grisette.Core.Data.Class.Mergeable (Mergeable, Mergeable1)
import Grisette.Core.Data.Class.SOrd (SOrd ((.<), (.>=)))
import Grisette.Core.Data.Class.SimpleMergeable
  ( UnionLike,
    merge,
    mrgIf,
    mrgSingle,
  )

-- $setup
-- >>> import Grisette.Core
-- >>> import Grisette.Experimental
-- >>> import Grisette.IR.SymPrim
-- >>> :set -XOverloadedStrings
-- >>> :set -XTypeApplications

-- | Class of types in which symbolic values can be generated with some
-- specification.
--
-- See 'GenSym' for more details. The difference of this class is that it allows
-- constraints to be generated along with the generation of symbolic values.
class (Mergeable a) => GenSymConstrained spec a where
  -- | Generates a symbolic value with the given specification.
  --
  -- Constraint violations will throw an error in the monadic environment.
  --
  -- >>> runFreshT (freshConstrained () (SOrdUpperBound (1 :: SymInteger) ())) "a" :: ExceptT () UnionM (UnionM SymInteger)
  -- ExceptT <If (<= 1 a@0) (Left ()) (Right {a@0})>
  freshConstrained ::
    (MonadFresh m, MonadError e m, UnionLike m) =>
    e ->
    spec ->
    m (UnionM a)
  default freshConstrained ::
    (GenSymSimpleConstrained spec a) =>
    ( MonadFresh m,
      MonadError e m,
      UnionLike m
    ) =>
    e ->
    spec ->
    m (UnionM a)
  freshConstrained e
e spec
spec = a -> UnionM a
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle (a -> UnionM a) -> m a -> m (UnionM a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> e -> spec -> m a
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> spec -> m a
simpleFreshConstrained e
e spec
spec

genSymConstrained :: forall spec a e. (GenSymConstrained spec a, Mergeable e) => e -> spec -> FreshIdent -> ExceptT e UnionM (UnionM a)
genSymConstrained :: forall spec a e.
(GenSymConstrained spec a, Mergeable e) =>
e -> spec -> FreshIdent -> ExceptT e UnionM (UnionM a)
genSymConstrained e
e spec
spec = ExceptT e UnionM (UnionM a) -> ExceptT e UnionM (UnionM a)
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => u a -> u a
merge (ExceptT e UnionM (UnionM a) -> ExceptT e UnionM (UnionM a))
-> (FreshIdent -> ExceptT e UnionM (UnionM a))
-> FreshIdent
-> ExceptT e UnionM (UnionM a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FreshT (ExceptT e UnionM) (UnionM a)
-> FreshIdent -> ExceptT e UnionM (UnionM a)
forall (m :: * -> *) a. Monad m => FreshT m a -> FreshIdent -> m a
runFreshT (e -> spec -> FreshT (ExceptT e UnionM) (UnionM a)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> spec -> m (UnionM a)
freshConstrained e
e spec
spec)

-- | Class of types in which symbolic values can be generated with some
-- specification.
--
-- See 'GenSymSimple' for more details. The difference of this class is that it allows
-- constraints to be generated along with the generation of symbolic values.
class (Mergeable a) => GenSymSimpleConstrained spec a where
  -- | Generates a symbolic value with the given specification.
  --
  -- Constraint violations will throw an error in the monadic environment.
  --
  -- >>> runFreshT (simpleFreshConstrained () (SOrdUpperBound (1 :: SymInteger) ())) "a" :: ExceptT () UnionM SymInteger
  -- ExceptT <If (<= 1 a@0) (Left ()) (Right a@0)>
  simpleFreshConstrained ::
    (MonadFresh m, MonadError e m, UnionLike m) =>
    e ->
    spec ->
    m a

genSymSimpleConstrained :: forall spec a e. (GenSymSimpleConstrained spec a, Mergeable e) => e -> spec -> FreshIdent -> ExceptT e UnionM a
genSymSimpleConstrained :: forall spec a e.
(GenSymSimpleConstrained spec a, Mergeable e) =>
e -> spec -> FreshIdent -> ExceptT e UnionM a
genSymSimpleConstrained e
e spec
spec = ExceptT e UnionM a -> ExceptT e UnionM a
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => u a -> u a
merge (ExceptT e UnionM a -> ExceptT e UnionM a)
-> (FreshIdent -> ExceptT e UnionM a)
-> FreshIdent
-> ExceptT e UnionM a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FreshT (ExceptT e UnionM) a -> FreshIdent -> ExceptT e UnionM a
forall (m :: * -> *) a. Monad m => FreshT m a -> FreshIdent -> m a
runFreshT (e -> spec -> FreshT (ExceptT e UnionM) a
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> spec -> m a
simpleFreshConstrained e
e spec
spec)

instance {-# OVERLAPPABLE #-} (Mergeable a, GenSym spec a) => GenSymConstrained spec a where
  freshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> spec -> m (UnionM a)
freshConstrained e
_ = spec -> m (UnionM a)
forall spec a (m :: * -> *).
(GenSym spec a, MonadFresh m) =>
spec -> m (UnionM a)
forall (m :: * -> *). MonadFresh m => spec -> m (UnionM a)
fresh

instance {-# OVERLAPPABLE #-} (Mergeable a, GenSymSimple spec a) => GenSymSimpleConstrained spec a where
  simpleFreshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> spec -> m a
simpleFreshConstrained e
_ = spec -> m a
forall spec a (m :: * -> *).
(GenSymSimple spec a, MonadFresh m) =>
spec -> m a
forall (m :: * -> *). MonadFresh m => spec -> m a
simpleFresh

-- | Exclusive bound, generates the values with the specification, then filters
-- out the ones that are greater than or equal to the bound
data SOrdUpperBound a spec = SOrdUpperBound a spec

instance {-# OVERLAPPABLE #-} (SOrd a, Mergeable a, GenSym spec a) => GenSymConstrained (SOrdUpperBound a spec) a where
  freshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> SOrdUpperBound a spec -> m (UnionM a)
freshConstrained e
e (SOrdUpperBound a
u spec
spec) = do
    UnionM a
s <- spec -> m (UnionM a)
forall spec a (m :: * -> *).
(GenSym spec a, MonadFresh m) =>
spec -> m (UnionM a)
forall (m :: * -> *). MonadFresh m => spec -> m (UnionM a)
fresh spec
spec
    a
v <- UnionM a -> m a
forall a (u :: * -> *).
(Mergeable a, MonadUnion u) =>
UnionM a -> u a
liftToMonadUnion UnionM a
s
    SymBool -> m () -> m () -> m ()
forall (u :: * -> *) a.
(UnionLike u, Mergeable a) =>
SymBool -> u a -> u a -> u a
mrgIf (a
v a -> a -> SymBool
forall a. SOrd a => a -> a -> SymBool
.>= a
u) (e -> m ()
forall a. e -> m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError e
e) (() -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ())
    UnionM a -> m (UnionM a)
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle (UnionM a -> m (UnionM a)) -> UnionM a -> m (UnionM a)
forall a b. (a -> b) -> a -> b
$ a -> UnionM a
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle a
v

instance {-# OVERLAPPABLE #-} (SOrd a, Mergeable a, GenSymSimple spec a) => GenSymSimpleConstrained (SOrdUpperBound a spec) a where
  simpleFreshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> SOrdUpperBound a spec -> m a
simpleFreshConstrained e
e (SOrdUpperBound a
u spec
spec) = do
    a
s <- spec -> m a
forall spec a (m :: * -> *).
(GenSymSimple spec a, MonadFresh m) =>
spec -> m a
forall (m :: * -> *). MonadFresh m => spec -> m a
simpleFresh spec
spec
    SymBool -> m () -> m () -> m ()
forall (u :: * -> *) a.
(UnionLike u, Mergeable a) =>
SymBool -> u a -> u a -> u a
mrgIf (a
s a -> a -> SymBool
forall a. SOrd a => a -> a -> SymBool
.>= a
u) (e -> m ()
forall a. e -> m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError e
e) (() -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ())
    a -> m a
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle a
s

-- | Inclusive bound, generates the values with the specification, then filters
-- out the ones that are less than the bound
data SOrdLowerBound a spec = SOrdLowerBound a spec

instance {-# OVERLAPPABLE #-} (SOrd a, Mergeable a, GenSym spec a) => GenSymConstrained (SOrdLowerBound a spec) a where
  freshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> SOrdLowerBound a spec -> m (UnionM a)
freshConstrained e
e (SOrdLowerBound a
l spec
spec) = do
    UnionM a
s <- spec -> m (UnionM a)
forall spec a (m :: * -> *).
(GenSym spec a, MonadFresh m) =>
spec -> m (UnionM a)
forall (m :: * -> *). MonadFresh m => spec -> m (UnionM a)
fresh spec
spec
    a
v <- UnionM a -> m a
forall a (u :: * -> *).
(Mergeable a, MonadUnion u) =>
UnionM a -> u a
liftToMonadUnion UnionM a
s
    SymBool -> m () -> m () -> m ()
forall (u :: * -> *) a.
(UnionLike u, Mergeable a) =>
SymBool -> u a -> u a -> u a
mrgIf (a
v a -> a -> SymBool
forall a. SOrd a => a -> a -> SymBool
.< a
l) (e -> m ()
forall a. e -> m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError e
e) (() -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ())
    UnionM a -> m (UnionM a)
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle (UnionM a -> m (UnionM a)) -> UnionM a -> m (UnionM a)
forall a b. (a -> b) -> a -> b
$ a -> UnionM a
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle a
v

instance {-# OVERLAPPABLE #-} (SOrd a, Mergeable a, GenSymSimple spec a) => GenSymSimpleConstrained (SOrdLowerBound a spec) a where
  simpleFreshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> SOrdLowerBound a spec -> m a
simpleFreshConstrained e
e (SOrdLowerBound a
l spec
spec) = do
    a
s <- spec -> m a
forall spec a (m :: * -> *).
(GenSymSimple spec a, MonadFresh m) =>
spec -> m a
forall (m :: * -> *). MonadFresh m => spec -> m a
simpleFresh spec
spec
    SymBool -> m () -> m () -> m ()
forall (u :: * -> *) a.
(UnionLike u, Mergeable a) =>
SymBool -> u a -> u a -> u a
mrgIf (a
s a -> a -> SymBool
forall a. SOrd a => a -> a -> SymBool
.< a
l) (e -> m ()
forall a. e -> m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError e
e) (() -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ())
    a -> m a
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle a
s

-- | Left-inclusive, right-exclusive bound, generates the values with the
-- specification, then filters out the ones that are out-of-bound
data SOrdBound a spec = SOrdBound a a spec

instance {-# OVERLAPPABLE #-} (SOrd a, Mergeable a, GenSym spec a) => GenSymConstrained (SOrdBound a spec) a where
  freshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> SOrdBound a spec -> m (UnionM a)
freshConstrained e
e (SOrdBound a
l a
u spec
spec) = do
    UnionM a
s <- spec -> m (UnionM a)
forall spec a (m :: * -> *).
(GenSym spec a, MonadFresh m) =>
spec -> m (UnionM a)
forall (m :: * -> *). MonadFresh m => spec -> m (UnionM a)
fresh spec
spec
    a
v <- UnionM a -> m a
forall a (u :: * -> *).
(Mergeable a, MonadUnion u) =>
UnionM a -> u a
liftToMonadUnion UnionM a
s
    SymBool -> m () -> m () -> m ()
forall (u :: * -> *) a.
(UnionLike u, Mergeable a) =>
SymBool -> u a -> u a -> u a
mrgIf (a
v a -> a -> SymBool
forall a. SOrd a => a -> a -> SymBool
.< a
l SymBool -> SymBool -> SymBool
forall b. LogicalOp b => b -> b -> b
.|| a
v a -> a -> SymBool
forall a. SOrd a => a -> a -> SymBool
.>= a
u) (e -> m ()
forall a. e -> m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError e
e) (() -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ())
    UnionM a -> m (UnionM a)
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle (UnionM a -> m (UnionM a)) -> UnionM a -> m (UnionM a)
forall a b. (a -> b) -> a -> b
$ a -> UnionM a
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle a
v

instance {-# OVERLAPPABLE #-} (SOrd a, Mergeable a, GenSymSimple spec a) => GenSymSimpleConstrained (SOrdBound a spec) a where
  simpleFreshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> SOrdBound a spec -> m a
simpleFreshConstrained e
e (SOrdBound a
l a
u spec
spec) = do
    a
s <- spec -> m a
forall spec a (m :: * -> *).
(GenSymSimple spec a, MonadFresh m) =>
spec -> m a
forall (m :: * -> *). MonadFresh m => spec -> m a
simpleFresh spec
spec
    SymBool -> m () -> m () -> m ()
forall (u :: * -> *) a.
(UnionLike u, Mergeable a) =>
SymBool -> u a -> u a -> u a
mrgIf (a
s a -> a -> SymBool
forall a. SOrd a => a -> a -> SymBool
.< a
l SymBool -> SymBool -> SymBool
forall b. LogicalOp b => b -> b -> b
.|| a
s a -> a -> SymBool
forall a. SOrd a => a -> a -> SymBool
.>= a
u) (e -> m ()
forall a. e -> m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError e
e) (() -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ())
    a -> m a
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle a
s

instance GenSymConstrained (SOrdBound Integer ()) Integer where
  freshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> SOrdBound Integer () -> m (UnionM Integer)
freshConstrained e
_ (SOrdBound Integer
l Integer
r ()
_) = [Integer] -> m (UnionM Integer)
forall a (m :: * -> *).
(Mergeable a, MonadFresh m) =>
[a] -> m (UnionM a)
chooseFresh [Integer
l .. Integer
r Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
- Integer
1]

-- Either
instance
  ( GenSymConstrained aspec a,
    Mergeable a,
    GenSymConstrained bspec b,
    Mergeable b
  ) =>
  GenSymConstrained (Either aspec bspec) (Either a b)
  where
  freshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> Either aspec bspec -> m (UnionM (Either a b))
freshConstrained e
e (Left aspec
aspec) = m (UnionM (Either a b)) -> m (UnionM (Either a b))
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => u a -> u a
merge (m (UnionM (Either a b)) -> m (UnionM (Either a b)))
-> m (UnionM (Either a b)) -> m (UnionM (Either a b))
forall a b. (a -> b) -> a -> b
$ (UnionM (Either a b) -> UnionM (Either a b)
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => u a -> u a
merge (UnionM (Either a b) -> UnionM (Either a b))
-> (UnionM a -> UnionM (Either a b))
-> UnionM a
-> UnionM (Either a b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Either a b) -> UnionM a -> UnionM (Either a b)
forall a b. (a -> b) -> UnionM a -> UnionM b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> Either a b
forall a b. a -> Either a b
Left) (UnionM a -> UnionM (Either a b))
-> m (UnionM a) -> m (UnionM (Either a b))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> e -> aspec -> m (UnionM a)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> aspec -> m (UnionM a)
freshConstrained e
e aspec
aspec
  freshConstrained e
e (Right bspec
bspec) = m (UnionM (Either a b)) -> m (UnionM (Either a b))
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => u a -> u a
merge (m (UnionM (Either a b)) -> m (UnionM (Either a b)))
-> m (UnionM (Either a b)) -> m (UnionM (Either a b))
forall a b. (a -> b) -> a -> b
$ (UnionM (Either a b) -> UnionM (Either a b)
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => u a -> u a
merge (UnionM (Either a b) -> UnionM (Either a b))
-> (UnionM b -> UnionM (Either a b))
-> UnionM b
-> UnionM (Either a b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (b -> Either a b) -> UnionM b -> UnionM (Either a b)
forall a b. (a -> b) -> UnionM a -> UnionM b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap b -> Either a b
forall a b. b -> Either a b
Right) (UnionM b -> UnionM (Either a b))
-> m (UnionM b) -> m (UnionM (Either a b))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> e -> bspec -> m (UnionM b)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> bspec -> m (UnionM b)
freshConstrained e
e bspec
bspec

instance
  ( GenSymSimpleConstrained a a,
    GenSymSimpleConstrained b b
  ) =>
  GenSymSimpleConstrained (Either a b) (Either a b)
  where
  simpleFreshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> Either a b -> m (Either a b)
simpleFreshConstrained = e -> Either a b -> m (Either a b)
forall a (m :: * -> *) e.
(Generic a, GenSymConstrainedSameShape (Rep a), Mergeable a,
 MonadFresh m, MonadError e m, UnionLike m) =>
e -> a -> m a
derivedSimpleFreshConstrainedSameShape

instance
  (GenSymConstrained () a, Mergeable a, GenSymConstrained () b, Mergeable b) =>
  GenSymConstrained () (Either a b)
  where
  freshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> () -> m (UnionM (Either a b))
freshConstrained = e -> () -> m (UnionM (Either a b))
forall a (m :: * -> *) e.
(Generic a, GenSymConstrainedNoSpec (Rep a), Mergeable a,
 MonadFresh m, MonadError e m, UnionLike m) =>
e -> () -> m (UnionM a)
derivedFreshConstrainedNoSpec

-- Maybe
instance
  (GenSymConstrained aspec a, Mergeable a) =>
  GenSymConstrained (Maybe aspec) (Maybe a)
  where
  freshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> Maybe aspec -> m (UnionM (Maybe a))
freshConstrained e
_ Maybe aspec
Nothing = UnionM (Maybe a) -> m (UnionM (Maybe a))
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle (UnionM (Maybe a) -> m (UnionM (Maybe a)))
-> UnionM (Maybe a) -> m (UnionM (Maybe a))
forall a b. (a -> b) -> a -> b
$ Maybe a -> UnionM (Maybe a)
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle Maybe a
forall a. Maybe a
Nothing
  freshConstrained e
e (Just aspec
aspec) = m (UnionM (Maybe a)) -> m (UnionM (Maybe a))
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => u a -> u a
merge (m (UnionM (Maybe a)) -> m (UnionM (Maybe a)))
-> m (UnionM (Maybe a)) -> m (UnionM (Maybe a))
forall a b. (a -> b) -> a -> b
$ (UnionM (Maybe a) -> UnionM (Maybe a)
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => u a -> u a
merge (UnionM (Maybe a) -> UnionM (Maybe a))
-> (UnionM a -> UnionM (Maybe a)) -> UnionM a -> UnionM (Maybe a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Maybe a) -> UnionM a -> UnionM (Maybe a)
forall a b. (a -> b) -> UnionM a -> UnionM b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> Maybe a
forall a. a -> Maybe a
Just) (UnionM a -> UnionM (Maybe a))
-> m (UnionM a) -> m (UnionM (Maybe a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> e -> aspec -> m (UnionM a)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> aspec -> m (UnionM a)
freshConstrained e
e aspec
aspec

instance
  (GenSymSimpleConstrained aspec a) =>
  GenSymSimpleConstrained (Maybe aspec) (Maybe a)
  where
  simpleFreshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> Maybe aspec -> m (Maybe a)
simpleFreshConstrained e
_ Maybe aspec
Nothing = Maybe a -> m (Maybe a)
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle Maybe a
forall a. Maybe a
Nothing
  simpleFreshConstrained e
e (Just aspec
aspec) = m (Maybe a) -> m (Maybe a)
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => u a -> u a
merge (m (Maybe a) -> m (Maybe a)) -> m (Maybe a) -> m (Maybe a)
forall a b. (a -> b) -> a -> b
$ a -> Maybe a
forall a. a -> Maybe a
Just (a -> Maybe a) -> m a -> m (Maybe a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> e -> aspec -> m a
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> aspec -> m a
simpleFreshConstrained e
e aspec
aspec

instance (GenSymConstrained aspec a, Mergeable a) => GenSymConstrained aspec (Maybe a) where
  freshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> aspec -> m (UnionM (Maybe a))
freshConstrained e
e aspec
aspec = do
    UnionM a
a :: UnionM a <- e -> aspec -> m (UnionM a)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> aspec -> m (UnionM a)
freshConstrained e
e aspec
aspec
    m (UnionM (Maybe a)) -> m (UnionM (Maybe a))
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => u a -> u a
merge (m (UnionM (Maybe a)) -> m (UnionM (Maybe a)))
-> m (UnionM (Maybe a)) -> m (UnionM (Maybe a))
forall a b. (a -> b) -> a -> b
$ [UnionM (Maybe a)] -> m (UnionM (Maybe a))
forall a (m :: * -> *).
(Mergeable a, MonadFresh m) =>
[UnionM a] -> m (UnionM a)
chooseUnionFresh [Maybe a -> UnionM (Maybe a)
forall a. a -> UnionM a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe a
forall a. Maybe a
Nothing, a -> Maybe a
forall a. a -> Maybe a
Just (a -> Maybe a) -> UnionM a -> UnionM (Maybe a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> UnionM a
a]

-- List
instance
  (GenSymConstrained () a, Mergeable a) =>
  GenSymConstrained Integer [a]
  where
  freshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> Integer -> m (UnionM [a])
freshConstrained e
e Integer
v = do
    [UnionM a]
l <- e -> Integer -> m [UnionM a]
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> Integer -> m [UnionM a]
gl e
e Integer
v
    let xs :: [[UnionM a]]
xs = [[UnionM a]] -> [[UnionM a]]
forall a. [a] -> [a]
reverse ([[UnionM a]] -> [[UnionM a]]) -> [[UnionM a]] -> [[UnionM a]]
forall a b. (a -> b) -> a -> b
$ (UnionM a -> [UnionM a] -> [UnionM a])
-> [UnionM a] -> [UnionM a] -> [[UnionM a]]
forall a b. (a -> b -> b) -> b -> [a] -> [b]
scanr (:) [] [UnionM a]
l
    m (UnionM [a]) -> m (UnionM [a])
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => u a -> u a
merge (m (UnionM [a]) -> m (UnionM [a]))
-> m (UnionM [a]) -> m (UnionM [a])
forall a b. (a -> b) -> a -> b
$ [UnionM [a]] -> m (UnionM [a])
forall a (m :: * -> *).
(Mergeable a, MonadFresh m) =>
[UnionM a] -> m (UnionM a)
chooseUnionFresh ([UnionM [a]] -> m (UnionM [a])) -> [UnionM [a]] -> m (UnionM [a])
forall a b. (a -> b) -> a -> b
$ UnionM [a] -> UnionM [a]
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => u a -> u a
merge (UnionM [a] -> UnionM [a])
-> ([UnionM a] -> UnionM [a]) -> [UnionM a] -> UnionM [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [UnionM a] -> UnionM [a]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence ([UnionM a] -> UnionM [a]) -> [[UnionM a]] -> [UnionM [a]]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [[UnionM a]]
xs
    where
      gl :: (MonadFresh m, MonadError e m, UnionLike m) => e -> Integer -> m [UnionM a]
      gl :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> Integer -> m [UnionM a]
gl e
e1 Integer
v1
        | Integer
v1 Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
<= Integer
0 = [UnionM a] -> m [UnionM a]
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle []
        | Bool
otherwise = do
            UnionM a
l <- e -> () -> m (UnionM a)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> () -> m (UnionM a)
freshConstrained e
e1 ()
            [UnionM a]
r <- e -> Integer -> m [UnionM a]
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> Integer -> m [UnionM a]
gl e
e1 (Integer
v1 Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
- Integer
1)
            [UnionM a] -> m [UnionM a]
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle ([UnionM a] -> m [UnionM a]) -> [UnionM a] -> m [UnionM a]
forall a b. (a -> b) -> a -> b
$ UnionM a
l UnionM a -> [UnionM a] -> [UnionM a]
forall a. a -> [a] -> [a]
: [UnionM a]
r

instance
  (GenSymConstrained spec a, Mergeable a) =>
  GenSymConstrained (ListSpec spec) [a]
  where
  freshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> ListSpec spec -> m (UnionM [a])
freshConstrained e
e (ListSpec Int
minLen Int
maxLen spec
subSpec) =
    if Int
minLen Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0 Bool -> Bool -> Bool
|| Int
maxLen Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0 Bool -> Bool -> Bool
|| Int
minLen Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
maxLen
      then [Char] -> m (UnionM [a])
forall a. HasCallStack => [Char] -> a
error ([Char] -> m (UnionM [a])) -> [Char] -> m (UnionM [a])
forall a b. (a -> b) -> a -> b
$ [Char]
"Bad lengths: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ (Int, Int) -> [Char]
forall a. Show a => a -> [Char]
show (Int
minLen, Int
maxLen)
      else do
        [UnionM a]
l <- e -> Int -> m [UnionM a]
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> Int -> m [UnionM a]
gl e
e Int
maxLen
        let xs :: [[UnionM a]]
xs = Int -> [[UnionM a]] -> [[UnionM a]]
forall a. Int -> [a] -> [a]
drop Int
minLen ([[UnionM a]] -> [[UnionM a]]) -> [[UnionM a]] -> [[UnionM a]]
forall a b. (a -> b) -> a -> b
$ [[UnionM a]] -> [[UnionM a]]
forall a. [a] -> [a]
reverse ([[UnionM a]] -> [[UnionM a]]) -> [[UnionM a]] -> [[UnionM a]]
forall a b. (a -> b) -> a -> b
$ (UnionM a -> [UnionM a] -> [UnionM a])
-> [UnionM a] -> [UnionM a] -> [[UnionM a]]
forall a b. (a -> b -> b) -> b -> [a] -> [b]
scanr (:) [] [UnionM a]
l
        m (UnionM [a]) -> m (UnionM [a])
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => u a -> u a
merge (m (UnionM [a]) -> m (UnionM [a]))
-> m (UnionM [a]) -> m (UnionM [a])
forall a b. (a -> b) -> a -> b
$ [UnionM [a]] -> m (UnionM [a])
forall a (m :: * -> *).
(Mergeable a, MonadFresh m) =>
[UnionM a] -> m (UnionM a)
chooseUnionFresh ([UnionM [a]] -> m (UnionM [a])) -> [UnionM [a]] -> m (UnionM [a])
forall a b. (a -> b) -> a -> b
$ UnionM [a] -> UnionM [a]
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => u a -> u a
merge (UnionM [a] -> UnionM [a])
-> ([UnionM a] -> UnionM [a]) -> [UnionM a] -> UnionM [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [UnionM a] -> UnionM [a]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence ([UnionM a] -> UnionM [a]) -> [[UnionM a]] -> [UnionM [a]]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [[UnionM a]]
xs
    where
      gl :: (MonadFresh m, MonadError e m, UnionLike m) => e -> Int -> m [UnionM a]
      gl :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> Int -> m [UnionM a]
gl e
e1 Int
currLen
        | Int
currLen Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0 = [UnionM a] -> m [UnionM a]
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return []
        | Bool
otherwise = do
            UnionM a
l <- e -> spec -> m (UnionM a)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> spec -> m (UnionM a)
freshConstrained e
e1 spec
subSpec
            [UnionM a]
r <- e -> Int -> m [UnionM a]
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> Int -> m [UnionM a]
gl e
e1 (Int
currLen Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)
            [UnionM a] -> m [UnionM a]
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ([UnionM a] -> m [UnionM a]) -> [UnionM a] -> m [UnionM a]
forall a b. (a -> b) -> a -> b
$ UnionM a
l UnionM a -> [UnionM a] -> [UnionM a]
forall a. a -> [a] -> [a]
: [UnionM a]
r

instance
  (GenSymConstrained a a, Mergeable a) =>
  GenSymConstrained [a] [a]
  where
  freshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> [a] -> m (UnionM [a])
freshConstrained e
e [a]
l = do
    [UnionM a]
r :: [UnionM a] <- (a -> m (UnionM a)) -> [a] -> m [UnionM a]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse (e -> a -> m (UnionM a)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> a -> m (UnionM a)
freshConstrained e
e) [a]
l
    UnionM [a] -> m (UnionM [a])
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle (UnionM [a] -> m (UnionM [a])) -> UnionM [a] -> m (UnionM [a])
forall a b. (a -> b) -> a -> b
$ UnionM [a] -> UnionM [a]
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => u a -> u a
merge (UnionM [a] -> UnionM [a]) -> UnionM [a] -> UnionM [a]
forall a b. (a -> b) -> a -> b
$ [UnionM a] -> UnionM [a]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [UnionM a]
r

instance
  (GenSymSimpleConstrained a a) =>
  GenSymSimpleConstrained [a] [a]
  where
  simpleFreshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> [a] -> m [a]
simpleFreshConstrained = e -> [a] -> m [a]
forall a (m :: * -> *) e.
(Generic a, GenSymConstrainedSameShape (Rep a), Mergeable a,
 MonadFresh m, MonadError e m, UnionLike m) =>
e -> a -> m a
derivedSimpleFreshConstrainedSameShape

instance
  (GenSymConstrained spec a, Mergeable a) =>
  GenSymConstrained (SimpleListSpec spec) [a]
  where
  freshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> SimpleListSpec spec -> m (UnionM [a])
freshConstrained e
e (SimpleListSpec Int
len spec
subSpec) =
    if Int
len Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0
      then [Char] -> m (UnionM [a])
forall a. HasCallStack => [Char] -> a
error ([Char] -> m (UnionM [a])) -> [Char] -> m (UnionM [a])
forall a b. (a -> b) -> a -> b
$ [Char]
"Bad lengths: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
len
      else do
        m (UnionM [a]) -> m (UnionM [a])
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => u a -> u a
merge (m (UnionM [a]) -> m (UnionM [a]))
-> m (UnionM [a]) -> m (UnionM [a])
forall a b. (a -> b) -> a -> b
$ UnionM [a] -> UnionM [a]
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => u a -> u a
merge (UnionM [a] -> UnionM [a])
-> ([UnionM a] -> UnionM [a]) -> [UnionM a] -> UnionM [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [UnionM a] -> UnionM [a]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence ([UnionM a] -> UnionM [a]) -> m [UnionM a] -> m (UnionM [a])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> e -> Int -> m [UnionM a]
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> Int -> m [UnionM a]
gl e
e Int
len
    where
      gl :: (MonadFresh m, MonadError e m, UnionLike m) => e -> Int -> m [UnionM a]
      gl :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> Int -> m [UnionM a]
gl e
e1 Int
currLen
        | Int
currLen Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0 = [UnionM a] -> m [UnionM a]
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle []
        | Bool
otherwise = do
            UnionM a
l <- e -> spec -> m (UnionM a)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> spec -> m (UnionM a)
freshConstrained e
e1 spec
subSpec
            [UnionM a]
r <- e -> Int -> m [UnionM a]
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> Int -> m [UnionM a]
gl e
e1 (Int
currLen Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)
            [UnionM a] -> m [UnionM a]
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle ([UnionM a] -> m [UnionM a]) -> [UnionM a] -> m [UnionM a]
forall a b. (a -> b) -> a -> b
$ UnionM a
l UnionM a -> [UnionM a] -> [UnionM a]
forall a. a -> [a] -> [a]
: [UnionM a]
r

instance
  (GenSymSimpleConstrained spec a) =>
  GenSymSimpleConstrained (SimpleListSpec spec) [a]
  where
  simpleFreshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> SimpleListSpec spec -> m [a]
simpleFreshConstrained e
e (SimpleListSpec Int
len spec
subSpec) =
    if Int
len Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0
      then [Char] -> m [a]
forall a. HasCallStack => [Char] -> a
error ([Char] -> m [a]) -> [Char] -> m [a]
forall a b. (a -> b) -> a -> b
$ [Char]
"Bad lengths: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
len
      else do
        e -> Int -> m [a]
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> Int -> m [a]
gl e
e Int
len
    where
      gl :: (MonadFresh m, MonadError e m, UnionLike m) => e -> Int -> m [a]
      gl :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> Int -> m [a]
gl e
e1 Int
currLen
        | Int
currLen Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0 = [a] -> m [a]
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle []
        | Bool
otherwise = do
            a
l <- e -> spec -> m a
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> spec -> m a
simpleFreshConstrained e
e1 spec
subSpec
            [a]
r <- e -> Int -> m [a]
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> Int -> m [a]
gl e
e1 (Int
currLen Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)
            [a] -> m [a]
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle ([a] -> m [a]) -> [a] -> m [a]
forall a b. (a -> b) -> a -> b
$ a
l a -> [a] -> [a]
forall a. a -> [a] -> [a]
: [a]
r

-- (,)
instance
  ( GenSymConstrained aspec a,
    Mergeable a,
    GenSymConstrained bspec b,
    Mergeable b
  ) =>
  GenSymConstrained (aspec, bspec) (a, b)
  where
  freshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> (aspec, bspec) -> m (UnionM (a, b))
freshConstrained e
err (aspec
aspec, bspec
bspec) = do
    UnionM a
a1 <- e -> aspec -> m (UnionM a)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> aspec -> m (UnionM a)
freshConstrained e
err aspec
aspec
    UnionM b
b1 <- e -> bspec -> m (UnionM b)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> bspec -> m (UnionM b)
freshConstrained e
err bspec
bspec
    UnionM (a, b) -> m (UnionM (a, b))
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle (UnionM (a, b) -> m (UnionM (a, b)))
-> UnionM (a, b) -> m (UnionM (a, b))
forall a b. (a -> b) -> a -> b
$ do
      a
ax <- UnionM a
a1
      b
bx <- UnionM b
b1
      (a, b) -> UnionM (a, b)
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle (a
ax, b
bx)

instance
  ( GenSymSimpleConstrained aspec a,
    GenSymSimpleConstrained bspec b
  ) =>
  GenSymSimpleConstrained (aspec, bspec) (a, b)
  where
  simpleFreshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> (aspec, bspec) -> m (a, b)
simpleFreshConstrained e
e (aspec
aspec, bspec
bspec) = do
    m (a, b) -> m (a, b)
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => u a -> u a
merge (m (a, b) -> m (a, b)) -> m (a, b) -> m (a, b)
forall a b. (a -> b) -> a -> b
$
      (,)
        (a -> b -> (a, b)) -> m a -> m (b -> (a, b))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> e -> aspec -> m a
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> aspec -> m a
simpleFreshConstrained e
e aspec
aspec
        m (b -> (a, b)) -> m b -> m (a, b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> e -> bspec -> m b
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> bspec -> m b
simpleFreshConstrained e
e bspec
bspec

-- (,,)
instance
  ( GenSymConstrained aspec a,
    Mergeable a,
    GenSymConstrained bspec b,
    Mergeable b,
    GenSymConstrained cspec c,
    Mergeable c
  ) =>
  GenSymConstrained (aspec, bspec, cspec) (a, b, c)
  where
  freshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> (aspec, bspec, cspec) -> m (UnionM (a, b, c))
freshConstrained e
err (aspec
aspec, bspec
bspec, cspec
cspec) = do
    UnionM a
a1 <- e -> aspec -> m (UnionM a)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> aspec -> m (UnionM a)
freshConstrained e
err aspec
aspec
    UnionM b
b1 <- e -> bspec -> m (UnionM b)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> bspec -> m (UnionM b)
freshConstrained e
err bspec
bspec
    UnionM c
c1 <- e -> cspec -> m (UnionM c)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> cspec -> m (UnionM c)
freshConstrained e
err cspec
cspec
    UnionM (a, b, c) -> m (UnionM (a, b, c))
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle (UnionM (a, b, c) -> m (UnionM (a, b, c)))
-> UnionM (a, b, c) -> m (UnionM (a, b, c))
forall a b. (a -> b) -> a -> b
$ do
      a
ax <- UnionM a
a1
      b
bx <- UnionM b
b1
      c
cx <- UnionM c
c1
      (a, b, c) -> UnionM (a, b, c)
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle (a
ax, b
bx, c
cx)

instance
  ( GenSymSimpleConstrained aspec a,
    GenSymSimpleConstrained bspec b,
    GenSymSimpleConstrained cspec c
  ) =>
  GenSymSimpleConstrained (aspec, bspec, cspec) (a, b, c)
  where
  simpleFreshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> (aspec, bspec, cspec) -> m (a, b, c)
simpleFreshConstrained e
e (aspec
aspec, bspec
bspec, cspec
cspec) = do
    m (a, b, c) -> m (a, b, c)
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => u a -> u a
merge (m (a, b, c) -> m (a, b, c)) -> m (a, b, c) -> m (a, b, c)
forall a b. (a -> b) -> a -> b
$
      (,,)
        (a -> b -> c -> (a, b, c)) -> m a -> m (b -> c -> (a, b, c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> e -> aspec -> m a
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> aspec -> m a
simpleFreshConstrained e
e aspec
aspec
        m (b -> c -> (a, b, c)) -> m b -> m (c -> (a, b, c))
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> e -> bspec -> m b
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> bspec -> m b
simpleFreshConstrained e
e bspec
bspec
        m (c -> (a, b, c)) -> m c -> m (a, b, c)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> e -> cspec -> m c
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> cspec -> m c
simpleFreshConstrained e
e cspec
cspec

-- (,,,)
instance
  ( GenSymConstrained aspec a,
    Mergeable a,
    GenSymConstrained bspec b,
    Mergeable b,
    GenSymConstrained cspec c,
    Mergeable c,
    GenSymConstrained dspec d,
    Mergeable d
  ) =>
  GenSymConstrained (aspec, bspec, cspec, dspec) (a, b, c, d)
  where
  freshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> (aspec, bspec, cspec, dspec) -> m (UnionM (a, b, c, d))
freshConstrained e
err (aspec
aspec, bspec
bspec, cspec
cspec, dspec
dspec) = do
    UnionM a
a1 <- e -> aspec -> m (UnionM a)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> aspec -> m (UnionM a)
freshConstrained e
err aspec
aspec
    UnionM b
b1 <- e -> bspec -> m (UnionM b)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> bspec -> m (UnionM b)
freshConstrained e
err bspec
bspec
    UnionM c
c1 <- e -> cspec -> m (UnionM c)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> cspec -> m (UnionM c)
freshConstrained e
err cspec
cspec
    UnionM d
d1 <- e -> dspec -> m (UnionM d)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> dspec -> m (UnionM d)
freshConstrained e
err dspec
dspec
    UnionM (a, b, c, d) -> m (UnionM (a, b, c, d))
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle (UnionM (a, b, c, d) -> m (UnionM (a, b, c, d)))
-> UnionM (a, b, c, d) -> m (UnionM (a, b, c, d))
forall a b. (a -> b) -> a -> b
$ do
      a
ax <- UnionM a
a1
      b
bx <- UnionM b
b1
      c
cx <- UnionM c
c1
      d
dx <- UnionM d
d1
      (a, b, c, d) -> UnionM (a, b, c, d)
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle (a
ax, b
bx, c
cx, d
dx)

instance
  ( GenSymSimpleConstrained aspec a,
    GenSymSimpleConstrained bspec b,
    GenSymSimpleConstrained cspec c,
    GenSymSimpleConstrained dspec d
  ) =>
  GenSymSimpleConstrained (aspec, bspec, cspec, dspec) (a, b, c, d)
  where
  simpleFreshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> (aspec, bspec, cspec, dspec) -> m (a, b, c, d)
simpleFreshConstrained e
e (aspec
aspec, bspec
bspec, cspec
cspec, dspec
dspec) = do
    m (a, b, c, d) -> m (a, b, c, d)
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => u a -> u a
merge (m (a, b, c, d) -> m (a, b, c, d))
-> m (a, b, c, d) -> m (a, b, c, d)
forall a b. (a -> b) -> a -> b
$
      (,,,)
        (a -> b -> c -> d -> (a, b, c, d))
-> m a -> m (b -> c -> d -> (a, b, c, d))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> e -> aspec -> m a
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> aspec -> m a
simpleFreshConstrained e
e aspec
aspec
        m (b -> c -> d -> (a, b, c, d))
-> m b -> m (c -> d -> (a, b, c, d))
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> e -> bspec -> m b
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> bspec -> m b
simpleFreshConstrained e
e bspec
bspec
        m (c -> d -> (a, b, c, d)) -> m c -> m (d -> (a, b, c, d))
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> e -> cspec -> m c
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> cspec -> m c
simpleFreshConstrained e
e cspec
cspec
        m (d -> (a, b, c, d)) -> m d -> m (a, b, c, d)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> e -> dspec -> m d
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> dspec -> m d
simpleFreshConstrained e
e dspec
dspec

-- (,,,,)
instance
  ( GenSymConstrained aspec a,
    Mergeable a,
    GenSymConstrained bspec b,
    Mergeable b,
    GenSymConstrained cspec c,
    Mergeable c,
    GenSymConstrained dspec d,
    Mergeable d,
    GenSymConstrained espec e,
    Mergeable e
  ) =>
  GenSymConstrained (aspec, bspec, cspec, dspec, espec) (a, b, c, d, e)
  where
  freshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e
-> (aspec, bspec, cspec, dspec, espec)
-> m (UnionM (a, b, c, d, e))
freshConstrained e
err (aspec
aspec, bspec
bspec, cspec
cspec, dspec
dspec, espec
espec) = do
    UnionM a
a1 <- e -> aspec -> m (UnionM a)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> aspec -> m (UnionM a)
freshConstrained e
err aspec
aspec
    UnionM b
b1 <- e -> bspec -> m (UnionM b)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> bspec -> m (UnionM b)
freshConstrained e
err bspec
bspec
    UnionM c
c1 <- e -> cspec -> m (UnionM c)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> cspec -> m (UnionM c)
freshConstrained e
err cspec
cspec
    UnionM d
d1 <- e -> dspec -> m (UnionM d)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> dspec -> m (UnionM d)
freshConstrained e
err dspec
dspec
    UnionM e
e1 <- e -> espec -> m (UnionM e)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> espec -> m (UnionM e)
freshConstrained e
err espec
espec
    UnionM (a, b, c, d, e) -> m (UnionM (a, b, c, d, e))
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle (UnionM (a, b, c, d, e) -> m (UnionM (a, b, c, d, e)))
-> UnionM (a, b, c, d, e) -> m (UnionM (a, b, c, d, e))
forall a b. (a -> b) -> a -> b
$ do
      a
ax <- UnionM a
a1
      b
bx <- UnionM b
b1
      c
cx <- UnionM c
c1
      d
dx <- UnionM d
d1
      e
ex <- UnionM e
e1
      (a, b, c, d, e) -> UnionM (a, b, c, d, e)
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle (a
ax, b
bx, c
cx, d
dx, e
ex)

instance
  ( GenSymSimpleConstrained aspec a,
    GenSymSimpleConstrained bspec b,
    GenSymSimpleConstrained cspec c,
    GenSymSimpleConstrained dspec d,
    GenSymSimpleConstrained espec e
  ) =>
  GenSymSimpleConstrained (aspec, bspec, cspec, dspec, espec) (a, b, c, d, e)
  where
  simpleFreshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> (aspec, bspec, cspec, dspec, espec) -> m (a, b, c, d, e)
simpleFreshConstrained e
e (aspec
aspec, bspec
bspec, cspec
cspec, dspec
dspec, espec
espec) = do
    m (a, b, c, d, e) -> m (a, b, c, d, e)
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => u a -> u a
merge (m (a, b, c, d, e) -> m (a, b, c, d, e))
-> m (a, b, c, d, e) -> m (a, b, c, d, e)
forall a b. (a -> b) -> a -> b
$
      (,,,,)
        (a -> b -> c -> d -> e -> (a, b, c, d, e))
-> m a -> m (b -> c -> d -> e -> (a, b, c, d, e))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> e -> aspec -> m a
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> aspec -> m a
simpleFreshConstrained e
e aspec
aspec
        m (b -> c -> d -> e -> (a, b, c, d, e))
-> m b -> m (c -> d -> e -> (a, b, c, d, e))
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> e -> bspec -> m b
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> bspec -> m b
simpleFreshConstrained e
e bspec
bspec
        m (c -> d -> e -> (a, b, c, d, e))
-> m c -> m (d -> e -> (a, b, c, d, e))
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> e -> cspec -> m c
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> cspec -> m c
simpleFreshConstrained e
e cspec
cspec
        m (d -> e -> (a, b, c, d, e)) -> m d -> m (e -> (a, b, c, d, e))
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> e -> dspec -> m d
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> dspec -> m d
simpleFreshConstrained e
e dspec
dspec
        m (e -> (a, b, c, d, e)) -> m e -> m (a, b, c, d, e)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> e -> espec -> m e
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> espec -> m e
simpleFreshConstrained e
e espec
espec

-- (,,,,,)
instance
  ( GenSymConstrained aspec a,
    Mergeable a,
    GenSymConstrained bspec b,
    Mergeable b,
    GenSymConstrained cspec c,
    Mergeable c,
    GenSymConstrained dspec d,
    Mergeable d,
    GenSymConstrained espec e,
    Mergeable e,
    GenSymConstrained fspec f,
    Mergeable f
  ) =>
  GenSymConstrained (aspec, bspec, cspec, dspec, espec, fspec) (a, b, c, d, e, f)
  where
  freshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e
-> (aspec, bspec, cspec, dspec, espec, fspec)
-> m (UnionM (a, b, c, d, e, f))
freshConstrained e
err (aspec
aspec, bspec
bspec, cspec
cspec, dspec
dspec, espec
espec, fspec
fspec) = do
    UnionM a
a1 <- e -> aspec -> m (UnionM a)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> aspec -> m (UnionM a)
freshConstrained e
err aspec
aspec
    UnionM b
b1 <- e -> bspec -> m (UnionM b)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> bspec -> m (UnionM b)
freshConstrained e
err bspec
bspec
    UnionM c
c1 <- e -> cspec -> m (UnionM c)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> cspec -> m (UnionM c)
freshConstrained e
err cspec
cspec
    UnionM d
d1 <- e -> dspec -> m (UnionM d)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> dspec -> m (UnionM d)
freshConstrained e
err dspec
dspec
    UnionM e
e1 <- e -> espec -> m (UnionM e)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> espec -> m (UnionM e)
freshConstrained e
err espec
espec
    UnionM f
f1 <- e -> fspec -> m (UnionM f)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> fspec -> m (UnionM f)
freshConstrained e
err fspec
fspec
    UnionM (a, b, c, d, e, f) -> m (UnionM (a, b, c, d, e, f))
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle (UnionM (a, b, c, d, e, f) -> m (UnionM (a, b, c, d, e, f)))
-> UnionM (a, b, c, d, e, f) -> m (UnionM (a, b, c, d, e, f))
forall a b. (a -> b) -> a -> b
$ do
      a
ax <- UnionM a
a1
      b
bx <- UnionM b
b1
      c
cx <- UnionM c
c1
      d
dx <- UnionM d
d1
      e
ex <- UnionM e
e1
      f
fx <- UnionM f
f1
      (a, b, c, d, e, f) -> UnionM (a, b, c, d, e, f)
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle (a
ax, b
bx, c
cx, d
dx, e
ex, f
fx)

instance
  ( GenSymSimpleConstrained aspec a,
    GenSymSimpleConstrained bspec b,
    GenSymSimpleConstrained cspec c,
    GenSymSimpleConstrained dspec d,
    GenSymSimpleConstrained espec e,
    GenSymSimpleConstrained fspec f
  ) =>
  GenSymSimpleConstrained (aspec, bspec, cspec, dspec, espec, fspec) (a, b, c, d, e, f)
  where
  simpleFreshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e
-> (aspec, bspec, cspec, dspec, espec, fspec)
-> m (a, b, c, d, e, f)
simpleFreshConstrained e
e (aspec
aspec, bspec
bspec, cspec
cspec, dspec
dspec, espec
espec, fspec
fspec) = do
    m (a, b, c, d, e, f) -> m (a, b, c, d, e, f)
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => u a -> u a
merge (m (a, b, c, d, e, f) -> m (a, b, c, d, e, f))
-> m (a, b, c, d, e, f) -> m (a, b, c, d, e, f)
forall a b. (a -> b) -> a -> b
$
      (,,,,,)
        (a -> b -> c -> d -> e -> f -> (a, b, c, d, e, f))
-> m a -> m (b -> c -> d -> e -> f -> (a, b, c, d, e, f))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> e -> aspec -> m a
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> aspec -> m a
simpleFreshConstrained e
e aspec
aspec
        m (b -> c -> d -> e -> f -> (a, b, c, d, e, f))
-> m b -> m (c -> d -> e -> f -> (a, b, c, d, e, f))
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> e -> bspec -> m b
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> bspec -> m b
simpleFreshConstrained e
e bspec
bspec
        m (c -> d -> e -> f -> (a, b, c, d, e, f))
-> m c -> m (d -> e -> f -> (a, b, c, d, e, f))
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> e -> cspec -> m c
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> cspec -> m c
simpleFreshConstrained e
e cspec
cspec
        m (d -> e -> f -> (a, b, c, d, e, f))
-> m d -> m (e -> f -> (a, b, c, d, e, f))
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> e -> dspec -> m d
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> dspec -> m d
simpleFreshConstrained e
e dspec
dspec
        m (e -> f -> (a, b, c, d, e, f))
-> m e -> m (f -> (a, b, c, d, e, f))
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> e -> espec -> m e
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> espec -> m e
simpleFreshConstrained e
e espec
espec
        m (f -> (a, b, c, d, e, f)) -> m f -> m (a, b, c, d, e, f)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> e -> fspec -> m f
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> fspec -> m f
simpleFreshConstrained e
e fspec
fspec

-- (,,,,,,)
instance
  ( GenSymConstrained aspec a,
    Mergeable a,
    GenSymConstrained bspec b,
    Mergeable b,
    GenSymConstrained cspec c,
    Mergeable c,
    GenSymConstrained dspec d,
    Mergeable d,
    GenSymConstrained espec e,
    Mergeable e,
    GenSymConstrained fspec f,
    Mergeable f,
    GenSymConstrained gspec g,
    Mergeable g
  ) =>
  GenSymConstrained (aspec, bspec, cspec, dspec, espec, fspec, gspec) (a, b, c, d, e, f, g)
  where
  freshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e
-> (aspec, bspec, cspec, dspec, espec, fspec, gspec)
-> m (UnionM (a, b, c, d, e, f, g))
freshConstrained e
err (aspec
aspec, bspec
bspec, cspec
cspec, dspec
dspec, espec
espec, fspec
fspec, gspec
gspec) = do
    UnionM a
a1 <- e -> aspec -> m (UnionM a)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> aspec -> m (UnionM a)
freshConstrained e
err aspec
aspec
    UnionM b
b1 <- e -> bspec -> m (UnionM b)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> bspec -> m (UnionM b)
freshConstrained e
err bspec
bspec
    UnionM c
c1 <- e -> cspec -> m (UnionM c)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> cspec -> m (UnionM c)
freshConstrained e
err cspec
cspec
    UnionM d
d1 <- e -> dspec -> m (UnionM d)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> dspec -> m (UnionM d)
freshConstrained e
err dspec
dspec
    UnionM e
e1 <- e -> espec -> m (UnionM e)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> espec -> m (UnionM e)
freshConstrained e
err espec
espec
    UnionM f
f1 <- e -> fspec -> m (UnionM f)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> fspec -> m (UnionM f)
freshConstrained e
err fspec
fspec
    UnionM g
g1 <- e -> gspec -> m (UnionM g)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> gspec -> m (UnionM g)
freshConstrained e
err gspec
gspec
    UnionM (a, b, c, d, e, f, g) -> m (UnionM (a, b, c, d, e, f, g))
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle (UnionM (a, b, c, d, e, f, g) -> m (UnionM (a, b, c, d, e, f, g)))
-> UnionM (a, b, c, d, e, f, g) -> m (UnionM (a, b, c, d, e, f, g))
forall a b. (a -> b) -> a -> b
$ do
      a
ax <- UnionM a
a1
      b
bx <- UnionM b
b1
      c
cx <- UnionM c
c1
      d
dx <- UnionM d
d1
      e
ex <- UnionM e
e1
      f
fx <- UnionM f
f1
      g
gx <- UnionM g
g1
      (a, b, c, d, e, f, g) -> UnionM (a, b, c, d, e, f, g)
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle (a
ax, b
bx, c
cx, d
dx, e
ex, f
fx, g
gx)

instance
  ( GenSymSimpleConstrained aspec a,
    GenSymSimpleConstrained bspec b,
    GenSymSimpleConstrained cspec c,
    GenSymSimpleConstrained dspec d,
    GenSymSimpleConstrained espec e,
    GenSymSimpleConstrained fspec f,
    GenSymSimpleConstrained gspec g
  ) =>
  GenSymSimpleConstrained (aspec, bspec, cspec, dspec, espec, fspec, gspec) (a, b, c, d, e, f, g)
  where
  simpleFreshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e
-> (aspec, bspec, cspec, dspec, espec, fspec, gspec)
-> m (a, b, c, d, e, f, g)
simpleFreshConstrained e
e (aspec
aspec, bspec
bspec, cspec
cspec, dspec
dspec, espec
espec, fspec
fspec, gspec
gspec) = do
    m (a, b, c, d, e, f, g) -> m (a, b, c, d, e, f, g)
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => u a -> u a
merge (m (a, b, c, d, e, f, g) -> m (a, b, c, d, e, f, g))
-> m (a, b, c, d, e, f, g) -> m (a, b, c, d, e, f, g)
forall a b. (a -> b) -> a -> b
$
      (,,,,,,)
        (a -> b -> c -> d -> e -> f -> g -> (a, b, c, d, e, f, g))
-> m a -> m (b -> c -> d -> e -> f -> g -> (a, b, c, d, e, f, g))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> e -> aspec -> m a
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> aspec -> m a
simpleFreshConstrained e
e aspec
aspec
        m (b -> c -> d -> e -> f -> g -> (a, b, c, d, e, f, g))
-> m b -> m (c -> d -> e -> f -> g -> (a, b, c, d, e, f, g))
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> e -> bspec -> m b
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> bspec -> m b
simpleFreshConstrained e
e bspec
bspec
        m (c -> d -> e -> f -> g -> (a, b, c, d, e, f, g))
-> m c -> m (d -> e -> f -> g -> (a, b, c, d, e, f, g))
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> e -> cspec -> m c
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> cspec -> m c
simpleFreshConstrained e
e cspec
cspec
        m (d -> e -> f -> g -> (a, b, c, d, e, f, g))
-> m d -> m (e -> f -> g -> (a, b, c, d, e, f, g))
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> e -> dspec -> m d
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> dspec -> m d
simpleFreshConstrained e
e dspec
dspec
        m (e -> f -> g -> (a, b, c, d, e, f, g))
-> m e -> m (f -> g -> (a, b, c, d, e, f, g))
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> e -> espec -> m e
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> espec -> m e
simpleFreshConstrained e
e espec
espec
        m (f -> g -> (a, b, c, d, e, f, g))
-> m f -> m (g -> (a, b, c, d, e, f, g))
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> e -> fspec -> m f
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> fspec -> m f
simpleFreshConstrained e
e fspec
fspec
        m (g -> (a, b, c, d, e, f, g)) -> m g -> m (a, b, c, d, e, f, g)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> e -> gspec -> m g
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> gspec -> m g
simpleFreshConstrained e
e gspec
gspec

-- (,,,,,,,)
instance
  ( GenSymConstrained aspec a,
    Mergeable a,
    GenSymConstrained bspec b,
    Mergeable b,
    GenSymConstrained cspec c,
    Mergeable c,
    GenSymConstrained dspec d,
    Mergeable d,
    GenSymConstrained espec e,
    Mergeable e,
    GenSymConstrained fspec f,
    Mergeable f,
    GenSymConstrained gspec g,
    Mergeable g,
    GenSymConstrained hspec h,
    Mergeable h
  ) =>
  GenSymConstrained (aspec, bspec, cspec, dspec, espec, fspec, gspec, hspec) (a, b, c, d, e, f, g, h)
  where
  freshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e
-> (aspec, bspec, cspec, dspec, espec, fspec, gspec, hspec)
-> m (UnionM (a, b, c, d, e, f, g, h))
freshConstrained e
err (aspec
aspec, bspec
bspec, cspec
cspec, dspec
dspec, espec
espec, fspec
fspec, gspec
gspec, hspec
hspec) = do
    UnionM a
a1 <- e -> aspec -> m (UnionM a)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> aspec -> m (UnionM a)
freshConstrained e
err aspec
aspec
    UnionM b
b1 <- e -> bspec -> m (UnionM b)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> bspec -> m (UnionM b)
freshConstrained e
err bspec
bspec
    UnionM c
c1 <- e -> cspec -> m (UnionM c)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> cspec -> m (UnionM c)
freshConstrained e
err cspec
cspec
    UnionM d
d1 <- e -> dspec -> m (UnionM d)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> dspec -> m (UnionM d)
freshConstrained e
err dspec
dspec
    UnionM e
e1 <- e -> espec -> m (UnionM e)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> espec -> m (UnionM e)
freshConstrained e
err espec
espec
    UnionM f
f1 <- e -> fspec -> m (UnionM f)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> fspec -> m (UnionM f)
freshConstrained e
err fspec
fspec
    UnionM g
g1 <- e -> gspec -> m (UnionM g)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> gspec -> m (UnionM g)
freshConstrained e
err gspec
gspec
    UnionM h
h1 <- e -> hspec -> m (UnionM h)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> hspec -> m (UnionM h)
freshConstrained e
err hspec
hspec
    UnionM (a, b, c, d, e, f, g, h)
-> m (UnionM (a, b, c, d, e, f, g, h))
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle (UnionM (a, b, c, d, e, f, g, h)
 -> m (UnionM (a, b, c, d, e, f, g, h)))
-> UnionM (a, b, c, d, e, f, g, h)
-> m (UnionM (a, b, c, d, e, f, g, h))
forall a b. (a -> b) -> a -> b
$ do
      a
ax <- UnionM a
a1
      b
bx <- UnionM b
b1
      c
cx <- UnionM c
c1
      d
dx <- UnionM d
d1
      e
ex <- UnionM e
e1
      f
fx <- UnionM f
f1
      g
gx <- UnionM g
g1
      h
hx <- UnionM h
h1
      (a, b, c, d, e, f, g, h) -> UnionM (a, b, c, d, e, f, g, h)
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle (a
ax, b
bx, c
cx, d
dx, e
ex, f
fx, g
gx, h
hx)

instance
  ( GenSymSimpleConstrained aspec a,
    GenSymSimpleConstrained bspec b,
    GenSymSimpleConstrained cspec c,
    GenSymSimpleConstrained dspec d,
    GenSymSimpleConstrained espec e,
    GenSymSimpleConstrained fspec f,
    GenSymSimpleConstrained gspec g,
    GenSymSimpleConstrained hspec h
  ) =>
  GenSymSimpleConstrained (aspec, bspec, cspec, dspec, espec, fspec, gspec, hspec) (a, b, c, d, e, f, g, h)
  where
  simpleFreshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e
-> (aspec, bspec, cspec, dspec, espec, fspec, gspec, hspec)
-> m (a, b, c, d, e, f, g, h)
simpleFreshConstrained e
e (aspec
aspec, bspec
bspec, cspec
cspec, dspec
dspec, espec
espec, fspec
fspec, gspec
gspec, hspec
hspec) = do
    m (a, b, c, d, e, f, g, h) -> m (a, b, c, d, e, f, g, h)
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => u a -> u a
merge (m (a, b, c, d, e, f, g, h) -> m (a, b, c, d, e, f, g, h))
-> m (a, b, c, d, e, f, g, h) -> m (a, b, c, d, e, f, g, h)
forall a b. (a -> b) -> a -> b
$
      (,,,,,,,)
        (a -> b -> c -> d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
-> m a
-> m (b -> c -> d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> e -> aspec -> m a
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> aspec -> m a
simpleFreshConstrained e
e aspec
aspec
        m (b -> c -> d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
-> m b
-> m (c -> d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> e -> bspec -> m b
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> bspec -> m b
simpleFreshConstrained e
e bspec
bspec
        m (c -> d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
-> m c -> m (d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> e -> cspec -> m c
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> cspec -> m c
simpleFreshConstrained e
e cspec
cspec
        m (d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
-> m d -> m (e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> e -> dspec -> m d
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> dspec -> m d
simpleFreshConstrained e
e dspec
dspec
        m (e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
-> m e -> m (f -> g -> h -> (a, b, c, d, e, f, g, h))
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> e -> espec -> m e
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> espec -> m e
simpleFreshConstrained e
e espec
espec
        m (f -> g -> h -> (a, b, c, d, e, f, g, h))
-> m f -> m (g -> h -> (a, b, c, d, e, f, g, h))
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> e -> fspec -> m f
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> fspec -> m f
simpleFreshConstrained e
e fspec
fspec
        m (g -> h -> (a, b, c, d, e, f, g, h))
-> m g -> m (h -> (a, b, c, d, e, f, g, h))
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> e -> gspec -> m g
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> gspec -> m g
simpleFreshConstrained e
e gspec
gspec
        m (h -> (a, b, c, d, e, f, g, h))
-> m h -> m (a, b, c, d, e, f, g, h)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> e -> hspec -> m h
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> hspec -> m h
simpleFreshConstrained e
e hspec
hspec

-- MaybeT
instance
  {-# OVERLAPPABLE #-}
  ( GenSymConstrained spec (m (Maybe a)),
    Mergeable1 m,
    Mergeable a
  ) =>
  GenSymConstrained spec (MaybeT m a)
  where
  freshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> spec -> m (UnionM (MaybeT m a))
freshConstrained e
e spec
v = do
    UnionM (m (Maybe a))
x <- e -> spec -> m (UnionM (m (Maybe a)))
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> spec -> m (UnionM (m (Maybe a)))
freshConstrained e
e spec
v
    UnionM (MaybeT m a) -> m (UnionM (MaybeT m a))
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle (UnionM (MaybeT m a) -> m (UnionM (MaybeT m a)))
-> UnionM (MaybeT m a) -> m (UnionM (MaybeT m a))
forall a b. (a -> b) -> a -> b
$ UnionM (MaybeT m a) -> UnionM (MaybeT m a)
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => u a -> u a
merge (UnionM (MaybeT m a) -> UnionM (MaybeT m a))
-> (UnionM (m (Maybe a)) -> UnionM (MaybeT m a))
-> UnionM (m (Maybe a))
-> UnionM (MaybeT m a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (m (Maybe a) -> MaybeT m a)
-> UnionM (m (Maybe a)) -> UnionM (MaybeT m a)
forall a b. (a -> b) -> UnionM a -> UnionM b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap m (Maybe a) -> MaybeT m a
forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a
MaybeT (UnionM (m (Maybe a)) -> UnionM (MaybeT m a))
-> UnionM (m (Maybe a)) -> UnionM (MaybeT m a)
forall a b. (a -> b) -> a -> b
$ UnionM (m (Maybe a))
x

instance
  {-# OVERLAPPABLE #-}
  ( GenSymSimpleConstrained spec (m (Maybe a)),
    Mergeable1 m,
    Mergeable a
  ) =>
  GenSymSimpleConstrained spec (MaybeT m a)
  where
  simpleFreshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> spec -> m (MaybeT m a)
simpleFreshConstrained e
e spec
v = m (MaybeT m a) -> m (MaybeT m a)
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => u a -> u a
merge (m (MaybeT m a) -> m (MaybeT m a))
-> m (MaybeT m a) -> m (MaybeT m a)
forall a b. (a -> b) -> a -> b
$ m (Maybe a) -> MaybeT m a
forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a
MaybeT (m (Maybe a) -> MaybeT m a) -> m (m (Maybe a)) -> m (MaybeT m a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> e -> spec -> m (m (Maybe a))
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> spec -> m (m (Maybe a))
simpleFreshConstrained e
e spec
v

instance
  {-# OVERLAPPING #-}
  ( GenSymSimpleConstrained (m (Maybe a)) (m (Maybe a)),
    Mergeable1 m,
    Mergeable a
  ) =>
  GenSymSimpleConstrained (MaybeT m a) (MaybeT m a)
  where
  simpleFreshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> MaybeT m a -> m (MaybeT m a)
simpleFreshConstrained e
e (MaybeT m (Maybe a)
v) = m (MaybeT m a) -> m (MaybeT m a)
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => u a -> u a
merge (m (MaybeT m a) -> m (MaybeT m a))
-> m (MaybeT m a) -> m (MaybeT m a)
forall a b. (a -> b) -> a -> b
$ m (Maybe a) -> MaybeT m a
forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a
MaybeT (m (Maybe a) -> MaybeT m a) -> m (m (Maybe a)) -> m (MaybeT m a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> e -> m (Maybe a) -> m (m (Maybe a))
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> m (Maybe a) -> m (m (Maybe a))
simpleFreshConstrained e
e m (Maybe a)
v

instance
  {-# OVERLAPPING #-}
  ( GenSymSimpleConstrained (m (Maybe a)) (m (Maybe a)),
    Mergeable1 m,
    Mergeable a
  ) =>
  GenSymConstrained (MaybeT m a) (MaybeT m a)

-- ExceptT
instance
  {-# OVERLAPPABLE #-}
  ( GenSymConstrained spec (m (Either a b)),
    Mergeable1 m,
    Mergeable a,
    Mergeable b
  ) =>
  GenSymConstrained spec (ExceptT a m b)
  where
  freshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> spec -> m (UnionM (ExceptT a m b))
freshConstrained e
e spec
v = do
    UnionM (m (Either a b))
x <- e -> spec -> m (UnionM (m (Either a b)))
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> spec -> m (UnionM (m (Either a b)))
freshConstrained e
e spec
v
    UnionM (ExceptT a m b) -> m (UnionM (ExceptT a m b))
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle (UnionM (ExceptT a m b) -> m (UnionM (ExceptT a m b)))
-> UnionM (ExceptT a m b) -> m (UnionM (ExceptT a m b))
forall a b. (a -> b) -> a -> b
$ UnionM (ExceptT a m b) -> UnionM (ExceptT a m b)
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => u a -> u a
merge (UnionM (ExceptT a m b) -> UnionM (ExceptT a m b))
-> (UnionM (m (Either a b)) -> UnionM (ExceptT a m b))
-> UnionM (m (Either a b))
-> UnionM (ExceptT a m b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (m (Either a b) -> ExceptT a m b)
-> UnionM (m (Either a b)) -> UnionM (ExceptT a m b)
forall a b. (a -> b) -> UnionM a -> UnionM b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap m (Either a b) -> ExceptT a m b
forall e (m :: * -> *) a. m (Either e a) -> ExceptT e m a
ExceptT (UnionM (m (Either a b)) -> UnionM (ExceptT a m b))
-> UnionM (m (Either a b)) -> UnionM (ExceptT a m b)
forall a b. (a -> b) -> a -> b
$ UnionM (m (Either a b))
x

instance
  {-# OVERLAPPABLE #-}
  ( GenSymSimpleConstrained spec (m (Either a b)),
    Mergeable1 m,
    Mergeable a,
    Mergeable b
  ) =>
  GenSymSimpleConstrained spec (ExceptT a m b)
  where
  simpleFreshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> spec -> m (ExceptT a m b)
simpleFreshConstrained e
e spec
v = m (ExceptT a m b) -> m (ExceptT a m b)
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => u a -> u a
merge (m (ExceptT a m b) -> m (ExceptT a m b))
-> m (ExceptT a m b) -> m (ExceptT a m b)
forall a b. (a -> b) -> a -> b
$ m (Either a b) -> ExceptT a m b
forall e (m :: * -> *) a. m (Either e a) -> ExceptT e m a
ExceptT (m (Either a b) -> ExceptT a m b)
-> m (m (Either a b)) -> m (ExceptT a m b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> e -> spec -> m (m (Either a b))
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> spec -> m (m (Either a b))
simpleFreshConstrained e
e spec
v

instance
  {-# OVERLAPPING #-}
  ( GenSymSimpleConstrained (m (Either e a)) (m (Either e a)),
    Mergeable1 m,
    Mergeable e,
    Mergeable a
  ) =>
  GenSymSimpleConstrained (ExceptT e m a) (ExceptT e m a)
  where
  simpleFreshConstrained :: forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> ExceptT e m a -> m (ExceptT e m a)
simpleFreshConstrained e
e (ExceptT m (Either e a)
v) = m (ExceptT e m a) -> m (ExceptT e m a)
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => u a -> u a
merge (m (ExceptT e m a) -> m (ExceptT e m a))
-> m (ExceptT e m a) -> m (ExceptT e m a)
forall a b. (a -> b) -> a -> b
$ m (Either e a) -> ExceptT e m a
forall e (m :: * -> *) a. m (Either e a) -> ExceptT e m a
ExceptT (m (Either e a) -> ExceptT e m a)
-> m (m (Either e a)) -> m (ExceptT e m a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> e -> m (Either e a) -> m (m (Either e a))
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> m (Either e a) -> m (m (Either e a))
simpleFreshConstrained e
e m (Either e a)
v

instance
  {-# OVERLAPPING #-}
  ( GenSymSimpleConstrained (m (Either e a)) (m (Either e a)),
    Mergeable1 m,
    Mergeable e,
    Mergeable a
  ) =>
  GenSymConstrained (ExceptT e m a) (ExceptT e m a)

-- Deriving

class GenSymConstrainedNoSpec a where
  freshConstrainedNoSpec ::
    ( MonadFresh m,
      MonadError e m,
      UnionLike m
    ) =>
    e ->
    m (UnionM (a c))

instance GenSymConstrainedNoSpec U1 where
  freshConstrainedNoSpec :: forall (m :: * -> *) e c.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> m (UnionM (U1 c))
freshConstrainedNoSpec e
_ = UnionM (U1 c) -> m (UnionM (U1 c))
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (UnionM (U1 c) -> m (UnionM (U1 c)))
-> UnionM (U1 c) -> m (UnionM (U1 c))
forall a b. (a -> b) -> a -> b
$ U1 c -> UnionM (U1 c)
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => a -> u a
mrgSingle U1 c
forall k (p :: k). U1 p
U1

instance (GenSymConstrained () c) => GenSymConstrainedNoSpec (K1 i c) where
  freshConstrainedNoSpec :: forall (m :: * -> *) e c.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> m (UnionM (K1 i c c))
freshConstrainedNoSpec e
e = (c -> K1 i c c) -> UnionM c -> UnionM (K1 i c c)
forall a b. (a -> b) -> UnionM a -> UnionM b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap c -> K1 i c c
forall k i c (p :: k). c -> K1 i c p
K1 (UnionM c -> UnionM (K1 i c c))
-> m (UnionM c) -> m (UnionM (K1 i c c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> e -> () -> m (UnionM c)
forall spec a (m :: * -> *) e.
(GenSymConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m (UnionM a)
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> () -> m (UnionM c)
freshConstrained e
e ()

instance (GenSymConstrainedNoSpec a) => GenSymConstrainedNoSpec (M1 i c a) where
  freshConstrainedNoSpec :: forall (m :: * -> *) e c.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> m (UnionM (M1 i c a c))
freshConstrainedNoSpec e
e = (a c -> M1 i c a c) -> UnionM (a c) -> UnionM (M1 i c a c)
forall a b. (a -> b) -> UnionM a -> UnionM b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a c -> M1 i c a c
forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
M1 (UnionM (a c) -> UnionM (M1 i c a c))
-> m (UnionM (a c)) -> m (UnionM (M1 i c a c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> e -> m (UnionM (a c))
forall (a :: * -> *) (m :: * -> *) e c.
(GenSymConstrainedNoSpec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> m (UnionM (a c))
forall (m :: * -> *) e c.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> m (UnionM (a c))
freshConstrainedNoSpec e
e

instance
  ( GenSymConstrainedNoSpec a,
    GenSymConstrainedNoSpec b,
    forall x. Mergeable (a x),
    forall x. Mergeable (b x)
  ) =>
  GenSymConstrainedNoSpec (a :+: b)
  where
  freshConstrainedNoSpec ::
    forall m c e.
    ( MonadFresh m,
      MonadError e m,
      UnionLike m
    ) =>
    e ->
    m (UnionM ((a :+: b) c))
  freshConstrainedNoSpec :: forall (m :: * -> *) c e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> m (UnionM ((:+:) a b c))
freshConstrainedNoSpec e
e = do
    SymBool
cond :: bool <- () -> m SymBool
forall spec a (m :: * -> *).
(GenSymSimple spec a, MonadFresh m) =>
spec -> m a
forall (m :: * -> *). MonadFresh m => () -> m SymBool
simpleFresh ()
    UnionM (a c)
l :: UnionM (a c) <- e -> m (UnionM (a c))
forall (a :: * -> *) (m :: * -> *) e c.
(GenSymConstrainedNoSpec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> m (UnionM (a c))
forall (m :: * -> *) e c.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> m (UnionM (a c))
freshConstrainedNoSpec e
e
    UnionM (b c)
r :: UnionM (b c) <- e -> m (UnionM (b c))
forall (a :: * -> *) (m :: * -> *) e c.
(GenSymConstrainedNoSpec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> m (UnionM (a c))
forall (m :: * -> *) e c.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> m (UnionM (b c))
freshConstrainedNoSpec e
e
    UnionM ((:+:) a b c) -> m (UnionM ((:+:) a b c))
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (UnionM ((:+:) a b c) -> m (UnionM ((:+:) a b c)))
-> UnionM ((:+:) a b c) -> m (UnionM ((:+:) a b c))
forall a b. (a -> b) -> a -> b
$ SymBool
-> UnionM ((:+:) a b c)
-> UnionM ((:+:) a b c)
-> UnionM ((:+:) a b c)
forall (u :: * -> *) a.
(UnionLike u, Mergeable a) =>
SymBool -> u a -> u a -> u a
mrgIf SymBool
cond ((a c -> (:+:) a b c) -> UnionM (a c) -> UnionM ((:+:) a b c)
forall a b. (a -> b) -> UnionM a -> UnionM b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a c -> (:+:) a b c
forall k (f :: k -> *) (g :: k -> *) (p :: k). f p -> (:+:) f g p
L1 UnionM (a c)
l) ((b c -> (:+:) a b c) -> UnionM (b c) -> UnionM ((:+:) a b c)
forall a b. (a -> b) -> UnionM a -> UnionM b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap b c -> (:+:) a b c
forall k (f :: k -> *) (g :: k -> *) (p :: k). g p -> (:+:) f g p
R1 UnionM (b c)
r)

instance
  (GenSymConstrainedNoSpec a, GenSymConstrainedNoSpec b) =>
  GenSymConstrainedNoSpec (a :*: b)
  where
  freshConstrainedNoSpec ::
    forall m c e.
    ( MonadFresh m,
      MonadError e m,
      UnionLike m
    ) =>
    e ->
    m (UnionM ((a :*: b) c))
  freshConstrainedNoSpec :: forall (m :: * -> *) c e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> m (UnionM ((:*:) a b c))
freshConstrainedNoSpec e
e = do
    UnionM (a c)
l :: UnionM (a c) <- e -> m (UnionM (a c))
forall (a :: * -> *) (m :: * -> *) e c.
(GenSymConstrainedNoSpec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> m (UnionM (a c))
forall (m :: * -> *) e c.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> m (UnionM (a c))
freshConstrainedNoSpec e
e
    UnionM (b c)
r :: UnionM (b c) <- e -> m (UnionM (b c))
forall (a :: * -> *) (m :: * -> *) e c.
(GenSymConstrainedNoSpec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> m (UnionM (a c))
forall (m :: * -> *) e c.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> m (UnionM (b c))
freshConstrainedNoSpec e
e
    UnionM ((:*:) a b c) -> m (UnionM ((:*:) a b c))
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (UnionM ((:*:) a b c) -> m (UnionM ((:*:) a b c)))
-> UnionM ((:*:) a b c) -> m (UnionM ((:*:) a b c))
forall a b. (a -> b) -> a -> b
$ do
      a c
l1 <- UnionM (a c)
l
      b c
r1 <- UnionM (b c)
r
      (:*:) a b c -> UnionM ((:*:) a b c)
forall a. a -> UnionM a
forall (m :: * -> *) a. Monad m => a -> m a
return ((:*:) a b c -> UnionM ((:*:) a b c))
-> (:*:) a b c -> UnionM ((:*:) a b c)
forall a b. (a -> b) -> a -> b
$ a c
l1 a c -> b c -> (:*:) a b c
forall k (f :: k -> *) (g :: k -> *) (p :: k).
f p -> g p -> (:*:) f g p
:*: b c
r1

-- | We cannot provide DerivingVia style derivation for 'GenSymConstrained', while you can
-- use this 'freshConstrained' implementation to implement 'GenSymConstrained' for your own types.
--
-- This 'freshConstrained' implementation is for the types that does not need any specification.
-- It will generate product types by generating each fields with @()@ as specification,
-- and generate all possible values for a sum type.
--
-- __Note:__ __Never__ use on recursive types.
derivedFreshConstrainedNoSpec ::
  forall a m e.
  ( Generic a,
    GenSymConstrainedNoSpec (Rep a),
    Mergeable a,
    MonadFresh m,
    MonadError e m,
    UnionLike m
  ) =>
  e ->
  () ->
  m (UnionM a)
derivedFreshConstrainedNoSpec :: forall a (m :: * -> *) e.
(Generic a, GenSymConstrainedNoSpec (Rep a), Mergeable a,
 MonadFresh m, MonadError e m, UnionLike m) =>
e -> () -> m (UnionM a)
derivedFreshConstrainedNoSpec e
e ()
_ = m (UnionM a) -> m (UnionM a)
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => u a -> u a
merge (m (UnionM a) -> m (UnionM a)) -> m (UnionM a) -> m (UnionM a)
forall a b. (a -> b) -> a -> b
$ (UnionM a -> UnionM a
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => u a -> u a
merge (UnionM a -> UnionM a)
-> (UnionM (Rep a Any) -> UnionM a)
-> UnionM (Rep a Any)
-> UnionM a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Rep a Any -> a) -> UnionM (Rep a Any) -> UnionM a
forall a b. (a -> b) -> UnionM a -> UnionM b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Rep a Any -> a
forall a x. Generic a => Rep a x -> a
forall x. Rep a x -> a
to) (UnionM (Rep a Any) -> UnionM a)
-> m (UnionM (Rep a Any)) -> m (UnionM a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> e -> m (UnionM (Rep a Any))
forall (a :: * -> *) (m :: * -> *) e c.
(GenSymConstrainedNoSpec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> m (UnionM (a c))
forall (m :: * -> *) e c.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> m (UnionM (Rep a c))
freshConstrainedNoSpec e
e

class GenSymSimpleConstrainedNoSpec a where
  simpleFreshConstrainedNoSpec ::
    ( MonadFresh m,
      MonadError e m,
      UnionLike m
    ) =>
    e ->
    m (a c)

instance GenSymSimpleConstrainedNoSpec U1 where
  simpleFreshConstrainedNoSpec :: forall (m :: * -> *) e c.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> m (U1 c)
simpleFreshConstrainedNoSpec e
_ = U1 c -> m (U1 c)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return U1 c
forall k (p :: k). U1 p
U1

instance (GenSymSimpleConstrained () c) => GenSymSimpleConstrainedNoSpec (K1 i c) where
  simpleFreshConstrainedNoSpec :: forall (m :: * -> *) e c.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> m (K1 i c c)
simpleFreshConstrainedNoSpec e
e = c -> K1 i c c
forall k i c (p :: k). c -> K1 i c p
K1 (c -> K1 i c c) -> m c -> m (K1 i c c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> e -> () -> m c
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> () -> m c
simpleFreshConstrained e
e ()

instance (GenSymSimpleConstrainedNoSpec a) => GenSymSimpleConstrainedNoSpec (M1 i c a) where
  simpleFreshConstrainedNoSpec :: forall (m :: * -> *) e c.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> m (M1 i c a c)
simpleFreshConstrainedNoSpec e
e = a c -> M1 i c a c
forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
M1 (a c -> M1 i c a c) -> m (a c) -> m (M1 i c a c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> e -> m (a c)
forall (a :: * -> *) (m :: * -> *) e c.
(GenSymSimpleConstrainedNoSpec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> m (a c)
forall (m :: * -> *) e c.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> m (a c)
simpleFreshConstrainedNoSpec e
e

instance
  (GenSymSimpleConstrainedNoSpec a, GenSymSimpleConstrainedNoSpec b) =>
  GenSymSimpleConstrainedNoSpec (a :*: b)
  where
  simpleFreshConstrainedNoSpec :: forall (m :: * -> *) e c.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> m ((:*:) a b c)
simpleFreshConstrainedNoSpec e
e = do
    a c
l :: a c <- e -> m (a c)
forall (a :: * -> *) (m :: * -> *) e c.
(GenSymSimpleConstrainedNoSpec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> m (a c)
forall (m :: * -> *) e c.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> m (a c)
simpleFreshConstrainedNoSpec e
e
    b c
r :: b c <- e -> m (b c)
forall (a :: * -> *) (m :: * -> *) e c.
(GenSymSimpleConstrainedNoSpec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> m (a c)
forall (m :: * -> *) e c.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> m (b c)
simpleFreshConstrainedNoSpec e
e
    (:*:) a b c -> m ((:*:) a b c)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ((:*:) a b c -> m ((:*:) a b c)) -> (:*:) a b c -> m ((:*:) a b c)
forall a b. (a -> b) -> a -> b
$ a c
l a c -> b c -> (:*:) a b c
forall k (f :: k -> *) (g :: k -> *) (p :: k).
f p -> g p -> (:*:) f g p
:*: b c
r

-- | We cannot provide DerivingVia style derivation for 'GenSymSimpleConstrained', while
-- you can use this 'simpleFreshConstrained' implementation to implement 'GenSymSimpleConstrained' fo
-- your own types.
--
-- This 'simpleFreshConstrained' implementation is for the types that does not need any specification.
-- It will generate product types by generating each fields with '()' as specification.
-- It will not work on sum types.
--
-- __Note:__ __Never__ use on recursive types.
derivedSimpleFreshConstrainedNoSpec ::
  forall a m e.
  ( Generic a,
    GenSymSimpleConstrainedNoSpec (Rep a),
    MonadFresh m,
    MonadError e m,
    UnionLike m,
    Mergeable a
  ) =>
  e ->
  () ->
  m a
derivedSimpleFreshConstrainedNoSpec :: forall a (m :: * -> *) e.
(Generic a, GenSymSimpleConstrainedNoSpec (Rep a), MonadFresh m,
 MonadError e m, UnionLike m, Mergeable a) =>
e -> () -> m a
derivedSimpleFreshConstrainedNoSpec e
e ()
_ = m a -> m a
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => u a -> u a
merge (m a -> m a) -> m a -> m a
forall a b. (a -> b) -> a -> b
$ (m a -> m a
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => u a -> u a
merge (m a -> m a) -> (m (Rep a Any) -> m a) -> m (Rep a Any) -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Rep a Any -> a) -> m (Rep a Any) -> m a
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Rep a Any -> a
forall a x. Generic a => Rep a x -> a
forall x. Rep a x -> a
to) (m (Rep a Any) -> m a) -> m (Rep a Any) -> m a
forall a b. (a -> b) -> a -> b
$ e -> m (Rep a Any)
forall (a :: * -> *) (m :: * -> *) e c.
(GenSymSimpleConstrainedNoSpec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> m (a c)
forall (m :: * -> *) e c.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> m (Rep a c)
simpleFreshConstrainedNoSpec e
e

class GenSymConstrainedSameShape a where
  simpleFreshConstrainedSameShape ::
    ( MonadFresh m,
      MonadError e m,
      UnionLike m
    ) =>
    e ->
    a c ->
    m (a c)

instance GenSymConstrainedSameShape U1 where
  simpleFreshConstrainedSameShape :: forall (m :: * -> *) e c.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> U1 c -> m (U1 c)
simpleFreshConstrainedSameShape e
_ U1 c
_ = U1 c -> m (U1 c)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return U1 c
forall k (p :: k). U1 p
U1

instance (GenSymSimpleConstrained c c) => GenSymConstrainedSameShape (K1 i c) where
  simpleFreshConstrainedSameShape :: forall (m :: * -> *) e c.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> K1 i c c -> m (K1 i c c)
simpleFreshConstrainedSameShape e
e (K1 c
c) = c -> K1 i c c
forall k i c (p :: k). c -> K1 i c p
K1 (c -> K1 i c c) -> m c -> m (K1 i c c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> e -> c -> m c
forall spec a (m :: * -> *) e.
(GenSymSimpleConstrained spec a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> spec -> m a
forall (m :: * -> *) e.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> c -> m c
simpleFreshConstrained e
e c
c

instance (GenSymConstrainedSameShape a) => GenSymConstrainedSameShape (M1 i c a) where
  simpleFreshConstrainedSameShape :: forall (m :: * -> *) e c.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> M1 i c a c -> m (M1 i c a c)
simpleFreshConstrainedSameShape e
e (M1 a c
a) = a c -> M1 i c a c
forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
M1 (a c -> M1 i c a c) -> m (a c) -> m (M1 i c a c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> e -> a c -> m (a c)
forall (a :: * -> *) (m :: * -> *) e c.
(GenSymConstrainedSameShape a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> a c -> m (a c)
forall (m :: * -> *) e c.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> a c -> m (a c)
simpleFreshConstrainedSameShape e
e a c
a

instance
  (GenSymConstrainedSameShape a, GenSymConstrainedSameShape b) =>
  GenSymConstrainedSameShape (a :+: b)
  where
  simpleFreshConstrainedSameShape :: forall (m :: * -> *) e c.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> (:+:) a b c -> m ((:+:) a b c)
simpleFreshConstrainedSameShape e
e (L1 a c
a) = a c -> (:+:) a b c
forall k (f :: k -> *) (g :: k -> *) (p :: k). f p -> (:+:) f g p
L1 (a c -> (:+:) a b c) -> m (a c) -> m ((:+:) a b c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> e -> a c -> m (a c)
forall (a :: * -> *) (m :: * -> *) e c.
(GenSymConstrainedSameShape a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> a c -> m (a c)
forall (m :: * -> *) e c.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> a c -> m (a c)
simpleFreshConstrainedSameShape e
e a c
a
  simpleFreshConstrainedSameShape e
e (R1 b c
a) = b c -> (:+:) a b c
forall k (f :: k -> *) (g :: k -> *) (p :: k). g p -> (:+:) f g p
R1 (b c -> (:+:) a b c) -> m (b c) -> m ((:+:) a b c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> e -> b c -> m (b c)
forall (a :: * -> *) (m :: * -> *) e c.
(GenSymConstrainedSameShape a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> a c -> m (a c)
forall (m :: * -> *) e c.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> b c -> m (b c)
simpleFreshConstrainedSameShape e
e b c
a

instance
  (GenSymConstrainedSameShape a, GenSymConstrainedSameShape b) =>
  GenSymConstrainedSameShape (a :*: b)
  where
  simpleFreshConstrainedSameShape :: forall (m :: * -> *) e c.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> (:*:) a b c -> m ((:*:) a b c)
simpleFreshConstrainedSameShape e
e (a c
a :*: b c
b) = do
    a c
l :: a c <- e -> a c -> m (a c)
forall (a :: * -> *) (m :: * -> *) e c.
(GenSymConstrainedSameShape a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> a c -> m (a c)
forall (m :: * -> *) e c.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> a c -> m (a c)
simpleFreshConstrainedSameShape e
e a c
a
    b c
r :: b c <- e -> b c -> m (b c)
forall (a :: * -> *) (m :: * -> *) e c.
(GenSymConstrainedSameShape a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> a c -> m (a c)
forall (m :: * -> *) e c.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> b c -> m (b c)
simpleFreshConstrainedSameShape e
e b c
b
    (:*:) a b c -> m ((:*:) a b c)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ((:*:) a b c -> m ((:*:) a b c)) -> (:*:) a b c -> m ((:*:) a b c)
forall a b. (a -> b) -> a -> b
$ a c
l a c -> b c -> (:*:) a b c
forall k (f :: k -> *) (g :: k -> *) (p :: k).
f p -> g p -> (:*:) f g p
:*: b c
r

-- | We cannot provide DerivingVia style derivation for 'GenSymSimpleConstrained', while
-- you can use this 'simpleFreshConstrained' implementation to implement 'GenSymSimpleConstrained' fo
-- your own types.
--
-- This 'simpleFreshConstrained' implementation is for the types that can be generated with
-- a reference value of the same type.
--
-- For sum types, it will generate the result with the same data constructor.
-- For product types, it will generate the result by generating each field with
-- the corresponding reference value.
--
-- __Note:__ __Can__ be used on recursive types.
derivedSimpleFreshConstrainedSameShape ::
  ( Generic a,
    GenSymConstrainedSameShape (Rep a),
    Mergeable a,
    MonadFresh m,
    MonadError e m,
    UnionLike m
  ) =>
  e ->
  a ->
  m a
derivedSimpleFreshConstrainedSameShape :: forall a (m :: * -> *) e.
(Generic a, GenSymConstrainedSameShape (Rep a), Mergeable a,
 MonadFresh m, MonadError e m, UnionLike m) =>
e -> a -> m a
derivedSimpleFreshConstrainedSameShape e
e a
a = m a -> m a
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => u a -> u a
merge (m a -> m a) -> m a -> m a
forall a b. (a -> b) -> a -> b
$ (m a -> m a
forall (u :: * -> *) a. (UnionLike u, Mergeable a) => u a -> u a
merge (m a -> m a) -> (m (Rep a Any) -> m a) -> m (Rep a Any) -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Rep a Any -> a) -> m (Rep a Any) -> m a
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Rep a Any -> a
forall a x. Generic a => Rep a x -> a
forall x. Rep a x -> a
to) (m (Rep a Any) -> m a) -> m (Rep a Any) -> m a
forall a b. (a -> b) -> a -> b
$ e -> Rep a Any -> m (Rep a Any)
forall (a :: * -> *) (m :: * -> *) e c.
(GenSymConstrainedSameShape a, MonadFresh m, MonadError e m,
 UnionLike m) =>
e -> a c -> m (a c)
forall (m :: * -> *) e c.
(MonadFresh m, MonadError e m, UnionLike m) =>
e -> Rep a c -> m (Rep a c)
simpleFreshConstrainedSameShape e
e (a -> Rep a Any
forall x. a -> Rep a x
forall a x. Generic a => a -> Rep a x
from a
a)