https://github.com/lysxia/generic-random

Generic random generators
https://github.com/lysxia/generic-random

arbitrary generics haskell quickcheck random-generation testing

Last synced: 10 days ago
JSON representation

Generic random generators

• Host: GitHub
• URL: https://github.com/lysxia/generic-random
• Owner: Lysxia
• License: mit
• Created: 2016-04-06T21:37:34.000Z (over 8 years ago)
• Default Branch: master
• Last Pushed: 2023-03-14T01:05:58.000Z (over 1 year ago)
• Last Synced: 2024-04-26T06:00:28.001Z (6 months ago)
• Topics: arbitrary, generics, haskell, quickcheck, random-generation, testing
• Language: Haskell
• Size: 285 KB
• Stars: 81
• Watchers: 8
• Forks: 5
• Open Issues: 5
• Metadata Files:
  • Readme: README.md
  • Changelog: CHANGELOG.md
  • License: LICENSE

Awesome Lists containing this project

README

        
Generic random generators [![Hackage](https://img.shields.io/hackage/v/generic-random.svg)](https://hackage.haskell.org/package/generic-random) [![Build Status](https://github.com/Lysxia/generic-random/actions/workflows/ci.yml/badge.svg)](https://github.com/Lysxia/generic-random/actions/workflows/ci.yml)

=========================

Generic random generators

to implement `Arbitrary` instances for [QuickCheck](https://hackage.haskell.org/package/QuickCheck)

Automating the `arbitrary` boilerplate also ensures that when a type changes to

have more or fewer constructors, then the generator either fixes itself to

generate that new case (when using the `uniform` distribution) or causes a

compilation error so you remember to fix it (when using an explicit

distribution).

This package also offers a simple (optional) strategy to ensure termination for

recursive types:

make `Test.QuickCheck.Gen`'s size parameter decrease at every recursive call;

when it reaches zero, sample directly from a trivially terminating generator

given explicitly (`genericArbitraryRec` and `withBaseCase`) or implicitly

(`genericArbitrary'`).

Example

-------

```haskell

{-# LANGUAGE DeriveGeneric #-}

import GHC.Generics (Generic)

import Test.QuickCheck

import Generic.Random

data Tree a = Leaf | Node (Tree a) a (Tree a)

  deriving (Show, Generic)

instance Arbitrary a => Arbitrary (Tree a) where

  arbitrary = genericArbitraryRec uniform `withBaseCase` return Leaf

-- Equivalent to

-- > arbitrary =

-- >   sized $ \n ->

-- >     if n == 0 then

-- >       return Leaf

-- >     else

-- >       oneof

-- >         [ return Leaf

-- >         , resize (n `div` 3) $

-- >             Node <$> arbitrary <*> arbitrary <*> arbitrary

-- >         ]

main :: IO ()

main = sample (arbitrary :: Gen (Tree ()))

```

Related

-------

- The following two packages also derive random generators, but only with a uniform

  distribution of constructors:

    + [quickcheck-arbitrary-template](https://hackage.haskell.org/package/quickcheck-arbitrary-template) (TH)

    + [generic-arbitrary](https://hackage.haskell.org/package/generic-arbitrary-0.1.0) (GHC Generics)

- [testing-feat](http://hackage.haskell.org/package/testing-feat):

  derive enumerations for algebraic data types, which can be turned into random generators (TH).

- [boltzmann-samplers](https://hackage.haskell.org/package/boltzmann-samplers):

  derive Boltzmann samplers (SYB).