{-# OPTIONS_HADDOCK not-home #-}
{-# LANGUAGE ApplicativeDo #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveFoldable #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE DeriveTraversable #-}
{-# LANGUAGE DoAndIfThenElse #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TupleSections #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-} -- MonadBase
#if __GLASGOW_HASKELL__ >= 806
{-# LANGUAGE DerivingVia #-}
#endif

module Hedgehog.Internal.Gen (
  -- * Transformer
    Gen
  , GenT(..)
  , MonadGen(..)

  -- * Combinators
  , generalize

  -- ** Shrinking
  , shrink
  , prune

  -- ** Size
  , small
  , scale
  , resize
  , sized

  -- ** Integral
  , integral
  , integral_

  , int
  , int8
  , int16
  , int32
  , int64

  , word
  , word8
  , word16
  , word32
  , word64

  -- ** Floating-point
  , realFloat
  , realFrac_
  , float
  , double

  -- ** Enumeration
  , enum
  , enumBounded
  , bool
  , bool_

  -- ** Characters
  , binit
  , octit
  , digit
  , hexit
  , lower
  , upper
  , alpha
  , alphaNum
  , ascii
  , latin1
  , unicode
  , unicodeAll

  -- ** Strings
  , string
  , text
  , utf8
  , bytes

  -- ** Choice
  , constant
  , element
  , choice
  , frequency
  , recursive

  -- ** Conditional
  , discard
  , ensure
  , filter
  , mapMaybe
  , filterT
  , mapMaybeT
  , just
  , justT

  -- ** Collections
  , maybe
  , either
  , either_
  , list
  , seq
  , nonEmpty
  , set
  , map

  -- ** Subterms
  , freeze
  , subterm
  , subtermM
  , subterm2
  , subtermM2
  , subterm3
  , subtermM3

  -- ** Combinations & Permutations
  , subsequence
  , shuffle
  , shuffleSeq

  -- * Sampling Generators
  , sample
  , print
  , printTree
  , printWith
  , printTreeWith
  , renderTree

  -- * Internal
  -- $internal

  -- ** Transfomer
  , runGenT
  , evalGen
  , evalGenT
  , mapGenT
  , generate
  , toTree
  , toTreeMaybeT
  , fromTree
  , fromTreeT
  , fromTreeMaybeT
  , runDiscardEffect
  , runDiscardEffectT

  -- ** Size
  , golden

  -- ** Shrinking
  , atLeast

  -- ** Characters
  , isSurrogate
  , isNoncharacter

  -- ** Subterms
  , Vec(..)
  , Nat(..)
  , subtermMVec
  ) where

import           Control.Applicative (Alternative(..),liftA2)
import           Control.Monad (MonadPlus(..), filterM, guard, replicateM, join)
import           Control.Monad.Base (MonadBase(..))
import           Control.Monad.Trans.Control (MonadBaseControl(..))
import           Control.Monad.Catch (MonadThrow(..), MonadCatch(..))
import           Control.Monad.Error.Class (MonadError(..))
import           Control.Monad.IO.Class (MonadIO(..))
import           Control.Monad.Morph (MFunctor(..), MMonad(..))
import qualified Control.Monad.Morph as Morph
import           Control.Monad.Primitive (PrimMonad(..))
import           Control.Monad.Reader.Class (MonadReader(..))
import           Control.Monad.State.Class (MonadState(..))
import           Control.Monad.Trans.Class (MonadTrans(..))
import           Control.Monad.Trans.Except (ExceptT(..))
import           Control.Monad.Trans.Identity (IdentityT(..))
import           Control.Monad.Trans.Maybe (MaybeT(..))
import           Control.Monad.Trans.Reader (ReaderT(..))
import           Control.Monad.Trans.Resource (MonadResource(..))
import qualified Control.Monad.Trans.State.Lazy as Lazy
import qualified Control.Monad.Trans.State.Strict as Strict
import qualified Control.Monad.Trans.Writer.Lazy as Lazy
import qualified Control.Monad.Trans.Writer.Strict as Strict
import           Control.Monad.Writer.Class (MonadWriter(..))
import           Control.Monad.Zip (MonadZip(..))

import           Data.Bifunctor (first)
import           Data.ByteString (ByteString)
import qualified Data.ByteString as ByteString
import qualified Data.Char as Char
import           Data.Foldable (for_, toList)
import           Data.Functor.Identity (Identity(..))
import           Data.Int (Int8, Int16, Int32, Int64)
import           Data.List.NonEmpty (NonEmpty)
import qualified Data.List.NonEmpty as NonEmpty
import           Data.Map (Map)
import qualified Data.Map as Map
import qualified Data.Maybe as Maybe
import qualified Data.Semigroup as Semigroup
import           Data.Sequence (Seq)
import qualified Data.Sequence as Seq
import           Data.Set (Set)
import           Data.Text (Text)
import qualified Data.Text as Text
import qualified Data.Text.Encoding as Text
import           Data.Word (Word8, Word16, Word32, Word64)

import           Hedgehog.Internal.Distributive (MonadTransDistributive(..))
import           Hedgehog.Internal.Prelude hiding (either, maybe, seq)
import           Hedgehog.Internal.Seed (Seed)
import qualified Hedgehog.Internal.Seed as Seed
import qualified Hedgehog.Internal.Shrink as Shrink
import           Hedgehog.Internal.Tree (Tree, TreeT(..), NodeT(..))
import qualified Hedgehog.Internal.Tree as Tree
import           Hedgehog.Range (Size, Range)
import qualified Hedgehog.Range as Range

#if __GLASGOW_HASKELL__ < 808
import qualified Control.Monad.Fail as Fail
#endif
#if __GLASGOW_HASKELL__ < 806
import           Data.Coerce (coerce)
#endif

------------------------------------------------------------------------
-- Generator transformer

-- | Generator for random values of @a@.
--
type Gen =
  GenT Identity

-- | Monad transformer which can generate random values of @a@.
--
newtype GenT m a =
  GenT {
      GenT m a -> Size -> Seed -> TreeT (MaybeT m) a
unGenT :: Size -> Seed -> TreeT (MaybeT m) a
    }

-- | Runs a generator, producing its shrink tree.
--
runGenT :: Size -> Seed -> GenT m a -> TreeT (MaybeT m) a
runGenT :: Size -> Seed -> GenT m a -> TreeT (MaybeT m) a
runGenT size :: Size
size seed :: Seed
seed (GenT m :: Size -> Seed -> TreeT (MaybeT m) a
m) =
  Size -> Seed -> TreeT (MaybeT m) a
m Size
size Seed
seed

-- | Run a generator, producing its shrink tree.
--
--   'Nothing' means discarded, 'Just' means we have a value.
--
evalGen :: Size -> Seed -> Gen a -> Maybe (Tree a)
evalGen :: Size -> Seed -> Gen a -> Maybe (Tree a)
evalGen size :: Size
size seed :: Seed
seed =
  (Maybe a -> Maybe a) -> Tree (Maybe a) -> Maybe (Tree a)
forall a b. (a -> Maybe b) -> Tree a -> Maybe (Tree b)
Tree.mapMaybe Maybe a -> Maybe a
forall a. a -> a
id (Tree (Maybe a) -> Maybe (Tree a))
-> (Gen a -> Tree (Maybe a)) -> Gen a -> Maybe (Tree a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  Size -> Seed -> Gen a -> Tree (Maybe a)
forall (m :: * -> *) a.
Monad m =>
Size -> Seed -> GenT m a -> TreeT m (Maybe a)
evalGenT Size
size Seed
seed

-- | Runs a generator, producing its shrink tree.
--
evalGenT :: Monad m => Size -> Seed -> GenT m a -> TreeT m (Maybe a)
evalGenT :: Size -> Seed -> GenT m a -> TreeT m (Maybe a)
evalGenT size :: Size
size seed :: Seed
seed =
  TreeT (MaybeT m) a -> TreeT m (Maybe a)
forall (m :: * -> *) a.
Monad m =>
TreeT (MaybeT m) a -> TreeT m (Maybe a)
runDiscardEffectT (TreeT (MaybeT m) a -> TreeT m (Maybe a))
-> (GenT m a -> TreeT (MaybeT m) a)
-> GenT m a
-> TreeT m (Maybe a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  Size -> Seed -> GenT m a -> TreeT (MaybeT m) a
forall (m :: * -> *) a.
Size -> Seed -> GenT m a -> TreeT (MaybeT m) a
runGenT Size
size Seed
seed

-- | Map over a generator's shrink tree.
--
mapGenT :: (TreeT (MaybeT m) a -> TreeT (MaybeT n) b) -> GenT m a -> GenT n b
mapGenT :: (TreeT (MaybeT m) a -> TreeT (MaybeT n) b) -> GenT m a -> GenT n b
mapGenT f :: TreeT (MaybeT m) a -> TreeT (MaybeT n) b
f gen :: GenT m a
gen =
  (Size -> Seed -> TreeT (MaybeT n) b) -> GenT n b
forall (m :: * -> *) a.
(Size -> Seed -> TreeT (MaybeT m) a) -> GenT m a
GenT ((Size -> Seed -> TreeT (MaybeT n) b) -> GenT n b)
-> (Size -> Seed -> TreeT (MaybeT n) b) -> GenT n b
forall a b. (a -> b) -> a -> b
$ \size :: Size
size seed :: Seed
seed ->
    TreeT (MaybeT m) a -> TreeT (MaybeT n) b
f (Size -> Seed -> GenT m a -> TreeT (MaybeT m) a
forall (m :: * -> *) a.
Size -> Seed -> GenT m a -> TreeT (MaybeT m) a
runGenT Size
size Seed
seed GenT m a
gen)

-- | Lift a predefined shrink tree in to a generator, ignoring the seed and the
--   size.
--
fromTree :: MonadGen m => Tree a -> m a
fromTree :: Tree a -> m a
fromTree =
  TreeT (GenBase m) a -> m a
forall (m :: * -> *) a. MonadGen m => TreeT (GenBase m) a -> m a
fromTreeT (TreeT (GenBase m) a -> m a)
-> (Tree a -> TreeT (GenBase m) a) -> Tree a -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  (forall a. Identity a -> GenBase m a)
-> Tree a -> TreeT (GenBase m) a
forall k (t :: (* -> *) -> k -> *) (m :: * -> *) (n :: * -> *)
       (b :: k).
(MFunctor t, Monad m) =>
(forall a. m a -> n a) -> t m b -> t n b
hoist (Identity a -> GenBase m a
forall (m :: * -> *) a. Monad m => Identity a -> m a
Morph.generalize)

-- | Lift a predefined shrink tree in to a generator, ignoring the seed and the
--   size.
--
fromTreeT :: MonadGen m => TreeT (GenBase m) a -> m a
fromTreeT :: TreeT (GenBase m) a -> m a
fromTreeT x :: TreeT (GenBase m) a
x =
  TreeT (MaybeT (GenBase m)) a -> m a
forall (m :: * -> *) a.
MonadGen m =>
TreeT (MaybeT (GenBase m)) a -> m a
fromTreeMaybeT (TreeT (MaybeT (GenBase m)) a -> m a)
-> TreeT (MaybeT (GenBase m)) a -> m a
forall a b. (a -> b) -> a -> b
$
    (forall a. GenBase m a -> MaybeT (GenBase m) a)
-> TreeT (GenBase m) a -> TreeT (MaybeT (GenBase m)) a
forall k (t :: (* -> *) -> k -> *) (m :: * -> *) (n :: * -> *)
       (b :: k).
(MFunctor t, Monad m) =>
(forall a. m a -> n a) -> t m b -> t n b
hoist (GenBase m (Maybe a) -> MaybeT (GenBase m) a
forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a
MaybeT (GenBase m (Maybe a) -> MaybeT (GenBase m) a)
-> (GenBase m a -> GenBase m (Maybe a))
-> GenBase m a
-> MaybeT (GenBase m) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Maybe a) -> GenBase m a -> GenBase m (Maybe a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> Maybe a
forall a. a -> Maybe a
Just) TreeT (GenBase m) a
x

-- | Lift a predefined shrink tree in to a generator, ignoring the seed and the
--   size.
--
fromTreeMaybeT :: MonadGen m => TreeT (MaybeT (GenBase m)) a -> m a
fromTreeMaybeT :: TreeT (MaybeT (GenBase m)) a -> m a
fromTreeMaybeT x :: TreeT (MaybeT (GenBase m)) a
x =
  GenT (GenBase m) a -> m a
forall (m :: * -> *) a. MonadGen m => GenT (GenBase m) a -> m a
fromGenT (GenT (GenBase m) a -> m a)
-> ((Size -> Seed -> TreeT (MaybeT (GenBase m)) a)
    -> GenT (GenBase m) a)
-> (Size -> Seed -> TreeT (MaybeT (GenBase m)) a)
-> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Size -> Seed -> TreeT (MaybeT (GenBase m)) a)
-> GenT (GenBase m) a
forall (m :: * -> *) a.
(Size -> Seed -> TreeT (MaybeT m) a) -> GenT m a
GenT ((Size -> Seed -> TreeT (MaybeT (GenBase m)) a) -> m a)
-> (Size -> Seed -> TreeT (MaybeT (GenBase m)) a) -> m a
forall a b. (a -> b) -> a -> b
$ \_ _ ->
    TreeT (MaybeT (GenBase m)) a
x

-- | Observe a generator's shrink tree.
--
toTree :: forall m a. (MonadGen m, GenBase m ~ Identity) => m a -> m (Tree a)
toTree :: m a -> m (Tree a)
toTree =
  (GenT (GenBase m) a -> GenT (GenBase m) (Tree a))
-> m a -> m (Tree a)
forall (m :: * -> *) (n :: * -> *) a b.
(MonadGen m, MonadGen n) =>
(GenT (GenBase m) a -> GenT (GenBase n) b) -> m a -> n b
withGenT ((GenT (GenBase m) a -> GenT (GenBase m) (Tree a))
 -> m a -> m (Tree a))
-> (GenT (GenBase m) a -> GenT (GenBase m) (Tree a))
-> m a
-> m (Tree a)
forall a b. (a -> b) -> a -> b
$ (TreeT (MaybeT Identity) a -> TreeT (MaybeT Identity) (Tree a))
-> GenT Identity a -> GenT Identity (Tree a)
forall (m :: * -> *) a (n :: * -> *) b.
(TreeT (MaybeT m) a -> TreeT (MaybeT n) b) -> GenT m a -> GenT n b
mapGenT (TreeT (MaybeT Identity) (Tree a)
-> (Tree a -> TreeT (MaybeT Identity) (Tree a))
-> Maybe (Tree a)
-> TreeT (MaybeT Identity) (Tree a)
forall b a. b -> (a -> b) -> Maybe a -> b
Maybe.maybe TreeT (MaybeT Identity) (Tree a)
forall (f :: * -> *) a. Alternative f => f a
empty Tree a -> TreeT (MaybeT Identity) (Tree a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe (Tree a) -> TreeT (MaybeT Identity) (Tree a))
-> (TreeT (MaybeT Identity) a -> Maybe (Tree a))
-> TreeT (MaybeT Identity) a
-> TreeT (MaybeT Identity) (Tree a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TreeT (MaybeT Identity) a -> Maybe (Tree a)
forall a. TreeT (MaybeT Identity) a -> Maybe (Tree a)
runDiscardEffect)

-- | Lift a predefined shrink tree in to a generator, ignoring the seed and the
--   size.
--
toTreeMaybeT :: MonadGen m => m a -> m (TreeT (MaybeT (GenBase m)) a)
toTreeMaybeT :: m a -> m (TreeT (MaybeT (GenBase m)) a)
toTreeMaybeT =
  (GenT (GenBase m) a
 -> GenT (GenBase m) (TreeT (MaybeT (GenBase m)) a))
-> m a -> m (TreeT (MaybeT (GenBase m)) a)
forall (m :: * -> *) (n :: * -> *) a b.
(MonadGen m, MonadGen n) =>
(GenT (GenBase m) a -> GenT (GenBase n) b) -> m a -> n b
withGenT ((GenT (GenBase m) a
  -> GenT (GenBase m) (TreeT (MaybeT (GenBase m)) a))
 -> m a -> m (TreeT (MaybeT (GenBase m)) a))
-> (GenT (GenBase m) a
    -> GenT (GenBase m) (TreeT (MaybeT (GenBase m)) a))
-> m a
-> m (TreeT (MaybeT (GenBase m)) a)
forall a b. (a -> b) -> a -> b
$ (TreeT (MaybeT (GenBase m)) a
 -> TreeT (MaybeT (GenBase m)) (TreeT (MaybeT (GenBase m)) a))
-> GenT (GenBase m) a
-> GenT (GenBase m) (TreeT (MaybeT (GenBase m)) a)
forall (m :: * -> *) a (n :: * -> *) b.
(TreeT (MaybeT m) a -> TreeT (MaybeT n) b) -> GenT m a -> GenT n b
mapGenT TreeT (MaybeT (GenBase m)) a
-> TreeT (MaybeT (GenBase m)) (TreeT (MaybeT (GenBase m)) a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure

-- | Lazily run the discard effects through the tree and reify it a
--   @Maybe (Tree a)@.
--
--   'Nothing' means discarded, 'Just' means we have a value.
--
--   Discards in the child nodes of the tree are simply removed.
--
runDiscardEffect :: TreeT (MaybeT Identity) a -> Maybe (Tree a)
runDiscardEffect :: TreeT (MaybeT Identity) a -> Maybe (Tree a)
runDiscardEffect =
  (Maybe a -> Maybe a) -> Tree (Maybe a) -> Maybe (Tree a)
forall a b. (a -> Maybe b) -> Tree a -> Maybe (Tree b)
Tree.mapMaybe Maybe a -> Maybe a
forall a. a -> a
id (Tree (Maybe a) -> Maybe (Tree a))
-> (TreeT (MaybeT Identity) a -> Tree (Maybe a))
-> TreeT (MaybeT Identity) a
-> Maybe (Tree a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  TreeT (MaybeT Identity) a -> Tree (Maybe a)
forall (m :: * -> *) a.
Monad m =>
TreeT (MaybeT m) a -> TreeT m (Maybe a)
runDiscardEffectT

-- | Run the discard effects through the tree and reify them as 'Maybe' values
--   at the nodes.
--
--   'Nothing' means discarded, 'Just' means we have a value.
--
runDiscardEffectT :: Monad m => TreeT (MaybeT m) a -> TreeT m (Maybe a)
runDiscardEffectT :: TreeT (MaybeT m) a -> TreeT m (Maybe a)
runDiscardEffectT =
  MaybeT (TreeT m) a -> TreeT m (Maybe a)
forall (m :: * -> *) a. MaybeT m a -> m (Maybe a)
runMaybeT (MaybeT (TreeT m) a -> TreeT m (Maybe a))
-> (TreeT (MaybeT m) a -> MaybeT (TreeT m) a)
-> TreeT (MaybeT m) a
-> TreeT m (Maybe a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  TreeT (MaybeT m) a -> MaybeT (TreeT m) a
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *)
       (m :: * -> *) a.
(MonadTransDistributive g, Transformer f g m) =>
g (f m) a -> f (g m) a
distributeT

-- | Lift a @Gen / GenT Identity@ in to a @Monad m => GenT m@
--
generalize :: Monad m => Gen a -> GenT m a
generalize :: Gen a -> GenT m a
generalize =
  (forall a. Identity a -> m a) -> Gen a -> GenT m a
forall k (t :: (* -> *) -> k -> *) (m :: * -> *) (n :: * -> *)
       (b :: k).
(MFunctor t, Monad m) =>
(forall a. m a -> n a) -> t m b -> t n b
hoist forall a. Identity a -> m a
forall (m :: * -> *) a. Monad m => Identity a -> m a
Morph.generalize

------------------------------------------------------------------------
-- MonadGen

-- | Class of monads which can generate input data for tests.
--
class (Monad m, Monad (GenBase m)) => MonadGen m where
  type GenBase m :: (* -> *)

  -- | Extract a 'GenT' from a  'MonadGen'.
  --
  toGenT :: m a -> GenT (GenBase m) a

  -- | Lift a 'GenT' in to a 'MonadGen'.
  --
  fromGenT :: GenT (GenBase m) a -> m a

-- | Transform a 'MonadGen' as a 'GenT'.
--
withGenT :: (MonadGen m, MonadGen n) => (GenT (GenBase m) a -> GenT (GenBase n) b) -> m a -> n b
withGenT :: (GenT (GenBase m) a -> GenT (GenBase n) b) -> m a -> n b
withGenT f :: GenT (GenBase m) a -> GenT (GenBase n) b
f =
  GenT (GenBase n) b -> n b
forall (m :: * -> *) a. MonadGen m => GenT (GenBase m) a -> m a
fromGenT (GenT (GenBase n) b -> n b)
-> (m a -> GenT (GenBase n) b) -> m a -> n b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GenT (GenBase m) a -> GenT (GenBase n) b
f (GenT (GenBase m) a -> GenT (GenBase n) b)
-> (m a -> GenT (GenBase m) a) -> m a -> GenT (GenBase n) b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m a -> GenT (GenBase m) a
forall (m :: * -> *) a. MonadGen m => m a -> GenT (GenBase m) a
toGenT

instance Monad m => MonadGen (GenT m) where
  -- | The type of the transformer stack's base 'Monad'.
  --
  type GenBase (GenT m) =
    m

  -- | Convert a 'MonadGen' to a 'GenT'.
  --
  toGenT :: GenT m a -> GenT (GenBase (GenT m)) a
toGenT =
    GenT m a -> GenT (GenBase (GenT m)) a
forall a. a -> a
id

  -- | Convert a 'GenT' to a 'MonadGen'.
  --
  fromGenT :: GenT (GenBase (GenT m)) a -> GenT m a
fromGenT =
    GenT (GenBase (GenT m)) a -> GenT m a
forall a. a -> a
id

instance MonadGen m => MonadGen (IdentityT m) where
  type GenBase (IdentityT m) =
    IdentityT (GenBase m)

  toGenT :: IdentityT m a -> GenT (GenBase (IdentityT m)) a
toGenT =
    IdentityT (GenT (GenBase m)) a -> GenT (IdentityT (GenBase m)) a
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *)
       (m :: * -> *) a.
(MonadTransDistributive g, Transformer f g m) =>
g (f m) a -> f (g m) a
distributeT (IdentityT (GenT (GenBase m)) a -> GenT (IdentityT (GenBase m)) a)
-> (IdentityT m a -> IdentityT (GenT (GenBase m)) a)
-> IdentityT m a
-> GenT (IdentityT (GenBase m)) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. m a -> GenT (GenBase m) a)
-> IdentityT m a -> IdentityT (GenT (GenBase m)) a
forall k (t :: (* -> *) -> k -> *) (m :: * -> *) (n :: * -> *)
       (b :: k).
(MFunctor t, Monad m) =>
(forall a. m a -> n a) -> t m b -> t n b
hoist forall a. m a -> GenT (GenBase m) a
forall (m :: * -> *) a. MonadGen m => m a -> GenT (GenBase m) a
toGenT

  fromGenT :: GenT (GenBase (IdentityT m)) a -> IdentityT m a
fromGenT =
    (forall a. GenT (GenBase m) a -> m a)
-> IdentityT (GenT (GenBase m)) a -> IdentityT m a
forall k (t :: (* -> *) -> k -> *) (m :: * -> *) (n :: * -> *)
       (b :: k).
(MFunctor t, Monad m) =>
(forall a. m a -> n a) -> t m b -> t n b
hoist forall a. GenT (GenBase m) a -> m a
forall (m :: * -> *) a. MonadGen m => GenT (GenBase m) a -> m a
fromGenT (IdentityT (GenT (GenBase m)) a -> IdentityT m a)
-> (GenT (IdentityT (GenBase m)) a
    -> IdentityT (GenT (GenBase m)) a)
-> GenT (IdentityT (GenBase m)) a
-> IdentityT m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GenT (IdentityT (GenBase m)) a -> IdentityT (GenT (GenBase m)) a
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *)
       (m :: * -> *) a.
(MonadTransDistributive g, Transformer f g m) =>
g (f m) a -> f (g m) a
distributeT

instance MonadGen m => MonadGen (MaybeT m) where
  type GenBase (MaybeT m) =
    MaybeT (GenBase m)

  toGenT :: MaybeT m a -> GenT (GenBase (MaybeT m)) a
toGenT =
    MaybeT (GenT (GenBase m)) a -> GenT (MaybeT (GenBase m)) a
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *)
       (m :: * -> *) a.
(MonadTransDistributive g, Transformer f g m) =>
g (f m) a -> f (g m) a
distributeT (MaybeT (GenT (GenBase m)) a -> GenT (MaybeT (GenBase m)) a)
-> (MaybeT m a -> MaybeT (GenT (GenBase m)) a)
-> MaybeT m a
-> GenT (MaybeT (GenBase m)) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. m a -> GenT (GenBase m) a)
-> MaybeT m a -> MaybeT (GenT (GenBase m)) a
forall k (t :: (* -> *) -> k -> *) (m :: * -> *) (n :: * -> *)
       (b :: k).
(MFunctor t, Monad m) =>
(forall a. m a -> n a) -> t m b -> t n b
hoist forall a. m a -> GenT (GenBase m) a
forall (m :: * -> *) a. MonadGen m => m a -> GenT (GenBase m) a
toGenT

  fromGenT :: GenT (GenBase (MaybeT m)) a -> MaybeT m a
fromGenT =
    (forall a. GenT (GenBase m) a -> m a)
-> MaybeT (GenT (GenBase m)) a -> MaybeT m a
forall k (t :: (* -> *) -> k -> *) (m :: * -> *) (n :: * -> *)
       (b :: k).
(MFunctor t, Monad m) =>
(forall a. m a -> n a) -> t m b -> t n b
hoist forall a. GenT (GenBase m) a -> m a
forall (m :: * -> *) a. MonadGen m => GenT (GenBase m) a -> m a
fromGenT (MaybeT (GenT (GenBase m)) a -> MaybeT m a)
-> (GenT (MaybeT (GenBase m)) a -> MaybeT (GenT (GenBase m)) a)
-> GenT (MaybeT (GenBase m)) a
-> MaybeT m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GenT (MaybeT (GenBase m)) a -> MaybeT (GenT (GenBase m)) a
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *)
       (m :: * -> *) a.
(MonadTransDistributive g, Transformer f g m) =>
g (f m) a -> f (g m) a
distributeT

instance MonadGen m => MonadGen (ExceptT x m) where
  type GenBase (ExceptT x m) =
    ExceptT x (GenBase m)

  toGenT :: ExceptT x m a -> GenT (GenBase (ExceptT x m)) a
toGenT =
    ExceptT x (GenT (GenBase m)) a -> GenT (ExceptT x (GenBase m)) a
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *)
       (m :: * -> *) a.
(MonadTransDistributive g, Transformer f g m) =>
g (f m) a -> f (g m) a
distributeT (ExceptT x (GenT (GenBase m)) a -> GenT (ExceptT x (GenBase m)) a)
-> (ExceptT x m a -> ExceptT x (GenT (GenBase m)) a)
-> ExceptT x m a
-> GenT (ExceptT x (GenBase m)) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. m a -> GenT (GenBase m) a)
-> ExceptT x m a -> ExceptT x (GenT (GenBase m)) a
forall k (t :: (* -> *) -> k -> *) (m :: * -> *) (n :: * -> *)
       (b :: k).
(MFunctor t, Monad m) =>
(forall a. m a -> n a) -> t m b -> t n b
hoist forall a. m a -> GenT (GenBase m) a
forall (m :: * -> *) a. MonadGen m => m a -> GenT (GenBase m) a
toGenT

  fromGenT :: GenT (GenBase (ExceptT x m)) a -> ExceptT x m a
fromGenT =
    (forall a. GenT (GenBase m) a -> m a)
-> ExceptT x (GenT (GenBase m)) a -> ExceptT x m a
forall k (t :: (* -> *) -> k -> *) (m :: * -> *) (n :: * -> *)
       (b :: k).
(MFunctor t, Monad m) =>
(forall a. m a -> n a) -> t m b -> t n b
hoist forall a. GenT (GenBase m) a -> m a
forall (m :: * -> *) a. MonadGen m => GenT (GenBase m) a -> m a
fromGenT (ExceptT x (GenT (GenBase m)) a -> ExceptT x m a)
-> (GenT (ExceptT x (GenBase m)) a
    -> ExceptT x (GenT (GenBase m)) a)
-> GenT (ExceptT x (GenBase m)) a
-> ExceptT x m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GenT (ExceptT x (GenBase m)) a -> ExceptT x (GenT (GenBase m)) a
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *)
       (m :: * -> *) a.
