packages feed

MonadRandom 0.6.1 → 0.6.2

raw patch · 5 files changed

+21/−7 lines, 5 filesdep ~randomPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: random

API changes (from Hackage documentation)

+ Control.Monad.Random.Lazy: --
+ Control.Monad.Random.Lazy: -- > fromSeed (toSeed gen) == gen
+ Control.Monad.Random.Lazy: -- </pre>
+ Control.Monad.Random.Lazy: -- <pre>
+ Control.Monad.Random.Lazy: -- pseudo-random number generator. It should be big enough to satisfy the
+ Control.Monad.Random.Lazy: -- roundtrip property:
+ Control.Monad.Random.Lazy: -- | Number of bytes that is required for storing the full state of a
+ Control.Monad.Random.Lazy: class (KnownNat SeedSize g, 1 <= SeedSize g, Typeable g) => SeedGen g where {
+ Control.Monad.Random.Lazy: class RandomGen g => SplitGen g
+ Control.Monad.Random.Lazy: data () => Seed g
+ Control.Monad.Random.Lazy: fromSeed :: SeedGen g => Seed g -> g
+ Control.Monad.Random.Lazy: fromSeed64 :: SeedGen g => NonEmpty Word64 -> g
+ Control.Monad.Random.Lazy: mkSeed :: (SeedGen g, MonadFail m) => ByteArray -> m (Seed g)
+ Control.Monad.Random.Lazy: mkSeedFromByteString :: (SeedGen g, MonadFail m) => ByteString -> m (Seed g)
+ Control.Monad.Random.Lazy: mkStdGen64 :: Word64 -> StdGen
+ Control.Monad.Random.Lazy: nonEmptyFromSeed :: SeedGen g => Seed g -> NonEmpty Word64
+ Control.Monad.Random.Lazy: nonEmptyToSeed :: SeedGen g => NonEmpty Word64 -> Seed g
+ Control.Monad.Random.Lazy: seedGenTypeName :: SeedGen g => String
+ Control.Monad.Random.Lazy: seedSize :: SeedGen g => Int
+ Control.Monad.Random.Lazy: seedSizeProxy :: forall proxy g. SeedGen g => proxy g -> Int
+ Control.Monad.Random.Lazy: splitGen :: SplitGen g => g -> (g, g)
+ Control.Monad.Random.Lazy: toSeed :: SeedGen g => g -> Seed g
+ Control.Monad.Random.Lazy: toSeed64 :: SeedGen g => g -> NonEmpty Word64
+ Control.Monad.Random.Lazy: type family SeedSize g :: Nat
+ Control.Monad.Random.Lazy: unSeed :: Seed g -> ByteArray
+ Control.Monad.Random.Lazy: unSeedToByteString :: Seed g -> ByteString
+ Control.Monad.Random.Lazy: uniformByteArray :: RandomGen g => Bool -> Int -> g -> (ByteArray, g)
+ Control.Monad.Random.Lazy: uniformByteString :: RandomGen g => Int -> g -> (ByteString, g)
+ Control.Monad.Random.Lazy: uniformFillMutableByteArray :: RandomGen g => MutableByteArray s -> Int -> Int -> g -> ST s g
+ Control.Monad.Random.Lazy: uniformList :: (Uniform a, RandomGen g) => Int -> g -> ([a], g)
+ Control.Monad.Random.Lazy: uniformListR :: (UniformRange a, RandomGen g) => Int -> (a, a) -> g -> ([a], g)
+ Control.Monad.Random.Lazy: uniformRs :: (UniformRange a, RandomGen g) => (a, a) -> g -> [a]
+ Control.Monad.Random.Lazy: uniformShortByteString :: RandomGen g => Int -> g -> (ShortByteString, g)
+ Control.Monad.Random.Lazy: uniformShuffleList :: RandomGen g => [a] -> g -> ([a], g)
+ Control.Monad.Random.Lazy: uniforms :: (Uniform a, RandomGen g) => g -> [a]
+ Control.Monad.Random.Lazy: unsafeUniformFillMutableByteArray :: RandomGen g => MutableByteArray s -> Int -> Int -> g -> ST s g
+ Control.Monad.Random.Lazy: withSeed :: SeedGen g => Seed g -> (g -> (a, g)) -> (a, Seed g)
+ Control.Monad.Random.Lazy: withSeedFile :: (SeedGen g, MonadIO m) => FilePath -> (Seed g -> m (a, Seed g)) -> m a
+ Control.Monad.Random.Lazy: withSeedM :: (SeedGen g, Functor f) => Seed g -> (g -> f (a, g)) -> f (a, Seed g)
+ Control.Monad.Random.Lazy: }
+ Control.Monad.Random.Strict: --
+ Control.Monad.Random.Strict: -- &gt; fromSeed (toSeed gen) == gen
+ Control.Monad.Random.Strict: -- </pre>
+ Control.Monad.Random.Strict: -- <pre>
+ Control.Monad.Random.Strict: -- pseudo-random number generator. It should be big enough to satisfy the
+ Control.Monad.Random.Strict: -- roundtrip property:
+ Control.Monad.Random.Strict: -- | Number of bytes that is required for storing the full state of a
+ Control.Monad.Random.Strict: class (KnownNat SeedSize g, 1 <= SeedSize g, Typeable g) => SeedGen g where {
+ Control.Monad.Random.Strict: class RandomGen g => SplitGen g
+ Control.Monad.Random.Strict: data () => Seed g
+ Control.Monad.Random.Strict: fromSeed :: SeedGen g => Seed g -> g
+ Control.Monad.Random.Strict: fromSeed64 :: SeedGen g => NonEmpty Word64 -> g
+ Control.Monad.Random.Strict: mkSeed :: (SeedGen g, MonadFail m) => ByteArray -> m (Seed g)
+ Control.Monad.Random.Strict: mkSeedFromByteString :: (SeedGen g, MonadFail m) => ByteString -> m (Seed g)
+ Control.Monad.Random.Strict: mkStdGen64 :: Word64 -> StdGen
+ Control.Monad.Random.Strict: nonEmptyFromSeed :: SeedGen g => Seed g -> NonEmpty Word64
+ Control.Monad.Random.Strict: nonEmptyToSeed :: SeedGen g => NonEmpty Word64 -> Seed g
+ Control.Monad.Random.Strict: seedGenTypeName :: SeedGen g => String
+ Control.Monad.Random.Strict: seedSize :: SeedGen g => Int
+ Control.Monad.Random.Strict: seedSizeProxy :: forall proxy g. SeedGen g => proxy g -> Int
+ Control.Monad.Random.Strict: splitGen :: SplitGen g => g -> (g, g)
+ Control.Monad.Random.Strict: toSeed :: SeedGen g => g -> Seed g
+ Control.Monad.Random.Strict: toSeed64 :: SeedGen g => g -> NonEmpty Word64
+ Control.Monad.Random.Strict: type family SeedSize g :: Nat
+ Control.Monad.Random.Strict: unSeed :: Seed g -> ByteArray
+ Control.Monad.Random.Strict: unSeedToByteString :: Seed g -> ByteString
+ Control.Monad.Random.Strict: uniformByteArray :: RandomGen g => Bool -> Int -> g -> (ByteArray, g)
+ Control.Monad.Random.Strict: uniformByteString :: RandomGen g => Int -> g -> (ByteString, g)
+ Control.Monad.Random.Strict: uniformFillMutableByteArray :: RandomGen g => MutableByteArray s -> Int -> Int -> g -> ST s g
+ Control.Monad.Random.Strict: uniformList :: (Uniform a, RandomGen g) => Int -> g -> ([a], g)
+ Control.Monad.Random.Strict: uniformListR :: (UniformRange a, RandomGen g) => Int -> (a, a) -> g -> ([a], g)
+ Control.Monad.Random.Strict: uniformRs :: (UniformRange a, RandomGen g) => (a, a) -> g -> [a]
+ Control.Monad.Random.Strict: uniformShortByteString :: RandomGen g => Int -> g -> (ShortByteString, g)
+ Control.Monad.Random.Strict: uniformShuffleList :: RandomGen g => [a] -> g -> ([a], g)
+ Control.Monad.Random.Strict: uniforms :: (Uniform a, RandomGen g) => g -> [a]
+ Control.Monad.Random.Strict: unsafeUniformFillMutableByteArray :: RandomGen g => MutableByteArray s -> Int -> Int -> g -> ST s g
+ Control.Monad.Random.Strict: withSeed :: SeedGen g => Seed g -> (g -> (a, g)) -> (a, Seed g)
+ Control.Monad.Random.Strict: withSeedFile :: (SeedGen g, MonadIO m) => FilePath -> (Seed g -> m (a, Seed g)) -> m a
+ Control.Monad.Random.Strict: withSeedM :: (SeedGen g, Functor f) => Seed g -> (g -> f (a, g)) -> f (a, Seed g)
+ Control.Monad.Random.Strict: }

