module UVMHS.Lib.Rand where

import UVMHS.Core

import System.Random as R

--------
-- RG --
--------

class MonadRand m where
  rng ∷ State RG a → m a

newtype RG = RG { RG -> StdGen
unRG ∷ R.StdGen }

instance MonadRand IO where
  rng :: forall a. State RG a -> IO a
rng State RG a
f = (StdGen -> (a, StdGen)) -> IO a
forall (m :: * -> *) a. MonadIO m => (StdGen -> (a, StdGen)) -> m a
R.getStdRandom ((StdGen -> (a, StdGen)) -> IO a)
-> (StdGen -> (a, StdGen)) -> IO a
forall a b. (a -> b) -> a -> b
$ \ StdGen
ℊ → 
    let RG StdGen
ℊ' :* a
x = RG -> State RG a -> RG ∧ a
forall s a. s -> State s a -> s ∧ a
runState (StdGen -> RG
RG StdGen
ℊ) State RG a
f
    in (a
x,StdGen
ℊ')

wrapPrimRandu ∷ (R.StdGen → (a,R.StdGen)) → State RG a
wrapPrimRandu :: forall a. (StdGen -> (a, StdGen)) -> State RG a
wrapPrimRandu StdGen -> (a, StdGen)
f = do
  RG StdGen
ℊ ← StateT RG ID RG
forall s (m :: * -> *). MonadState s m => m s
get
  let (a
x,StdGen
ℊ') = StdGen -> (a, StdGen)
f StdGen
ℊ 
  RG -> StateT RG ID ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put (RG -> StateT RG ID ()) -> RG -> StateT RG ID ()
forall a b. (a -> b) -> a -> b
$ StdGen -> RG
RG StdGen
ℊ'
  a -> State RG a
forall a. a -> StateT RG ID a
forall (m :: * -> *) a. Return m => a -> m a
return a
x

wrapPrimRandr ∷ ((a,a) → R.StdGen → (a,R.StdGen)) → a → a → State RG a
wrapPrimRandr :: forall a. ((a, a) -> StdGen -> (a, StdGen)) -> a -> a -> State RG a
wrapPrimRandr (a, a) -> StdGen -> (a, StdGen)
f a
xl a
xh = do
  RG StdGen
ℊ ← StateT RG ID RG
forall s (m :: * -> *). MonadState s m => m s
get 
  let (a
x,StdGen
ℊ') = (a, a) -> StdGen -> (a, StdGen)
f (a
xl,a
xh) StdGen
ℊ 
  RG -> StateT RG ID ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put (RG -> StateT RG ID ()) -> RG -> StateT RG ID ()
forall a b. (a -> b) -> a -> b
$ StdGen -> RG
RG StdGen
ℊ' 
  a -> State RG a
forall a. a -> StateT RG ID a
forall (m :: * -> *) a. Return m => a -> m a
return a
x

------------------------
-- BASE VALUE CLASSES --
------------------------

class RandUniform a where
  prandu ∷ State RG a

class RandRange a where
  prandr ∷ a → a → State RG a

prandrRadius ∷ (RandRange a,Zero a,Minus a) ⇒ a → State RG a
prandrRadius :: forall a. (RandRange a, Zero a, Minus a) => a -> State RG a
prandrRadius a
x = a -> a -> State RG a
forall a. RandRange a => a -> a -> State RG a
prandr (a -> a
forall a. (Zero a, Minus a) => a -> a
neg a
x) a
x

-----------------
-- FUZZY CLASS --
-----------------

class Fuzzy a where
  fuzzy ∷ FuzzyM a

data FuzzyEnv = FuzzyEnv
  { FuzzyEnv -> ℕ64
fuzzyEnvRadius ∷ ℕ64
  , FuzzyEnv -> ℕ64
fuzzyEnvDepth  ∷ ℕ64
  }

newtype FuzzyM a = FuzzyM { forall a. FuzzyM a -> RWS FuzzyEnv () RG a
unRandM ∷ RWS FuzzyEnv () RG a }
  deriving
  ( (forall a. a -> FuzzyM a) -> Return FuzzyM
forall a. a -> FuzzyM a
forall (m :: * -> *). (forall a. a -> m a) -> Return m
$creturn :: forall a. a -> FuzzyM a
return :: forall a. a -> FuzzyM a
Return,(forall a b. FuzzyM a -> (a -> FuzzyM b) -> FuzzyM b)
-> Bind FuzzyM
forall a b. FuzzyM a -> (a -> FuzzyM b) -> FuzzyM b
forall (m :: * -> *).
(forall a b. m a -> (a -> m b) -> m b) -> Bind m
$c≫= :: forall a b. FuzzyM a -> (a -> FuzzyM b) -> FuzzyM b
≫= :: forall a b. FuzzyM a -> (a -> FuzzyM b) -> FuzzyM b
Bind,(forall a b. (a -> b) -> FuzzyM a -> FuzzyM b) -> Functor FuzzyM
forall a b. (a -> b) -> FuzzyM a -> FuzzyM b
forall (t :: * -> *).
(forall a b. (a -> b) -> t a -> t b) -> Functor t
$cmap :: forall a b. (a -> b) -> FuzzyM a -> FuzzyM b
map :: forall a b. (a -> b) -> FuzzyM a -> FuzzyM b
Functor,Bind FuzzyM
Return FuzzyM
Functor FuzzyM
(Functor FuzzyM, Return FuzzyM, Bind FuzzyM) => Monad FuzzyM
forall (m :: * -> *). (Functor m, Return m, Bind m) => Monad m
Monad
  , MonadReader FuzzyEnv
  , MonadState RG
  )

makeLenses ''FuzzyEnv

mkFuzzyM ∷ (FuzzyEnv → RG → RG ∧ a) → FuzzyM a
mkFuzzyM :: forall a. (FuzzyEnv -> RG -> RG ∧ a) -> FuzzyM a
mkFuzzyM FuzzyEnv -> RG -> RG ∧ a
f = RWS FuzzyEnv () RG a -> FuzzyM a
forall a. RWS FuzzyEnv () RG a -> FuzzyM a
FuzzyM (RWS FuzzyEnv () RG a -> FuzzyM a)
-> RWS FuzzyEnv () RG a -> FuzzyM a
forall a b. (a -> b) -> a -> b
$ (FuzzyEnv -> RG -> (RG ∧ ()) ∧ a) -> RWS FuzzyEnv () RG a
forall r o s a. (r -> s -> (s ∧ o) ∧ a) -> RWS r o s a
mkRWS ((FuzzyEnv -> RG -> (RG ∧ ()) ∧ a) -> RWS FuzzyEnv () RG a)
-> (FuzzyEnv -> RG -> (RG ∧ ()) ∧ a) -> RWS FuzzyEnv () RG a
forall a b. (a -> b) -> a -> b
$ \ FuzzyEnv
γ RG
ℊ → (RG -> RG ∧ ()) -> (RG ∧ a) -> (RG ∧ ()) ∧ a
forall a₁ a₂ b. (a₁ -> a₂) -> (a₁ ∧ b) -> a₂ ∧ b
mapFst ((RG -> () -> RG ∧ ()) -> () -> RG -> RG ∧ ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip RG -> () -> RG ∧ ()
forall a b. a -> b -> a ∧ b
(:*) ()) ((RG ∧ a) -> (RG ∧ ()) ∧ a) -> (RG ∧ a) -> (RG ∧ ()) ∧ a
forall a b. (a -> b) -> a -> b
$ FuzzyEnv -> RG -> RG ∧ a
f FuzzyEnv
γ RG
ℊ

runFuzzyM ∷ FuzzyEnv → RG → FuzzyM a → RG ∧ a
runFuzzyM :: forall a. FuzzyEnv -> RG -> FuzzyM a -> RG ∧ a
runFuzzyM FuzzyEnv
γ RG
ℊ = ((RG ∧ ()) -> RG) -> ((RG ∧ ()) ∧ a) -> RG ∧ a
forall a₁ a₂ b. (a₁ -> a₂) -> (a₁ ∧ b) -> a₂ ∧ b
mapFst (RG ∧ ()) -> RG
forall a b. (a ∧ b) -> a
fst (((RG ∧ ()) ∧ a) -> RG ∧ a)
-> (RWS FuzzyEnv () RG a -> (RG ∧ ()) ∧ a)
-> RWS FuzzyEnv () RG a
-> RG ∧ a
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ FuzzyEnv -> RG -> RWS FuzzyEnv () RG a -> (RG ∧ ()) ∧ a
forall r o s a. r -> s -> RWS r o s a -> (s ∧ o) ∧ a
runRWS FuzzyEnv
γ RG
ℊ (RWS FuzzyEnv () RG a -> RG ∧ a)
-> (FuzzyM a -> RWS FuzzyEnv () RG a) -> FuzzyM a -> RG ∧ a
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ FuzzyM a -> RWS FuzzyEnv () RG a
forall a. FuzzyM a -> RWS FuzzyEnv () RG a
unRandM

runFuzzyMRG ∷ FuzzyEnv → FuzzyM a → State RG a
runFuzzyMRG :: forall a. FuzzyEnv -> FuzzyM a -> State RG a
runFuzzyMRG FuzzyEnv
γ FuzzyM a
xM = (RG -> RG ∧ a) -> State RG a
forall s a. (s -> s ∧ a) -> State s a
mkState ((RG -> RG ∧ a) -> State RG a) -> (RG -> RG ∧ a) -> State RG a
forall a b. (a -> b) -> a -> b
$ \ RG
ℊ → FuzzyEnv -> RG -> FuzzyM a -> RG ∧ a
forall a. FuzzyEnv -> RG -> FuzzyM a -> RG ∧ a
runFuzzyM FuzzyEnv
γ RG
ℊ FuzzyM a
xM

fuzzyRec ∷ FuzzyM a → FuzzyM a
fuzzyRec :: forall a. FuzzyM a -> FuzzyM a
fuzzyRec = (FuzzyEnv ⟢ ℕ64) -> (ℕ64 -> ℕ64) -> FuzzyM a -> FuzzyM a
forall (m :: * -> *) r₁ r₂ a.
(Monad m, MonadReader r₁ m) =>
(r₁ ⟢ r₂) -> (r₂ -> r₂) -> m a -> m a
mapEnvL FuzzyEnv ⟢ ℕ64
fuzzyEnvDepthL (\ ℕ64
d → ℕ64
dℕ64 -> ℕ64 -> ℕ64
forall a. Minus a => a -> a -> a
-ℕ64
1)

instance MonadRand FuzzyM where
  rng :: forall a. State RG a -> FuzzyM a
rng State RG a
xM = RWS FuzzyEnv () RG a -> FuzzyM a
forall a. RWS FuzzyEnv () RG a -> FuzzyM a
FuzzyM (RWS FuzzyEnv () RG a -> FuzzyM a)
-> RWS FuzzyEnv () RG a -> FuzzyM a
forall a b. (a -> b) -> a -> b
$ (FuzzyEnv -> RG -> (RG ∧ ()) ∧ a) -> RWS FuzzyEnv () RG a
forall r o s a. (r -> s -> (s ∧ o) ∧ a) -> RWS r o s a
mkRWS ((FuzzyEnv -> RG -> (RG ∧ ()) ∧ a) -> RWS FuzzyEnv () RG a)
-> (FuzzyEnv -> RG -> (RG ∧ ()) ∧ a) -> RWS FuzzyEnv () RG a
forall a b. (a -> b) -> a -> b
$ \ FuzzyEnv
_γ RG
ℊ → (RG -> RG ∧ ()) -> (RG ∧ a) -> (RG ∧ ()) ∧ a
forall a₁ a₂ b. (a₁ -> a₂) -> (a₁ ∧ b) -> a₂ ∧ b
mapFst ((RG -> () -> RG ∧ ()) -> () -> RG -> RG ∧ ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip RG -> () -> RG ∧ ()
forall a b. a -> b -> a ∧ b
(:*) ()) ((RG ∧ a) -> (RG ∧ ()) ∧ a) -> (RG ∧ a) -> (RG ∧ ()) ∧ a
forall a b. (a -> b) -> a -> b
$ RG -> State RG a -> RG ∧ a
forall s a. s -> State s a -> s ∧ a
runState RG
ℊ State RG a
xM

--------------------------
-- BASE VALUE INSTANCES --
--------------------------

instance RandUniform 𝔹   where prandu :: State RG 𝔹
prandu = (StdGen -> (𝔹, StdGen)) -> State RG 𝔹
forall a. (StdGen -> (a, StdGen)) -> State RG a
wrapPrimRandu StdGen -> (𝔹, StdGen)
forall g a. (RandomGen g, Uniform a) => g -> (a, g)
R.uniform

instance RandUniform ℕ64 where prandu :: State RG ℕ64
prandu = (StdGen -> (ℕ64, StdGen)) -> State RG ℕ64
forall a. (StdGen -> (a, StdGen)) -> State RG a
wrapPrimRandu StdGen -> (ℕ64, StdGen)
forall g a. (RandomGen g, Uniform a) => g -> (a, g)
R.uniform
instance RandUniform ℕ32 where prandu :: State RG ℕ32
prandu = (StdGen -> (ℕ32, StdGen)) -> State RG ℕ32
forall a. (StdGen -> (a, StdGen)) -> State RG a
wrapPrimRandu StdGen -> (ℕ32, StdGen)
forall g a. (RandomGen g, Uniform a) => g -> (a, g)
R.uniform
instance RandUniform ℕ16 where prandu :: State RG ℕ16
prandu = (StdGen -> (ℕ16, StdGen)) -> State RG ℕ16
forall a. (StdGen -> (a, StdGen)) -> State RG a
wrapPrimRandu StdGen -> (ℕ16, StdGen)
forall g a. (RandomGen g, Uniform a) => g -> (a, g)
R.uniform
instance RandUniform ℕ8  where prandu :: State RG ℕ8
prandu = (StdGen -> (ℕ8, StdGen)) -> State RG ℕ8
forall a. (StdGen -> (a, StdGen)) -> State RG a
wrapPrimRandu StdGen -> (ℕ8, StdGen)
forall g a. (RandomGen g, Uniform a) => g -> (a, g)
R.uniform

instance RandUniform ℤ64 where prandu :: State RG ℤ64
prandu = (StdGen -> (ℤ64, StdGen)) -> State RG ℤ64
forall a. (StdGen -> (a, StdGen)) -> State RG a
wrapPrimRandu StdGen -> (ℤ64, StdGen)
forall g a. (RandomGen g, Uniform a) => g -> (a, g)
R.uniform
instance RandUniform ℤ32 where prandu :: State RG ℤ32
prandu = (StdGen -> (ℤ32, StdGen)) -> State RG ℤ32
forall a. (StdGen -> (a, StdGen)) -> State RG a
wrapPrimRandu StdGen -> (ℤ32, StdGen)
forall g a. (RandomGen g, Uniform a) => g -> (a, g)
R.uniform
instance RandUniform ℤ16 where prandu :: State RG ℤ16
prandu = (StdGen -> (ℤ16, StdGen)) -> State RG ℤ16
forall a. (StdGen -> (a, StdGen)) -> State RG a
wrapPrimRandu StdGen -> (ℤ16, StdGen)
forall g a. (RandomGen g, Uniform a) => g -> (a, g)
R.uniform
instance RandUniform ℤ8  where prandu :: State RG ℤ8
prandu = (StdGen -> (ℤ8, StdGen)) -> State RG ℤ8
forall a. (StdGen -> (a, StdGen)) -> State RG a
wrapPrimRandu StdGen -> (ℤ8, StdGen)
forall g a. (RandomGen g, Uniform a) => g -> (a, g)
R.uniform

instance RandRange ℕ64   where prandr :: ℕ64 -> ℕ64 -> State RG ℕ64
prandr = ((ℕ64, ℕ64) -> StdGen -> (ℕ64, StdGen))
-> ℕ64 -> ℕ64 -> State RG ℕ64
forall a. ((a, a) -> StdGen -> (a, StdGen)) -> a -> a -> State RG a
wrapPrimRandr (ℕ64, ℕ64) -> StdGen -> (ℕ64, StdGen)
forall g a. (RandomGen g, UniformRange a) => (a, a) -> g -> (a, g)
R.uniformR
instance RandRange ℕ32   where prandr :: ℕ32 -> ℕ32 -> State RG ℕ32
prandr = ((ℕ32, ℕ32) -> StdGen -> (ℕ32, StdGen))
-> ℕ32 -> ℕ32 -> State RG ℕ32
forall a. ((a, a) -> StdGen -> (a, StdGen)) -> a -> a -> State RG a
wrapPrimRandr (ℕ32, ℕ32) -> StdGen -> (ℕ32, StdGen)
forall g a. (RandomGen g, UniformRange a) => (a, a) -> g -> (a, g)
R.uniformR
instance RandRange ℕ16   where prandr :: ℕ16 -> ℕ16 -> State RG ℕ16
prandr = ((ℕ16, ℕ16) -> StdGen -> (ℕ16, StdGen))
-> ℕ16 -> ℕ16 -> State RG ℕ16
forall a. ((a, a) -> StdGen -> (a, StdGen)) -> a -> a -> State RG a
wrapPrimRandr (ℕ16, ℕ16) -> StdGen -> (ℕ16, StdGen)
forall g a. (RandomGen g, UniformRange a) => (a, a) -> g -> (a, g)
R.uniformR
instance RandRange ℕ8    where prandr :: ℕ8 -> ℕ8 -> State RG ℕ8
prandr = ((ℕ8, ℕ8) -> StdGen -> (ℕ8, StdGen)) -> ℕ8 -> ℕ8 -> State RG ℕ8
forall a. ((a, a) -> StdGen -> (a, StdGen)) -> a -> a -> State RG a
wrapPrimRandr (ℕ8, ℕ8) -> StdGen -> (ℕ8, StdGen)
forall g a. (RandomGen g, UniformRange a) => (a, a) -> g -> (a, g)
R.uniformR

instance RandRange ℤ64   where prandr :: ℤ64 -> ℤ64 -> State RG ℤ64
prandr = ((ℤ64, ℤ64) -> StdGen -> (ℤ64, StdGen))
-> ℤ64 -> ℤ64 -> State RG ℤ64
forall a. ((a, a) -> StdGen -> (a, StdGen)) -> a -> a -> State RG a
wrapPrimRandr (ℤ64, ℤ64) -> StdGen -> (ℤ64, StdGen)
forall g a. (RandomGen g, UniformRange a) => (a, a) -> g -> (a, g)
R.uniformR
instance RandRange ℤ32   where prandr :: ℤ32 -> ℤ32 -> State RG ℤ32
prandr = ((ℤ32, ℤ32) -> StdGen -> (ℤ32, StdGen))
-> ℤ32 -> ℤ32 -> State RG ℤ32
forall a. ((a, a) -> StdGen -> (a, StdGen)) -> a -> a -> State RG a
wrapPrimRandr (ℤ32, ℤ32) -> StdGen -> (ℤ32, StdGen)
forall g a. (RandomGen g, UniformRange a) => (a, a) -> g -> (a, g)
R.uniformR
instance RandRange ℤ16   where prandr :: ℤ16 -> ℤ16 -> State RG ℤ16
prandr = ((ℤ16, ℤ16) -> StdGen -> (ℤ16, StdGen))
-> ℤ16 -> ℤ16 -> State RG ℤ16
forall a. ((a, a) -> StdGen -> (a, StdGen)) -> a -> a -> State RG a
wrapPrimRandr (ℤ16, ℤ16) -> StdGen -> (ℤ16, StdGen)
forall g a. (RandomGen g, UniformRange a) => (a, a) -> g -> (a, g)
R.uniformR
instance RandRange ℤ8    where prandr :: ℤ8 -> ℤ8 -> State RG ℤ8
prandr = ((ℤ8, ℤ8) -> StdGen -> (ℤ8, StdGen)) -> ℤ8 -> ℤ8 -> State RG ℤ8
forall a. ((a, a) -> StdGen -> (a, StdGen)) -> a -> a -> State RG a
wrapPrimRandr (ℤ8, ℤ8) -> StdGen -> (ℤ8, StdGen)
forall g a. (RandomGen g, UniformRange a) => (a, a) -> g -> (a, g)
R.uniformR

instance RandRange 𝔻     where prandr :: 𝔻 -> 𝔻 -> State RG 𝔻
prandr = ((𝔻, 𝔻) -> StdGen -> (𝔻, StdGen)) -> 𝔻 -> 𝔻 -> State RG 𝔻
forall a. ((a, a) -> StdGen -> (a, StdGen)) -> a -> a -> State RG a
wrapPrimRandr (𝔻, 𝔻) -> StdGen -> (𝔻, StdGen)
forall g a. (RandomGen g, UniformRange a) => (a, a) -> g -> (a, g)
R.uniformR

-----------------
-- COMBINATORS --
-----------------

randu ∷ ∀ a m. (MonadRand m,RandUniform a) ⇒ m a
randu :: forall a (m :: * -> *). (MonadRand m, RandUniform a) => m a
randu = State RG a -> m a
forall a. State RG a -> m a
forall (m :: * -> *) a. MonadRand m => State RG a -> m a
rng State RG a
forall a. RandUniform a => State RG a
prandu

randr ∷ ∀ a m. (MonadRand m,RandRange a) ⇒ a → a → m a
randr :: forall a (m :: * -> *). (MonadRand m, RandRange a) => a -> a -> m a
randr a
lb a
hb = State RG a -> m a
forall a. State RG a -> m a
forall (m :: * -> *) a. MonadRand m => State RG a -> m a
rng (State RG a -> m a) -> State RG a -> m a
forall a b. (a -> b) -> a -> b
$ a -> a -> State RG a
forall a. RandRange a => a -> a -> State RG a
prandr a
lb a
hb

randrRadius ∷ ∀ a m. (MonadRand m,RandRange a,Zero a,Minus a) ⇒ a → m a
randrRadius :: forall a (m :: * -> *).
(MonadRand m, RandRange a, Zero a, Minus a) =>
a -> m a
randrRadius = State RG a -> m a
forall a. State RG a -> m a
forall (m :: * -> *) a. MonadRand m => State RG a -> m a
rng (State RG a -> m a) -> (a -> State RG a) -> a -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ a -> State RG a
forall a. (RandRange a, Zero a, Minus a) => a -> State RG a
prandrRadius

rand ∷ ∀ a m. (MonadRand m,Fuzzy a) ⇒ ℕ64 → ℕ64 → m a
rand :: forall a (m :: * -> *). (MonadRand m, Fuzzy a) => ℕ64 -> ℕ64 -> m a
rand ℕ64
r ℕ64
d = State RG a -> m a
forall a. State RG a -> m a
forall (m :: * -> *) a. MonadRand m => State RG a -> m a
rng (State RG a -> m a) -> State RG a -> m a
forall a b. (a -> b) -> a -> b
$ FuzzyEnv -> FuzzyM a -> State RG a
forall a. FuzzyEnv -> FuzzyM a -> State RG a
runFuzzyMRG (ℕ64 -> ℕ64 -> FuzzyEnv
FuzzyEnv ℕ64
r ℕ64
d) FuzzyM a
forall a. Fuzzy a => FuzzyM a
fuzzy

wrchoose ∷ ∀ t m a. (Monad m,MonadRand m,ToIter (ℕ64 ∧ (() → m a)) t) ⇒ t → m a
wrchoose :: forall t (m :: * -> *) a.
(Monad m, MonadRand m, ToIter (ℕ64 ∧ (() -> m a)) t) =>
t -> m a
wrchoose t
wxs 
  | t -> 𝔹
forall a t. ToIter a t => t -> 𝔹
isEmpty t
wxs = 𝕊 -> m a
forall a. STACK => 𝕊 -> a
error 𝕊
"wrchoose not defined for zero elements"
  | 𝔹
otherwise   = do
      let w₀ :: ℕ64
w₀ = 𝐼 ℕ64 -> ℕ64
forall a t. (ToIter a t, Additive a) => t -> a
sum (𝐼 ℕ64 -> ℕ64) -> 𝐼 ℕ64 -> ℕ64
forall a b. (a -> b) -> a -> b
$ ((ℕ64 ∧ (() -> m a)) -> ℕ64) -> 𝐼 (ℕ64 ∧ (() -> m a)) -> 𝐼 ℕ64
forall a b. (a -> b) -> 𝐼 a -> 𝐼 b
forall (t :: * -> *) a b. Functor t => (a -> b) -> t a -> t b
map (ℕ64 ∧ (() -> m a)) -> ℕ64
forall a b. (a ∧ b) -> a
fst (𝐼 (ℕ64 ∧ (() -> m a)) -> 𝐼 ℕ64) -> 𝐼 (ℕ64 ∧ (() -> m a)) -> 𝐼 ℕ64
forall a b. (a -> b) -> a -> b
$ t -> 𝐼 (ℕ64 ∧ (() -> m a))
forall a t. ToIter a t => t -> 𝐼 a
iter t
wxs
      let ()
_ = if ℕ64
w₀ ℕ64 -> ℕ64 -> 𝔹
forall a. Eq a => a -> a -> 𝔹
≡ ℕ64
0 then 𝕊 -> ()
forall a. STACK => 𝕊 -> a
error 𝕊
"wrchoose not defined for zero total weight" else ()
      ℕ64
n ← ℕ64 -> ℕ64 -> m ℕ64
forall a (m :: * -> *). (MonadRand m, RandRange a) => a -> a -> m a
randr ℕ64
1 ℕ64
w₀
      (ℕ64 -> m a) -> ContT a m ℕ64 -> m a
forall {k} a (m :: k -> *) (u :: k).
(a -> m u) -> ContT u m a -> m u
runContT (\ ℕ64
n' → 𝕊 -> m a
forall a. STACK => 𝕊 -> a
error (𝕊 -> m a) -> 𝕊 -> m a
forall a b. (a -> b) -> a -> b
$ 𝕊
"impossible" 𝕊 -> 𝕊 -> 𝕊
forall a. Append a => a -> a -> a
⧺ ℕ64 -> 𝕊
forall a. Show a => a -> 𝕊
show𝕊 ℕ64
n') (ContT a m ℕ64 -> m a) -> ContT a m ℕ64 -> m a
forall a b. (a -> b) -> a -> b
$ t
-> ℕ64
-> ((ℕ64 ∧ (() -> m a)) -> ℕ64 -> ContT a m ℕ64)
-> ContT a m ℕ64
forall (m :: * -> *) a t b.
(Monad m, ToIter a t) =>
t -> b -> (a -> b -> m b) -> m b
mfoldOnFrom t
wxs ℕ64
0 (((ℕ64 ∧ (() -> m a)) -> ℕ64 -> ContT a m ℕ64) -> ContT a m ℕ64)
-> ((ℕ64 ∧ (() -> m a)) -> ℕ64 -> ContT a m ℕ64) -> ContT a m ℕ64
forall a b. (a -> b) -> a -> b
$ \ (ℕ64
w :* () -> m a
xM) ℕ64
wᵢ →
        let wᵢ' :: ℕ64
wᵢ' = ℕ64
wᵢℕ64 -> ℕ64 -> ℕ64
forall a. Plus a => a -> a -> a
+ℕ64
w 
        in
        if ℕ64
n ℕ64 -> ℕ64 -> 𝔹
forall a. Ord a => a -> a -> 𝔹
≤ ℕ64
wᵢ'
        then ((ℕ64 -> ContT a m a) -> ContT a m a) -> ContT a m ℕ64
forall a. ((a -> ContT a m a) -> ContT a m a) -> ContT a m a
forall r (m :: * -> *) a.
MonadCont r m =>
((a -> m r) -> m r) -> m a
callCC (((ℕ64 -> ContT a m a) -> ContT a m a) -> ContT a m ℕ64)
-> ((ℕ64 -> ContT a m a) -> ContT a m a) -> ContT a m ℕ64
forall a b. (a -> b) -> a -> b
$ \ ℕ64 -> ContT a m a
_𝓀 → m a -> ContT a m a
forall (m :: * -> *) a. Monad m => m a -> ContT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(Transformer t, Monad m) =>
m a -> t m a
lift (m a -> ContT a m a) -> m a -> ContT a m a
forall a b. (a -> b) -> a -> b
$ () -> m a
xM ()
        else ℕ64 -> ContT a m ℕ64
forall a. a -> ContT a m a
forall (m :: * -> *) a. Return m => a -> m a
return ℕ64
wᵢ'

rchoose ∷ (Monad m,MonadRand m,ToIter (() → m a) t) ⇒ t → m a
rchoose :: forall (m :: * -> *) a t.
(Monad m, MonadRand m, ToIter (() -> m a) t) =>
t -> m a
rchoose t
xMs 
  | t -> 𝔹
forall a t. ToIter a t => t -> 𝔹
isEmpty t
xMs = 𝕊 -> m a
forall a. STACK => 𝕊 -> a
error 𝕊
"rchoose not defined for zero elements"
  | 𝔹
otherwise   = 𝐼 (ℕ64 ∧ (() -> m a)) -> m a
forall t (m :: * -> *) a.
(Monad m, MonadRand m, ToIter (ℕ64 ∧ (() -> m a)) t) =>
t -> m a
wrchoose (𝐼 (ℕ64 ∧ (() -> m a)) -> m a) -> 𝐼 (ℕ64 ∧ (() -> m a)) -> m a
forall a b. (a -> b) -> a -> b
$ ((() -> m a) -> ℕ64 ∧ (() -> m a))
-> 𝐼 (() -> m a) -> 𝐼 (ℕ64 ∧ (() -> m a))
forall a b. (a -> b) -> 𝐼 a -> 𝐼 b
forall (t :: * -> *) a b. Functor t => (a -> b) -> t a -> t b
map (ℕ64
forall a. One a => a
one ℕ64 -> (() -> m a) -> ℕ64 ∧ (() -> m a)
forall a b. a -> b -> a ∧ b
:*) (𝐼 (() -> m a) -> 𝐼 (ℕ64 ∧ (() -> m a)))
-> 𝐼 (() -> m a) -> 𝐼 (ℕ64 ∧ (() -> m a))
forall a b. (a -> b) -> a -> b
$ t -> 𝐼 (() -> m a)
forall a t. ToIter a t => t -> 𝐼 a
iter t
xMs

randTny ∷ ∀ a m. (MonadRand m,Fuzzy a) ⇒ m a
randTny :: forall a (m :: * -> *). (MonadRand m, Fuzzy a) => m a
randTny = ℕ64 -> ℕ64 -> m a
forall a (m :: * -> *). (MonadRand m, Fuzzy a) => ℕ64 -> ℕ64 -> m a
rand ℕ64
1 ℕ64
1

randSml ∷ ∀ a m. (MonadRand m,Fuzzy a) ⇒ m a
randSml :: forall a (m :: * -> *). (MonadRand m, Fuzzy a) => m a
randSml = ℕ64 -> ℕ64 -> m a
forall a (m :: * -> *). (MonadRand m, Fuzzy a) => ℕ64 -> ℕ64 -> m a
rand ℕ64
4 ℕ64
4

randMed ∷ ∀ a m. (MonadRand m,Fuzzy a) ⇒ m a
randMed :: forall a (m :: * -> *). (MonadRand m, Fuzzy a) => m a
randMed = ℕ64 -> ℕ64 -> m a
forall a (m :: * -> *). (MonadRand m, Fuzzy a) => ℕ64 -> ℕ64 -> m a
rand ℕ64
16 ℕ64
16 

randLrg ∷ ∀ a m. (MonadRand m,Fuzzy a) ⇒ m a
randLrg :: forall a (m :: * -> *). (MonadRand m, Fuzzy a) => m a
randLrg = ℕ64 -> ℕ64 -> m a
forall a (m :: * -> *). (MonadRand m, Fuzzy a) => ℕ64 -> ℕ64 -> m a
rand ℕ64
64 ℕ64
64

untilPass ∷ (Monad m) ⇒ (a → 𝔹) → m a → m a
untilPass :: forall (m :: * -> *) a. Monad m => (a -> 𝔹) -> m a -> m a
untilPass a -> 𝔹
f m a
xM = m a
loop
  where
    loop :: m a
loop = do
      a
x ← m a
xM
      if a -> 𝔹
f a
x 
      then a -> m a
forall a. a -> m a
forall (m :: * -> *) a. Return m => a -> m a
return a
x
      else m a
loop

---------------------
-- FUZZY INSTANCES --
---------------------

instance Fuzzy ℕ64 where fuzzy :: FuzzyM ℕ64
fuzzy = ℕ64 -> ℕ64 -> FuzzyM ℕ64
forall a (m :: * -> *). (MonadRand m, RandRange a) => a -> a -> m a
randr ℕ64
forall a. Zero a => a
zero          (ℕ64 -> FuzzyM ℕ64) -> (ℕ64 -> ℕ64) -> ℕ64 -> FuzzyM ℕ64
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ (ℕ64 -> ℕ64 -> ℕ64
forall a. Times a => a -> a -> a
×ℕ64
2) (ℕ64 -> FuzzyM ℕ64) -> FuzzyM ℕ64 -> FuzzyM ℕ64
forall (m :: * -> *) a b. Bind m => (a -> m b) -> m a -> m b
*$ (FuzzyEnv ⟢ ℕ64) -> FuzzyM ℕ64
forall r'. (FuzzyEnv ⟢ r') -> FuzzyM r'
forall r (m :: * -> *) r'. MonadReader r m => (r ⟢ r') -> m r'
askL FuzzyEnv ⟢ ℕ64
fuzzyEnvRadiusL
instance Fuzzy ℕ32 where fuzzy :: FuzzyM ℕ32
fuzzy = ℕ32 -> ℕ32 -> FuzzyM ℕ32
forall a (m :: * -> *). (MonadRand m, RandRange a) => a -> a -> m a
randr ℕ32
forall a. Zero a => a
zero (ℕ32 -> FuzzyM ℕ32) -> (ℕ64 -> ℕ32) -> ℕ64 -> FuzzyM ℕ32
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ ℕ64 -> ℕ32
forall a. (ToNatO32 a, STACK) => a -> ℕ32
natΩ32 (ℕ64 -> FuzzyM ℕ32) -> (ℕ64 -> ℕ64) -> ℕ64 -> FuzzyM ℕ32
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ (ℕ64 -> ℕ64 -> ℕ64
forall a. Times a => a -> a -> a
×ℕ64
2) (ℕ64 -> FuzzyM ℕ32) -> FuzzyM ℕ64 -> FuzzyM ℕ32
forall (m :: * -> *) a b. Bind m => (a -> m b) -> m a -> m b
*$ (FuzzyEnv ⟢ ℕ64) -> FuzzyM ℕ64
forall r'. (FuzzyEnv ⟢ r') -> FuzzyM r'
forall r (m :: * -> *) r'. MonadReader r m => (r ⟢ r') -> m r'
askL FuzzyEnv ⟢ ℕ64
fuzzyEnvRadiusL
instance Fuzzy ℕ16 where fuzzy :: FuzzyM ℕ16
fuzzy = ℕ16 -> ℕ16 -> FuzzyM ℕ16
forall a (m :: * -> *). (MonadRand m, RandRange a) => a -> a -> m a
randr ℕ16
forall a. Zero a => a
zero (ℕ16 -> FuzzyM ℕ16) -> (ℕ64 -> ℕ16) -> ℕ64 -> FuzzyM ℕ16
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ ℕ64 -> ℕ16
forall a. (ToNatO16 a, STACK) => a -> ℕ16
natΩ16 (ℕ64 -> FuzzyM ℕ16) -> (ℕ64 -> ℕ64) -> ℕ64 -> FuzzyM ℕ16
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ (ℕ64 -> ℕ64 -> ℕ64
forall a. Times a => a -> a -> a
×ℕ64
2) (ℕ64 -> FuzzyM ℕ16) -> FuzzyM ℕ64 -> FuzzyM ℕ16
forall (m :: * -> *) a b. Bind m => (a -> m b) -> m a -> m b
*$ (FuzzyEnv ⟢ ℕ64) -> FuzzyM ℕ64
forall r'. (FuzzyEnv ⟢ r') -> FuzzyM r'
forall r (m :: * -> *) r'. MonadReader r m => (r ⟢ r') -> m r'
askL FuzzyEnv ⟢ ℕ64
fuzzyEnvRadiusL
instance Fuzzy ℕ8  where fuzzy :: FuzzyM ℕ8
fuzzy = ℕ8 -> ℕ8 -> FuzzyM ℕ8
forall a (m :: * -> *). (MonadRand m, RandRange a) => a -> a -> m a
randr ℕ8
forall a. Zero a => a
zero (ℕ8 -> FuzzyM ℕ8) -> (ℕ64 -> ℕ8) -> ℕ64 -> FuzzyM ℕ8
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ ℕ64 -> ℕ8
forall a. (ToNatO8 a, STACK) => a -> ℕ8
natΩ8  (ℕ64 -> FuzzyM ℕ8) -> (ℕ64 -> ℕ64) -> ℕ64 -> FuzzyM ℕ8
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ (ℕ64 -> ℕ64 -> ℕ64
forall a. Times a => a -> a -> a
×ℕ64
2) (ℕ64 -> FuzzyM ℕ8) -> FuzzyM ℕ64 -> FuzzyM ℕ8
forall (m :: * -> *) a b. Bind m => (a -> m b) -> m a -> m b
*$ (FuzzyEnv ⟢ ℕ64) -> FuzzyM ℕ64
forall r'. (FuzzyEnv ⟢ r') -> FuzzyM r'
forall r (m :: * -> *) r'. MonadReader r m => (r ⟢ r') -> m r'
askL FuzzyEnv ⟢ ℕ64
fuzzyEnvRadiusL

