Haskell Language
Överbelastade bokstäver
Sök…
Anmärkningar
Heltalsbokstäver
är en siffra utan decimal
till exempel 0 , 1 , 42 , ...
tillämpas implicit på fromInteger som är en del av klassen Num typ så den har verkligen typen Num a => a - det vill säga den kan ha vilken typ som helst som är en instans av Num
Fraktionella bokstäver
är en siffra med en decimal
till exempel 0.0 , -0.1111 , ...
tillämpas implicit på fromRational som är en del av Fractional så den har verkligen typ a => a - det vill fromRational att den kan ha vilken typ som helst som är en instans av Fractional
String Literals
Om du lägger till språkförlängningen OverloadedStrings till GHC kan du ha samma för String litteraler som sedan tillämpas på fromString från klassen Data.String.IsString
Detta används ofta för att ersätta String med Text eller ByteString .
Lista bokstäver
Listor kan definieras med [1, 2, 3] bokstavssyntax. I GHC 7.8 och senare kan detta också användas för att definiera andra listliknande strukturer med förlängningen OverloadedLists .
Som standard är typen av [] :
> :t []
[] :: [t]
Med OverloadedLists listor blir detta:
[] :: GHC.Exts.IsList l => l
Heltalsnummer
Typen av det bokstavliga
Prelude> :t 1
1 :: Num a => a
välja en konkret typ med kommentarer
Du kan ange typen så länge måltypen är Num med en kommentar :
Prelude> 1 :: Int
1
it :: Int
Prelude> 1 :: Double
1.0
it :: Double
Prelude> 1 :: Word
1
it :: Word
om inte kommer kompilatorn att klaga
Förspel> 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
Flytande siffror
Typen av det bokstavliga
Prelude> :t 1.0
1.0 :: Fractional a => a
Att välja en konkret typ med anteckningar
Du kan ange typen med en typanteckning . Det enda kravet är att typen måste ha en Fractional instans.
Prelude> 1.0 :: Double
1.0
it :: Double
Prelude> 1.0 :: Data.Ratio.Ratio Int
1 % 1
it :: GHC.Real.Ratio Int
om inte kommer kompilatorn att klaga
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
strängar
Typen av det bokstavliga
Utan några förlängningar är typen av en strängbokstavlig - dvs. något mellan dubbla citat - bara en sträng, alias lista med tecken:
Prelude> :t "foo"
"foo" :: [Char]
Men när förlängningen OverloadedStrings är aktiverad, blir strängbokstäver polymorfa, liknande antalet bokstäver :
Prelude> :set -XOverloadedStrings
Prelude> :t "foo"
"foo" :: Data.String.IsString t => t
Detta gör att vi kan definiera värden för strängliknande typer utan att behöva några uttryckliga konverteringar. I huvudsak OverloadedStrings tillägget OverloadedStrings bara alla sträng som är bokstavliga i den generiska konverteringsfunktionen från fromString , så om sammanhanget kräver t.ex. den mer effektiva Text istället för String behöver du inte oroa dig själv.
Använda strängbokstäver
{-# 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"
Lägg märke till hur vi kunde konstruera värden på Text och ByteString på samma sätt som vi konstruerar vanliga String (eller [Char] ) värden, snarare än att använda paketfunktioner för varje typ pack att koda strängen uttryckligen.
Mer information om språkförlängningen OverloadedStrings finns i dokumentationen för tillägget .
Lista bokstäver
Med GHCs OverloadedLists- förlängning kan du konstruera listliknande datastrukturer med listans bokstavssyntax.
Detta tillåter dig att Data.Map så här:
> :set -XOverloadedLists
> import qualified Data.Map as M
> M.lookup "foo" [("foo", 1), ("bar", 2)]
Just 1
Istället för detta (notera användningen av den extra M.fromList ):
> import Data.Map as M
> M.lookup "foo" (M.fromList [("foo", 1), ("bar", 2)])
Just 1