Haskell Language
Letterali sovraccaricati
Ricerca…
Osservazioni
Integer Literals
è un numero senza un punto decimale
per esempio 0 , 1 , 42 , ...
viene applicato implicitamente a fromInteger che fa parte della classe di tipo Num , quindi ha in effetti il tipo Num a => a - ovvero può avere qualsiasi tipo che è un'istanza di Num
Letterali frazionari
è un numero con un punto decimale
ad esempio 0.0 , -0.1111 , ...
è implicitamente applicato a fromRational che fa parte della classe di tipo Fractional quindi ha infatti tipo a => a - cioè può avere qualsiasi tipo che è un'istanza di Fractional
String letterali
Se si aggiunge l'estensione della lingua OverloadedStrings a GHC, è possibile avere lo stesso per String -literals che vengono quindi applicati a fromString dalla classe di tipo Data.String.IsString
Questo è spesso usato per sostituire String con Text o ByteString .
Elenca i letterali
Le liste possono essere definite con la sintassi letterale [1, 2, 3] . In GHC 7.8 e oltre, questo può anche essere usato per definire altre strutture di tipo listuale con l'estensione OverloadedLists .
Per impostazione predefinita, il tipo di [] è:
> :t []
[] :: [t]
Con OverloadedLists , questo diventa:
[] :: GHC.Exts.IsList l => l
Numero intero
Il tipo di letterale
Prelude> :t 1
1 :: Num a => a
scegliendo un tipo concreto con annotazioni
Puoi specificare il tipo finché il tipo di destinazione è Num con un'annotazione :
Prelude> 1 :: Int
1
it :: Int
Prelude> 1 :: Double
1.0
it :: Double
Prelude> 1 :: Word
1
it :: Word
altrimenti il compilatore si lamenterà
Preludio> 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
Numero galleggiante
Il tipo di letterale
Prelude> :t 1.0
1.0 :: Fractional a => a
Scelta di un tipo concreto con annotazioni
È possibile specificare il tipo con un'annotazione di tipo . L'unico requisito è che il tipo deve avere un'istanza Fractional .
Prelude> 1.0 :: Double
1.0
it :: Double
Prelude> 1.0 :: Data.Ratio.Ratio Int
1 % 1
it :: GHC.Real.Ratio Int
altrimenti il compilatore si lamenterà
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
stringhe
Il tipo di letterale
Senza estensioni, il tipo di stringa letterale, ad esempio qualcosa tra virgolette, è solo una stringa, ovvero un elenco di caratteri:
Prelude> :t "foo"
"foo" :: [Char]
Tuttavia, quando l'estensione OverloadedStrings è abilitata, i valori letterali stringa diventano polimorfici, simili ai numeri letterali :
Prelude> :set -XOverloadedStrings
Prelude> :t "foo"
"foo" :: Data.String.IsString t => t
Questo ci consente di definire i valori dei tipi di stringhe senza necessità di conversioni esplicite. In sostanza, l'estensione OverloadedStrings fromString ogni stringa letterale nella funzione di conversione generica fromString , quindi se il contesto richiede ad esempio il Text più efficiente invece di String , non devi preoccuparti di te stesso.
Utilizzo di stringhe letterali
{-# 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"
Si noti come siamo stati in grado di costruire valori di Text e ByteString nello stesso modo in cui costruiamo valori ordinari di String (o [Char] ), piuttosto che utilizzare ciascuna funzione del pack tipi per codificare esplicitamente la stringa.
Per ulteriori informazioni sull'estensione di lingua OverloadedStrings , consultare la documentazione relativa all'estensione .
Elenca i letterali
L'estensione OverloadedLists di GHC consente di costruire strutture di dati di tipo elenco con la sintassi letterale di lista.
Questo ti permette di Data.Map in questo modo:
> :set -XOverloadedLists
> import qualified Data.Map as M
> M.lookup "foo" [("foo", 1), ("bar", 2)]
Just 1
Invece di questo (si noti l'uso di M.fromList in più ):
> import Data.Map as M
> M.lookup "foo" (M.fromList [("foo", 1), ("bar", 2)])
Just 1
