Haskell Language
Littéraux surchargés
Recherche…
Remarques
Littéraux entiers
est un chiffre sans point décimal
par exemple 0 , 1 , 42 , ...
est implicitement appliqué à fromInteger qui fait partie de la classe de type Num donc il a en effet le type Num a => a - c'est-à-dire qu'il peut avoir n'importe quel type qui est une instance de Num
Littéraux fractionnaires
est un chiffre avec un point décimal
par exemple 0.0 , -0.1111 , ...
est implicitement appliqué à fromRational qui fait partie de la classe de type Fractional , il a donc bien le type a => a - c'est-à-dire qu'il peut avoir n'importe quel type qui est une instance de Fractional
Littéraux de chaîne
Si vous ajoutez l'extension de langue OverloadedStrings à GHC, vous pouvez avoir la même chose pour les listes String qui sont ensuite appliquées à fromString partir de la classe de type Data.String.IsString .
Ceci est souvent utilisé pour remplacer la String avec du Text ou ByteString .
Liste des littéraux
Les listes peuvent être définies avec la syntaxe littérale [1, 2, 3] . Dans GHC 7.8 et au-delà, cela peut également être utilisé pour définir d'autres structures de type liste avec l'extension OverloadedLists .
Par défaut, le type de [] est:
> :t []
[] :: [t]
Avec OverloadedLists , cela devient:
[] :: GHC.Exts.IsList l => l
Nombre entier
Le type du littéral
Prelude> :t 1
1 :: Num a => a
choisir un type de béton avec des annotations
Vous pouvez spécifier le type tant que le type de cible est Num avec une annotation :
Prelude> 1 :: Int
1
it :: Int
Prelude> 1 :: Double
1.0
it :: Double
Prelude> 1 :: Word
1
it :: Word
sinon le compilateur se plaindra
Prelude> 1 :: String
<interactive>:
No instance for (Num String) arising from the literal `1'
In the expression: 1 :: String
In an equation for `it': it = 1 :: String
Chiffre flottant
Le type du littéral
Prelude> :t 1.0
1.0 :: Fractional a => a
Choisir un type concret avec des annotations
Vous pouvez spécifier le type avec une annotation de type . La seule exigence est que le type doit avoir une instance Fractional .
Prelude> 1.0 :: Double
1.0
it :: Double
Prelude> 1.0 :: Data.Ratio.Ratio Int
1 % 1
it :: GHC.Real.Ratio Int
sinon le compilateur se plaindra
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
Cordes
Le type du littéral
Sans aucune extension, le type d'une chaîne littérale - c'est-à-dire quelque chose entre les guillemets - est juste une chaîne, c'est-à-dire une liste de caractères:
Prelude> :t "foo"
"foo" :: [Char]
Cependant, lorsque l'extension OverloadedStrings est activée, les littéraux de chaîne deviennent polymorphes, similaires aux littéraux numériques :
Prelude> :set -XOverloadedStrings
Prelude> :t "foo"
"foo" :: Data.String.IsString t => t
Cela nous permet de définir des valeurs de type chaîne sans nécessiter de conversion explicite. Essentiellement, l'extension OverloadedStrings ne fait qu'emballer chaque littéral de chaîne dans la fonction de conversion fromString générique, donc si le contexte demande, par exemple, le Text le plus efficace au lieu de String , vous n'avez pas à vous en soucier.
Utiliser des littéraux de chaîne
{-# 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"
Remarquez comment nous avons pu construire des valeurs de Text et ByteString de la même manière que nous construisons des valeurs String (ou [Char] ) ordinaires, plutôt que d'utiliser la fonction de pack types pour encoder explicitement la chaîne.
Pour plus d'informations sur l'extension de langue OverloadedStrings , consultez la documentation de l'extension .
Liste des littéraux
L'extension OverloadedLists de GHC vous permet de construire des structures de données de type liste avec la syntaxe littérale de liste.
Cela vous permet de Data.Map comme ceci:
> :set -XOverloadedLists
> import qualified Data.Map as M
> M.lookup "foo" [("foo", 1), ("bar", 2)]
Just 1
Au lieu de cela (notez l'utilisation de la M.fromList supplémentaire):
> import Data.Map as M
> M.lookup "foo" (M.fromList [("foo", 1), ("bar", 2)])
Just 1