(MonadTransDistributive g, Transformer f g m) =>
g (f m) a -> f (g m) a
distributeT

instance MonadGen m => MonadGen (ReaderT r m) where
  type GenBase (ReaderT r m) =
    ReaderT r (GenBase m)

  toGenT :: ReaderT r m a -> GenT (GenBase (ReaderT r m)) a
toGenT =
    ReaderT r (GenT (GenBase m)) a -> GenT (ReaderT r (GenBase m)) a
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *)
       (m :: * -> *) a.
(MonadTransDistributive g, Transformer f g m) =>
g (f m) a -> f (g m) a
distributeT (ReaderT r (GenT (GenBase m)) a -> GenT (ReaderT r (GenBase m)) a)
-> (ReaderT r m a -> ReaderT r (GenT (GenBase m)) a)
-> ReaderT r m a
-> GenT (ReaderT r (GenBase m)) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. m a -> GenT (GenBase m) a)
-> ReaderT r m a -> ReaderT r (GenT (GenBase m)) a
forall k (t :: (* -> *) -> k -> *) (m :: * -> *) (n :: * -> *)
       (b :: k).
(MFunctor t, Monad m) =>
(forall a. m a -> n a) -> t m b -> t n b
hoist forall a. m a -> GenT (GenBase m) a
forall (m :: * -> *) a. MonadGen m => m a -> GenT (GenBase m) a
toGenT

  fromGenT :: GenT (GenBase (ReaderT r m)) a -> ReaderT r m a
