Merge pull request #13 from RyosukeDTomita/feature/WhyFunctionalProgramingMatters

feature/WhyFunctionalProgramingMatters

Author: RyosukeDTomita

.envrc

@@ -0,0 +1 @@
+use flake

.gitignore

@@ -1,2 +1,29 @@
 # all .out files
 *.out
+input.txt
+inputs.txt
+.direnv/
+# https://github.com/github/gitignore/blob/main/Haskell.gitignore
+dist
+dist-*
+cabal-dev
+*.o
+*.hi
+*.hie
+*.chi
+*.chs.h
+*.dyn_o
+*.dyn_hi
+.hpc
+.hsenv
+.cabal-sandbox/
+cabal.sandbox.config
+*.prof
+*.aux
+*.hp
+*.eventlog
+.stack-work/
+cabal.project.local
+cabal.project.local~
+.HTF/
+.ghc.environment.*

.vscode/settings.json

@@ -12,9 +12,11 @@
     "editor.defaultFormatter": "haskell.haskell",
     "editor.formatOnSave": true
   },
-  "haskell.manageHLS": "GHCup",
+  "haskell.manageHLS": "PATH", // nix
   "haskell.formattingProvider": "ormolu",
-  "haskell.ghcupExecutablePath": "~/.ghcup/bin/ghcup",
+  "haskell.ghcupExecutablePath": "",
+  "haskell.upgradeGHCup": false,
+  "haskell.serverExecutablePath": "haskell-language-server",
   "github.copilot.enable": {
     "haskell": false
   },
@@ -27,5 +29,5 @@
     "unlines",
     "zipWith",
     "elems"
-  ]
-}
+  ],
+}

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,59 @@
+-- https://www.sampou.org/haskell/article/whyfp.html より
+-- Tree aはラベルaと自分自身(Tree a)のリストを持つデータ構造
+-- つまり木の構造を表す
+-- Node 1 [Node 2 [], Node 3 [Node 4 []]]
+data Tree a = Node a [Tree a] deriving (Show)
+
+-- 木のリストに対する畳み込み
+redtree ::
+  (a -> c -> b) -> -- f : node を潰す
+  (b -> c -> c) -> -- g : cons を潰す
+  c -> -- a : nil を潰す
+  Tree a ->
+  b
+redtree f g a (Node label subtrees) =
+  f label (redtree' f g a subtrees)
+
+-- ツリーのリストを処理する関数
+redtree' ::
+  (a -> c -> b) ->
+  (b -> c -> c) ->
+  c ->
+  [Tree a] ->
+  c
+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
+
+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 (Node . f) (:) [] tree
+
+tree :: Tree Int
+tree =
+  Node
+    1
+    ( (:)
+        (Node 2 [])
+        ( (:)
+            ( Node
+                3
+                ((:) (Node 4 []) [])
+            )
+            []
+        )
+    )
+
+main :: IO ()
+main = do
+  print $ sumtree tree -- 10
+  print $ labels tree -- [1, 2, 3, 4]
+  print $ maptree (* 2) tree

math/newton/newtonRoot.hs …ionalProgrammingMatters/4_1newtonRoot.hsmath/newton/newtonRoot.hs renamed to WhyFunctionalProgrammingMatters/4_1newtonRoot.hs math/newton/newtonRoot.hs renamed to WhyFunctionalProgrammingMatters/4_1newtonRoot.hs

@@ -0,0 +1,4 @@
+main :: IO ()
+main = do
+  print $ (\input -> (+ 1) ((* 2) input)) 3 -- lambda式版
+  print $ ((+ 1) . (* 2)) 3 -- 関数合成のほうが完結に書ける 3*2+1