Haskell Language
Überladene Literale

Bemerkungen

> :t []
[] :: [t]

[] :: GHC.Exts.IsList l => l

Ganzzahl

Die Art des Literal

Prelude> :t 1
1 :: Num a => a

Auswahl eines konkreten Typs mit Anmerkungen

Sie können den Typ angeben, solange der Zieltyp Num mit einer Anmerkung ist :

Prelude> 1 :: Int
1
it :: Int
Prelude> 1 :: Double
1.0
it :: Double
Prelude> 1 :: Word
1
it :: Word

Wenn nicht, beschwert sich der Compiler

Vorspiel> 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

Fließende Zahl

Die Art des Literal

Prelude> :t 1.0
1.0 :: Fractional a => a

Einen konkreten Typ mit Anmerkungen auswählen

Sie können den Typ mit einer Typanmerkung angeben. Die einzige Voraussetzung ist, dass der Typ eine Fractional Instanz haben muss.

Prelude> 1.0 :: Double
1.0
it :: Double
Prelude> 1.0 :: Data.Ratio.Ratio Int
1 % 1
it :: GHC.Real.Ratio Int 

Wenn nicht, beschwert sich der Compiler

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

Zeichenketten

Die Art des Literal

Ohne Erweiterungen ist der Typ eines Zeichenfolgenliteral, dh etwas zwischen Anführungszeichen, nur eine Zeichenfolge, eine Liste von Zeichen:

Prelude> :t "foo"
"foo" :: [Char]

Wenn jedoch die OverloadedStrings Erweiterung aktiviert ist, werden Zeichenfolgenliterale polymorph, ähnlich wie Zahlenliterale :

Prelude> :set -XOverloadedStrings
Prelude> :t "foo"
"foo" :: Data.String.IsString t => t

Auf diese Weise können wir Werte von String-ähnlichen Typen definieren, ohne dass explizite Konvertierungen erforderlich sind. Im Wesentlichen umhüllt die OverloadedStrings Erweiterung lediglich jedes String-Literal in der generischen fromString Konvertierungsfunktion. Wenn also der Kontext z. B. den effizienteren Text anstelle von String erfordert, müssen Sie sich nicht darum kümmern.

Verwenden von String-Literalen

{-# 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"

Beachten Sie, wie wir in der Lage waren Werte zu konstruieren , Text und ByteString in der gleichen Art , wie wir gewöhnliches konstruieren String (oder [Char] ) Werte, anstatt jede Art mit pack Funktion die Zeichenfolge explizit zu codieren.

Weitere Informationen zur Spracherweiterung OverloadedStrings finden Sie in der Erweiterungsdokumentation .

List Literals

Mit der OverloadedLists- Erweiterung von GHC können Sie listenartige Datenstrukturen mit der Listenliteral-Syntax erstellen.

Dies ermöglicht es Ihnen, Data.Map wie folgt :

> :set -XOverloadedLists
> import qualified Data.Map as M
> M.lookup "foo" [("foo", 1), ("bar", 2)]
Just 1

Stattdessen (beachten Sie die Verwendung der zusätzlichen M. aus der Liste ):

> import Data.Map as M
> M.lookup "foo" (M.fromList [("foo", 1), ("bar", 2)])
Just 1