Help us understand the problem. What is going on with this article?

Maybe自作から学ぶHaskell!

More than 1 year has passed since last update.

haskell Advent Calendar 2017に参加しました!!
https://qiita.com/advent-calendar/2017/haskell3

はい、というわけで! 初心者ですが頑張って書きます!

やること

説明を交えながら、Maybeを自作していく。
型クラスもやる。

なぜMaybeを自作しようと思ったのか。

Haskellを理解するには、実際に何らかの既存の型を自作してみて、体に馴染ませていくのが良いと思ったからである。

Maybeとは

Maybeは標準で使える代数データ型の一つであり、何らかの計算が成功・失敗したかを安全に扱える便利なやつである。
計算が成功すると、Just <計算結果>を返し、
失敗なら、Nothingを返す。

Maybeの代数データ型を定義してみる

というわけで、オリジナルのMaybe型を定義しよう。
名前は…うーん……Elipmocで!!
data Elipmoc a = Bat | Good a
実際に使用してみよう。

data Elipmoc a = Bat | Good a 

main::IO()
main = do
    print . Good $ 2
    print . Good $ "hogehoge"
    print (Bat::Elipmoc Int)

ファイル名はMain.hsにした
コンパイルはめんどいのでrunghcで直接実行する。
$ stack runghc Main.hs
実行結果

Main.hs:5:5: error:
    ? No instance for (Show (Elipmoc a0)) arising from a use of ‘print’
    ? In the first argument of ‘(.)’, namely ‘print’
      In the expression: print . Good
      In a stmt of a 'do' block: print . Good $ 2
以下略

おっとエラーになってしまったぞ。

derivingしよう

先程の例のprint関数は内部でshow関数を使っている。
Show型クラスはオブジェクトから文字列を返すshow関数を定義しており。
ElipmocはShow型クラスのインスタンスでないので、show関数が使えずエラーとなった。
とりあえず、Maybeが持つ型クラスを調べてみることにしよう。
REPLを使用する。

$ stack ghci

―略―

Prelude> :i Maybe
data Maybe a = Nothing | Just a         -- Defined in ‘GHC.Base’
instance Eq a => Eq (Maybe a) -- Defined in ‘GHC.Base’
instance Monad Maybe -- Defined in ‘GHC.Base’
instance Functor Maybe -- Defined in ‘GHC.Base’
instance Ord a => Ord (Maybe a) -- Defined in ‘GHC.Base’
instance Read a => Read (Maybe a) -- Defined in ‘GHC.Read’
instance Show a => Show (Maybe a) -- Defined in ‘GHC.Show’
instance Applicative Maybe -- Defined in ‘GHC.Base’
instance Foldable Maybe -- Defined in ‘Data.Foldable’
instance Traversable Maybe -- Defined in ‘Data.Traversable’
instance Monoid a => Monoid (Maybe a) -- Defined in ‘GHC.Base’

Maybe型の持つ型クラスがずらずら列挙された。
この内Eq,Ord,Read,Showはderivingを使って自動でインスタンスにできるので、早速やってみる。

修正後のコード

data Elipmoc a = Bat | Good a deriving (Eq,Ord,Read,Show)

main::IO()
main = do
    print . Good $ 2
    print . Good $ "hogehoge"
    print (Bat::Elipmoc Int)

実行結果

$ stack runghc Main.hs
Good 2
Good "hogehoge"
Bat

うん、ちゃんとできた。
ついでに、Eq,Ord,Readについても確かめてみよう。
その前に各種型クラスの説明をすこしだけ。

Eqは==と/=演算子が定義されていて、
等しいかどうかを調べることができる型クラスだ。

OrdはEqを継承した型クラスであり、
<と<=と>と>=演算子を定義されていて、
大小比較ができる型クラスだ。

ReadはShowクラスとは逆で、
文字列からオブジェクトを構成するread関数が定義されている。

