haskell / random / 353

Committed 28 Oct 2024 02:58PM UTC coverage: 69.751% (-3.0%) from 72.752%

Build # 353

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #161 from haskell/lehins/avoid-too-strict-mutation

Make result lazy when mutating

Run Details

9 of 9 new or added lines in 1 file covered. (100.0%)

180 existing lines in 4 files now uncovered.

588 of 843 relevant lines covered (69.75%)

1.31 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/System/Random/GFinite.hs

{-# LANGUAGE DefaultSignatures    #-}
{-# LANGUAGE FlexibleContexts     #-}
{-# LANGUAGE LambdaCase           #-}
{-# LANGUAGE MagicHash            #-}
{-# LANGUAGE ScopedTypeVariables  #-}
{-# LANGUAGE TypeOperators        #-}

-- |
-- Module      :  System.Random.GFinite
-- Copyright   :  (c) Andrew Lelechenko 2020
-- License     :  BSD-style (see the file LICENSE in the 'random' repository)
-- Maintainer  :  libraries@haskell.org
--
module System.Random.GFinite
  ( Cardinality(..)
  , Finite(..)
  , GFinite(..)
  ) where

import Data.Bits
import Data.Int
import Data.Void
import Data.Word
import GHC.Exts (Proxy#, proxy#)
import GHC.Generics

-- | Cardinality of a set.
data Cardinality
  = Shift !Int -- ^ Shift n is equivalent to Card (bit n)
  | Card  !Integer
  deriving (Eq, Ord, Show)

-- | This is needed only as a superclass of 'Integral'.
instance Enum Cardinality where
  toEnum = fromIntegral
  fromEnum = fromIntegral
  succ = (+ 1)
  pred = subtract 1
  enumFrom x           = map fromInteger (enumFrom (toInteger x))
  enumFromThen x y     = map fromInteger (enumFromThen (toInteger x) (toInteger y))
  enumFromTo x y       = map fromInteger (enumFromTo (toInteger x) (toInteger y))
  enumFromThenTo x y z = map fromInteger (enumFromThenTo (toInteger x) (toInteger y) (toInteger z))

instance Num Cardinality where
  fromInteger 1 = Shift 0  -- ()
  fromInteger 2 = Shift 1  -- Bool
  fromInteger n = Card n
  {-# INLINE fromInteger #-}

  x + y = fromInteger (toInteger x + toInteger y)
  {-# INLINE (+) #-}

  Shift x * Shift y = Shift (x + y)
  Shift x * Card  y = Card (y `shiftL` x)
  Card  x * Shift y = Card (x `shiftL` y)
  Card  x * Card  y = Card (x * y)
  {-# INLINE (*) #-}

  abs    = Card . abs    . toInteger
  signum = Card . signum . toInteger
  negate = Card . negate . toInteger

-- | This is needed only as a superclass of 'Integral'.
instance Real Cardinality where
  toRational = fromIntegral

instance Integral Cardinality where
  toInteger = \case
    Shift n -> bit n
    Card  n -> n
  {-# INLINE toInteger #-}

  quotRem x' = \case
    Shift n -> (Card (x `shiftR` n), Card (x .&. (bit n - 1)))
    Card  n -> let (q, r) = x `quotRem` n in (Card q, Card r)
    where
      x = toInteger x'
  {-# INLINE quotRem #-}

-- | A type class for data with a finite number of inhabitants. This type class
-- is used in the default implementation of 'System.Random.Stateful.Uniform'.
--
-- Users are not supposed to write instances of 'Finite' manually.
-- There is a default implementation in terms of 'Generic' instead.
--
-- >>> :seti -XDeriveGeneric -XDeriveAnyClass
-- >>> import GHC.Generics (Generic)
-- >>> data MyBool = MyTrue | MyFalse deriving (Generic, Finite)
-- >>> data Action = Code MyBool | Eat (Maybe Bool) | Sleep deriving (Generic, Finite)
--
class Finite a where
  cardinality :: Proxy# a -> Cardinality
  toFinite :: Integer -> a
  fromFinite :: a -> Integer

  default cardinality :: (Generic a, GFinite (Rep a)) => Proxy# a -> Cardinality
  cardinality _ = gcardinality (proxy# :: Proxy# (Rep a))
  {-# INLINE cardinality #-}

  default toFinite :: (Generic a, GFinite (Rep a)) => Integer -> a
  toFinite = to . toGFinite
  {-# INLINE toFinite #-}

  default fromFinite :: (Generic a, GFinite (Rep a)) => a -> Integer
  fromFinite = fromGFinite . from
  {-# INLINE fromFinite #-}

class GFinite f where
  gcardinality :: Proxy# f -> Cardinality
  toGFinite :: Integer -> f a
  fromGFinite :: f a -> Integer

instance GFinite V1 where
  gcardinality _ = 0
  {-# INLINE gcardinality #-}
  toGFinite = const $ error "GFinite: V1 has no inhabitants"
  {-# INLINE toGFinite #-}
  fromGFinite = const $ error "GFinite: V1 has no inhabitants"
  {-# INLINE fromGFinite #-}

instance GFinite U1 where
  gcardinality _ = 1
  {-# INLINE gcardinality #-}
  toGFinite = const U1
  {-# INLINE toGFinite #-}
  fromGFinite = const 0
  {-# INLINE fromGFinite #-}

instance Finite a => GFinite (K1 _x a) where
  gcardinality _ = cardinality (proxy# :: Proxy# a)
  {-# INLINE gcardinality #-}
  toGFinite = K1 . toFinite
  {-# INLINE toGFinite #-}
  fromGFinite = fromFinite . unK1
  {-# INLINE fromGFinite #-}

instance GFinite a => GFinite (M1 _x _y a) where
  gcardinality _ = gcardinality (proxy# :: Proxy# a)
  {-# INLINE gcardinality #-}
  toGFinite = M1 . toGFinite
  {-# INLINE toGFinite #-}
  fromGFinite = fromGFinite . unM1
  {-# INLINE fromGFinite #-}

instance (GFinite a, GFinite b) => GFinite (a :+: b) where
  gcardinality _ =
    gcardinality (proxy# :: Proxy# a) + gcardinality (proxy# :: Proxy# b)
  {-# INLINE gcardinality #-}

  toGFinite n
    | n < cardA = L1 $ toGFinite n
    | otherwise = R1 $ toGFinite (n - cardA)
    where
      cardA = toInteger (gcardinality (proxy# :: Proxy# a))
  {-# INLINE toGFinite #-}

  fromGFinite = \case
     L1 x -> fromGFinite x
     R1 x -> fromGFinite x + toInteger (gcardinality (proxy# :: Proxy# a))
  {-# INLINE fromGFinite #-}

instance (GFinite a, GFinite b) => GFinite (a :*: b) where
  gcardinality _ =
    gcardinality (proxy# :: Proxy# a) * gcardinality (proxy# :: Proxy# b)
  {-# INLINE gcardinality #-}

  toGFinite n = toGFinite (toInteger q) :*: toGFinite (toInteger r)
    where
      cardB = gcardinality (proxy# :: Proxy# b)
      (q, r) = Card n `quotRem` cardB
  {-# INLINE toGFinite #-}

  fromGFinite (q :*: r) =
    toInteger (gcardinality (proxy# :: Proxy# b) * Card (fromGFinite q)) + fromGFinite r
  {-# INLINE fromGFinite #-}

instance Finite Void
instance Finite ()
instance Finite Bool
instance Finite Ordering

instance Finite Char where
  cardinality _ = Card $ toInteger (fromEnum (maxBound :: Char)) + 1
  {-# INLINE cardinality #-}
  toFinite = toEnum . fromInteger
  {-# INLINE toFinite #-}
  fromFinite = toInteger . fromEnum
  {-# INLINE fromFinite #-}

cardinalityDef :: forall a. (Num a, FiniteBits a) => Proxy# a -> Cardinality
cardinalityDef _ = Shift (finiteBitSize (0 :: a))

toFiniteDef :: forall a. (Num a, FiniteBits a) => Integer -> a
toFiniteDef n
    | isSigned (0 :: a) = fromInteger (n - bit (finiteBitSize (0 :: a) - 1))
    | otherwise = fromInteger n

fromFiniteDef :: (Integral a, FiniteBits a) => a -> Integer
fromFiniteDef x
    | isSigned x = toInteger x + bit (finiteBitSize x - 1)
    | otherwise = toInteger x

instance Finite Word8 where
  cardinality = cardinalityDef
  {-# INLINE cardinality #-}
  toFinite = toFiniteDef
  {-# INLINE toFinite #-}
  fromFinite = fromFiniteDef
  {-# INLINE fromFinite #-}
instance Finite Word16 where
  cardinality = cardinalityDef
  {-# INLINE cardinality #-}
  toFinite = toFiniteDef
  {-# INLINE toFinite #-}
  fromFinite = fromFiniteDef
  {-# INLINE fromFinite #-}
instance Finite Word32 where
  cardinality = cardinalityDef
  {-# INLINE cardinality #-}
  toFinite = toFiniteDef
  {-# INLINE toFinite #-}
  fromFinite = fromFiniteDef
  {-# INLINE fromFinite #-}
instance Finite Word64 where
  cardinality = cardinalityDef
  {-# INLINE cardinality #-}
  toFinite = toFiniteDef
  {-# INLINE toFinite #-}
  fromFinite = fromFiniteDef
  {-# INLINE fromFinite #-}
instance Finite Word where
  cardinality = cardinalityDef
  {-# INLINE cardinality #-}
  toFinite = toFiniteDef
  {-# INLINE toFinite #-}
  fromFinite = fromFiniteDef
  {-# INLINE fromFinite #-}
instance Finite Int8 where
  cardinality = cardinalityDef
  {-# INLINE cardinality #-}
  toFinite = toFiniteDef
  {-# INLINE toFinite #-}
  fromFinite = fromFiniteDef
  {-# INLINE fromFinite #-}
instance Finite Int16 where
  cardinality = cardinalityDef
  {-# INLINE cardinality #-}
  toFinite = toFiniteDef
  {-# INLINE toFinite #-}
  fromFinite = fromFiniteDef
  {-# INLINE fromFinite #-}
instance Finite Int32 where
  cardinality = cardinalityDef
  {-# INLINE cardinality #-}
  toFinite = toFiniteDef
  {-# INLINE toFinite #-}
  fromFinite = fromFiniteDef
  {-# INLINE fromFinite #-}
instance Finite Int64 where
  cardinality = cardinalityDef
  {-# INLINE cardinality #-}
  toFinite = toFiniteDef
  {-# INLINE toFinite #-}
  fromFinite = fromFiniteDef
  {-# INLINE fromFinite #-}
instance Finite Int where
  cardinality = cardinalityDef
  {-# INLINE cardinality #-}
  toFinite = toFiniteDef
  {-# INLINE toFinite #-}
  fromFinite = fromFiniteDef
  {-# INLINE fromFinite #-}

instance Finite a => Finite (Maybe a)
instance (Finite a, Finite b) => Finite (Either a b)
instance (Finite a, Finite b) => Finite (a, b)
instance (Finite a, Finite b, Finite c) => Finite (a, b, c)
instance (Finite a, Finite b, Finite c, Finite d) => Finite (a, b, c, d)
instance (Finite a, Finite b, Finite c, Finite d, Finite e) => Finite (a, b, c, d, e)
instance (Finite a, Finite b, Finite c, Finite d, Finite e, Finite f) => Finite (a, b, c, d, e, f)
instance (Finite a, Finite b, Finite c, Finite d, Finite e, Finite f, Finite g) => Finite (a, b, c, d, e, f, g)

1	{-# LANGUAGE DefaultSignatures #-}
2	{-# LANGUAGE FlexibleContexts #-}
3	{-# LANGUAGE LambdaCase #-}
4	{-# LANGUAGE MagicHash #-}
5	{-# LANGUAGE ScopedTypeVariables #-}
6	{-# LANGUAGE TypeOperators #-}
7
8	-- \|
9	-- Module : System.Random.GFinite
10	-- Copyright : (c) Andrew Lelechenko 2020
11	-- License : BSD-style (see the file LICENSE in the 'random' repository)
12	-- Maintainer : libraries@haskell.org
13	--
14	module System.Random.GFinite
15	( Cardinality(..)
16	, Finite(..)
17	, GFinite(..)
18	) where
19
20	import Data.Bits
21	import Data.Int
22	import Data.Void
23	import Data.Word
24	import GHC.Exts (Proxy#, proxy#)
25	import GHC.Generics
26
27	-- \| Cardinality of a set.
28	data Cardinality
29	= Shift !Int -- ^ Shift n is equivalent to Card (bit n)
30	\| Card !Integer
UNCOV 31	deriving (Eq, Ord, Show)	×
32
33	-- \| This is needed only as a superclass of 'Integral'.
34	instance Enum Cardinality where
UNCOV 35	toEnum = fromIntegral	×
36	fromEnum = fromIntegral	×
37	succ = (+ 1)	×
38	pred = subtract 1	×
39	enumFrom x = map fromInteger (enumFrom (toInteger x))	×
40	enumFromThen x y = map fromInteger (enumFromThen (toInteger x) (toInteger y))	×
41	enumFromTo x y = map fromInteger (enumFromTo (toInteger x) (toInteger y))	×
42	enumFromThenTo x y z = map fromInteger (enumFromThenTo (toInteger x) (toInteger y) (toInteger z))	×
43
44	instance Num Cardinality where
UNCOV 45	fromInteger 1 = Shift 0 -- ()	×
46	fromInteger 2 = Shift 1 -- Bool	×
47	fromInteger n = Card n	×
48	{-# INLINE fromInteger #-}
49
UNCOV 50	x + y = fromInteger (toInteger x + toInteger y)	×
51	{-# INLINE (+) #-}
52
UNCOV 53	Shift x * Shift y = Shift (x + y)	×
54	Shift x * Card y = Card (y `shiftL` x)	×
55	Card x * Shift y = Card (x `shiftL` y)	×
56	Card x * Card y = Card (x * y)	×
57	{-# INLINE (*) #-}
58
UNCOV 59	abs = Card . abs . toInteger	×
60	signum = Card . signum . toInteger	×
61	negate = Card . negate . toInteger	×
62
63	-- \| This is needed only as a superclass of 'Integral'.
64	instance Real Cardinality where
UNCOV 65	toRational = fromIntegral	×
66
67	instance Integral Cardinality where
UNCOV 68	toInteger = \case	×
69	Shift n -> bit n	×
70	Card n -> n	×
71	{-# INLINE toInteger #-}
72
UNCOV 73	quotRem x' = \case	×
74	Shift n -> (Card (x `shiftR` n), Card (x .&. (bit n - 1)))	×
75	Card n -> let (q, r) = x `quotRem` n in (Card q, Card r)	×
76	where
UNCOV 77	x = toInteger x'	×
78	{-# INLINE quotRem #-}
79
80	-- \| A type class for data with a finite number of inhabitants. This type class
81	-- is used in the default implementation of 'System.Random.Stateful.Uniform'.
82	--
83	-- Users are not supposed to write instances of 'Finite' manually.
84	-- There is a default implementation in terms of 'Generic' instead.
85	--
86	-- >>> :seti -XDeriveGeneric -XDeriveAnyClass
87	-- >>> import GHC.Generics (Generic)
88	-- >>> data MyBool = MyTrue \| MyFalse deriving (Generic, Finite)
89	-- >>> data Action = Code MyBool \| Eat (Maybe Bool) \| Sleep deriving (Generic, Finite)
90	--
91	class Finite a where
92	cardinality :: Proxy# a -> Cardinality
93	toFinite :: Integer -> a
94	fromFinite :: a -> Integer
95
96	default cardinality :: (Generic a, GFinite (Rep a)) => Proxy# a -> Cardinality
UNCOV 97	cardinality _ = gcardinality (proxy# :: Proxy# (Rep a))	×
98	{-# INLINE cardinality #-}
99
100	default toFinite :: (Generic a, GFinite (Rep a)) => Integer -> a
UNCOV 101	toFinite = to . toGFinite	×
102	{-# INLINE toFinite #-}
103
104	default fromFinite :: (Generic a, GFinite (Rep a)) => a -> Integer
UNCOV 105	fromFinite = fromGFinite . from	×
106	{-# INLINE fromFinite #-}
107
108	class GFinite f where
109	gcardinality :: Proxy# f -> Cardinality
110	toGFinite :: Integer -> f a
111	fromGFinite :: f a -> Integer
112
113	instance GFinite V1 where
UNCOV 114	gcardinality _ = 0	×
115	{-# INLINE gcardinality #-}
UNCOV 116	toGFinite = const $ error "GFinite: V1 has no inhabitants"	×
117	{-# INLINE toGFinite #-}
UNCOV 118	fromGFinite = const $ error "GFinite: V1 has no inhabitants"	×
119	{-# INLINE fromGFinite #-}
120
121	instance GFinite U1 where
UNCOV 122	gcardinality _ = 1	×
123	{-# INLINE gcardinality #-}
UNCOV 124	toGFinite = const U1	×
125	{-# INLINE toGFinite #-}
UNCOV 126	fromGFinite = const 0	×
127	{-# INLINE fromGFinite #-}
128
129	instance Finite a => GFinite (K1 _x a) where
UNCOV 130	gcardinality _ = cardinality (proxy# :: Proxy# a)	×
131	{-# INLINE gcardinality #-}
UNCOV 132	toGFinite = K1 . toFinite	×
133	{-# INLINE toGFinite #-}
UNCOV 134	fromGFinite = fromFinite . unK1	×
135	{-# INLINE fromGFinite #-}
136
137	instance GFinite a => GFinite (M1 _x _y a) where
UNCOV 138	gcardinality _ = gcardinality (proxy# :: Proxy# a)	×
139	{-# INLINE gcardinality #-}
UNCOV 140	toGFinite = M1 . toGFinite	×
141	{-# INLINE toGFinite #-}
UNCOV 142	fromGFinite = fromGFinite . unM1	×
143	{-# INLINE fromGFinite #-}
144
145	instance (GFinite a, GFinite b) => GFinite (a :+: b) where
UNCOV 146	gcardinality _ =	×
147	gcardinality (proxy# :: Proxy# a) + gcardinality (proxy# :: Proxy# b)	×
148	{-# INLINE gcardinality #-}
149
UNCOV 150	toGFinite n	×
151	\| n < cardA = L1 $ toGFinite n	×
152	\| otherwise = R1 $ toGFinite (n - cardA)	×
153	where
UNCOV 154	cardA = toInteger (gcardinality (proxy# :: Proxy# a))	×
155	{-# INLINE toGFinite #-}
156
UNCOV 157	fromGFinite = \case	×
158	L1 x -> fromGFinite x	×
159	R1 x -> fromGFinite x + toInteger (gcardinality (proxy# :: Proxy# a))	×
160	{-# INLINE fromGFinite #-}
161
162	instance (GFinite a, GFinite b) => GFinite (a :*: b) where
UNCOV 163	gcardinality _ =	×
164	gcardinality (proxy# :: Proxy# a) * gcardinality (proxy# :: Proxy# b)	×
165	{-# INLINE gcardinality #-}
166
UNCOV 167	toGFinite n = toGFinite (toInteger q) :*: toGFinite (toInteger r)	×
168	where
UNCOV 169	cardB = gcardinality (proxy# :: Proxy# b)	×
170	(q, r) = Card n `quotRem` cardB	×
171	{-# INLINE toGFinite #-}
172
UNCOV 173	fromGFinite (q :*: r) =	×
174	toInteger (gcardinality (proxy# :: Proxy# b) * Card (fromGFinite q)) + fromGFinite r	×
175	{-# INLINE fromGFinite #-}
176
177	instance Finite Void
178	instance Finite ()
179	instance Finite Bool
180	instance Finite Ordering
181
182	instance Finite Char where
UNCOV 183	cardinality _ = Card $ toInteger (fromEnum (maxBound :: Char)) + 1	×
184	{-# INLINE cardinality #-}
UNCOV 185	toFinite = toEnum . fromInteger	×
186	{-# INLINE toFinite #-}
UNCOV 187	fromFinite = toInteger . fromEnum	×
188	{-# INLINE fromFinite #-}
189
190	cardinalityDef :: forall a. (Num a, FiniteBits a) => Proxy# a -> Cardinality
UNCOV 191	cardinalityDef _ = Shift (finiteBitSize (0 :: a))	×
192
193	toFiniteDef :: forall a. (Num a, FiniteBits a) => Integer -> a
UNCOV 194	toFiniteDef n	×
195	\| isSigned (0 :: a) = fromInteger (n - bit (finiteBitSize (0 :: a) - 1))	×
196	\| otherwise = fromInteger n	×
197
198	fromFiniteDef :: (Integral a, FiniteBits a) => a -> Integer
UNCOV 199	fromFiniteDef x	×
200	\| isSigned x = toInteger x + bit (finiteBitSize x - 1)	×
201	\| otherwise = toInteger x	×
202
203	instance Finite Word8 where
UNCOV 204	cardinality = cardinalityDef	×
205	{-# INLINE cardinality #-}
UNCOV 206	toFinite = toFiniteDef	×
207	{-# INLINE toFinite #-}
UNCOV 208	fromFinite = fromFiniteDef	×
209	{-# INLINE fromFinite #-}
210	instance Finite Word16 where
UNCOV 211	cardinality = cardinalityDef	×
212	{-# INLINE cardinality #-}
UNCOV 213	toFinite = toFiniteDef	×
214	{-# INLINE toFinite #-}
UNCOV 215	fromFinite = fromFiniteDef	×
216	{-# INLINE fromFinite #-}
217	instance Finite Word32 where
UNCOV 218	cardinality = cardinalityDef	×
219	{-# INLINE cardinality #-}
UNCOV 220	toFinite = toFiniteDef	×
221	{-# INLINE toFinite #-}
UNCOV 222	fromFinite = fromFiniteDef	×
223	{-# INLINE fromFinite #-}
224	instance Finite Word64 where
UNCOV 225	cardinality = cardinalityDef	×
226	{-# INLINE cardinality #-}
UNCOV 227	toFinite = toFiniteDef	×
228	{-# INLINE toFinite #-}
UNCOV 229	fromFinite = fromFiniteDef	×
230	{-# INLINE fromFinite #-}
231	instance Finite Word where
UNCOV 232	cardinality = cardinalityDef	×
233	{-# INLINE cardinality #-}
UNCOV 234	toFinite = toFiniteDef	×
235	{-# INLINE toFinite #-}
UNCOV 236	fromFinite = fromFiniteDef	×
237	{-# INLINE fromFinite #-}
238	instance Finite Int8 where
UNCOV 239	cardinality = cardinalityDef	×
240	{-# INLINE cardinality #-}
UNCOV 241	toFinite = toFiniteDef	×
242	{-# INLINE toFinite #-}
UNCOV 243	fromFinite = fromFiniteDef	×
244	{-# INLINE fromFinite #-}
245	instance Finite Int16 where
UNCOV 246	cardinality = cardinalityDef	×
247	{-# INLINE cardinality #-}
UNCOV 248	toFinite = toFiniteDef	×
249	{-# INLINE toFinite #-}
UNCOV 250	fromFinite = fromFiniteDef	×
251	{-# INLINE fromFinite #-}
252	instance Finite Int32 where
UNCOV 253	cardinality = cardinalityDef	×
254	{-# INLINE cardinality #-}
UNCOV 255	toFinite = toFiniteDef	×
256	{-# INLINE toFinite #-}
UNCOV 257	fromFinite = fromFiniteDef	×
258	{-# INLINE fromFinite #-}
259	instance Finite Int64 where
UNCOV 260	cardinality = cardinalityDef	×
261	{-# INLINE cardinality #-}
UNCOV 262	toFinite = toFiniteDef	×
263	{-# INLINE toFinite #-}
UNCOV 264	fromFinite = fromFiniteDef	×
265	{-# INLINE fromFinite #-}
266	instance Finite Int where
UNCOV 267	cardinality = cardinalityDef	×
268	{-# INLINE cardinality #-}
UNCOV 269	toFinite = toFiniteDef	×
270	{-# INLINE toFinite #-}
UNCOV 271	fromFinite = fromFiniteDef	×
272	{-# INLINE fromFinite #-}
273
274	instance Finite a => Finite (Maybe a)
275	instance (Finite a, Finite b) => Finite (Either a b)
276	instance (Finite a, Finite b) => Finite (a, b)
277	instance (Finite a, Finite b, Finite c) => Finite (a, b, c)
278	instance (Finite a, Finite b, Finite c, Finite d) => Finite (a, b, c, d)
279	instance (Finite a, Finite b, Finite c, Finite d, Finite e) => Finite (a, b, c, d, e)
280	instance (Finite a, Finite b, Finite c, Finite d, Finite e, Finite f) => Finite (a, b, c, d, e, f)
281	instance (Finite a, Finite b, Finite c, Finite d, Finite e, Finite f, Finite g) => Finite (a, b, c, d, e, f, g)

haskell / random / 353

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous