dynamic first appeared 1990 2004 2007 2012 related ML ML Lisp Lisp 🐬's note lazy/pure FPL standard OOPL in FPL's skin modern functional Lisp Erlang + Ruby + Clojure Haskell Scala Clojure Elixir 30
パブリック変数 a :: Int a = 1 -- プライベート変数 b :: Int b = 2 /* Scala */ // ( シングルトン) オブジェクト object SomeModule: // パブリック変数 val a: Int = 1 // プライベート変数 private val b: Int = 2 31
:: Int -> Int square n = n * n -- プライベート関数 double :: Int -> Int double n = n * 2 /* Scala */ object SimpleMath: // パブリックメソッド def square(n: Int): Int = n * n // プライベートメソッド private def double(n: Int): Int = n * 2 33
n n)) ;; プライベート関数 (defn- double' [n] (* n 2)) ## Elixir defmodule SimpleMath do # パブリック関数 def square(n), do: n * n # プライベート関数 defp double(n), do: n * 2 end 34
λ| -- ML 系言語でお馴染み(?) のlet 式 λ| let x = 5 λ| y = M.square(x) λ| in "square " ++ show x ++ " = " ++ show y λ| :} -- REPL での複数行入力の終了 "square 5 = 25" it :: [Char] /* Scala */ scala> val x = 5 val x: Int = 5 scala> val y = M.square(x) val y: Int = 25 scala> s"square($x) = $y" val res2: String = square(5) = 25 37
n * n) 2 8 it :: Num a => a λ> map (\n -> n * n * n) [0..10] [0,1,8,27,64,125,216,343,512,729,1000] it :: (Num b, Enum b) => [b] /* Scala */ scala> ((n: Int) => n * n * n)(2) val res0: Int = 8 scala> (0 to 10).map(n => n * n * n) val res1: IndexedSeq[Int] = Vector(0, 1, 8, 27, 64, 125, 216, 343, 512, 729, 1000) 39
Integral a => a -> a factorial 0 = 1 factorial n = n * factorial (n - 1) factorialSeq :: Integral a => [a] factorialSeq = scanl (*) 1 [1..] -- import Factorial (factorialSeq) λ> take 10 factorialSeq [1,1,2,6,24,120,720,5040,40320,362880] it :: Integral a => [a] λ> factorialSeq !! 100 9332621544394415268169923885626670049071596826438162146859296 3895217599993229915608941463976156518286253697920827223758251 185210916864000000000000000000000000 it :: Integral a => a 41
Integral a => a -> a fib 0 = 0 fib 1 = 1 fib n = fib (n - 1) + fib (n - 2) fibSeq :: Integral a => [a] fibSeq = map fst $ iterate (\(a, b) -> (b, a + b)) (0, 1) -- import Fibonacci (fibSeq) λ> take 10 fibSeq [0,1,1,2,3,5,8,13,21,34] it :: Integral a => [a] λ> take 3 $ drop 100 fibSeq [354224848179261915075,573147844013817084101, 927372692193078999176] it :: Integral a => [a] 45
化されている map :: (a -> b) -> [a] -> [b] λ> :t (+) -- 演算子もカリー化されている (+) :: Num a => a -> a -> a λ> :t (+ 1) -- \x -> x + 1 と等価( セクション記法による部分適用) (+ 1) :: Num a => a -> a λ> :t map (+ 1) -- \xs -> map (+ 1) xs と等価( 部分適用) map (+ 1) :: Num b => [b] -> [b] λ> map (+ 1) [0..9] [1,2,3,4,5,6,7,8,9,10] it :: (Num b, Enum b) => [b] λ> f x y z = x * y * z f :: Num a => a -> a -> a -> a λ> :t f 2 3 -- 2 番目の引数まで部分適用 f 2 3 :: Num a => a -> a λ> f 2 3 4 24 it :: Num a => a 54
-> x + y end と等価 &:erlang.+/2 iex(2)> &(&1 + 1) # fn x -> x + 1 end と等価( 部分適用) #Function<42.81571850/1 in :erl_eval.expr/6> iex(3)> Enum.map(0..9, &(&1 + 1)) [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] iex(4)> f = fn x -> fn y -> fn z -> x * y * z end end end #Function<42.81571850/1 in :erl_eval.expr/6> iex(5)> f.(2).(3) # 2 番目の引数まで部分適用 #Function<42.81571850/1 in :erl_eval.expr/6> iex(6)> f.(2).(3).(4) 24 57
upper = sum (takeWhile (<= upper) (filter even (drop 2 fibSeq))) sumOfEvenFibs :: Integral a => a -> a λ> :{ λ| sumOfEvenFibs' upper = sum λ| $ takeWhile (<= upper) -- f $ x = f x λ| $ filter even -- ( 関数適用演算子) λ| $ drop 2 fibSeq λ| :} sumOfEvenFibs' :: Integral a => a -> a λ> sumOfEvenFibs' 4000000 4613732 it :: Integral a => a #2 Even Fibonacci Numbers - Project Euler 58
=> a -> [a] -> a λ| sumOfEvenNums upper = sum λ| . takeWhile (<= upper) -- f . g = \x -> f (g x) λ| . filter even -- ( 関数合成演算子) λ| :} sumOfEvenNums :: Integral a => a -> [a] -> a λ> sumOfEvenNums 4000000 $ drop 2 fibSeq 4613732 it :: Integral a => a 59
-- ( 連結) リスト [1, 2, 3] :: Num a => [a] λ> 0 : [1, 2, 3] -- 先頭に要素追加(cons) [0,1,2,3] it :: Num a => [a] λ> import qualified Data.Vector as V λ> :t V.fromList [1, 2, 3] -- ベクター( 可変長配列) V.fromList [1, 2, 3] :: Num a => V.Vector a λ> V.snoc (V.fromList [1, 2, 3]) 4 -- 末尾に要素追加(snoc) [1,2,3,4] it :: Num a => V.Vector a 71
[1..2], y <- [1..9]] -- リスト内包表記 [1,2,3,4,5,6,7,8,9,2,4,6,8,10,12,14,16,18] it :: (Enum a, Num a) => [a] λ> :{ λ| do -- do 記法(a.k.a. モナド内包表記) λ| x <- [1..2] λ| y <- [1..9] λ| return $ x * y λ| :} [1,2,3,4,5,6,7,8,9,2,4,6,8,10,12,14,16,18] it :: (Num b, Enum b) => [b] λ> :{ λ| do -- Maybe, Either など任意のモナドで利用できる λ| x <- Just 2 λ| y <- Just 3 λ| return $ x * y λ| :} Just 6 it :: Num b => Maybe b 73
| x <- 1 to 2 | y <- 1 to 9 | yield x * y val res8: IndexedSeq[Int] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 2, 4, 6, 8, 10, 12, 14, 16, 18) scala> for // Option, Either などflatMap/map を備えた型で利用できる | x <- Some(2) | y <- Some(3) | yield x * y val res9: Option[Int] = Some(6) 76
a -- 代数的データ型の定義 λ| = Leaf !a λ| | Branch { left :: !(Tree a) λ| , right :: !(Tree a) λ| } λ| deriving (Show, Eq) λ| :} type Tree :: * -> * data Tree a = ... left :: Tree a -> Tree a right :: Tree a -> Tree a 83
(Branch (Leaf 2) (Leaf 3))) (Leaf 4) t :: Num a => Tree a [Prelude] λ> left t Branch {left = Leaf 1, right = Branch {left = Leaf 2, right = Leaf 3}} it :: Num a => Tree a λ> right t Leaf 4 it :: Num a => Tree a λ> :{ λ| size :: Tree a -> Int λ| size (Leaf _) = 1 -- 関数の引数でのパターンマッチ λ| size (Branch l r) = 1 + size l + size r λ| :} size :: Tree a -> Int λ> size t 7 it :: Int 84
def size: Int = tree match | case Leaf(_) => 1 | case Branch(l, r) => 1 + l.size + r.size | def size[A](tree: Tree[A]): Int scala> t.size val res2: Int = 7 86
by need λ> f x y = if x > 0 then x else y f :: (Ord a, Num a) => a -> a -> a -- 引数y にアクセスされなければエラーが生じない λ> f 1 (2 `div` 0) 1 it :: Integral a => a λ> f 0 (2 `div` 0) *** Exception: divide by zero -- bang pattern を利用した関数の定義: call by value λ> g !x !y = if x > 0 then x else y g :: (Ord a, Num a) => a -> a -> a -- 引数x, y は直ちに評価される λ> g 1 (2 `div` 0) *** Exception: divide by zero 95
{ l :: Int, r :: Int } ... -- r にアクセスしなければエラーが生じない λ> l $ Pair 1 (2 `div` 0) 1 it :: Int λ> r $ Pair 1 (2 `div` 0) *** Exception: divide by zero -- 値コンストラクタに正格性フラグを利用したデータ型の定義 λ> data Pair' = Pair' { l :: !Int, r :: !Int } ... -- r にアクセスしなくてもエラーが生じる λ> l $ Pair' 1 (2 `div` 0) *** Exception: divide by zero 97
iex(1)> defmodule Some do ...(1)> def f(x, y) do ...(1)> if x > 0, do: x, else: y ...(1)> end ...(1)> end {:module, Some, ...} # 引数x, y は直ちに評価される iex(2)> Some.f(1, 2 / 0) ** (ArithmeticError) bad argument in arithmetic expression... 103
2] # 3 番目の要素にアクセスしなければエラーが生じない iex(8)> 1..3 |> Stream.map(fn n -> if n < 3, do: n, else: n / 0 end) |> Enum.at(2) ** (ArithmeticError) bad argument in arithmetic expression... iex(9)> 1..3 |> Stream.map(fn n -> if n < 3, do: n, else: n / 0 end) |> Enum.take(2) [1, 2] 105
-- 型クラスのインスタンスの定義 λ| surfaceArea (Cuboid a b c) = λ| 2 * (a * b + b * c + c * a) λ| volume (Cuboid a b c) = λ| a * b * c λ| λ| instance Solid Sphere where λ| surfaceArea (Sphere r) = λ| 4 * pi * r ^ 2 λ| volume (Sphere r) = λ| 4 / 3 * pi * r ^ 3 λ| :} 116
(a: A) | def surfaceArea: Double | def volume: Double | // defined trait Solid2 scala> case class Cuboid2( | a: Double, | b: Double, | c: Double, | ) // defined case class Cuboid2 scala> case class Sphere2(r: Double) // defined case class Sphere2 118
[a b c]}] (* 2 (+ (* a b) (* b c) (* c a)))) (volume [{:keys [a b c]}] (* a b c)) Sphere (surface-area [{:keys [r]}] (* 4 Math/PI (Math/pow r 2))) (volume [{:keys [r]}] (* 4/3 Math/PI (Math/pow r 3)))) nil 122
...(4)> def surface_area(%Cuboid{a: a, b: b, c: c}) do ...(4)> 2 * (a * b + b * c + c * a) ...(4)> end ...(4)> def volume(%Cuboid{a: a, b: b, c: c}) do ...(4)> a * b * c ...(4)> end ...(4)> end {:module, Solid.Cuboid, ...} iex(5)> defimpl Solid, for: Sphere do ...(5)> def surface_area(%Sphere{r: r}) do ...(5)> 4 * :math.pi() * r ** 2 ...(5)> end ...(5)> def volume(%Sphere{r: r}) do ...(5)> 4 / 3 * :math.pi() * r ** 3 ...(5)> end ...(5)> end {:module, Solid.Sphere, ...} 125
は? id :: a -> a -- 型a λ> id 42 -- id を数値に適用したとき 42 it :: Num a => a -- 型クラスNum の制約付きの型a λ> :t Just -- 1 引数の値コンストラクタJust Just :: a -> Maybe a λ> :t Just 42 -- Just を数値に適用したとき Just 42 :: Num a => Maybe a λ> :t Nothing -- 0 引数の値コンストラクタNothing Nothing :: Maybe a -- cf. 型Maybe a の定義( 抜粋) data Maybe a = Nothing | Just a 127
Maybe :: * -> * -- 型レベルでの関数に相当 λ> :k Num a => Maybe a -- Maybe を型a に適用したとき Num a => Maybe a :: * -- 型レベルでの値に相当 λ> :k Functor -- 型クラスFunctor Functor :: (* -> *) -> Constraint -- 型レベルでの高階関数に相当 λ> :k Functor Maybe -- Functor をMaybe に適用したとき Functor Maybe :: Constraint -- cf. 型クラスFunctor の定義( 抜粋) class Functor f where fmap :: (a -> b) -> f a -> f b 128
val res0: [A] => (x: A) => A = Lambda/0x00002000015018d8@3... scala> identity(42) val res1: Int = 42 scala> [A] => (x: A) => Some(x) val res2: [A] => (x: A) => Some[A] = Lambda/0x000020000150... scala> val x: Option[Int] = Some(42) // Some はOption の派生型 val x: Option[Int] = Some(42) scala> val y: Option[Int] = None // None はOption の派生型 val y: Option[Int] = None scala> val z: Option[Any] = x // 型パラメータA は共変(covariant) val z: Option[Any] = Some(42) // cf. 関数identity の定義( 抜粋) def identity[A](x: A): A = x // cf. 型Option[+A] の定義( 抜粋) sealed abstract class Option[+A] extends IterableOnce[A] with Product with Serializable final case class Some[+A](value: A) extends Option[A] case object None extends Option[Nothing] 130
lagenorhynque
kentaroutakeda
shimomura
teba_eleven
irof
syumai
.png){kind=avatar}
takahirom
lnit
javiergs
rebase_engineering
v0lka
nekoya3
masahiro_nishimi
colly
kastner
soudai
keathley
danielanewman
zakiyama
3n
garrettdimon
destraynor
sergeychernyshev
stephaniewalter
mongodb
![[ 参考] 🐬の関数型言語学習/ 利用経験 Most Used Languages Clojure 42.14% Haskell](https://files.speakerdeck.com/presentations/e8fe6ea3c59c4c9c9f4efc7f8ffe3783/slide_2.jpg){kind=link}
![;;; Clojure (ns simple-math) ;; パブリック関数 (defn square [n] (*](https://files.speakerdeck.com/presentations/e8fe6ea3c59c4c9c9f4efc7f8ffe3783/slide_33.jpg){kind=link}
![;;; Clojure user=> ((fn [n] (* n n n ))](https://files.speakerdeck.com/presentations/e8fe6ea3c59c4c9c9f4efc7f8ffe3783/slide_39.jpg){kind=link}
![;;; Clojure (ns factorial) (defn factorial [n] (if (zero? n)](https://files.speakerdeck.com/presentations/e8fe6ea3c59c4c9c9f4efc7f8ffe3783/slide_42.jpg){kind=link}
![;;; Clojure (ns fibonacci) (defn fib [n] (case n 0](https://files.speakerdeck.com/presentations/e8fe6ea3c59c4c9c9f4efc7f8ffe3783/slide_46.jpg){kind=link}
![[PR] のグッズ👕 関数型まつり 公式オンラインストア 49](https://files.speakerdeck.com/presentations/e8fe6ea3c59c4c9c9f4efc7f8ffe3783/slide_48.jpg){kind=link}
![/* Scala */ scala> extension (nums: Seq[BigInt]) // 拡張メソッドの定義 |](https://files.speakerdeck.com/presentations/e8fe6ea3c59c4c9c9f4efc7f8ffe3783/slide_60.jpg){kind=link}
![/* Scala */ scala> def sumOfEvenNums2(upper: BigInt)(nums: Seq[BigInt]): BigInt =](https://files.speakerdeck.com/presentations/e8fe6ea3c59c4c9c9f4efc7f8ffe3783/slide_61.jpg){kind=link}
![;;; Clojure: (require '[fibonacci :refer [fib-seq]]) user=> (defn sum-of-even-fibs [upper]](https://files.speakerdeck.com/presentations/e8fe6ea3c59c4c9c9f4efc7f8ffe3783/slide_62.jpg){kind=link}
![;;; Clojure user=> (defn sum-of-even-fibs'' [upper] (transduce ;; 関数合成関数comp でトランスデューサー(transducer)](https://files.speakerdeck.com/presentations/e8fe6ea3c59c4c9c9f4efc7f8ffe3783/slide_63.jpg){kind=link}
![## Elixir: import Fibonacci, only: [fib_seq: 0] iex(2)> require Integer](https://files.speakerdeck.com/presentations/e8fe6ea3c59c4c9c9f4efc7f8ffe3783/slide_64.jpg){kind=link}
![標準の不変/ 永続コレクション {- Haskell -} λ> :t [1, 2, 3]](https://files.speakerdeck.com/presentations/e8fe6ea3c59c4c9c9f4efc7f8ffe3783/slide_70.jpg){kind=link}
![## Elixir iex(1)> i [1, 2, 3] # ( 連結)](https://files.speakerdeck.com/presentations/e8fe6ea3c59c4c9c9f4efc7f8ffe3783/slide_79.jpg){kind=link}
![## Elixir iex(5)> i MapSet.new([1, 2, 3]) # セット Term](https://files.speakerdeck.com/presentations/e8fe6ea3c59c4c9c9f4efc7f8ffe3783/slide_80.jpg){kind=link}
![/* Scala */ scala> enum Tree[+A]: // 代数的データ型の定義 | case](https://files.speakerdeck.com/presentations/e8fe6ea3c59c4c9c9f4efc7f8ffe3783/slide_84.jpg){kind=link}
 // 拡張メソッドの定義 |](https://files.speakerdeck.com/presentations/e8fe6ea3c59c4c9c9f4efc7f8ffe3783/slide_85.jpg){kind=link}
![;;; Clojure user=> (defrecord Leaf [value]) ; レコードの定義 user.Leaf user=>](https://files.speakerdeck.com/presentations/e8fe6ea3c59c4c9c9f4efc7f8ffe3783/slide_86.jpg){kind=link}
![{- Haskell -} -- 無限に続く整数のリストから先頭3 要素を取り出す λ> take 3 [0..]](https://files.speakerdeck.com/presentations/e8fe6ea3c59c4c9c9f4efc7f8ffe3783/slide_95.jpg){kind=link}
![;;; Clojure user=> (defn inspect [v i s] (println (str](https://files.speakerdeck.com/presentations/e8fe6ea3c59c4c9c9f4efc7f8ffe3783/slide_106.jpg){kind=link}
![/* Scala */ scala> trait Solid2[A]: // 型クラスの定義 | extension](https://files.speakerdeck.com/presentations/e8fe6ea3c59c4c9c9f4efc7f8ffe3783/slide_117.jpg){kind=link}
![/* Scala */ scala> given Solid2[Cuboid2] with // 型クラスのインスタンスの定義 |](https://files.speakerdeck.com/presentations/e8fe6ea3c59c4c9c9f4efc7f8ffe3783/slide_118.jpg){kind=link}
: Map[String, Double]](https://files.speakerdeck.com/presentations/e8fe6ea3c59c4c9c9f4efc7f8ffe3783/slide_119.jpg){kind=link}
![;;; Clojure user=> (defprotocol Solid ; プロトコルの定義 (surface-area [this]) (volume](https://files.speakerdeck.com/presentations/e8fe6ea3c59c4c9c9f4efc7f8ffe3783/slide_120.jpg){kind=link}
![;;; Clojure user=> (defn solid-props [x] {:surface-area (surface-area x) :volume](https://files.speakerdeck.com/presentations/e8fe6ea3c59c4c9c9f4efc7f8ffe3783/slide_122.jpg){kind=link}
![/* Scala */ scala> [A] => (x: A) => identity(x)](https://files.speakerdeck.com/presentations/e8fe6ea3c59c4c9c9f4efc7f8ffe3783/slide_129.jpg){kind=link}
![/* Scala */ // 型クラスFunctor の定義 scala> trait Functor[F[_]]: |](https://files.speakerdeck.com/presentations/e8fe6ea3c59c4c9c9f4efc7f8ffe3783/slide_130.jpg){kind=link}
