feat: add 'Why Functional Programming Matters' section with README and Haskell examples, and update root README

Author: RyosukeDTomita

README.md

@@ -4,27 +4,16 @@
 
 ## INDEX
 
-- [sort](./sort/README.md)
-
 ---
 
 ## ABOUT
 
 基本アルゴリズムを学習するためのリポジトリですので途中過程など過剰なほどコメントを書いてます。
 
-
----
-
-## TARGET
-
-- 各アルゴリズムの理解を深める。
-- 計算量を意識する。
-- 言語の特性を感じる。
-
 ---
 
 ## ENVIRONMENT
 
 - python3
 - C/C++
-  そのうち rust も追加するかもしれません。
+- Haskell

WhyFunctionalProgrammingMatters/3_list.hs

@@ -0,0 +1,83 @@
+-- Haskell版
+sumList :: (Num a) => [a] -> a
+sumList [] = 0
+sumList (x : xs) = x + sumList xs
+
+-- Haskellのfoldrと同じ
+reduce' :: (a -> b -> b) -> b -> [a] -> b
+reduce' _ x [] = x
+reduce' f x (a : l) = f a (reduce' f x l)
+
+-- reduce版 sum
+sumList' :: (Num a) => [a] -> a
+sumList' xs = reduce' (+) 0 xs -- reduce'はfoldrで置き換え可能
+
+product' :: (Num a) => [a] -> a
+product' xs = reduce' (*) 1 xs
+
+-- Haskellにはandという関数がある
+allTrue :: [Bool] -> Bool
+allTrue xs = foldr (&&) True xs
+
+-- Haskellにはorという関数がある
+anyTrue :: [Bool] -> Bool
+anyTrue xs = foldr (||) False xs
+
+-- リストの連結を行う
+append' :: [a] -> [a] -> [a]
+append' xs ys = foldr (:) ys xs
+
+-- リストの中身を2倍にする
+doubleall :: (Foldable t, Num a) => t a -> [a]
+doubleall xs = foldr doubleandcons [] xs
+  where
+    doubleandcons num xs = (:) (2 * num) xs
+
+-- リストの中身を2倍にする(関数合成版)
+doubleall' :: (Foldable t, Num a) => t a -> [a]
+doubleall' xs = foldr ((:) . double) [] xs
+  where
+    double n = 2 * n
+
+-- リストの中身を2倍にする(map + 関数合成版)
+doubleall'' :: (Foldable t, Num a) => t a -> [a]
+doubleall'' xs = map' double xs
+  where
+    map' f xs = foldr ((:) . f) [] xs
+    double n = 2 * n
+
+-- 2次元配列を全部足す
+sumMatrix :: [[a]] -> a
+sumMatrix xxs = (sum . map sum) xxs
+
+main :: IO ()
+main = do
+  -- リストの定義
+  print $ 1 : (2 : (3 : [])) -- [1, 2, 3]
+
+  -- sum
+  print $ sumList [1, 2, 3] -- 1 + 2 + 3 = 6
+
+  -- reduce版
+  print $ sumList' [1, 2, 3]
+  print $ product' [1, 2, 3] -- 1 * 2 * 3 = 6
+
+  -- リストの要素が全てTrueか
+  print $ allTrue [True, True, True] -- True
+  print $ allTrue [True, True, False] -- False
+
+  -- リストの要素が一つでもTrueか
+  print $ anyTrue [True, True, True] -- True
+  print $ anyTrue [True, True, False] -- True
+  print $ anyTrue [False, False, False] -- False
+
+  -- リストの連結
+  print $ append' [1, 2, 3] [4, 5]
+
+  -- リストの中身を2倍にする
+  print $ doubleall [1, 2, 3]
+  print $ doubleall' [1, 2, 3]
+
+  -- mapの発見
+  print $ doubleall'' [1, 2, 3]
+  print $ sumMatrix [[1, 2, 3], [4, 5], [6, 7, 8, 9]]

WhyFunctionalProgrammingMatters/3_tree.hs

@@ -0,0 +1,56 @@
+-- https://www.sampou.org/haskell/article/whyfp.html より
+data Tree a = Node a [Tree a]
+
+-- 木のリストに対する畳み込み
+redtree ::
+  (a -> b -> b) -> -- f : node を潰す
+  (b -> b -> b) -> -- g : cons を潰す
+  b -> -- a : nil を潰す
+  Tree a ->
+  b
+redtree f g a (Node label subtrees) =
+  f label (redtree' f g a subtrees)
+
+-- ツリーのリストを処理する関数
+redtree' ::
+  (a -> b -> b) ->
+  (b -> b -> b) ->
+  b ->
+  [Tree a] ->
+  b
+redtree' f g a (subtree : rest) =
+  g
+    (redtree f g a subtree) -- リストのサイズが1に分解して潰す --> f label (redtree' f g a [先頭の木]) ...という流れでredtree' _ _ a [] = aにたどりつく
+    (redtree' f g a rest) -- 残りで再帰
+redtree' _ _ a [] =
+  a
+
+tree :: Tree Int
+tree =
+  Node
+    1
+    ( (:)
+        (Node 2 [])
+        ( (:)
+            ( Node
+                3
+                ((:) (Node 4 []) [])
+            )
+            []
+        )
+    )
+
+sumtree :: (Num a) => Tree a -> a
+sumtree tree = redtree (+) (+) 0 tree
+
+labels :: (Num a) => Tree a -> [a]
+labels tree = redtree (:) (++) [] tree
+
+maptree :: (a -> b) -> Tree a -> Tree b
+maptree f tree = redtree (\label subtrees -> Node (f label) subtrees) (:) [] tree
+
+main :: IO ()
+main = do
+  print $ sumtree tree -- 10
+  print $ labels tree -- [1, 2, 3, 4]
+  print $ maptree (* 2) tree