Prepare release 0.1

Resolve: #23,
drop random dependency unconditionally.

.travis.yml

@@ -8,7 +8,7 @@
 #
 # For more information, see https://github.com/haskell-CI/haskell-ci
 #
-# version: 0.10
+# version: 0.10.1
 #
 version: ~> 1.0
 language: c
@@ -211,14 +211,10 @@ script:
   # Building without installed constraints for packages in global-db...
   - rm -f cabal.project.local
   - ${CABAL} v2-build $WITHCOMPILER --disable-tests --disable-benchmarks all
-  # Constraint sets
-  - rm -rf cabal.project.local
-  # Constraint set no-random
-  - ${CABAL} v2-build $WITHCOMPILER --disable-tests --disable-benchmarks --constraint='splitmix -random' all
   # Raw travis commands
   - export CABAL
   - export HC
   - if [ ! $GHCJS ]; then (cd ${PKGDIR_splitmix} && sh test-hugs.sh); fi
 
-# REGENDATA ("0.10",["--config=cabal.haskell-ci","splitmix.cabal"])
+# REGENDATA ("0.10.1",["--config=cabal.haskell-ci","splitmix.cabal"])
 # EOF

Changelog.md

@@ -1,3 +1,8 @@
+# 0.1
+
+- Drop `random` dependency unconditionally.
+  https://github.com/phadej/splitmix/issues/34
+
 # 0.0.5
 
 - Add `nextInteger`

bench/Bench.hs

@@ -16,53 +16,54 @@ import qualified System.Random.SplitMix32 as SM32
 -------------------------------------------------------------------------------
 
 -- infinite list
-genList :: R.RandomGen g => g -> [Int]
-genList = unfoldr (Just . R.next)
+genList :: (g -> (Int, g)) -> g -> [Int]
+genList next = unfoldr (Just . next)
 
 -- truncated
-genListN :: R.RandomGen g => g -> [Int]
-genListN = take 2048 . genList
+genListN :: (g -> (Int, g)) -> g -> [Int]
+genListN next = take 2048 . genList next
 
 randomList :: Int -> [Int]
-randomList = genListN . R.mkStdGen
+randomList = genListN R.random . R.mkStdGen
 
 tfRandomList :: Word64 -> [Int]
-tfRandomList w64 = genListN $ TF.seedTFGen (w64, w64, w64, w64)
+tfRandomList w64 = genListN R.random $ TF.seedTFGen (w64, w64, w64, w64)
 
 splitMixList :: Word64 -> [Int]
-splitMixList w64 = genListN $ SM.mkSMGen w64
+splitMixList w64 = genListN SM.nextInt $ SM.mkSMGen w64
 
 splitMix32List :: Word64 -> [Int]
-splitMix32List w64 = genListN $ SM32.mkSMGen $ fromIntegral w64
+splitMix32List w64 = genListN SM32.nextInt $ SM32.mkSMGen $ fromIntegral w64
 
 -------------------------------------------------------------------------------
 -- Tree
 -------------------------------------------------------------------------------
 