instance Fuzzy ℤ64 where fuzzy :: FuzzyM ℤ64
fuzzy = ℤ64 -> FuzzyM ℤ64
forall a (m :: * -> *).
(MonadRand m, RandRange a, Zero a, Minus a) =>
a -> m a
randrRadius (ℤ64 -> FuzzyM ℤ64) -> (ℕ64 -> ℤ64) -> ℕ64 -> FuzzyM ℤ64
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ ℕ64 -> ℤ64
forall a. (ToIntO64 a, STACK) => a -> ℤ64
intΩ64 (ℕ64 -> FuzzyM ℤ64) -> FuzzyM ℕ64 -> FuzzyM ℤ64
forall (m :: * -> *) a b. Bind m => (a -> m b) -> m a -> m b
*$ (FuzzyEnv ⟢ ℕ64) -> FuzzyM ℕ64
forall r'. (FuzzyEnv ⟢ r') -> FuzzyM r'
forall r (m :: * -> *) r'. MonadReader r m => (r ⟢ r') -> m r'
askL FuzzyEnv ⟢ ℕ64
fuzzyEnvRadiusL
instance Fuzzy ℤ32 where fuzzy :: FuzzyM ℤ32
fuzzy = ℤ32 -> FuzzyM ℤ32
forall a (m :: * -> *).
(MonadRand m, RandRange a, Zero a, Minus a) =>
a -> m a
randrRadius (ℤ32 -> FuzzyM ℤ32) -> (ℕ64 -> ℤ32) -> ℕ64 -> FuzzyM ℤ32
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ ℕ64 -> ℤ32
forall a. (ToIntO32 a, STACK) => a -> ℤ32
intΩ32 (ℕ64 -> FuzzyM ℤ32) -> FuzzyM ℕ64 -> FuzzyM ℤ32
forall (m :: * -> *) a b. Bind m => (a -> m b) -> m a -> m b
*$ (FuzzyEnv ⟢ ℕ64) -> FuzzyM ℕ64
forall r'. (FuzzyEnv ⟢ r') -> FuzzyM r'
forall r (m :: * -> *) r'. MonadReader r m => (r ⟢ r') -> m r'
askL FuzzyEnv ⟢ ℕ64
fuzzyEnvRadiusL
instance Fuzzy ℤ16 where fuzzy :: FuzzyM ℤ16
fuzzy = ℤ16 -> FuzzyM ℤ16
forall a (m :: * -> *).
(MonadRand m, RandRange a, Zero a, Minus a) =>
a -> m a
randrRadius (ℤ16 -> FuzzyM ℤ16) -> (ℕ64 -> ℤ16) -> ℕ64 -> FuzzyM ℤ16
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ ℕ64 -> ℤ16
forall a. (ToIntO16 a, STACK) => a -> ℤ16
intΩ16 (ℕ64 -> FuzzyM ℤ16) -> FuzzyM ℕ64 -> FuzzyM ℤ16
forall (m :: * -> *) a b. Bind m => (a -> m b) -> m a -> m b
*$ (FuzzyEnv ⟢ ℕ64) -> FuzzyM ℕ64
forall r'. (FuzzyEnv ⟢ r') -> FuzzyM r'
forall r (m :: * -> *) r'. MonadReader r m => (r ⟢ r') -> m r'
askL FuzzyEnv ⟢ ℕ64
fuzzyEnvRadiusL
instance Fuzzy ℤ8  where fuzzy :: FuzzyM ℤ8
fuzzy = ℤ8 -> FuzzyM ℤ8
forall a (m :: * -> *).
(MonadRand m, RandRange a, Zero a, Minus a) =>
a -> m a
randrRadius (ℤ8 -> FuzzyM ℤ8) -> (ℕ64 -> ℤ8) -> ℕ64 -> FuzzyM ℤ8
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ ℕ64 -> ℤ8
forall a. (ToIntO8 a, STACK) => a -> ℤ8
intΩ8  (ℕ64 -> FuzzyM ℤ8) -> FuzzyM ℕ64 -> FuzzyM ℤ8
forall (m :: * -> *) a b. Bind m => (a -> m b) -> m a -> m b
*$ (FuzzyEnv ⟢ ℕ64) -> FuzzyM ℕ64
forall r'. (FuzzyEnv ⟢ r') -> FuzzyM r'
forall r (m :: * -> *) r'. MonadReader r m => (r ⟢ r') -> m r'
askL FuzzyEnv ⟢ ℕ64
fuzzyEnvRadiusL

