Haskell Language
Literales sobrecargados
Buscar..
Observaciones
Literales enteros
es un numeral sin un punto decimal
por ejemplo 0 , 1 , 42 , ...
se aplica implícitamente a fromInteger que forma parte de la clase de tipo Num , por lo que efectivamente tiene el tipo Num a => a , es decir, puede tener cualquier tipo que sea una instancia de Num
Literales fraccionales
es un numeral con un punto decimal
por ejemplo 0.0 , -0.1111 , ...
se aplica implícitamente a fromRational que forma parte de la clase de tipo Fractional , por lo que de hecho tiene el tipo a => a , es decir, puede tener cualquier tipo que sea una instancia de Fractional
Literales de cuerda
Si agrega la extensión de lenguaje OverloadedStrings a GHC , puede tener la misma para String -literals que luego se aplican a fromString desde la clase de tipo Data.String.IsString
Esto se usa a menudo para reemplazar String con Text o ByteString .
Lista de literales
Las listas se pueden definir con la sintaxis literal [1, 2, 3] . En GHC 7.8 y más allá, esto también se puede usar para definir otras estructuras similares a listas con la extensión OverloadedLists .
Por defecto, el tipo de [] es:
> :t []
[] :: [t]
Con OverloadedLists , esto se convierte en:
[] :: GHC.Exts.IsList l => l
Numero entero
El tipo del literal.
Prelude> :t 1
1 :: Num a => a
Elegir un tipo concreto con anotaciones.
Puede especificar el tipo siempre que el tipo de destino sea Num con una anotación :
Prelude> 1 :: Int
1
it :: Int
Prelude> 1 :: Double
1.0
it :: Double
Prelude> 1 :: Word
1
it :: Word
si no el compilador se quejará
Preludio> 1 :: Cuerda
<interactive>:
No instance for (Num String) arising from the literal `1'
In the expression: 1 :: String
In an equation for `it': it = 1 :: String
Numeral flotante
El tipo del literal.
Prelude> :t 1.0
1.0 :: Fractional a => a
Elegir un tipo concreto con anotaciones.
Puede especificar el tipo con una anotación de tipo . El único requisito es que el tipo debe tener una instancia Fractional .
Prelude> 1.0 :: Double
1.0
it :: Double
Prelude> 1.0 :: Data.Ratio.Ratio Int
1 % 1
it :: GHC.Real.Ratio Int
si no el compilador se quejará
Prelude> 1.0 :: Int
<interactive>:
No instance for (Fractional Int) arising from the literal `1.0'
In the expression: 1.0 :: Int
In an equation for `it': it = 1.0 :: Int
Instrumentos de cuerda
El tipo del literal.
Sin ninguna extensión, el tipo de un literal de cadena, es decir, algo entre comillas dobles, es solo una cadena, también conocida como lista de caracteres:
Prelude> :t "foo"
"foo" :: [Char]
Sin embargo, cuando la extensión OverloadedStrings está habilitada, los literales de cadena se convierten en polimórficos, similar a los literales de números :
Prelude> :set -XOverloadedStrings
Prelude> :t "foo"
"foo" :: Data.String.IsString t => t
Esto nos permite definir valores de tipos similares a cadenas sin la necesidad de conversiones explícitas. En esencia, la extensión OverloadedStrings simplemente envuelve cada literal de cadena en la función de conversión genérica fromString , por lo que si el contexto exige, por ejemplo, el Text más eficiente en lugar de la String , no necesita preocuparse por eso.
Usando cadenas literales
{-# LANGUAGE OverloadedStrings #-}
import Data.Text (Text, pack)
import Data.ByteString (ByteString, pack)
withString :: String
withString = "Hello String"
-- The following two examples are only allowed with OverloadedStrings
withText :: Text
withText = "Hello Text" -- instead of: withText = Data.Text.pack "Hello Text"
withBS :: ByteString
withBS = "Hello ByteString" -- instead of: withBS = Data.ByteString.pack "Hello ByteString"
Observe cómo pudimos construir valores de Text y ByteString de la misma manera en que construimos los valores de String (o [Char] ) ordinarios, en lugar de usar cada función de pack tipos para codificar explícitamente la cadena.
Para obtener más información sobre la extensión de lenguaje OverloadedStrings , consulte la documentación de la extensión .
Lista de literales
La extensión OverloadedLists de GHC le permite construir estructuras de datos similares a listas con la sintaxis literal de listas.
Esto le permite a Data.Map como esto:
> :set -XOverloadedLists
> import qualified Data.Map as M
> M.lookup "foo" [("foo", 1), ("bar", 2)]
Just 1
En lugar de esto (note el uso de M.fromList extra):
> import Data.Map as M
> M.lookup "foo" (M.fromList [("foo", 1), ("bar", 2)])
Just 1