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


Modified text is an extract of the original Stack Overflow Documentation
Sous licence CC BY-SA 3.0
Non affilié à Stack Overflow