instance Fuzzy 𝔻   where fuzzy :: FuzzyM 𝔻
fuzzy = 𝔻 -> FuzzyM 𝔻
forall a (m :: * -> *).
(MonadRand m, RandRange a, Zero a, Minus a) =>
a -> m a
randrRadius (𝔻 -> FuzzyM 𝔻) -> (ℕ64 -> 𝔻) -> ℕ64 -> FuzzyM 𝔻
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ ℕ64 -> 𝔻
forall a. ToDouble a => a -> 𝔻
dbl    (ℕ64 -> FuzzyM 𝔻) -> FuzzyM ℕ64 -> FuzzyM 𝔻
forall (m :: * -> *) a b. Bind m => (a -> m b) -> m a -> m b
*$ (FuzzyEnv ⟢ ℕ64) -> FuzzyM ℕ64
forall r'. (FuzzyEnv ⟢ r') -> FuzzyM r'
forall r (m :: * -> *) r'. MonadReader r m => (r ⟢ r') -> m r'
askL FuzzyEnv ⟢ ℕ64
fuzzyEnvRadiusL

instance Fuzzy () where fuzzy :: FuzzyM ()
fuzzy = () -> FuzzyM ()
forall a. a -> FuzzyM a
forall (m :: * -> *) a. Return m => a -> m a
return ()