fromGenT =
    (forall a. GenT (GenBase m) a -> m a)
-> ReaderT r (GenT (GenBase m)) a -> ReaderT r m a
forall k (t :: (* -> *) -> k -> *) (m :: * -> *) (n :: * -> *)
       (b :: k).
(MFunctor t, Monad m) =>
(forall a. m a -> n a) -> t m b -> t n b
hoist forall a. GenT (GenBase m) a -> m a
forall (m :: * -> *) a. MonadGen m => GenT (GenBase m) a -> m a
fromGenT (ReaderT r (GenT (GenBase m)) a -> ReaderT r m a)
-> (GenT (ReaderT r (GenBase m)) a
    -> ReaderT r (GenT (GenBase m)) a)
-> GenT (ReaderT r (GenBase m)) a
-> ReaderT r m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GenT (ReaderT r (GenBase m)) a -> ReaderT r (GenT (GenBase m)) a
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *)
       (m :: * -> *) a.
(MonadTransDistributive g, Transformer f g m) =>
g (f m) a -> f (g m) a
distributeT

instance MonadGen m => MonadGen (Lazy.StateT r m) where
  type GenBase (Lazy.StateT r m) =
    Lazy.StateT r (GenBase m)

  toGenT :: StateT r m a -> GenT (GenBase (StateT r m)) a
