Haskell Language
Overbelaste literals
Zoeken…
Opmerkingen
Integer literals
is een cijfer zonder decimale punt
bijvoorbeeld 0 , 1 , 42 , ...
wordt impliciet toegepast op fromInteger dat deel uitmaakt van de klasse Num type, dus het heeft inderdaad type Num a => a - dat wil zeggen elk type dat een instantie van Num
Fractionele literals
is een cijfer met een decimaalteken
bijvoorbeeld 0.0 , -0.1111 , ...
wordt impliciet toegepast op fromRational dat deel uitmaakt van de Fractional type klasse, dus het heeft inderdaad type a => a - dat wil zeggen elk type dat een instantie van Fractional
String Literals
Als u de Data.String.IsString OverloadedStrings toevoegt aan GHC, kunt u hetzelfde hebben voor String -literals die vervolgens worden toegepast op fromString vanuit de klasse Data.String.IsString
Dit wordt vaak gebruikt om String te vervangen door Text of ByteString .
Lijst met literatuur
Lijsten kunnen worden gedefinieerd met de letterlijke syntaxis [1, 2, 3] . In GHC 7.8 en hoger kan dit ook worden gebruikt om andere lijstachtige structuren te definiëren met de extensie OverloadedLists .
Standaard is het type [] :
> :t []
[] :: [t]
Met OverloadedLists wordt dit:
[] :: GHC.Exts.IsList l => l
Geheel getal
Het type letterlijke
Prelude> :t 1
1 :: Num a => a
een concreet type kiezen met annotaties
U kunt het type opgeven zolang het doeltype Num met een annotatie :
Prelude> 1 :: Int
1
it :: Int
Prelude> 1 :: Double
1.0
it :: Double
Prelude> 1 :: Word
1
it :: Word
zo niet, dan zal de compiler klagen
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
Drijvend cijfer
Het type letterlijke
Prelude> :t 1.0
1.0 :: Fractional a => a
Een concreet type kiezen met annotaties
U kunt het type opgeven met een type-annotatie . De enige vereiste is dat het type een Fractional instantie moet hebben.
Prelude> 1.0 :: Double
1.0
it :: Double
Prelude> 1.0 :: Data.Ratio.Ratio Int
1 % 1
it :: GHC.Real.Ratio Int
zo niet, dan zal de compiler klagen
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
strings
Het type letterlijke
Zonder enige extensie is het type van een letterlijke tekenreeks - dat wil zeggen iets tussen dubbele aanhalingstekens - gewoon een tekenreeks, ook wel een lijst met tekens genoemd:
Prelude> :t "foo"
"foo" :: [Char]
Wanneer de extensie OverloadedStrings is ingeschakeld, worden stringliteralen polymorf, vergelijkbaar met aantalliteralen :
Prelude> :set -XOverloadedStrings
Prelude> :t "foo"
"foo" :: Data.String.IsString t => t
Dit stelt ons in staat om waarden van string-achtige types te definiëren zonder expliciete conversies. In wezen verpakt de extensie OverloadedStrings elke string letterlijk in de generieke fromString conversiefunctie, dus als de context bijvoorbeeld de efficiëntere Text vereist in plaats van String , hoeft u zich daar geen zorgen over te maken.
Stringliterals gebruiken
{-# 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"
Merk op hoe we in staat waren om de waarden van de bouw van Text en ByteString op dezelfde manier bouwen we gewoon String (of [Char] ) Waarden, in plaats van elk type pack functie om de string expliciet coderen.
Zie de extensiedocumentatie voor meer informatie over de OverloadedStrings .
Lijst met literatuur
Met de extensie OverloadedLists van GHC kunt u lijstachtige gegevensstructuren samenstellen met de letterlijke syntaxis.
Hiermee kunt u Data.Map als volgt:
> :set -XOverloadedLists
> import qualified Data.Map as M
> M.lookup "foo" [("foo", 1), ("bar", 2)]
Just 1
In plaats hiervan (let op het gebruik van de extra M.fromList ):
> import Data.Map as M
> M.lookup "foo" (M.fromList [("foo", 1), ("bar", 2)])
Just 1