instance Fuzzy 𝔹 where 
  fuzzy :: FuzzyM 𝔹
fuzzy = [() -> FuzzyM 𝔹] -> FuzzyM 𝔹
forall (m :: * -> *) a t.
(Monad m, MonadRand m, ToIter (() -> m a) t) =>
t -> m a
rchoose ([() -> FuzzyM 𝔹] -> FuzzyM 𝔹) -> [() -> FuzzyM 𝔹] -> FuzzyM 𝔹
forall a b. (a -> b) -> a -> b
$ (𝔹 -> () -> FuzzyM 𝔹) -> [𝔹] -> [() -> FuzzyM 𝔹]
forall a b. (a -> b) -> [a] -> [b]
forall (t :: * -> *) a b. Functor t => (a -> b) -> t a -> t b
map (FuzzyM 𝔹 -> () -> FuzzyM 𝔹
forall a b. a -> b -> a
const (FuzzyM 𝔹 -> () -> FuzzyM 𝔹)
-> (𝔹 -> FuzzyM 𝔹) -> 𝔹 -> () -> FuzzyM 𝔹
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ 𝔹 -> FuzzyM 𝔹
forall a. a -> FuzzyM a
forall (m :: * -> *) a. Return m => a -> m a
return)
    [ 𝔹
True
    , 𝔹
False
    ]

