技術ブログを開設しました。

関数型プログラミング入門~Contravariantについて~

こんにちは。G・B・S第２システム開発部の小路です。

Haskellの入門本には、Functorについての解説は載っているものの、Contravariantについては触れないことが多いので、学習がてら概要をまとめてみようと思います。

Functorについておさらい

Contravariantについて触れる前に、Functorを振り返っておきます。
HaskellにおけるFunctor型クラスの定義は以下のようになっています。

Functor型クラスの定義

  1. class Functor (f :: * -> *) where
  2. fmap :: (a -> b) -> f a -> f b
class Functor (f :: * -> *) where
  fmap :: (a -> b) -> f a -> f b

fmapを使用することによって、通常の関数をFunctorインスタンスの文脈に持ち上げることができました。
fmapの型注釈から読み取れるのは、第1引数の「(a -> b)」と第2引数の「f a」において、型変数aの型は同じでなければならないということです。

コンパイル可能なfmapの使用例を見てみます。例として、Functor型クラスのインスタンスは((->) r)を使います。
((->) r)のfmapの定義は(.)と等しいです。つまり関数合成です。

コンパイル可能な例

 

  1. -- instance Functor ((->) r) where
  2. -- fmap = (.)
  4. intToString :: Int -> String
  5. intToString = show
  7. doubleToInt :: Double -> Int
  8. doubleToInt = floor
  10. main :: IO ()
  11. main = do
  12. xs <- return $ f 100.0 print xs where f :: Double -> String
  13. f = intToString <$> doubleToInt -- fmap intToString doubleToInt
-- instance Functor ((->) r) where
-- fmap = (.)

intToString :: Int -> String
intToString = show

doubleToInt :: Double -> Int
doubleToInt = floor

main :: IO ()
main = do
  xs <- return $ f 100.0 print xs where f :: Double -> String
  f = intToString <$> doubleToInt -- fmap intToString doubleToInt

 

出力結果

  1. "100"
"100"

 

期待通りの結果です。

では、次はコンパイルできない例を見てみます。

コンパイルできない例

  1. import Data.Ratio
  3. main :: IO ()
  4. main = do
  5. xs <- return $ f (100 % 3) print xs where f :: Double -> String
  6. f = intToString <$> doubleToInt
import Data.Ratio

main :: IO ()
main = do
  xs <- return $ f (100 % 3) print xs where f :: Double -> String
  f = intToString <$> doubleToInt

これがコンパイルできないのは、関数fの第1引数はDouble型の値を要求するにも関わらず、Ratio Integer型の値に適用してしまっているからです。

エラー内容

  1. • Couldn't match expected type ‘Double’
  2. with actual type ‘Ratio Integer’
  3. • In the first argument of ‘f’, namely ‘(100 % 3)’
  4. In the second argument of ‘($)’, namely ‘f (100 % 3)’
  5. In a stmt of a 'do' block: xs <- return $ f (100 % 3) (以下略)
• Couldn't match expected type ‘Double’
with actual type ‘Ratio Integer’
• In the first argument of ‘f’, namely ‘(100 % 3)’
In the second argument of ‘($)’, namely ‘f (100 % 3)’
In a stmt of a 'do' block: xs <- return $ f (100 % 3) (以下略)

fmapでは、通常の関数fをFunctor型クラスのインスタンスに適用することにより、最終的に得られる型の値を任意のFunctor型クラスのインスタンスの値に持ち上げることができました。 （このことから、fmapは「producer of output　（出力の生産者）」と表現されることがあります。） しかし、fmapで「出力」の型を変化させることができますが、「入力」の型を変えることはできません。「入力」の型を変える一般化された計算の概念はないのでしょうか。そんな時に登場するのがContravariantです。

Contravariant

Contravariant型クラスの定義は以下のようになっています。

Contravariant型クラスの定義

  1. class Contravariant (f :: * -> *) where
  2. contramap :: (b -> a) -> f a -> f b
class Contravariant (f :: * -> *) where
  contramap :: (b -> a) -> f a -> f b

contramapはfmapの型注釈とよく似た形をしていますが、第1引数が(b -> a)となっています。
この(b -> a)は、型変数bの型から型変数aの型へ変換する方法を示しているとも読めます。
contramapを、型bから型aへの変換方法と、中身に型aの値を持つContravariant型クラスのインスタンスに適用することで、型bの値を持つContravariant型クラスのインスタンスが得られます。

この手の概念を理解する手っ取り早い方法は具体例を見ることです。ということで、Contravariantの使用例を見てみましょう。
と、その前に、新たな型を定義しておきます。

新たな型の定義

  1. newtype Op z a = Op { getOp :: a -> z }