toGenT =
    StateT r (GenT (GenBase m)) a -> GenT (StateT r (GenBase m)) a
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *)
       (m :: * -> *) a.
(MonadTransDistributive g, Transformer f g m) =>
g (f m) a -> f (g m) a
distributeT (StateT r (GenT (GenBase m)) a -> GenT (StateT r (GenBase m)) a)
-> (StateT r m a -> StateT r (GenT (GenBase m)) a)
-> StateT r m a
-> GenT (StateT r (GenBase m)) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. m a -> GenT (GenBase m) a)
-> StateT r m a -> StateT r (GenT (GenBase m)) a
forall k (t :: (* -> *) -> k -> *) (m :: * -> *) (n :: * -> *)
       (b :: k).
(MFunctor t, Monad m) =>
(forall a. m a -> n a) -> t m b -> t n b
hoist forall a. m a -> GenT (GenBase m) a
forall (m :: * -> *) a. MonadGen m => m a -> GenT (GenBase m) a
toGenT

  fromGenT :: GenT (GenBase (StateT r m)) a -> StateT r m a
fromGenT =
    (forall a. GenT (GenBase m) a -> m a)
-> StateT r (GenT (GenBase m)) a -> StateT r m a
forall k (t :: (* -> *) -> k -> *) (m :: * -> *) (n :: * -> *)
       (b :: k).