instance (Fuzzy a) ⇒ Fuzzy (𝑂 a) where 
  fuzzy :: FuzzyM (𝑂 a)
fuzzy = [() -> FuzzyM (𝑂 a)] -> FuzzyM (𝑂 a)
forall (m :: * -> *) a t.
(Monad m, MonadRand m, ToIter (() -> m a) t) =>
t -> m a
rchoose ([() -> FuzzyM (𝑂 a)] -> FuzzyM (𝑂 a))
-> [() -> FuzzyM (𝑂 a)] -> FuzzyM (𝑂 a)
forall a b. (a -> b) -> a -> b
$ (FuzzyM (𝑂 a) -> () -> FuzzyM (𝑂 a))
-> [FuzzyM (𝑂 a)] -> [() -> FuzzyM (𝑂 a)]
forall a b. (a -> b) -> [a] -> [b]
forall (t :: * -> *) a b. Functor t => (a -> b) -> t a -> t b
map FuzzyM (𝑂 a) -> () -> FuzzyM (𝑂 a)
forall a b. a -> b -> a
const
    [ 𝑂 a -> FuzzyM (𝑂 a)
forall a. a -> FuzzyM a
forall (m :: * -> *) a. Return m => a -> m a
return 𝑂 a
forall a. 𝑂 a
None
    , a -> 𝑂 a
forall a. a -> 𝑂 a
Some (a -> 𝑂 a) -> FuzzyM a -> FuzzyM (𝑂 a)
forall (t :: * -> *) a b. Functor t => (a -> b) -> t a -> t b
^$ FuzzyM a
forall a. Fuzzy a => FuzzyM a
fuzzy
    ]

