module Test.SmallCheck.Series.Instances () where
#if !MIN_VERSION_base(4,8,0)
import Control.Applicative ((<$>))
#endif
import Data.Int
import Data.Word
import qualified Data.ByteString as B
import qualified Data.ByteString.Lazy as BL
import qualified Data.Text as T
import qualified Data.Text.Lazy as TL
import Data.Map
import qualified Data.Map as Map
import Test.SmallCheck.Series
instance Monad m => Serial m Int8 where
series = (fromIntegral :: Int -> Int8) <$> series
instance Monad m => CoSerial m Int8 where
coseries rs = (. (fromIntegral :: Int8 -> Int)) <$> coseries rs
instance Monad m => Serial m Int16 where
series = (fromIntegral :: Int -> Int16) <$> series
instance Monad m => CoSerial m Int16 where
coseries rs = (. (fromIntegral :: Int16 -> Int)) <$> coseries rs
instance Monad m => Serial m Int32 where
series = (fromIntegral :: Int -> Int32) <$> series
instance Monad m => CoSerial m Int32 where
coseries rs = (. (fromIntegral :: Int32 -> Int)) <$> coseries rs
instance Monad m => Serial m Int64 where
series = (fromIntegral :: Int -> Int64) <$> series
instance Monad m => CoSerial m Int64 where
coseries rs = (. (fromIntegral :: Int64 -> Int)) <$> coseries rs
instance Monad m => Serial m Word where
series = generate $ \d -> take (d+1) [0..maxBound]
instance Monad m => CoSerial m Word where
coseries rs =
alts0 rs >>- \z ->
alts1 rs >>- \f ->
return $ \w ->
if w > 0
then f (w1)
else z
instance Monad m => Serial m Word8 where
series = (fromIntegral :: Word -> Word8) <$> series
instance Monad m => CoSerial m Word8 where
coseries rs = (. (fromIntegral :: Word8 -> Word)) <$> coseries rs
instance Monad m => Serial m Word16 where
series = (fromIntegral :: Word -> Word16) <$> series
instance Monad m => CoSerial m Word16 where
coseries rs = (. (fromIntegral :: Word16 -> Word)) <$> coseries rs
instance Monad m => Serial m Word32 where
series = (fromIntegral :: Word -> Word32) <$> series
instance Monad m => CoSerial m Word32 where
coseries rs = (. (fromIntegral :: Word32 -> Word)) <$> coseries rs
instance Monad m => Serial m Word64 where
series = (fromIntegral :: Word -> Word64) <$> series
instance Monad m => CoSerial m Word64 where
coseries rs = (. (fromIntegral :: Word64 -> Word)) <$> coseries rs
instance Monad m => Serial m B.ByteString where
series = cons0 B.empty \/ cons2 B.cons
instance Monad m => CoSerial m B.ByteString where
coseries rs =
alts0 rs >>- \y ->
alts2 rs >>- \f ->
return $ \bs -> case B.uncons bs of
Nothing -> y
Just (b,bs') -> f (B.singleton b) bs'
instance Monad m => Serial m BL.ByteString where
series = cons0 BL.empty \/ cons2 BL.cons
instance Monad m => CoSerial m BL.ByteString where
coseries rs =
alts0 rs >>- \y ->
alts2 rs >>- \f ->
return $ \bs -> case BL.uncons bs of
Nothing -> y
Just (b,bs') -> f (BL.singleton b) bs'
instance Monad m => Serial m T.Text where
series = cons0 T.empty \/ cons2 T.cons
instance Monad m => CoSerial m T.Text where
coseries rs =
alts0 rs >>- \y ->
alts2 rs >>- \f ->
return $ \bs -> case T.uncons bs of
Nothing -> y
Just (b,bs') -> f (T.singleton b) bs'
instance Monad m => Serial m TL.Text where
series = cons0 TL.empty \/ cons2 TL.cons
instance Monad m => CoSerial m TL.Text where
coseries rs =
alts0 rs >>- \y ->
alts2 rs >>- \f ->
return $ \bs -> case TL.uncons bs of
Nothing -> y
Just (b,bs') -> f (TL.singleton b) bs'
instance (Serial m k, Serial m v) => Serial m (Map k v) where
series = Map.singleton <$> series <~> series
instance (Ord k, CoSerial m k, CoSerial m v) => CoSerial m (Map k v) where
coseries rs =
alts0 rs >>- \y ->
alts2 rs >>- \f ->
return $ \m -> case pop m of
Nothing -> y
Just ((k,v), m') -> f (Map.singleton k v) m'
where
pop m = case Map.toList m of
[] -> Nothing
(kv:its) -> Just (kv, Map.fromList its)