Files

CHANGES.markdown view
@@ -1,3 +1,9 @@+0.6.2 (5 March 2025)+--------------------++- Support `random-1.3`.  Thanks to @bgamari and @lehins for help+  making the necessary updates.+ 0.6.1 (22 October 2024) -----------------------
Control/Monad/Random/Class.hs view
@@ -366,7 +366,7 @@       -- Subtract from 1 to match the way uniform Double values are       -- generated, and hence match the old behavior of this function.       let p = s * (1 - toRational (w :: Word64) / toRational (maxBound :: Word64))-      return . Just . fst . head . dropWhile ((< p) . snd) $ cums+      return . fmap fst . F.find ((>= p) . snd) $ cums  -- | Sample a value uniformly from a nonempty collection of elements. uniform :: (F.Foldable t, MonadRandom m) => t a -> m a@@ -386,12 +386,12 @@ -- The old implementation of `fromListMay`, for comparison.  See -- https://github.com/byorgey/MonadRandom/issues/53 and -- https://byorgey.github.io/blog/posts/2024/10/14/MonadRandom-version-bump.html-fromListMayOld :: MonadRandom m => [(a, Rational)] -> m (Maybe a)-fromListMayOld xs = do+_fromListMayOld :: MonadRandom m => [(a, Rational)] -> m (Maybe a)+_fromListMayOld xs = do   let s = fromRational (sum (map snd xs)) :: Double       cums = scanl1 (\ ~(_, q) ~(y, s') -> (y, s' + q)) xs   if s <= 0     then return Nothing     else do       p <- liftM toRational $ getRandomR (0, s)-      return . Just . fst . head . dropWhile ((< p) . snd) $ cums+      return . fmap fst . F.find ((>= p) . snd) $ cums
Control/Monad/Trans/Random/Lazy.hs view
@@ -282,7 +282,11 @@   uniformWord16 = applyRandT genWord16   uniformWord32 = applyRandT genWord32   uniformWord64 = applyRandT genWord64+#if MIN_VERSION_random(1,3,0)+  uniformByteArrayM pinned sz = applyRandT $ uniformByteArray pinned sz+#else   uniformShortByteString n = applyRandT (genShortByteString n)+#endif  -- | --
Control/Monad/Trans/Random/Strict.hs view
@@ -289,7 +289,11 @@   uniformWord16 = applyRandT genWord16   uniformWord32 = applyRandT genWord32   uniformWord64 = applyRandT genWord64+#if MIN_VERSION_random(1,3,0)+  uniformByteArrayM pinned sz = applyRandT $ uniformByteArray pinned sz+#else   uniformShortByteString n = applyRandT (genShortByteString n)+#endif  -- | --
MonadRandom.cabal view
@@ -1,5 +1,5 @@ name:                MonadRandom-version:             0.6.1+version:             0.6.2 synopsis:            Random-number generation monad. description:         Support for computations which consume random values. license:             BSD3@@ -11,7 +11,7 @@ build-type:          Simple cabal-version:       >=1.10 extra-source-files:  CHANGES.markdown-tested-with:         GHC ==7.10.3 || ==8.0.2 || ==8.2.2 || ==8.4.4 || ==8.6.5 || ==8.8.4 || ==8.10.7 || ==9.0.2 || ==9.2.8 || ==9.4.8 || ==9.6.5 || ==9.8.2 || ==9.10.1+tested-with:         GHC ==7.10.3 || ==8.0.2 || ==8.2.2 || ==8.4.4 || ==8.6.5 || ==8.8.4 || ==8.10.7 || ==9.0.2 || ==9.2.8 || ==9.4.8 || ==9.6.6 || ==9.8.2 || ==9.10.1 || ==9.12.1  source-repository head   type:     git@@ -32,7 +32,7 @@     transformers-compat >=0.4 && <0.8,     mtl                 >=2.2.1 && <2.3 || >= 2.3.1 && < 2.4,     primitive           >=0.6 && <0.10,-    random              >=1.0.1 && <1.3+    random              >=1.0.1 && <1.4   ghc-options:         -Wall   default-language:    Haskell2010   other-extensions:    Safe