我正在查看這個，以及考慮非十進制文字的整個問題，例如，1只是糖fromInteger 1，然后我發現型別是
λ> :t 1
1 :: Num p => p
這和宣告
整數文字表示函式 fromInteger 對 Integer 型別的適當值的應用。
讓我想知道到底發生了什么。同樣地，
λ> :t 3.149
3.149 :: Fractional p => p
理查德伯德 說
浮點文字，例如
3.149表示對fromRational適當有理數的應用。因此3.149 :: Fractional a => a
不理解對適當有理數的應用fromRational意味著什么。然后他說這是能夠添加的所有必要條件，例如，42 3.149。
我覺得這里發生了很多我不明白的事情。就像我揮手的次數太多了。它似乎是對特定型別的未識別的非十進制或十進制的強制轉換，Integer并且Rational. 那么首先，為什么1實際上是在fromInteger 1內部？我意識到每個運算式都必須作為一種型別進行評估，但為什么會fromInteger涉及fromRational？
輔助
所以在這個頁面
從整數型別轉換的主力是
fromIntegral，它將從任何Integral型別轉換為任何數值型別（包括Int、Integer、Rational和Double）：fromIntegral :: (Num b, Integral a) => a -> b
然后是例子
λ> sqrt 1
1.0
λ> sqrt (1 :: Int)
... error...
λ> sqrt (fromInteger 1)
1.0
λ> :t sqrt 1
sqrt 1 :: Floating a => a
λ> :t sqrt (1 :: Int)
...error...
λ> :t sqrt
sqrt :: Floating a => a -> a
λ> :t sqrt (fromInteger 1)
sqrt (fromInteger 1) :: Floating a => a
所以是的，這是一個演員表，但我不知道如何fromI*做到這一點的機制——因為從技術上講，它不是 C/C 意義上的演員表。的所有實體都Num必須有一個fromInteger. Haskell 似乎在幕后將您放入的任何內容都通用化為Integeror Rational，然后將其“歸還”給原始函式，例如sqrt (fromInteger 1)type Floating a => a。這對于容易過度思考的人來說是非常神秘的。
所以是的，1是一個文字，一個多型的常量。它可以表示1任何實體化的型別Num。must的作用fromInteger是允許從與情況要求一致的整數常量中提取值（強制轉換）。但這在某些時候是揮手的談話。我不明白這實際上是如何發生的。
uj5u.com熱心網友回復：
也許這會有所幫助...
想象一下像 Haskell 這樣的語言，除了文字程式文本1表示一個Integer值為 1 的型別術語，而文字程式文本3.14表示一個Rational值為 3.14 的型別術語。我們稱這種語言為“AnnoyingHaskell”。
需要明確的是，當我在上一段中說“表示”時，我的意思是 AnnoyingHaskell 編譯器實際上將這些文字編譯成機器代碼，Integer在第一種情況下產生一個值為數字 1 的Rational項，以及一個值為第二種情況下的數字 3.14。AnInteger的核心是 GMP 庫實作的任意精度整數，而 aRational是一對兩個Integers，被理解為有理數的分子和分母。對于這個特殊的有理數，這兩個整數將是 157 和 50（即 157/50=3.14）。
AnnoyingHaskell 會......呃......使用起來很煩人。例如，以下運算式不會輸入檢查：
take 3 "hello"
因為3is anInteger但是take的第一個引數是 an Int。同樣，運算式：
42 3.149
不會鍵入檢查，因為42is an Integerand 3.149is a Rational，并且在 AnnoyingHaskell 中，就像在 Haskell 本身中一樣，您不能添加 anInteger和 a Rational。
因為這很煩人，Haskell 的設計者決定將文字程式文本42和3.149視為 AnnoyingHaskell 運算式fromInteger 42和fromRational 3.149.
AnnoyingHaskell 運算式：
fromInteger 42 fromRational 3.149
進行型別檢查。具體來說，多型函式：
fromInteger :: (Num a) => Integer -> a
接受 AnnoyingHaskell 文字42 :: Integer作為其引數，并且結果子運算式fromInteger 42具有Num a => a某些新型別的結果型別a。同樣，fromRational 3.149is of typeFractional b => b對于一些新鮮的型別b。運算子將這 兩種型別統一為一個型別(Num c, Fractional c) => c，但由于是 的超類，所以Num c是多余的，因此整個運算式具有多型型別：NumFractional
fromInteger 42 fromRational 3.149 :: Fractional c => c
也就是說，這個運算式可以被實體化為具有Fractional約束的任何型別。例如。在 Haskell 程式中：
main = print $ 42 3.149
這相當于 AnnoyingHaskell 程式：
main = print $ fromInteger 42 fromRational 3.149
通常的“默認”規則適用，并且由于傳遞給陳述句的運算式是具有約束print的未知型別，因此默認為，允許程式實際運行、計算和列印所需的.cFractional cDoubleDouble
如果編譯器很糟糕，這個程式將通過42 :: Integer在堆上創建 a 來運行，呼叫fromInteger(specialized to fromInteger :: Integer -> Double) 創建 a 42 :: Double，然后3.149 :: Rational在堆上創建，呼叫fromRational(specialized to fromRational :: Rational -> Double) 創建 a 3.149 :: Double，然后將它們加在一起以創建最終的回答45.149 :: Double。因為編譯器不是那么糟糕，它只是45.149 :: Double直接創建數字。
uj5u.com熱心網友回復：
也許這會有所幫助。您似乎正在努力解決的一件事是型別值的性質Num a => a，例如由fromInteger (1 :: Integer). 我認為您以某種方式想象將其fromInteger“打包”1 :: Integer在一個盒子中，以便以后可以通過特殊的編譯器魔術將其轉換為 a 1 :: Intor 1 :: Double。
這不是正在發生的事情。
考慮以下型別類：
{-# LANGUAGE FlexibleInstances #-}
class Thing a where
thing :: a
與關聯的實體：
instance Thing Bool where thing = True
instance Thing Int where thing = 16
instance Thing String where thing = "hello, world"
instance Thing (Int -> String) where thing n = replicate n '*'
并觀察運行結果：
main = do
print (thing :: Bool)
print (thing :: Int)
print (thing :: String)
print $ (thing :: Int -> String) 15
希望您對型別類感到滿意，不會對輸出感到驚訝。大概你不認為它thing包含一些特定的、可識別的“東西”，這些“東西”被“強制轉換”為Bool,Int等。它只是thing一個多型值，其定義取決于它的型別；這就是型別類的作業方式。
現在，考慮類似的例子：
{-# LANGUAGE FlexibleInstances #-}
import Data.Ratio
import Data.Word
import Unsafe.Coerce
class Three a where
three :: a
-- for base >= 4.10.0.0, can import GHC.Float (castWord64ToDouble)
-- more generally, we can use this unsafe coercion:
castWord64ToDouble :: Word64 -> Double
castWord64ToDouble w = unsafeCoerce w
instance Three Int where
three = length "aaa"
instance Three Double where
three = castWord64ToDouble 0x4008000000000000
instance Three Rational where
three = (6 :: Integer) % (2 :: Integer)
main = do
print (three :: Int)
print (three :: Double)
print (three :: Rational)
print $ take three "abcdef"
print $ (sqrt three :: Double)
你能在這里看到如何three :: Three a => a表示一個可以用作Int、Double或的值Rational嗎？如果您想將其視為強制轉換，那很好，但顯然沒有可識別的單個“3”被打包在three通過編譯器魔術轉換為不同型別的值中。只是呼叫了不同的定義three，具體取決于呼叫者要求的型別。
從這里開始，這并不是一個很大的飛躍：
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MagicHash #-}
import Data.Ratio
import Data.Word
import Unsafe.Coerce
class MyFromInteger a where
myFromInteger :: Integer -> a
instance MyFromInteger Integer where
myFromInteger x = x
instance MyFromInteger Int where
-- for base >= 4.10.0.0 can use the following:
-- -- Note: data Integer = IS Int | ...
-- myFromInteger (IS i) = I# i
-- myFromInteger _ = error "not supported"
-- to support more GHC versions, we'll just use this extremely
-- dangerous coercion:
myFromInteger i = unsafeCoerce i
instance MyFromInteger Rational where
myFromInteger x = x % (1 :: Integer)
main = do
print (myFromInteger 1 :: Integer)
print (myFromInteger 2 :: Int)
print (myFromInteger 3 :: Rational)
print $ take (myFromInteger 4) "abcdef"
從概念上講，基本庫fromInteger (1 :: Integer) :: Num a => a與此代碼沒有什么不同myFromInteger (1 :: Integer) :: MyFromInteger a => a，只是實作更好并且更多型別具有實體。
看，這并不是運算式fromInteger (1 :: Integer)將1 :: Integera 封裝到一個型別的包中以Num a => a供以后轉換。正是這個運算式的型別背景關系導致分派到適當的Num型別類實體，并fromInteger呼叫不同的定義，具體取決于所需的型別。該fromInteger函式始終使用引數呼叫1 :: Integer，但回傳的型別取決于背景關系，以及呼叫呼叫的代碼fromInteger（即fromIntegerused 的定義）將引數轉換或“強制轉換”1 :: Integer為所需型別的“一”值取決于需要哪種回傳型別。
而且，更進一步，只要我們通過關閉單態限制來處理技術細節，我們可以這樣寫：
{-# LANGUAGE NoMonomorphismRestriction #-}
main = do
let two = myFromInteger 2
print (two :: Integer)
print (two :: Int)
print (two :: Rational)
這可能看起來很奇怪，但就像使用 的定義產生最終值myFromInteger 2的型別運算式一樣，取決于最終需要什么型別，該運算式也是使用的定義產生最終值的型別的運算式取決于最終需要什么型別，即使文字程式文本沒有出現在運算式中。此外，繼續：Num a => amyFromIntegertwoNum a => amyFromIntegermyFromIntegertwo
let four = two two
print (four :: Integer)
print (four :: Int)
print (four :: Rational)
fourtype的運算式Num a => a將產生一個最終值，該值取決于最終要求的回傳型別的定義myFromInteger和定義。( )
換句話說，與其將其視為將被轉換為各種型別four的封裝，不如將其視為完全等同于其完整定義：4 :: Integerfour
four = myFromInteger 2 myFromInteger 2
最終值將通過使用 和 的定義來確定，該值myFromInteger適用( )于所需的任何型別four，無論是four :: Integer還是four :: Rational。
之后也是如此sqrt (fromIntegral 1) ：
x = sqrt (fromIntegral (1 :: Integer))
的值x :: Floating a => a相當于完整的運算式：
sqrt (fromIntegral (1 :: Integer))
并且在使用它的每個地方，都將使用所需的最終型別的和實體的定義sqrt和實體來計算它。fromIntegralFloatingNum
這是一個檔案中的所有代碼，使用 GHC 8.2.2 和 9.2.4 進行測驗。
{-# LANGUAGE Haskell98 #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE NoMonomorphismRestriction #-}
import Data.Ratio
import GHC.Num
import GHC.Int
import GHC.Float (castWord64ToDouble)
class Thing a where
thing :: a
instance Thing Bool where thing = True
instance Thing Int where thing = 16
instance Thing String where thing = "hello, world"
instance Thing (Int -> String) where thing n = replicate n '*'
class Three a where
three :: a
instance Three Int where
three = length "aaa"
instance Three Double where
three = castWord64ToDouble 0x4008000000000000
instance Three Rational where
three = (6 :: Integer) % (2 :: Integer)
class MyFromInteger a where
myFromInteger :: Integer -> a
instance MyFromInteger Integer where
myFromInteger x = x
instance MyFromInteger Int where
-- Note: data Integer = IS Int | ...
myFromInteger (IS i) = I# i
myFromInteger _ = error "not supported"
instance MyFromInteger Rational where
myFromInteger x = x % (1 :: Integer)
main = do
print (thing :: Bool)
print (thing :: Int)
print (thing :: String)
print $ (thing :: Int -> String) 15
print (three :: Int)
print (three :: Double)
print (three :: Rational)
print $ take three "abcdef"
print $ (sqrt three :: Double)
print (myFromInteger 1 :: Integer)
print (myFromInteger 2 :: Int)
print (myFromInteger 3 :: Rational)
print $ take (myFromInteger 4) "abcdef"
let two = myFromInteger 2
print (two :: Integer)
print (two :: Int)
print (two :: Rational)
let four = two two
print (four :: Integer)
print (four :: Int)
print (four :: Rational)
轉載請註明出處，本文鏈接：https://www.uj5u.com/qiye/528503.html
標籤：哈斯克尔类型数字