module Fake.Combinators where ------------------------------------------------------------------------------ import Control.Monad import Data.List import Data.Ord import System.Random ------------------------------------------------------------------------------ import Fake.Types ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ -- ** Common generators and combinators ------------------------------------------------------------------------------ -- | Generates a random element in the given inclusive range. fromRange :: Random a => (a,a) -> FGen a fromRange rng = MkFGen (\r -> let (x,_) = randomR rng r in x) ------------------------------------------------------------------------------ -- | Generates a random element over the natural range of `a`. pickAny :: Random a => FGen a pickAny = MkFGen (\r -> let (x,_) = random r in x) ------------------------------------------------------------------------------ -- | Generates a value that satisfies a predicate. suchThat :: FGen a -> (a -> Bool) -> FGen a gen `suchThat` p = do mx <- gen `suchThatMaybe` p case mx of Just x -> return x Nothing -> gen `suchThat` p ------------------------------------------------------------------------------ -- | Tries to generate a value that satisfies a predicate. suchThatMaybe :: FGen a -> (a -> Bool) -> FGen (Maybe a) gen `suchThatMaybe` p = do x <- gen return \$ if p x then Just x else Nothing ------------------------------------------------------------------------------ -- | Randomly uses one of the given generators. The input list -- must be non-empty. oneof :: [FGen a] -> FGen a oneof [] = error "Fake.oneof used with empty list" oneof gs = fromRange (0,length gs - 1) >>= (gs !!) ------------------------------------------------------------------------------ -- | Chooses one of the given generators, with a weighted random distribution. -- The input list must be non-empty. frequency :: [(Int, FGen a)] -> FGen a frequency [] = error "Fake.frequency used with empty list" frequency xs0 = fromRange (1, tot) >>= (`pick` xs0) where tot = sum (map fst xs0) pick n ((k,x):xs) | n <= k = x | otherwise = pick (n-k) xs pick _ _ = error "Fake.pick used with empty list" ------------------------------------------------------------------------------ -- | Generates one of the given values. The input list must be non-empty. elements :: [a] -> FGen a elements [] = error "Fake.element used with empty list" elements xs = (xs !!) `fmap` fromRange (0, length xs - 1) ------------------------------------------------------------------------------ -- | Generates a random subsequence of the given list. sublistOf :: [a] -> FGen [a] sublistOf = filterM (\_ -> fromRange (False, True)) ------------------------------------------------------------------------------ -- | Generates a random permutation of the given list. shuffle :: [a] -> FGen [a] shuffle xs = do ns <- vectorOf (length xs) (fromRange (minBound :: Int, maxBound)) return (map snd (sortBy (comparing fst) (zip ns xs))) ------------------------------------------------------------------------------ -- | Generates a list of random length. listUpTo :: Int -> FGen a -> FGen [a] listUpTo n gen = do k <- fromRange (0,n) vectorOf k gen ------------------------------------------------------------------------------ -- | Generates a non-empty list of random length. The maximum length -- depends on the size parameter. listUpTo1 :: Int -> FGen a -> FGen [a] listUpTo1 n gen = do k <- fromRange (1,1 `max` n) vectorOf k gen ------------------------------------------------------------------------------ -- | Generates a list of the given length. vectorOf :: Int -> FGen a -> FGen [a] vectorOf = replicateM ------------------------------------------------------------------------------ -- | Generates an infinite list. infiniteListOf :: FGen a -> FGen [a] infiniteListOf gen = sequence (repeat gen) ------------------------------------------------------------------------------ -- | Generates an ordered list. orderedList :: (Ord a) => Int -> FGen a -> FGen [a] orderedList n gen = sort <\$> listUpTo n gen ------------------------------------------------------------------------------ -- | Generate a value of an enumeration in the range [from, to]. fakeEnumFromTo :: Enum a => a -> a -> FGen a fakeEnumFromTo from to = toEnum <\$> fromRange (fromEnum from, fromEnum to) ------------------------------------------------------------------------------ -- | Generate a value of an enumeration in the range [minBound, maxBound]. fakeEnum :: (Enum a, Bounded a) => FGen a fakeEnum = fakeEnumFromTo minBound maxBound ------------------------------------------------------------------------------ -- | 'fakeEnumFromTo' specialized to Int. fakeInt :: Int -> Int -> FGen Int fakeInt = fakeEnumFromTo ------------------------------------------------------------------------------ -- | 'fakeEnumFromTo' specialized to Int. fakeDouble :: Double -> Double -> FGen Double fakeDouble a b = fromRange (a,b) ------------------------------------------------------------------------------ fakeDigit :: FGen Char fakeDigit = fakeEnumFromTo '0' '9' ------------------------------------------------------------------------------ fakeDigitNonzero :: FGen Char fakeDigitNonzero = fakeEnumFromTo '1' '9' ------------------------------------------------------------------------------ fakeLetter :: FGen Char fakeLetter = fakeEnumFromTo 'a' 'z' ------------------------------------------------------------------------------ fakeCapitalLetter :: FGen Char fakeCapitalLetter = fakeEnumFromTo 'A' 'A'