newtype Op z a = Op { getOp :: a -> z }

以下のコードはHaskellではコンパイルできませんので、newtypeとして型変数の順序を逆にしたラッパー型Opを作成しました。

  1. instance Contravariant (-> r) where -- これはコンパイルエラー
instance Contravariant (-> r) where -- これはコンパイルエラー

これをContravariant型クラスのインスタンスにします。

  1. instance Contravariant (Op z) where
  2. -- contramap :: (b -> a) -> Op z a -> Op z b
  3. contramap f (Op g) = Op (g . f)
instance Contravariant (Op z) where
-- contramap :: (b -> a) -> Op z a -> Op z b
  contramap f (Op g) = Op (g . f)

では、実際に使用例を見てみます。

まず、先ほどの(Double -> String)型の関数をOp型の値として持たせ、contramapの適用対象にします。

  1. f :: Double -> String
  2. f = intToString <$> doubleToInt
  4. opF :: Op String Double
  5. opF = Op f
f :: Double -> String
f = intToString <$> doubleToInt

opF :: Op String Double
opF = Op f

opFの型はOp String Doubleです。
contramapとopFを使用して、Op String Rational型の値を得る例を見てみましょう。

  1. rationalToDouble :: Rational -> Double
  2. rationalToDouble = fromRational
  4. g :: Op String Rational -- getOpでアンラップすると、(Rational -> String)型の関数が得られる
  5. g = contramap rationalToDouble opF -- rationalToDouble >$< opF
rationalToDouble :: Rational -> Double
rationalToDouble = fromRational

g :: Op String Rational -- getOpでアンラップすると、(Rational -> String)型の関数が得られる
g = contramap rationalToDouble opF -- rationalToDouble >$< opF

Op String Rationalをアンラップすると、(Rational -> String)型の関数が得られます。
ここで、関数fは元々の定義から変更を加えていません。contramapを使うことにより入力の型をDoubleからRationalに変更することができました。
（Contravariantは「consumer of input (入力の消費者)」と表現されることがあります。）

では、動かしてみましょう。

Main.hs

  1. import Data.Ratio
  2. import Data.Functor.Contravariant hiding (Op, getOp)
  4. newtype Op z a = Op { getOp :: (a -> z) }
  6. instance Contravariant (Op z) where
  7. contramap f (Op g) = Op (g . f)
  9. intToString :: Int -> String
  10. intToString = show
  12. doubleToInt :: Double -> Int
  13. doubleToInt = floor
  15. rationalToDouble :: Rational -> Double
  16. rationalToDouble = fromRational
  18. f :: Double -> String
  19. f = intToString <$> doubleToInt
  21. opF :: Op String Double
  22. opF = Op f
  24. g :: Op String Rational -- getOpでアンラップすると、(Rational -> String)型の関数が得られる
  25. g = contramap rationalToDouble opF -- rationalToDouble >$< opF
  27. main :: IO ()
  28. main = do
  29. xs <- return $ f 100.0
  30. print xs
  32. xs' <- return $ getOp g (100 % 3)
  33. print xs'
import Data.Ratio
import Data.Functor.Contravariant hiding (Op, getOp)

newtype Op z a = Op { getOp :: (a -> z) }

instance Contravariant (Op z) where
contramap f (Op g) = Op (g . f)

intToString :: Int -> String
intToString = show

doubleToInt :: Double -> Int
doubleToInt = floor

rationalToDouble :: Rational -> Double
rationalToDouble = fromRational

f :: Double -> String
f = intToString <$> doubleToInt

opF :: Op String Double
opF = Op f

g :: Op String Rational -- getOpでアンラップすると、(Rational -> String)型の関数が得られる
g = contramap rationalToDouble opF -- rationalToDouble >$< opF

main :: IO ()
main = do
  xs <- return $ f 100.0
  print xs

  xs' <- return $ getOp g (100 % 3) 
  print xs'

出力結果

  1. "100"
  2. "33"
"100"
"33"

期待通りです。 Op型はcontramapの使用方法を学ぶ上で（個人的に）分かりやすいと思ったので、こちらを使用しましたが、お気付きの通り、上記の例はわざわざOp String Rationalにしなくても、通常の関数合成で目的は達成できます。

  1. g' :: Rational -> String
  2. g' = f . fromRational
g' :: Rational -> String
g' = f . fromRational

なんにせよ、contramapの使い方のイメージはつかめたのではないでしょうか。

Op以外にもContravariant型クラスのインスタンスは他にも色々あります。
最後に、Contravariant型クラスのインスタンスの一つであるEquivalenceの例を見て終わります。

