[HASKELL] Conversione binaria

[Hysoka]

Ciao a tutti,
non so se qualcuno ne parla in questo forum, ma ho un problema con questo (come lo definisco io) mental programming language chiamato Haskell.
Premetto che lo sto imparando per un corso universitario e, quindi, sono forzato.
A prescindere tutto

binaryConversion x      | x == 0 = []
		        	| x == 1 = [1]
				| otherwise = (mod x 2):binaryConversion (floor (x/2))

questa funzione dovrebbe restituire la conversione binaria di un numero naturale (a meno di un reverse della lista, ma non è quello che mi interessa).

Quando lo carico su hugs tutto apposto, se non che

Main> binaryConversion 10
ERROR - Unresolved overloading
*** Type : (RealFrac a, Integral a) => [a]
*** Expression : binaryConversion 10

Ho provato a fare
binaryConversion :: (Integral a) => a->[b]
non c'è verso
e adesso non so più veramente dove sbattere la testa...spero che c'è qualcuno che ne capisca di programmazione funzionale.

[toraz]

Se controlli il tipo che inferisce il compilatore con il comando :type vedrai che e` (RealFrac a, Integral a) => a -> [a]. Il problema e` che ovviamente non trova un tipo che sia sia un'istanza di RealFrac e di Integral.
Per risolvere il problema devi riscrivere la funzione usando delle funzioni della classe Integral, ovvero

bConv x | x == 0 = [0]
               | x == 1 = [1]
               | otherwise = (mod x 2) : bConv (div x 2)

il cui tipo e` (Integral a) => a -> [a]



Non prenderlo per oro colato, ma il principio a grandi linee dovrebbe essere questo.

[Hysoka]

uhmmm
ti ringrazio perché funziona, però mi piacerebbe capire ESATTAMENTE perché non funziona...cmq perlomeno adesso posso completare l'esercizio....spero di ricordarmi questa domanda la sett prox a lezione
cheers

[toraz]

Tento di spiegarti meglio che posso, con una funzione un po' piu` semplice...

Prendi le funzioni

f x = floor (x / 2)
g x = mod x 2

che sono rispettivamente di tipo

f :: (RealFrac a, Integral b) => a -> b
g :: (Integral a) => a -> a

Ora se le metti insieme (togliendo di mezzo la ricorsione, perche' non ho idea di come faccia il compilatore a inferire il tipo di una funziona ricorsiva)

h x = (g x, f x)

Ottieni che h e` di tipo

(RealFrac a, Integral a, Integral b) => a -> (a, b)

Ovvero il compilatore si aspetta come parametro un valore di un tipo che sia allo stesso tempo un'istanza di RealFrac (Float o Double) e di Integral (Int o Integer), siccome non esiste un tipo del genere ti da l'errore.

[Hysoka]

Grazie per la spiegazione

Originariamente inviato da toraz
Ora se le metti insieme (togliendo di mezzo la ricorsione, perche' non ho idea di come faccia il compilatore a inferire il tipo di una funziona ricorsiva)

Questo credo di saperlo io...
haskell ha una strategia di valutazione delle espressione di tipo lazy, ovver lui valuta il più tardi possibile e (questo non so veramente come faccia) valuta le funzioni ricorsive il minimo indispensabile. Tant'è vero che con haskell puoi fare operazioni su insiemi infiniti.