Haskell Language
Przeciążone literały

Uwagi

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

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

Liczby całkowite

Rodzaj literału

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

wybór konkretnego typu z adnotacjami

Możesz określić typ, o ile typem docelowym jest Num z adnotacją :

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

jeśli nie, kompilator będzie narzekał

Preludium> 1 :: Ciąg

<interactive>:
    No instance for (Num String) arising from the literal `1'
    In the expression: 1 :: String
    In an equation for `it': it = 1 :: String

Liczba zmiennoprzecinkowa

Rodzaj literału

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

Wybór konkretnego typu z adnotacjami

Możesz określić typ za pomocą adnotacji typu . Jedynym wymaganiem jest to, że typ musi mieć instancję Fractional .

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

jeśli nie, kompilator będzie narzekał

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

Smyczki

Rodzaj literału

Bez żadnych rozszerzeń typ literału łańcuchowego - tzn. Coś pomiędzy podwójnymi cudzysłowami - jest po prostu łańcuchem, czyli listą znaków:

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

Jednak po włączeniu rozszerzenia OverloadedStrings literały łańcuchowe stają się polimorficzne, podobnie jak literały liczbowe :

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

To pozwala nam definiować wartości typów ciągów bez potrzeby jawnej konwersji. Zasadniczo rozszerzenie OverloadedStrings po prostu otacza każdy literał łańcucha w ogólnej funkcji konwersji fromString , więc jeśli kontekst wymaga np. Bardziej wydajnego Text zamiast String , nie musisz się tym martwić.

Używanie literałów łańcuchowych

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

Zauważ, jak udało nam się skonstruować wartości Text i ByteString w taki sam sposób, w jaki konstruujemy zwykłe wartości String (lub [Char] ), zamiast używać funkcji pack każdego typu do jawnego kodowania łańcucha.

Aby uzyskać więcej informacji na temat rozszerzenia języka OverloadedStrings , zobacz dokumentację rozszerzenia .

Lista literałów

Rozszerzenie OverloadedLists w GHC umożliwia konstruowanie struktur danych podobnych do listy przy użyciu składni literału listy.

Pozwala to na Data.Map w następujący sposób:

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

Zamiast tego (zwróć uwagę na użycie dodatkowego M.fromList ):

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