Equivalence

  1. newtype Equivalence a = Equivalence { getEquivalence :: a -> a -> Bool }
  3. instance Contravariant Equivalence where
  4. contramap f g = Equivalence $ on (getEquivalence g) f
  6. -- (==)を使って等値判定を行うEquivalence型の値
  7. defaultEquivalence :: Eq a => Equivalence a
  8. defaultEquivalence = Equivalence (==)
newtype Equivalence a = Equivalence { getEquivalence :: a -> a -> Bool }

instance Contravariant Equivalence where
contramap f g = Equivalence $ on (getEquivalence g) f

-- (==)を使って等値判定を行うEquivalence型の値
defaultEquivalence :: Eq a => Equivalence a
defaultEquivalence = Equivalence (==)

通常のタプルの等値判定では、第１要素と第２要素の両方の等値判定を行いますが、
contramapを使って、１つの要素だけに対して、等値判定を行うようにする例を見てみます。

  1. import Data.Functor.Contravariant
  3. -- (>$<)はcontramapの中置演算子版
  4. fstEquivalence :: Eq a => Equivalence (a, b)
  5. fstEquivalence = fst >$< defaultEquivalence -- contramap fst defaultEquivalence
  7. sndEquivalence :: Equivalence (a, String)
  8. sndEquivalence = snd >$< defaultEquivalence
  10. sndEquivalence' :: Equivalence (a, String)
  11. sndEquivalence' = (show . convertString2Int . snd) >$< defaultEquivalence
  13. convertString2Int :: String -> Int
  14. convertString2Int xs
  15. | xs == "1" = 1
  16. | xs == "one" = 1
  17. | xs == "2" = 2
  18. | xs == "two" = 2
  19. | otherwise = 0
  21. main :: IO ()
  22. main = do
  23. print $ getEquivalence defaultEquivalence (1, 2) (1, 2)
  24. print $ getEquivalence defaultEquivalence (1, 2) (1, 3)
  26. print $ getEquivalence fstEquivalence (1, 2) (1, 3)
  27. print $ getEquivalence fstEquivalence (2, 2) (1, 3)
  29. print $ getEquivalence sndEquivalence (1, "1") (2, "one")
  30. print $ getEquivalence sndEquivalence (1, "2") (1, "two")
  32. print $ getEquivalence sndEquivalence' (1, "1") (2, "one")
  33. print $ getEquivalence sndEquivalence' (1, "2") (2, "two")
import Data.Functor.Contravariant

-- (>$<)はcontramapの中置演算子版
fstEquivalence :: Eq a => Equivalence (a, b)
fstEquivalence = fst >$< defaultEquivalence -- contramap fst defaultEquivalence 

sndEquivalence :: Equivalence (a, String) 
sndEquivalence = snd >$< defaultEquivalence 

sndEquivalence' :: Equivalence (a, String)
sndEquivalence' = (show . convertString2Int . snd) >$< defaultEquivalence

convertString2Int :: String -> Int
convertString2Int xs
  | xs == "1"   = 1
  | xs == "one" = 1
  | xs == "2"   = 2
  | xs == "two" = 2
  | otherwise   = 0

main :: IO ()
main = do
  print $ getEquivalence defaultEquivalence (1, 2) (1, 2)
  print $ getEquivalence defaultEquivalence (1, 2) (1, 3)

  print $ getEquivalence fstEquivalence (1, 2) (1, 3)
  print $ getEquivalence fstEquivalence (2, 2) (1, 3)

  print $ getEquivalence sndEquivalence (1, "1") (2, "one")
  print $ getEquivalence sndEquivalence (1, "2") (1, "two")

  print $ getEquivalence sndEquivalence' (1, "1") (2, "one")
  print $ getEquivalence sndEquivalence' (1, "2") (2, "two")

出力結果

  1. True
  2. False
  3. True
  4. False
  5. False
  6. False
  7. True
  8. True
True
False
True
False
False
False
True
True

contramapでは、型が合えば、入力の型を消費する方法（型bから型aへの変換）は問うていません。
sndEquivalence、sndEquivalence’ともに型注釈はEquivalence (a, String)となっていますが、
出力結果は異なるものとなっていることに注目しましょう。

まとめ

  • contramapを(b -> a)（第1引数）とf a（第2引数）に適用すると、f bの型の値が得られます。これはContravariant型クラスのインスタンスfに対する入力の型をaからbに変換していると見ることができます。
  • contramapの第1引数(b -> a)では、型bから型aに変換する方法は制限していません。なので、上記のsndEquivalence、sndEquivalence’のように、同一のタプル値を入力に与えても、出力結果は異なるものとなり得ます。
  • 上記のような性質から、Contravariantは「consumer of input（入力の消費者）」と表現されたりします。