instance (Fuzzy a,Fuzzy b) ⇒ Fuzzy (a ∨ b) where 
  fuzzy :: FuzzyM (a ∨ b)
fuzzy = [() -> FuzzyM (a ∨ b)] -> FuzzyM (a ∨ b)
forall (m :: * -> *) a t.
(Monad m, MonadRand m, ToIter (() -> m a) t) =>
t -> m a
rchoose ([() -> FuzzyM (a ∨ b)] -> FuzzyM (a ∨ b))
-> [() -> FuzzyM (a ∨ b)] -> FuzzyM (a ∨ b)
forall a b. (a -> b) -> a -> b
$ (FuzzyM (a ∨ b) -> () -> FuzzyM (a ∨ b))
-> [FuzzyM (a ∨ b)] -> [() -> FuzzyM (a ∨ b)]
forall a b. (a -> b) -> [a] -> [b]
forall (t :: * -> *) a b. Functor t => (a -> b) -> t a -> t b
map FuzzyM (a ∨ b) -> () -> FuzzyM (a ∨ b)
forall a b. a -> b -> a
const
    [ a -> a ∨ b
forall a b. a -> a ∨ b
Inl (a -> a ∨ b) -> FuzzyM a -> FuzzyM (a ∨ b)
forall (t :: * -> *) a b. Functor t => (a -> b) -> t a -> t b
^$ FuzzyM a
forall a. Fuzzy a => FuzzyM a
fuzzy
    , b -> a ∨ b
forall a b. b -> a ∨ b
Inr (b -> a ∨ b) -> FuzzyM b -> FuzzyM (a ∨ b)
forall (t :: * -> *) a b. Functor t => (a -> b) -> t a -> t b
^$ FuzzyM b
forall a. Fuzzy a => FuzzyM a
fuzzy
    ]