-genTree :: R.RandomGen g => g -> T.Tree Int
-genTree g = case R.next g of
-    ~(i, g') -> T.Node i $ case R.split g' of
-        (ga, gb) -> [genTree ga, genTree gb]
+genTree :: (g -> (Int, g)) -> (g -> (g, g)) -> g -> T.Tree Int
+genTree next split = go where
+    go g = case next g of
+        ~(i, g') -> T.Node i $ case split g' of
+            (ga, gb) -> [go ga, go gb]
 
-genTreeN :: R.RandomGen g => g -> T.Tree Int
-genTreeN = cutTree 9 . genTree
+genTreeN :: (g -> (Int, g)) -> (g -> (g, g)) -> g -> T.Tree Int
+genTreeN next split = cutTree 9 . genTree next split
   where
     cutTree :: Int -> T.Tree a -> T.Tree a
     cutTree n (T.Node x forest)
         | n <= 0    = T.Node x []
         | otherwise = T.Node x (map (cutTree (n - 1)) forest)
 
 randomTree :: Int -> T.Tree Int
-randomTree = genTreeN . R.mkStdGen
+randomTree = genTreeN R.next R.split . R.mkStdGen
 
 tfRandomTree :: Word64 -> T.Tree Int
-tfRandomTree w64 = genTreeN $ TF.seedTFGen (w64, w64, w64, w64)
+tfRandomTree w64 = genTreeN R.next R.split $ TF.seedTFGen (w64, w64, w64, w64)
 
 splitMixTree :: Word64 -> T.Tree Int
-splitMixTree w64 = genTreeN $ SM.mkSMGen w64
+splitMixTree w64 = genTreeN SM.nextInt SM.splitSMGen $ SM.mkSMGen w64
 
 splitMix32Tree :: Word64 -> T.Tree Int
-splitMix32Tree w64 = genTreeN $ SM32.mkSMGen $ fromIntegral w64
+splitMix32Tree w64 = genTreeN SM32.nextInt SM32.splitSMGen $ SM32.mkSMGen $ fromIntegral w64
 
 -------------------------------------------------------------------------------
 -- List Word64
@@ -92,31 +93,31 @@ splitMix32List64 w64 = genListN64 SM32.nextWord64 $ SM32.mkSMGen $ fromIntegral
 -- Tree Word64
 -------------------------------------------------------------------------------
 
-genTree64 :: R.RandomGen g => (g -> (Word64, g)) -> g -> T.Tree Word64
-genTree64 r = go where
+genTree64 ::(g -> (Word64, g)) -> (g -> (g, g)) -> g -> T.Tree Word64
+genTree64 r split = go where
     go g = case r g of
-        ~(i, g') -> T.Node i $ case R.split g' of
+        ~(i, g') -> T.Node i $ case split g' of
             (ga, gb) -> [go ga, go gb]
 
-genTreeN64 :: R.RandomGen g => (g -> (Word64, g)) -> g -> T.Tree Word64
-genTreeN64 r = cutTree 9 . genTree64 r
+genTreeN64 :: (g -> (Word64, g)) -> (g -> (g, g)) -> g -> T.Tree Word64
+genTreeN64 r split = cutTree 9 . genTree64 r split
   where
     cutTree :: Word64 -> T.Tree a -> T.Tree a
     cutTree n (T.Node x forest)
         | n <= 0    = T.Node x []
         | otherwise = T.Node x (map (cutTree (n - 1)) forest)
 
 randomTree64 :: Int -> T.Tree Word64
-randomTree64 = genTreeN64 R.random . R.mkStdGen
+randomTree64 = genTreeN64 R.random R.split . R.mkStdGen
 
 tfRandomTree64 :: Word64 -> T.Tree Word64
-tfRandomTree64 w64 = genTreeN64 TF.random $ TF.seedTFGen (w64, w64, w64, w64)
+tfRandomTree64 w64 = genTreeN64 TF.random R.split $ TF.seedTFGen (w64, w64, w64, w64)
 
 splitMixTree64 :: Word64 -> T.Tree Word64
-splitMixTree64 w64 = genTreeN64 SM.nextWord64 $ SM.mkSMGen w64
+splitMixTree64 w64 = genTreeN64 SM.nextWord64 SM.splitSMGen $ SM.mkSMGen w64
 
 splitMix32Tree64 :: Word64 -> T.Tree Word64
-splitMix32Tree64 w64 = genTreeN64 SM32.nextWord64 $ SM32.mkSMGen $ fromIntegral w64
+splitMix32Tree64 w64 = genTreeN64 SM32.nextWord64 SM32.splitSMGen $ SM32.mkSMGen $ fromIntegral w64
 
 -------------------------------------------------------------------------------
 -- Main

bench/Range.hs

@@ -8,7 +8,6 @@ import Data.Bits.Compat
 import Data.List        (unfoldr)
 import Data.Word        (Word32, Word64)
 
-import qualified System.Random            as R
 import qualified System.Random.SplitMix32 as SM
 
 #if defined(__GHCJS__)
@@ -21,7 +20,7 @@ main :: IO ()
 main = do
     gen <- SM.newSMGen
 
-    bench gen (\g h -> R.randomR (0, pred h) g)
+    -- bench gen (\g h -> R (0, pred h) g)
     bench gen classicMod
     bench gen intMult
     bench gen bitmaskWithRejection

cabal.haskell-ci

@@ -5,9 +5,6 @@ benchmarks: >=7.4
 ghcjs-tests: True
 apt: hugs libhugs-time-bundled
 
-constraint-set no-random
-  constraints: splitmix -random
-
 raw-travis:
   export CABAL
   export HC

splitmix.cabal

@@ -1,6 +1,6 @@
 cabal-version:      >=1.10
 name:               splitmix
-version:            0.0.5
+version:            0.1
 synopsis:           Fast Splittable PRNG
 description:
   Pure Haskell implementation of SplitMix described in
@@ -58,11 +58,6 @@ flag optimised-mixer
   manual:      True
   default:     False
 
-flag random
-  description: Providen RandomGen SMGen instance
-  manual:      True
-  default:     True
-
 library
   default-language: Haskell2010
   ghc-options:      -Wall
@@ -81,9 +76,6 @@ library
     , deepseq  >=1.3.0.0 && <1.5
     , time     >=1.2.0.3 && <1.10
 
-  if flag(random)
-    build-depends: random >=1.0 && <1.2
-
   if flag(optimised-mixer)
     cpp-options: -DOPTIMISED_MIX32=1
 

src/System/Random/SplitMix.hs

@@ -69,10 +69,6 @@ import Data.Word (Word)
 import Control.DeepSeq (NFData (..))
 #endif
 
-#ifdef MIN_VERSION_random
-import qualified System.Random as R
-#endif
-
 #if !__GHCJS__
 import System.CPUTime (cpuTimePrecision, getCPUTime)
 #endif
@@ -397,16 +393,6 @@ mkSeedTime = do
 #endif
     return $ fromIntegral hi `shiftL` 32 .|. fromIntegral lo
 
--------------------------------------------------------------------------------
--- System.Random
--------------------------------------------------------------------------------
-
-#ifdef MIN_VERSION_random
-instance R.RandomGen SMGen where
-    next = nextInt
-    split = splitSMGen
-#endif
-
 -------------------------------------------------------------------------------
 -- Hugs
 -------------------------------------------------------------------------------

src/System/Random/SplitMix32.hs

@@ -53,10 +53,6 @@ import Data.Word (Word)
 import Control.DeepSeq (NFData (..))
 #endif
 
-#ifdef MIN_VERSION_random
-import qualified System.Random as R
-#endif
-
 #if !__GHCJS__
 import System.CPUTime (cpuTimePrecision, getCPUTime)
 #endif
@@ -375,13 +371,3 @@ mkSeedTime = do
     let hi = fromIntegral (cpu `div` cpuTimePrecision) :: Word32
 #endif
     return $ fromIntegral hi `shiftL` 32 .|. fromIntegral lo
-
--------------------------------------------------------------------------------
--- System.Random
--------------------------------------------------------------------------------
-
-#ifdef MIN_VERSION_random
-instance R.RandomGen SMGen where
-    next = nextInt
-    split = splitSMGen
-#endif