Eq,Ord,Readも試してみよう。

data Elipmoc a = Bat | Good a deriving (Eq,Ord,Read,Show)

main::IO()
main = do
    print (Good 2 == Good 2)
    print (Good 5 /= Good 5)
    print (Good 20 > Good 2)
    print $ Good 20 < Good 8
    print $ (read "Bat"::Elipmoc Int)
    print $ (read "Good 35"::Elipmoc Int)

実行結果

True
False
True
False
Bat
Good 35

Monoid実装

Monoidは二項演算の型クラスである。

定義を示す

class Monoid a where
    mempty :: a 
    mappend :: a -> a -> a 
    mconcat :: [a] -> a
    mconcat = foldr mappend mempty

memptyは単位元を返す関数で、
mappendは2つの値を結合して1つの値にする関数だ。
例としてリストで説明しよう。
リストには++という二項演算子がある。
この演算子は
( ( [1]++[2] )++[3] )
でも
( [1]++( [2]++[3] ) )
でも
結果は[1,2,3]であり、どの順番で計算しても問題無いことがわかる。
このような性質をMonoidと呼び、
haskellではMonoid型クラスのインスタンスにすることができる。
このとおり、リストはMonoid型クラスのインスタンスであるので、
上記のコードをMonoid型クラスのmappendで書き換えることができる。
[1] `mappend` [2] `mappend` [3]
このように、リストでmappendを使うと++演算子と同じ働きをする。
Monoidになるためにはさらにもう一つ条件があり、それは単位元が定義できることだ。
単位元とは、a `mappend` e → a を満たすeがあることである。
例えばリストの単位元は[]である。
[1]++[] → [1] 
ほらね。
Monoid型クラスではmemptyとして定義されている。
上記をmemptyで書き換えると
[1] `mappend` mempty → [1]

で、MaybeもMonoidのインスタンスなので
Elipmocにも実装してみよう!

ではElipmocをMonoidのインスタンスにしてみよう。

instance Monoid a => Monoid (Elipmoc a) where
    mempty = Bat
    Bat `mappend` m = m
    m `mappend` Bat = m
    Good m1 `mappend` Good m2 = Good (m1 `mappend` m2)

mconcatはデフォルトで実装されているので、
実装する必要はない。

では実際に使用してみよう。

main::IO()
main = do
    print (Good [5] `mappend` Good [4])
    print (Bat `mappend` Good [3])
    print (Good [2] `mappend` Bat)

実行結果

Good [5,4]
Good [3]
Good [2]

Functorを作ろう

Functorの定義を示す。

class  Functor f  where
    fmap        :: (a -> b) -> f a -> f b
    (<$)        :: a -> f b -> f a
    (<$)        =  fmap . const

Functorには、mapという関数が定義されている。
例えば、
f x = 2*x という関数があったとして、
f (Just 5) のように値を渡すことはできない。5はJustで包まれているからだ。
こういうときにfmapを使うと
fmap f (Just 5) というふうに書くことができる。
fmapはfで包まれたaを取り出して、関数(a->b)に渡して加工して、加工したbを再びf型に包むという操作を行う。
さらにもう一つ、Functorには<$という演算子が定義されている。
<$の左辺には任意の型aを、右辺にはf型で包まれているbを渡す。
そうすると、左辺のaを右辺のf型で包んだaを返す。右辺の値は捨てられる。
例を挙げる。
176 <$ Just 810
右辺はMaybeで包まれているので、Just 176が返り、Just 810は捨てられる。

では、サクッと実装しますね。
<$はデフォルトで実装されるので自分で定義する必要はありません。

instance Functor Elipmoc where
    fmap _ Bat = Bat
    fmap f (Good a) = Good (f a)

プログラム例

main::IO()
main = do
    print ( fmap (\x->[4+x]) (Good 5))
    print ( fmap (\x->[4+x]) (Bat))

