Haskell Language
오버로드 된 리터럴

비고

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

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

정수

리터럴 유형

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

특수 효과가있는 구체적인 유형 선택

대상 유형이 주석 이있는 Num 한 유형을 지정할 수 있습니다.

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

그렇지 않다면 컴파일러는 불평 할 것이다.

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

부동 숫자

리터럴 유형

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

특수 효과가있는 구체적인 유형 선택

유형 주석으로 유형을 지정할 수 있습니다. 유일한 요구 사항은 유형에 Fractional 인스턴스가 있어야한다는 것입니다.

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

그렇지 않다면 컴파일러는 불평 할 것이다.

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

문자열

리터럴 유형

확장자가 없으면 문자열 리터럴 유형 (즉, 큰 따옴표 사이의 값)은 문자열 일뿐입니다. 문자 목록입니다.

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

그러나 OverloadedStrings 확장이 활성화되면 문자열 리터럴은 숫자 리터럴 과 비슷한 다형성이됩니다.

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

이렇게하면 명시적인 변환이 필요없이 문자열 형식의 값을 정의 할 수 있습니다. 본질적으로 OverloadedStrings 확장은 모든 문자열 리터럴을 일반 fromString 변환 함수로 래핑하므로 문맥에서 String 아닌 더 효율적인 Text 가 필요한 경우 직접 걱정할 필요가 없습니다.

문자열 리터럴 사용

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

문자열을 명시 적으로 인코딩하기 위해 각 유형 pack 함수를 사용하는 대신 일반 String (또는 [Char] ) 값을 생성하는 것과 같은 방법으로 Text 및 ByteString 값을 생성 할 수있었습니다.

OverloadedStrings 언어 확장에 대한 자세한 내용 은 확장 문서를 참조하십시오.

리터럴 목록

GHC의 OverloadedLists 확장을 사용하면 목록 리터럴 구문을 사용하여 목록과 유사한 데이터 구조를 구성 할 수 있습니다.

이렇게하면 Data.Map을 다음 과 같이 할 수 있습니다.

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

대신 이것 (여분의 M.fromList 의 사용에주의하십시오) :

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