programas - problemas con conversiones de números triviales en Haskell

programas hechos en haskell

Question

Estoy intentando escribir una función trivial para soltar el último dígito de un número y devolver el resto del número.

dropLastDigit :: (Integral b) => b -> b
dropLastDigit x = (quot x 10) * (floor $ logBase 10 x)

sin embargo, cuando intento cargar esto en ghci, obtengo:

Could not deduce (Floating b) arising from a use of ‘logBase’
from the context (Integral b)
bound by the type signature for
dropLastDigit :: Integral b => b -> b
at haskelljokes.hs:6:18-39
Possible fix:
add (Floating b) to the context of
the type signature for dropLastDigit :: Integral b => b -> b
In the second argument of ‘($)’, namely ‘logBase 10 x’
In the expression: floor $ logBase 10 x
In an equation for ‘dropLastDigit’:
dropLastDigit x = floor $ logBase 10 x

Sin embargo, ejecutar este código en ghci:

:t (quot 101 10) * (floor $ logBase 10 101)

produce: (quot 101 10) * (floor $ logBase 10 101) :: Integral a => a

Mi pregunta es, ¿qué estoy haciendo mal? ¿Y por qué (el código idéntico?) Trabaja en ghci?

Answer 1

Cambia tu función a

dropLastDigit :: (Integral b) => b -> b
dropLastDigit x = (quot x 10) * (floor $ logBase 10 (fromIntegral x))

El código que estás ejecutando en GHCi no es idéntico. Usted ha reemplazado x por 101 . La x en su función fue anotada (por tipo de firma) para ser de tipo b para cualquier tipo b en la clase Integral , pero logBase necesita algo en la clase Floating .

Por otro lado, el literal 101 es de tipo Num a => a , es decir, está sobrecargado y se puede usar en cualquier tipo numérico. Entonces GHCi puede usarlo en tipo Integer en la primera aparición, como un argumento de quot , y como un Double en la segunda ocurrencia, como un argumento para logBase .

Answer 2

No es idéntico. Puedes verificar esto fácilmente:

ghci> let value101 = 101 :: Integral b => b
ghci> let value10 = 10 :: Integral b => b
ghci> (quot value101 value10) * (floor $ logBase value10 value101)
<interactive>:7:28:
Could not deduce (RealFrac s0) arising from a use of `floor''
from the context (Integral a)
bound by the inferred type of it :: Integral a => a
at <interactive>:7:1-60
The type variable `s0'' is ambiguous
Note: there are several potential instances:
instance RealFrac Double -- Defined in `GHC.Float''
instance RealFrac Float -- Defined in `GHC.Float''
instance Integral a => RealFrac (GHC.Real.Ratio a)
-- Defined in `GHC.Real''
In the expression: floor
In the second argument of `(*)'', namely
`(floor $ logBase value10 value101)''
In the expression:
(quot value101 value10) * (floor $ logBase value10 value101)
-- even more...

El problema es que tanto 10 como 101 tienen el tipo Num a => a , independientemente de dónde los use. Así que logBase 10 101 usó con la instancia Fractional predeterminada ( Double ), mientras que quot usó con la instancia Integral predeterminada.

Dicho esto, su función no "suelta" el último dígito. Si solo quiere transformar 12345 a 1234 , puede simplificar dropLastDigit para

dropLastDigit x = x `div` 10

Si, sin embargo, desea transformar 12345 a 12340 , solo tiene que multiplicar por diez después:

dropLastDigit x = 10 * (x `div` 10)