(MFunctor t, Monad m) =>
(forall a. m a -> n a) -> t m b -> t n b
hoist forall a. GenT (GenBase m) a -> m a
forall (m :: * -> *) a. MonadGen m => GenT (GenBase m) a -> m a
fromGenT (StateT r (GenT (GenBase m)) a -> StateT r m a)
-> (GenT (StateT r (GenBase m)) a -> StateT r (GenT (GenBase m)) a)
-> GenT (StateT r (GenBase m)) a
-> StateT r m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GenT (StateT r (GenBase m)) a -> StateT r (GenT (GenBase m)) a
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *)
       (m :: * -> *) a.
(MonadTransDistributive g, Transformer f g m) =>
g (f m) a -> f (g m) a
distributeT

instance MonadGen m => MonadGen (Strict.StateT r m) where
  type GenBase (Strict.StateT r m) =
    Strict.StateT r (GenBase m)

  toGenT :: StateT r m a -> GenT (GenBase (StateT r m)) a
toGenT =
    StateT r (GenT (GenBase m)) a -> GenT (StateT r (GenBase m)) a
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *)
       (m :: * -> *) a.
(MonadTransDistributive g, Transformer f g m) =>
g (f m) a -> f (g m) a
distributeT (StateT r (GenT (GenBase m)) a -> GenT (StateT r (GenBase m)) a)
-> (StateT r m a -> StateT r (GenT (GenBase m)) a)
-> StateT r m a
-> GenT (StateT r (GenBase m)) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. m a -> GenT (GenBase m) a)
-> StateT r m a -> StateT r (GenT (GenBase m)) a
forall k (t :: (* -> *) -> k -> *) (m :: * -> *) (n :: * -> *)
       (b :: k).