instance (Fuzzy a,Fuzzy b) ⇒ Fuzzy (a ∧ b) where 
  fuzzy :: FuzzyM (a ∧ b)
fuzzy = do
    a
x ← FuzzyM a
forall a. Fuzzy a => FuzzyM a
fuzzy
    b
y ← FuzzyM b
forall a. Fuzzy a => FuzzyM a
fuzzy
    (a ∧ b) -> FuzzyM (a ∧ b)
forall a. a -> FuzzyM a
forall (m :: * -> *) a. Return m => a -> m a
return ((a ∧ b) -> FuzzyM (a ∧ b)) -> (a ∧ b) -> FuzzyM (a ∧ b)
forall a b. (a -> b) -> a -> b
$ a
x a -> b -> a ∧ b
forall a b. a -> b -> a ∧ b
:* b
y

instance (Fuzzy a) ⇒ Fuzzy (𝐿 a) where 
  fuzzy :: FuzzyM (𝐿 a)
fuzzy = do
    ℕ64
w ← (ℕ64 -> ℕ64 -> ℕ64
forall a. Times a => a -> a -> a
×ℕ64
2) (ℕ64 -> ℕ64) -> FuzzyM ℕ64 -> FuzzyM ℕ64
forall (t :: * -> *) a b. Functor t => (a -> b) -> t a -> t b
^$ (FuzzyEnv ⟢ ℕ64) -> FuzzyM ℕ64
forall r'. (FuzzyEnv ⟢ r') -> FuzzyM r'
forall r (m :: * -> *) r'. MonadReader r m => (r ⟢ r') -> m r'
askL FuzzyEnv ⟢ ℕ64
fuzzyEnvRadiusL
    𝐼 a -> 𝐿 a