このようにfmapに加工する関数を渡すと、Elipmocの中身を取り出し加工して再び包んで返す。

実行結果

Good [9]
Bat

Applicativeを作ろう

Applicativeの実装を示す。

class Functor f => Applicative f where
    pure :: a -> f a

    (<*>) :: f (a -> b) -> f a -> f b

    liftA2 :: (a -> b -> c) -> f a -> f b -> f c
    liftA2 f x = (<*>) (fmap f x)

    (*>) :: f a -> f b -> f b
    a1 *> a2 = (id <$ a1) <*> a2

    (<*) :: f a -> f b -> f a
    (<*) = liftA2 const

pure関数は任意のa型の値を受け取って、それをfの型で包んで返します。
<*>演算子はfで包まれた左辺f(a->b)と任意の型aの右辺を受け取り、左辺の中身の関数(a->b)に、右辺の中身bを引数として渡し、結果をfで包んで返します。
<*演算子は左辺と右辺を受け取り、右辺を捨てて左辺を返す。
*>演算子は左辺を捨てて右辺を返す。
あと<$>演算子も紹介しよう。
<$>の定義を示す。

(<$>) :: Functor f => (a -> b) -> f a -> f b
(<$>) = fmap

<$>演算子は<*>ととても似ていて、違いは左辺がfで包まれていないだけである。
というか、ただのfmapである。
これらを使うことで見やすいコードを書くことができる。(投げやり)
じゃあ型クラス作りましょう。

instance Applicative Elipmoc where
    pure a = Good a
    (<*>) (Good f) x = fmap f x
    (<*>) Bat _ = Bat 

サンプルコード

func x y= x+y

main::IO()
main = do
    print ( func <$> Bat <*> Good 2)
    print ( func <$> Good 5 <*> Good 3 <* Good 2)
    print ( func <$> Good 5 <*> Good 3 <* Bat)

実行結果

Bat
Good 8
Bat

Monadを作ろう

どんどん作っていきます

Monadの定義を示す

class Applicative m => Monad m where
    (>>=)       :: m a -> (a -> m b) -> m b

    (>>)        :: m a -> m b -> m b
    m >> k = m >>= \_ -> k

    return      :: a -> m a
    return      = pure

Monadを使うことで、複数の処理を連結させて、1つの処理にまとめることができる。

ElipmocをMonadのインスタンスにする。

instance Monad Elipmoc where
    (Good x) >>= k = k x
    Bat  >>= _ = Bat

    (Good _) >> k = k
    Bat  >>  _ = Bat

    return = Good
    fail _ = Bat

サンプルコード

func 0= Bat
func x= return (x*10)

func2 = return (931::Int)

main::IO()
main = do
    print ( Good 2 >>= func)
    print ( Good 0 >>= func)
    print ( Good 1 >>= func >>= func)
    print ( Good 32 >> func2)

計算結果

Good 20
Bat
Good 100
Good 931

この記事を書いた感想

うん。正直どこまで説明を細かく書くべきかわからず苦しんだよ。
モナドについてはもはや説明という説明すらない。
途中で、あれ?これ定義を書いとけば日本語でいちいち説明する必要なくね?と思ったからだ。

Why not register and get more from Qiita?
  1. We will deliver articles that match you
    By following users and tags, you can catch up information on technical fields that you are interested in as a whole
  2. you can read useful information later efficiently
    By "stocking" the articles you like, you can search right away
Comments
Sign up for free and join this conversation.
If you already have a Qiita account
Why do not you register as a user and use Qiita more conveniently?
You need to log in to use this function. Qiita can be used more conveniently after logging in.
You seem to be reading articles frequently this month. Qiita can be used more conveniently after logging in.
  1. We will deliver articles that match you
    By following users and tags, you can catch up information on technical fields that you are interested in as a whole
  2. you can read useful information later efficiently
    By "stocking" the articles you like, you can search right away