(MFunctor t, Monad m) =>
(forall a. m a -> n a) -> t m b -> t n b
hoist forall a. m a -> GenT (GenBase m) a
forall (m :: * -> *) a. MonadGen m => m a -> GenT (GenBase m) a
toGenT

  fromGenT :: GenT (GenBase (StateT r m)) a -> StateT r m a
fromGenT =
    (forall a. GenT (GenBase m) a -> m a)
-> StateT r (GenT (GenBase m)) a -> StateT r m a
forall k (t :: (* -> *) -> k -> *) (m :: * -> *) (n :: * -> *)
       (b :: k).
(MFunctor t, Monad m) =>
(forall a. m a -> n a) -> t m b -> t n b
hoist forall a. GenT (GenBase m) a -> m a
forall (m :: * -> *) a. MonadGen m => GenT (GenBase m) a -> m a
fromGenT (StateT r (GenT (GenBase m)) a -> StateT r m a)
-> (GenT (StateT r (GenBase m)) a -> StateT r (GenT (GenBase m)) a)
-> GenT (StateT r (GenBase m)) a
-> StateT r m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GenT (StateT r (GenBase m)) a -> StateT r (GenT (GenBase m)) a
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *)
       (m :: * -> *) a.
(MonadTransDistributive g, Transformer f g m) =>
g (f m) a -> f (g m) a
distributeT

instance (MonadGen m, Monoid w) => MonadGen (Lazy.WriterT w m) where
  type GenBase (Lazy.WriterT w m) =
    Lazy.WriterT w (GenBase m)

  toGenT :: WriterT w m a -> GenT (GenBase (WriterT w m)) a
toGenT =
    WriterT w (GenT (GenBase m)) a -> GenT (WriterT w (GenBase m)) a
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *)
       (m :: * -> *) a.
(MonadTransDistributive g, Transformer f g m) =>
g (f m) a -> f (g m) a
distributeT (WriterT w (GenT (GenBase m)) a -> GenT (WriterT w (GenBase m)) a)
-> (WriterT w m a -> WriterT w (GenT (GenBase m)) a)
-> WriterT w m a
-> GenT (WriterT w (GenBase m)) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. m a -> GenT (GenBase m) a)
-> WriterT w m a -> WriterT w (GenT (GenBase m)) a
forall k (t :: (* -> *) -> k -> *) (m :: * -> *) (n :: * -> *)
       (b :: k).
(MFunctor t, Monad m) =>
(forall a. m a -> n a) -> t m b -> t n b
hoist forall a. m a -> GenT (GenBase m) a
forall (m :: * -> *) a. MonadGen m => m a -> GenT (GenBase m) a
toGenT

  fromGenT :: GenT (GenBase (WriterT w m)) a -> WriterT w m a
fromGenT =
    (forall a. GenT (GenBase m) a -> m a)
-> WriterT w (GenT (GenBase m)) a -> WriterT w m a
forall k (t :: (* -> *) -> k -> *) (m :: * -> *) (n :: * -> *)
       (b :: k).
(MFunctor t, Monad m) =>
(forall a. m a -> n a) -> t m b -> t n b
hoist forall a. GenT (GenBase m) a -> m a
forall (m :: * -> *) a. MonadGen m => GenT (GenBase m) a -> m a
fromGenT (WriterT w (GenT (GenBase m)) a -> WriterT w m a)
-> (GenT (WriterT w (GenBase m)) a
    -> WriterT w (GenT (GenBase m)) a)
-> GenT (WriterT w (GenBase m)) a
-> WriterT w m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GenT (WriterT w (GenBase m)) a -> WriterT w (GenT (GenBase m)) a
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *)
       (m :: * -> *) a.
(MonadTransDistributive g, Transformer f g m) =>
g (f m) a -> f (g m) a
distributeT

instance (MonadGen m, Monoid w) => MonadGen (Strict.WriterT w m) where
  type GenBase (Strict.WriterT w m) =
    Strict.WriterT w (GenBase m)

  toGenT :: WriterT w m a -> GenT (GenBase (WriterT w m)) a
toGenT =
    WriterT w (GenT (GenBase m)) a -> GenT (WriterT w (GenBase m)) a
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *)
       (m :: * -> *) a.
(MonadTransDistributive g, Transformer f g m) =>
g (f m) a -> f (g m) a
distributeT (WriterT w (GenT (GenBase m)) a -> GenT (WriterT w (GenBase m)) a)
-> (WriterT w m a -> WriterT w (GenT (GenBase m)) a)
-> WriterT w m a
-> GenT (WriterT w (GenBase m)) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. m a -> GenT (GenBase m) a)
-> WriterT w m a -> WriterT w (GenT (GenBase m)) a
forall k (t :: (* -> *) -> k -> *) (m :: * -> *) (n :: * -> *)
       (b :: k).
(MFunctor t, Monad m) =>
(forall a. m a -> n a) -> t m b -> t n b
hoist forall a. m a -> GenT (GenBase m) a
forall (m :: * -> *) a. MonadGen m => m a -> GenT (GenBase m) a
toGenT

  fromGenT :: GenT (GenBase (WriterT w m)) a -> WriterT w m a
fromGenT =
    (forall a. GenT (GenBase m) a -> m a)
-> WriterT w (GenT (GenBase m)) a -> WriterT w m a
forall k (t :: (* -> *) -> k -> *) (m :: * -> *) (n :: * -> *)
       (b :: k).
(MFunctor t, Monad m) =>
(forall a. m a -> n a) -> t m b -> t n b
hoist forall a. GenT (GenBase m) a -> m a
forall (m :: * -> *) a. MonadGen m => GenT (GenBase m) a -> m a
fromGenT (WriterT w (GenT (GenBase m)) a -> WriterT w m a)
-> (GenT (WriterT w (GenBase m)) a
    -> WriterT w (GenT (GenBase m)) a)
-> GenT (WriterT w (GenBase m)) a
-> WriterT w m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GenT (WriterT w (GenBase m)) a -> WriterT w (GenT (GenBase m)) a
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *)
       (m :: * -> *) a.
(MonadTransDistributive g, Transformer f g m) =>
g (f m) a -> f (g m) a
distributeT

------------------------------------------------------------------------
-- GenT instances

instance w a distributeT

(StateT r (GenT (GenBase m)) a -> GenT (StateT r (GenBase m)) a)
-> (StateT r m a -> StateT r (GenT (GenBase m)) a)
-> StateT r m a
-> GenT (StateT r (GenBase m)) a
forall b c a. (b -> c) -> (a -> b) -> a >

04
an class="anno"annottext">(StateT r (GenT (GenBase m)) a -> (GenBase m)) a)
-> StateT r m a
-> GenT (IdentityT (GenBase m)) a
fora) a

04
an class="anno"annottext">(StateT r (GenT=3GenBase m)) a -> (GenBase m)) a)
-> StateT r m a
-> GenT (IdentityT (GenBase m)) a
fora) a

04
an class="anno"annottext">(StateT r (GenT,3GenBase m)) a -> (GenBase m)) a)
-> StateT r m a
-&gpmerenT (IdentityT (GenBase m)) a
fora) a

04
an class="anno"annottext">(StateT r (GenT,3GenBase m))text">StateT r (GenT (GenBase m)) a -&g"annottext">(StateT r (GenT (GenBase m)) a -> GenT (StateT r (GenBase m)) a)
-> (StateT r m a -> StateT r (GenT (GenBase m)) a)
-> StateT r m a
-> GenT (StateT r (GenBase m)) a
forall b c a. (b -> c) -> (a -> b) -> a >
 *) ->(8829gt; *) (f :: (* -> *) -> * -> *)
       (m :: * -> *) a.
(MonadTransDistributive g, Transformer f g m) =>
g (f m) a -> f (g m) a
distributeT (WriterT w (GenT (GenBase m)) a -> GenT (WriterT w (Gss="hs-special">)

. (forall a. m a -&an class="annottext">toGenT :: WriterT w m a -> GenT (GenBase (Writspan class="hs-identifier hs-v-ateT r m a -> StateT r (GenT (GenBase m)) a)
-> StateT r m a
-> GenT (StateT r (GenBase m)) a
forall b c a. (b -> c) -> (a -> b) -> a >
 *) ->(8829gt; *) (f :: (* -> *) -> * -> *)
       (m :: * -> *) a.
(MonadS12">seq
  , nonEmpty
  , 
04
an class="anno"annottext">(StateT r (Gedentifier">nonEmpty
  ,     , nonEmpty
  nonEmpty
  nonEmpty
class="hs-identifier">nonEmpty(StateT r (Gedentifier">nonEmpty
  ,  (foraae/span>  (StateT r (Gedentifier">nonEmpty  ,  (WriterT w (GenT (GenBase m)) a -> Writg.Interna/span> (IdentityT (GenT (GenBase m)) a -> IdentityT m a)
-> (GenT (IdentityT (GenBase m)) a
    -> IdentityT (GenT (GenBase m)) a)
-> GenT (IdentityT (GenBase m)) a
-> IdentityT m a
forall b c a. (b -&-spe, toGenT =
    ExceptT x (GenT (GenBase m)) a -> GenT (ExceptT x (GenBase m)) a
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *)
       (m :: * -> *) a.
(MonadTransDiass="hs-giyn>toGenT =
    ExceptT x (GenT (GenBase m)) a -> GenT (ExceptT x (GenBase m)) a
forall (g :: (* -> *) -&mz; * -> *) (f :: (* -> *) -> * -1pan>
    ExceptT x (GenT (GenBase m)) a -> GenT (ExceptT x (GenBase m)) a
forall (g :: (* -> *) -&mz; * -> *) (f :: (* -> *) -> * -1pan>
ByteString)
n> seed (ReaderT r m) ) ) >id (Tree (Maybe a) -> Maybe (Tree a))
-> (Gen a -> Tree (Maybe a)) -> Gen a -> Maybe (Tree a)
forall b c a. (b -> c) -> (a -> b) -> a ->e a)
forall b c a. (b -> c) -> (a -> b) -> a ->e a)
forall b c a. (b -> c) -> (a -> b) -> a ->e a)
forall b c a. (b -> c) -> (a -> b) -> a ->e a)
forall b c a. (b -> c) -> (a -> b) -> a ->e a)
forall b c a. (b -&gass="hs-identifier hs-type">Laa ->e a)
forall b c a. (b -&gass="hs-identifier hs-type">Laa ->e a)
forall b c a. (b -&gass="hs-identifier hs-type">Laa ->e a)
forall b c a. (b -&gass="hs-identifier hs-type">Lr hs-type">Laa ->e a)
foralntifier hs-var">id (Tree (Mayb
-> (GenT (IdentityT (GenBase m)) a
    -> IdentityT (GenT (GenBase m)) a)
-> GenT (IdentityT (Gen) -> * ->1*) (f :: (* -> *) -> * -> *)
       (m :: * ->1 *) a.
(MonadTransDiass="hs-giyn>toGenT =
   ,  ,  (WriterT w (GenT (GenBase m)) attext">(Witg.Interna/span> (IdentityT (GenT (GenBase m)) a -> IdentityT m aot">m
ByteString)
n> seed ( r ( ( (r (