forall a t. ToIter a t => t -> 𝐿 a
list (𝐼 a -> 𝐿 a) -> FuzzyM (𝐼 a) -> FuzzyM (𝐿 a)
forall (t :: * -> *) a b. Functor t => (a -> b) -> t a -> t b
^$ 𝐼 ℕ64 -> (ℕ64 -> FuzzyM a) -> FuzzyM (𝐼 a)
forall (t :: * -> *) (m :: * -> *) a b.
(FunctorM t, Monad m) =>
t a -> (a -> m b) -> m (t b)
mapMOn (ℕ64 -> 𝐼 ℕ64
forall n. (Eq n, Zero n, One n, Plus n) => n -> 𝐼 n
upto ℕ64
w) ((ℕ64 -> FuzzyM a) -> FuzzyM (𝐼 a))
-> (ℕ64 -> FuzzyM a) -> FuzzyM (𝐼 a)
forall a b. (a -> b) -> a -> b
$ FuzzyM a -> ℕ64 -> FuzzyM a
forall a b. a -> b -> a
const FuzzyM a
forall a. Fuzzy a => FuzzyM a
fuzzy

instance (Ord k,Fuzzy k,Fuzzy v) ⇒ Fuzzy (k ⇰ v) where 
  fuzzy :: FuzzyM (k ⇰ v)
fuzzy = 𝐿 (k ∧ v) -> k ⇰ v
forall (d :: * -> *) t a k s.
(Dict k s d, ToIter (k ∧ a) t) =>
t -> d a
assoc (𝐿 (k ∧ v) -> k ⇰ v) -> FuzzyM (𝐿 (k ∧ v)) -> FuzzyM (k ⇰ v)
forall (t :: * -> *) a b. Functor t => (a -> b) -> t a -> t b
^$ forall a. Fuzzy a => FuzzyM a
fuzzy @(𝐿 _)

instance (Fuzzy a) ⇒ Fuzzy (() → a) where fuzzy :: FuzzyM (() -> a)
fuzzy = a -> () -> a
forall a b. a -> b -> a
const (a -> () -> a) -> FuzzyM a -> FuzzyM (() -> a)
forall (t :: * -> *) a b. Functor t => (a -> b) -> t a -> t b
^$ FuzzyM a
forall a. Fuzzy a => FuzzyM a
fuzzy