なっとく！関数型プログラミング　を読んで関数型プログラミングを学んだ

[EDOCODE](https://www.edocode.co.jp/)でエンジニアをしているYutakaです。

- こちらは社内勉強会で発表した資料を元にしています。

- 関数型言語の知識がほとんどないエンジニアが[なっとく！関数型プログラミング](https://www.shoeisha.co.jp/book/detail/9784798179803)で学んだ用語を一部まとめました。原著は[Grokking Functional Programming](https://michalplachta.com/book/)です。本書はScalaとJavaで説明がされていますが、できる限り社内で使われている言語(Go, JavaScript, TypeScript)でサンプルコードを記載しました。

- 書籍のソースコードは[こちら](https://github.com/miciek/grokkingfp-examples)に全て公開されています。　

# そもそも関数型プログラミングとは?

プログラミングのパラダイムには大きく①命令型プログラミング②宣言型プログラミングがあります。

①命令型プログラミングとは
どのよう(**HOW**)に計算するかに焦点を合わせ、段階的なアルゴリズムを詳細に定義します。これは実際のハードウェアの計算処理の流れに沿っています。


②宣言型プログラミングとは
どのように計算をするかではなく何(**WHAT**)を行うかに焦点を当てています。

また①命令型プログラミングの中には
- 手続型プログラミング
- 構造化プログラミング
- オブジェクト指向プログラミング

②宣言型プログラミングの中には
- 関数型プログラミング
- 論理プログラミング

などがあります。
 
具体的な違いを知るため、下記は`scala`という文字が入っている本のタイトルを取り出す処理を①命令型と②宣言型で書いたものです。

```javascript
// [JavaScript] ①命令型 と ②宣言型 の比較

class Book {
  constructor(title, authors) {
    this.title = title;
    this.authors = authors;
  }
}

const books = [
  new Book("Functional Programming in Scala", ["Paul Chiusano", "Runar Bjarnason"]),
  new Book("Grokking Machine Learning", ["Luis G. Serrano"]),
  new Book("Rust Servers, Services, and Apps", ["Prabhu Eshwarla"])
];

// ①命令型
let imperativeScalaBooks = [];
for (let i = 0; i < books.length; i++) {
  if (books[i].title.toLowerCase().includes('scala')) {
    imperativeScalaBooks.push(books[i].title);
  }
}
console.log(imperativeScalaBooks); // ["Functional Programming in Scala"]

// ②宣言型
const declarativeScalaBooks = books
  .filter(book => book.title.toLowerCase().includes('scala'))
  .map(book => book.title);

console.log(declarativeScalaBooks); // ["Functional Programming in Scala"]
```

UIの①命令型と②宣言型の比較はReact公式が出している[宣言型 UI と命令型 UI の比較](https://ja.react.dev/learn/reacting-to-input-with-state)がわかりやすいです。

関数型言語は数学の関数の考え方を使い、関数型プログラミングを行える言語です。社内のプロダクト開発で使われている言語(Perl, Go, JavaScript, TypeScriptなど)はマルチパラダイム(①命令型と②宣言型)をサポートしている言語です。一方でSQLは②宣言型に該当します。

# 関数型プログラミングを知るメリット

以下のものがあると感じました。

1. 命令型と宣言型（関数型プログラミング）の二つの違う視点でコーディングを行うことが出来るようになる

1. 普段使っているフレームワークにも宣言型(関数型)の考えが根底になっているものが多くあり、学習や理解が早くなる
EX: フロントフレームワーク(React, Vue), バックエンドフレームワーク(echoの[middleware](https://echo.labstack.com/docs/cookbook/middleware)), モバイルのUIフレームワーク(SwiftUI, Jetpack Compose)


# 具体的に関数型プログラミングとは？

書籍には次を満たす小さな関数を組み合わせて行うプログラミングのことだと説明がありました。

A. シグニチャが "嘘" をつかない
B. 関数本体が宣言的

それぞれ詳しく見ていきます。

## A. シグニチャ が "嘘" をつかない　とは？

関数の[シグニチャ](https://developer.mozilla.org/ja/docs/Glossary/Signature/Function)は関数名、引数、戻り値を含めたものでTypeScriptやGoだと

```typescript
// TypeScript
function increment(num: number): number
```

```go
// Go
func increment(num int) int
```

の部分がシグニチャに該当します。


### シグニチャが"嘘"をつく3つのケース

**"嘘"** とは具体的に下記のケースの場合です。

① 関数が既存の値を変更する(サイドエフェクトがある)
② null(やnil)を返す
③ エラーをthrowする

これらに関してそれぞれ見ていきます。

#### ①関数が既存の値を変更する(サイドエフェクトがある)

関数が既存の値を変更することを[サイドエフェクト](https://en.wikipedia.org/wiki/Side_effect_(computer_science))があると言います。具体的には　API呼び出し、global変数の変更、DB操作などがあります。

サイドエフェクトの例を下記の２つのサンプルコードで説明します。

- サイドエフェクトの例①

```javascript
// [JavaScript] サイドエフェクトの例①

function replaceFirstElement(list, newItem) {
    list[0] = newItem; // <-　　originalListを変更している
    return list;
}

let originalList = [1,2,3,4] // mutable
newList = replaceFirstElement(originalList, "A")

console.log(newList)         // ['A', 2, 3, 4]
console.log(originalList)    // ['A', 2, 3, 4]
```

問題点: 関数の引数(変数`originalList`)を変更している


- サイドエフェクトの例②

```javascript
// [JavaScript] サイドエフェクトの例②

let count = 0; // mutableなグローバル変数

function incrementCounter() {
  count += 1; // <- グローバル変数(count)を変更している
  console.log(`Count is now: ${count}`);
}
```

問題点: 引数にはないグローバル変数`count`を変更している


このような問題に対して関数型言語では基本的にimmutable(変更不可)なデータ型を使います。上記のサイドエフェクトの例①　をScalaで実装すると下記のようになります。Scalaの[`List`](https://www.scala-lang.org/api/current/scala/collection/immutable/List.html)はimmutableのため`originalList`の値は変わりません。

```scala
// [Scala] List(immutable)の例

def replaceFirstElement[A](list: List[A], newItem: A): List[A] = {
  list match {
    case Nil =>
      List(
        newItem
      )
    case _ :: tail =>
      newItem :: tail
  }
}

val originalList = List(1, 2, 3, 4) // immutable list
val newList = replaceFirstElement(originalList, "A")

println(newList)      // List(A, 2, 3, 4)
println(originalList) // List(1, 2, 3, 4)

```

#### ②null(やnil)を返す

戻り値からnilを返すかわからない場合、ヌルポインタが返ってくる可能性があります。そのため、正しく処理をしないとプログラムが実行時にエラーを起こしランタイムエラーが起こる可能性があります。


該当のユーザーがないときにnilが返ってくる関数の例(Go)は下記です([playground](https://play.golang.com/p/BlUjy-tpX5l))。サンプルコードをわかりやすくするため、**②null(やnil)を返す**と**③エラーをthrowする**では同じ処理を違う言語や書き方で記載しています。

```golang
// [Go] ランタイムエラーが起こる例(User取得)

package main

import (
	"fmt"
)

type User struct {
	Name string
}

func getUser(found bool) *User {
	if !found {
		// userが見つからなかったらnilポインタを返す
		return nil
	}
	// userが見つかったら新しいユーザーへのポインタを返す
	return &User{Name: "John Doe"}
}

func main() {
	user := getUser(false) // nilを返すためにfalseを渡す

	fmt.Println(user.Name)
	// -> panic: runtime error: invalid memory address or nil pointer dereference
}
```
問題点: 実行時にpanicが起こる

この問題に対して関数型言語では[Option型](https://ja.wikipedia.org/wiki/Option%E5%9E%8B)を使います。

上記のGoの例をScalaの[Option型](https://www.scala-lang.org/api/current/scala/Option.html)を使って書いたのが以下になります。Scalaの場合、`Option[A]`は`Some[A]`もしくは`None`です。
これによりシグニチャを見るだけでNoneが返ってくる可能性があることを知ることが出来ます。

```scala
// [Scala] Option型の例(User取得)

case class User(name: String)

// Option[User]が戻り値のためSome[User], Noneが返ってくることがわかる
def getUser(found: Boolean): Option[User] = {
  if (!found) {
    // userが見つからなかったらNoneを返す
    None
  } else {
    // userが見つかったらSome[User]をを返す
    Some(User("John Doe"))
  }
}

val userOption = getUser(false) // Noneを返すためにfalseを渡す

// Goの例と同じようにNoneのnameフィールドにアクセスを試みる
println(userOption.map(u => u.name)) // Output: None
// エラーは起こらない
```

#### ③エラーをthrowする

例外をthrowする言語(EX: TypeScript, JavaScript, Javaなど)の場合、例外処理のため`try...catch`で括る必要があります。

`try...catch`で括る場合の問題点は以下のようなものがあります。

- そもそもどの関数がthrowするかシグニチャからわからない
- ビジネスロジック以外のコードが入り、読みにくくなる
- エラー後の処理が煩雑になる

これに関数型言語では[Result型](https://ja.wikipedia.org/wiki/Result%E5%9E%8B)でerrorを**値**として扱います。具体的にはScalaの場合、**②null(やnil)を返す**で紹介した[Option型](https://www.scala-lang.org/api/current/scala/Option.html)または[Either型](https://www.scala-lang.org/api/3.x/scala/util/Either.html)を使います。`Either[A, B]`は`Left[A]`か`Right[B]`です。慣習的にLeftは異常時、Rightは正常時の値を入れます。`throw`する代わりにOption型やResult型を使うことでシグニチャから利用者は関数がエラーを返すかを知ることができます。


下記は**②null(やnil)を返す**のUser取得の例をScalaのEitherを使った例です。

```scala
// [Scala] Either型の例(User取得)

case class User(name: String)

// Either[String, User]が戻り値のため失敗時はLeft[String],成功時はRight[User]が返ってくることがわかる
def getUser(found: Boolean): Either[String, User] = {
  if (!found) {
    // userが見つからなかったらLeft[String]を返す
    Left("No user found")
  } else {
    // userが見つかったらRight[User]を返す
    Right(User("John Doe"))
  }
}

val userEither = getUser(false) // Left(失敗)を返すためにfalseを渡す

// LeftとRightを処理するためmatchを利用
userEither match {
  case Left(error) => println(s"Error: $error")
  case Right(user) => println(s"User found: ${user.name}")
}

// Output: Error: No user found
```

Goでは関数型のようにerrorを**値**として扱います([Errors are values.](https://go-proverbs.github.io/))。Either型やOption型は用意されていないため、[errorsパッケージ](https://pkg.go.dev/errors@go1.22.1)の[`New`](https://pkg.go.dev/errors@go1.22.1#New)を使ってerrorの値を作ることが一般的です。

下記はerrorを**値**として返しているGoのコードです。　([go playground](https://play.golang.com/p/fdDs91tGC17))
```golang
// [Go] Errorを値として返す(User取得)

package main

import (
	"errors"
	"fmt"
)

type User struct {
	Name string
}

// errorを返す値を戻り値に追加
func getUser(found bool) (*User, error) {
	if !found {
		// userが見つからなかったらエラーを返す
		return nil, errors.New("user not found")
	}
	// userが見つかったら新しいユーザーへのポインタとnilエラーを返す
	return &User{Name: "John Doe"}, nil
}

func main() {
	user, err := getUser(false) // getUser now also returns an error value
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	fmt.Println(user.Name)
}
```

## シグニチャが嘘をつかない = 純粋関数

つまりシグニチャが嘘をつかない ということは [純粋関数(pure function)](https://en.wikipedia.org/wiki/Pure_function)と言えます。

定義は下記のようになっています

> In computer programming, a pure function is a function that has the following properties:
> 1. the function return values are identical for identical arguments (no variation with local static variables, non-local variables, mutable reference arguments or input streams, i.e., referential transparency), and
> 2. the function has no side effects (no mutation of local static variables, non-local variables, mutable reference arguments or input/output streams).
> 
> ("Pure function", Wikipedia, https://en.wikipedia.org/wiki/Pure_function, accessed 2024/3/26).


日本語にすると下記のようになります。


> コンピュータープログラミングにおいて、純粋関数とは、以下の特性を持つ関数のことです：
> 1. 関数の戻り値は同じ引数に対しては常に同一です (ローカルの静的変数、非ローカル変数、可変参照引数や入力ストリームによる変動がなく、つまり**参照透過性**がある)
> 2. 関数は副作用がありません (ローカルの静的変数、非ローカル変数、可変参照引数や入出力ストリームを変更しません)



### 参照透過性とは？

[参照透過性](https://ja.wikipedia.org/wiki/%E5%8F%82%E7%85%A7%E9%80%8F%E9%81%8E%E6%80%A7)があるとは簡単に言うと関数を同じ引数を用いた場合、同じ戻り値が必ず返ってくるということです。

下記は参照透過性のある関数の例をTypeScriptで記載したものです。`add(2,3)`の結果は必ず`5`になります。

```typescript
// [TypeScript] 参照透過性の例
function add(a: number, b: number): number {
    return a + b;
}

console.log(add(2, 3)); // 5
```

### 純粋関数のルールに沿ってプログラミングをするメリット

下記があると思います。

- リーダブルなコードになる
サイドエフェクトがないため、コードを読むときに推論しやすく読みやすくなる。

- ユニットテストが書きやすくなる
サイドエフェクトがないためモック等不要になります。また参照透過性がある(同じ引数の値の時は戻り値は必ず決まっている)ためテストが書きやすい。

## B. 本体が宣言的　とは？

もう一つの条件である`本体が宣言的`について説明していきます。改めて、宣言的プログラミングは**What**に命令型は**How**に焦点を合わせています。

そのため、本体が宣言的な場合、**式**を多く使っていると言えます。

### 文と式

文は値を**返さない**　一方　式は値を**返す**　ものです。

文と式の例をJavaScriptを使って見ていきます。

```javascript
// [JavaScript] 文と式

// 下記は文
let a = 5;
if (a > 0) {
    console.log('Positive');
} else {
    console.log('Non-positive');
}

for(let i = 0; i < a; i++) {
    console.log(i);
}

let x = 3;


// 下記は式
let y = x * 2;
```

JavaScriptのifは**文**のため下記のようには書くことができません。

```javascript
// [JavaScript] ifは式として使えない
let max = if (a > b) { a } else { b } 
// -> Uncaught SyntaxError: Unexpected token 'if'
```

一方でScalaのforやifは**式**です。そのため下記のように書くことができます。

```scala
// [Scala] ifとforを式として使う
val max =
  if (a > b)
    a
  else
    b

val nums = List(1, 2, 3, 4)
val evenNumbers = for (
  n <- nums
  if n % 2 == 0
) yield n
```
</details>

多くの言語(Go, JavaScript, TypeScript, Perl, Scalaなど)で関数は**値**のため、関数の引数や戻り値として関数を使うことができます。

※このようなプログラミング言語の性質のことを[第一級関数(first-class function)](https://ja.wikipedia.org/wiki/%E7%AC%AC%E4%B8%80%E7%B4%9A%E9%96%A2%E6%95%B0)と言います。


### 高階関数

[高階関数](https://ja.wikipedia.org/wiki/%E9%AB%98%E9%9A%8E%E9%96%A2%E6%95%B0)は引数や戻り値に関数を使うことが出来る関数のことです。

次は高階関数の例です。

```javascript
// [JavaScript] 戻り値が関数　と　引数が関数

// largerThan: 戻り値が関数
function largerThan(a) {
  return function(i) {
    return i > a;
  };
}

// filter: 引数が関数
let t = [1,2,3,4,5,6,7,8]
t.filter(largerThan(3)) // [4,5,6,7,8]
```

私がJavaScriptでよく使う高階関数は次のようなものがあります。

- [map](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/map)
- [filter](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/filter)

次にGoで高階関数の例を見ていきます。業務で使っているフレームワーク[Echo](https://echo.labstack.com/)のmiddlewareは高階関数です。これは引数と戻り値の両方が関数です。
下記は公式ドキュメントの[Middleware](https://echo.labstack.com/docs/cookbook/middleware#:~:text=//%20Process%20is%20the,nil%0A%09%7D%0A%7D)のサンプルコードです。

```golang
// [Go] 高階関数(引数と戻り値が関数)の例
// ソース
// https://echo.labstack.com/docs/cookbook/middleware#:~:text=//%20Process%20is%20the,nil%0A%09%7D%0A%7D

// Process is the middleware function.
func (s *Stats) Process(next echo.HandlerFunc) echo.HandlerFunc {
	return func(c echo.Context) error {
		if err := next(c); err != nil {
			c.Error(err)
		}
		s.mutex.Lock()
		defer s.mutex.Unlock()
		s.RequestCount++
		status := strconv.Itoa(c.Response().Status)
		s.Statuses[status]++
		return nil
	}
}
```
引数と戻り値で使われている`echo.HandlerFunc`は下記でContextを引数errorを戻り値にする[関数](https://github.com/labstack/echo/blob/011acb4732fe4bdca1cb6d8ea9c29735e0b941f7/echo.go#L129)です。

```golang
// [Go] echo.HandlerFunc
// ソース
// https://github.com/labstack/echo/blob/011acb4732fe4bdca1cb6d8ea9c29735e0b941f7/echo.go#L129

// HandlerFunc defines a function to serve HTTP requests.
type HandlerFunc func(c Context) error
```

### カリー化

最後に関連した用語としてカリー化を紹介します。[カリー化](https://ja.wikipedia.org/wiki/%E3%82%AB%E3%83%AA%E3%83%BC%E5%8C%96)は①複数の引数を持つ関数　を　②引数が「もとの関数の最初の引数」で戻り値が「もとの関数の残りの引数を取り結果を返す関数」の関数に変換することを言います。文字ではイメージがつきにくいと思うので同様にコードで説明します。

下記は同じログ処理をカリー化の前(`logging`)と後(`curriedLogging`)をJavaScriptとGoで書いたものになります。 カリー化をすることで`logInfoNow`という関数を作ることができ、重複した引数(`level`,`timestamp`)を毎回渡す必要がなくなります。

```javascript
// [JavaScript] カリー化前後(ログ処理)

// (カリー化前)logging: 3つの引数を持つ関数
function logging(level, timestamp, message) {
    console.log(`[${level}] - ${timestamp}: ${message}`);
}

logging('INFO', new Date().toISOString(), 'This is a message'); // [INFO] - 2024-04-07T08:16:53.942Z: This is a message


// (カリー化後)curriedLogging
function curriedLogging(level) {
    return function(timestamp) {
        return function(message) {
            console.log(`[${level}] - ${timestamp}: ${message}`);
        };
    };
}

const logInfo = curriedLogging('INFO');
const logInfoNow = logInfo(new Date().toISOString());
logInfoNow('This is a message'); // [INFO] - 2024-04-07T08:13:55.301Z: This is a message
curriedLogging('ERROR')(new Date().toISOString())('An error occurred'); // [ERROR] - 2024-04-07T08:18:09.289Z: An error occurred
```
[playground](https://go.dev/play/p/PcnRcewN8Za)

```go
// [Go] カリー化前後(ログ処理)

package main

import (
	"fmt"
	"time"
)

// (カリー化前)logging: 3つの引数を持つ関数
func logging(level string, timestamp string, message string) {
	fmt.Printf("[%s] - %s: %s\n", level, timestamp, message)
}


// (カリー化後)curriedLogging
func curriedLogging(level string) func(string) func(string) {
	return func(timestamp string) func(string) {
		return func(message string) {
			fmt.Printf("[%s] - %s: %s\n", level, timestamp, message)
		}
	}
}

func main() {
	logging("INFO", time.Now().Format(time.RFC3339), "This is a message")

	logInfo := curriedLogging("INFO")
	logInfoNow := logInfo(time.Now().Format(time.RFC3339))
	logInfoNow("This is a message")
	curriedLogging("ERROR")(time.Now().Format(time.RFC3339))("An error occurred")
}
```

# 最後に

今回は書籍の前半(第6章エラー処理)までの用語をまとめました。後半ではサイドエフェクト(DB接続やAPIコール)がある場合や並行プログラミングをどうやって関数型で記述するかの説明があります。

書籍には練習問題やサンプルコードが豊富にあるため、学習しやすかったです。今までとは少し違う視点でプログラミングを見ることが出来るようになりました。