Haskell: "instancja (Enum a, Bounded a) => Losowo a" i "= Arbitralnie a"

Question

W Haskell, Czy istnieje "standardowa" biblioteka/pakiet do generowania enumeracji Random/Arbitrary?

Napisałem poniższy kod, ale nie mogę uwierzyć, że jestem pierwszą osobą, która ma tę potrzebę lub rozwiązała ją (i nie jestem pewien, czy moje rozwiązanie jest całkowicie poprawne). Mam również nadzieję, że istniejące rozwiązanie ma przy nim inne miłe funkcje.

Oto parę funkcji wybrać losową wartość od typu ENUM:

enumRandomR :: (RandomGen g, Enum e) => (e, e) -> g -> (e, g) 
enumRandomR (lo,hi) gen = 
    let (int, gen') = randomR (fromEnum lo, fromEnum hi) gen in (toEnum int, gen') 

enumRandom :: (RandomGen g, Enum e) => g -> (e, g) 
enumRandom gen = 
    let (int, gen') = random gen in (toEnum int, gen') 

i oto przypadki dla System.Random.Random i Test.QuickCheck.Arbitrary

{-# LANGUAGE FlexibleInstances, UndecidableInstances, OverlappingInstances #-} 

instance (Enum a, Bounded a) => Random a where 
    random = enumRandom 
    randomR = enumRandomR 

instance (Enum a, Bounded a) => Arbitrary a where 
    arbitrary = choose (minBound, maxBound) 

Oto przykład Bounded, Enum typ

data Dir = N | E | S | W 
    deriving (Show, Enum, Bounded) 

A oto test losowe/metody arbitralne

> import Test.QuickCheck 
> sample (arbitrary:: Gen Dir) 
N 
E 
N 
S 
N 
E 
W 
N 
N 
W 
W 

Nie jestem zachwycony, że moje rozwiązanie opiera się na tych rozszerzeniach:

{-# LANGUAGE FlexibleInstances, UndecidableInstances, OverlappingInstances #-}" 

ponieważ:

- Constraint is no smaller than the instance head 
    in the constraint: Enum a 
(Use -XUndecidableInstances to permit this) 

,

- Overlapping instances for Random Int 
    arising from a use of `randomR' 
Matching instances: 
    instance Random Int -- Defined in System.Random 
    instance (Enum a, Bounded a) => Random a 

, oraz

- Illegal instance declaration for `Random a' 
    (All instance types must be of the form (T a1 ... an) 
    where a1 ... an are *distinct type variables*, 
    and each type variable appears at most once in the instance head. 
    Use -XFlexibleInstances if you want to disable this.) 

Czy istnieje lepszy sposób? Czy moje rozwiązanie zawodzi w przypadku niektórych (bardziej "egzotycznych") typów ograniczonej enum niż mój prosty przykład?

Answer 1

Standardowym sposobem obejścia tego problemu jest utworzenie opakowania typu newtype i dostarczenie w zamian jego wystąpień.

{-# LANGUAGE GeneralizedNewtypeDeriving #-} -- avoid some boilerplate 

newtype Enum' a = Enum' a 
    deriving (Bounded, Enum, Show) 

instance (Enum a, Bounded a) => Random (Enum' a) where 
    random = enumRandom 
    randomR = enumRandomR 

instance (Enum a, Bounded a) => Arbitrary (Enum' a) where 
    arbitrary = choose (minBound, maxBound) 

Oczywiście, takie podejście wymaga dodatkowego opakowania i rozpakowaniu podczas korzystania z nowego rodzaju, ale do użytku z QuickCheck, że nie powinno być tak źle, jak to zwykle wystarczy wzór meczu raz na własność:

prop_foo (Enum' x) = ... -- use x as before here 

Answer 2

Nie jest bezpiecznie zadeklarować wystąpienia tego typu dla dowolnego typu Enum. Powodem tego jest to, że nie można zagwarantować, że toEnum . fromEnum zachowuje się jak id. Weź przykład Enum dla przykładu: Double; funkcja fromEnum po prostu zwraca "skróconą" wartość całkowitą podwójnego. Te "bardziej egzotyczne" typy (jak je nazywacie) nie będą działać z twoim rozwiązaniem.

Dlatego generalnie warto utworzyć instancje Random dla konkretnych typów i całkowicie uniknąć takich ogólnych deklaracji.

Wymienione rozszerzenia są koniecznie wymagane, jeśli naprawdę chcesz zadeklarować wystąpienie, które zadeklarowałeś, ponieważ jest to podpis samej deklaracji instancji, która ich wymaga.

Answer 3

Kolejny powód, dla którego nie należy sprawiać, by instancje były "uniwersalne": osoba, która chce częściej odzwierciedlać wartości "rzeczywistego świata", a zatem chce niestandardowej instancji Arbitrary z różnymi wagami.

(Powiedział, że użyłem i zdefiniowane funkcję pomocnika na piśmie, że Arbitrary wystąpienie w moim kodu tylko w celu uniknięcia konieczności powtarzania go dla każdego małego typu.)

Answer 4

QuickCheck eksportuje funkcję

arbitraryBoundedEnum :: (Bounded a, Enum a) => Gen a 

Ta funkcja może być rozumiana jako "standardowa".