Chaos and Order

💡 왼쪽 원문을 읽으면서 오른쪽에 따라 써보세요. Tab 키로 힌트를 받을 수 있습니다.

원문 렌더가 준비되기 전까지 텍스트 가이드로 표시합니다.

2026 年の関数型プログラミングは、もはや「学界の贅沢」ではない。Elixir は Phoenix LiveView 1.1 とともに一部の SSR React 領域を侵食し、KakaoBank や Toss などで主要ワークロードを動かしている。Gleam は 1.6 以降に GitHub スター数を毎月急増させ、「型のある BEAM」という新しい市場を切り開いた。Haskell は GHC 9.12 とともに金融・コンパイラ・ブロックチェーンで堅実に使われ、OCaml 5.x のマルチコアランタイムはついに安定化し、Jane Street を越えて一般のバックエンドにも広がりつつある。本稿では Erlang/OTP 28、F# 9、Scala 3、Clojure 1.13 に加え、Roc、Lean 4、Unison、Idris 2、Koka まで、2026 年の関数型風景を一気に整理する。

なぜ今また関数型か — 2026 年の流れ

LLM 時代が本格化すると、興味深い変化が起こった。コード生成ツールが爆発的に一般化したことで、「人間がデバッグしやすいコード」より「型システムが捕まえてくれるコード」の価値が再び大きくなった。Haskell・OCaml・Rust・Gleam の検証可能性と BEAM 系の耐障害性が組み合わさり、関数型は LLM のボイラープレートが生むミクロなバグをすくい上げる安全網として再評価されている。

もう一つの流れは並行性だ。CPU コア数が増えるにつれ、GIL ベースの言語(Python・Ruby)は GIL 撤廃に向けて作業中だがまだ道は長く、Goroutine モデルもチャネルやミューテックス周辺で微妙なデッドロック問題が積み上がっている。Erlang/BEAM のアクターモデル、OCaml 5 のエフェクトハンドラ並行性、Haskell の STM、Scala の ZIO・Cats Effect — 関数型系の並行性モデルは 2026 年に再び主流の選択肢に戻った。

Elixir 1.18 — set-theoretic types プレビューのインパクト

2025 年末にリリースされた Elixir 1.18 は、José Valim と Guillaume Duboc 主導の set-theoretic types(集合論的型)プレビューを一層本格的に取り込んだ。関数シグネチャに型を宣言しなくても、コンパイラが呼び出し箇所を分析して和型を推論する仕組みだ。Dialyzer と違ってインクリメンタルに動作し、IDE 連携もはるかに滑らかである。

defmodule Account do

defstruct [:id, :balance]

@spec withdraw(%Account{}, pos_integer()) ::

{:ok, %Account{}} | {:error, :insufficient_funds}

def withdraw(%Account{balance: balance} = acc, amount)

when balance >= amount do

{:ok, %{acc | balance: balance - amount}}

end

def withdraw(_acc, _amount), do: {:error, :insufficient_funds}

end

上のコードで `withdraw/2` の戻り値型は `{:ok, %Account{}}` または `{:error, :insufficient_funds}` の和型である。1.18 の推論器は、呼び出し側で失敗ブランチに対するパターンマッチを省略すると警告を出す。Mix `mix compile --warnings-as-errors` と組み合わせれば、CI で強力な安全網となる。

Phoenix 1.8 + LiveView 1.1 — SSR とリアルタイムの融合

Phoenix 1.8 は LiveView 1.1 と同時にリリースされ、最大の変化は streams API の安定化と async assigns のバックプレッシャ対応である。WebSocket 上でサーバーレンダリングされた HTML diff を送る方式は、React Server Components が解こうとした問題を、はるかに単純なメンタルモデルで解決する。

defmodule MyAppWeb.OrdersLive do

use MyAppWeb, :live_view

def mount(_params, _session, socket) do

Phoenix.PubSub.subscribe(MyApp.PubSub, "orders")

{:ok, stream(socket, :orders, MyApp.Orders.recent())}

end

def handle_info({:new_order, order}, socket) do

{:noreply, stream_insert(socket, :orders, order, at: 0)}

end

def handle_event("cancel", %{"id" => id}, socket) do

case MyApp.Orders.cancel(id) do

{:ok, order} ->

{:noreply, stream_delete(socket, :orders, order)}

{:error, reason} ->

{:noreply, put_flash(socket, :error, "取消に失敗: #{inspect(reason)}")}

end

LiveView の本当の強みは、上のコードが SSR、リアルタイムプッシュ、楽観的 UI 更新を 1 ファイル内で処理することにある。Phoenix Channels の上の PubSub はノード間分散まで自然に拡張される。KakaoBank が自社のバックオフィスの一部を LiveView に移した理由はそこにある — 数十名のオペレーターが同じ画面をリアルタイム共有しつつ、React+WebSocket を別途実装する必要がない。

OTP パターン — Supervisor、GenServer、ETS、Mnesia

Elixir/Erlang の真価は OTP(Open Telecom Platform)パターンにある。Supervisor が子プロセスのポリシー(`one_for_one`、`rest_for_one`、`one_for_all`)で再起動を管理し、GenServer が状態をカプセル化し、ETS がインメモリのキー・バリューストアを提供する。Mnesia は ETS の上に ACID をかぶせる分散トランザクション DB である。

defmodule MyApp.RateLimiter do

use GenServer

def start_link(opts) do

GenServer.start_link(__MODULE__, opts, name: __MODULE__)

end

def init(_opts) do

:ets.new(:rate_limits, [:set, :public, :named_table])

{:ok, %{}}

end

def allow?(key, limit, window_ms) do

now = System.monotonic_time(:millisecond)

case :ets.lookup(:rate_limits, key) do

[{^key, count, window_start}] when now - window_start < window_ms ->

if count < limit do

:ets.insert(:rate_limits, {key, count + 1, window_start})

true

else

false

end

_ ->

:ets.insert(:rate_limits, {key, 1, now})

true

end

ETS はマイクロ秒単位の読み出しを保証し、Mnesia はデータセンター間のレプリケーションをオプションで持つ。2026 年も小さなチームが PostgreSQL と Redis と RabbitMQ を一度に導入するとき、「Elixir + OTP で全部いける」という冗談半分の真実は生きている。

Broadway + Oban + Ash Framework

データパイプライン向けの Broadway は Kafka・SQS・RabbitMQ からメッセージを受けてバッチ処理し、Oban は PostgreSQL ベースのバックグラウンドジョブキューで、cron・優先度・リトライ方針を提供する。Ash Framework は「リソース宣言」だけで GraphQL/REST/管理 UI まで生成するメタプログラミングフレームワークである。

defmodule MyApp.Resources.User do

use Ash.Resource,

data_layer: AshPostgres.DataLayer

attributes do

uuid_primary_key :id

attribute :email, :string, allow_nil?: false

attribute :name, :string

timestamps()

end

actions do

defaults [:read, :update, :destroy]

create :register do

accept [:email, :name]

change MyApp.Changes.HashPassword

end

policies do

policy action_type(:read) do

authorize_if expr(id == ^actor(:id))

end

Ash は宣言的なフルスタックバックエンドの定番ツールとなり、2026 年には LiveView との連携が一段と滑らかになった。ash_admin が生成する管理 UI は Retool のような SaaS を代替できる水準だ。

Erlang/OTP 28 — JIT 成熟と mTLS

2025 年後半にリリースされた Erlang/OTP 28 は、BeamAsm JIT をさらに磨き、ARM64 でも x86 並みのスループットを示す。さらに mTLS・QUIC のサポートが標準ライブラリに深く統合され、分散ノード間通信が一層安全になった。Erlang 単体で新規プロジェクトを始める例はまれだが、RabbitMQ・CouchDB・Riak・VerneMQ・WhatsApp バックエンドのように既存資産を維持する場面では中核インフラとして生き続けている。

-module(echo_server).

-behaviour(gen_server).

-export([start_link/0, echo/1, init/1, handle_call/3, handle_cast/2]).

start_link() ->

gen_server:start_link({local, ?MODULE}, ?MODULE, [], []).

echo(Msg) ->

gen_server:call(?MODULE, {echo, Msg}).

init([]) ->

{ok, #{count => 0}}.

handle_call({echo, Msg}, _From, State = #{count := N}) ->

{reply, {ok, Msg, N}, State#{count := N + 1}};

handle_call(_, _From, State) ->

{reply, {error, unknown}, State}.

handle_cast(_Msg, State) -> {noreply, State}.

Erlang 構文は Prolog の血筋を引き、ドット・セミコロン・カンマを使い分けるため初心者には急な学習曲線になる。しかし一度習得すれば、OTP のすべてのデザインパターンがそのまま適用できる。

Gleam 1.6+ — 型のある BEAM の新星

Gleam は 2026 年時点で 1.6 から 1.10 までバージョンを急速に上げ、Erlang VM と JavaScript の両方にコンパイルされる唯一の静的型付き関数型言語として定着した。Louis Pilfold が BDFL を務め、文法は Rust・Elm・F# の良いところを集めたような印象だ。OpenTelemetry サポートと Lustre フロントエンドフレームワークのおかげで、フルスタック Gleam アプリも現実的になった。

pub type Order {

Order(id: Int, total: Float, status: Status)

}

pub type Status {

Pending

Paid

Shipped

Cancelled

}

pub fn settle(order: Order) -> Result(Order, String) {

case order.status {

Pending -> Ok(Order(..order, status: Paid))

Paid -> Ok(Order(..order, status: Shipped))

Shipped -> Error("already shipped")

Cancelled -> Error("cancelled order cannot proceed")

}

pub fn main() {

let orders = [

Order(1, 99.0, Pending),

Order(2, 49.5, Paid),

]

orders

|> list.map(settle)

|> list.each(io.debug)

}

Gleam の魅力は「Erlang のアクターモデルをそのまま使いつつ、コンパイル時に型を検証する」点にある。Phoenix LiveView のようなメタフレームワークはまだないが、Lustre がそのポジションを急速に埋めつつある。

LFE(Lisp Flavored Erlang) — 小さくとも堅実な生態系

LFE は Robert Virding(Erlang 共同創設者)が作った Lisp 方言で、BEAM の上で動く。マクロシステムと同型性(homoiconicity)を BEAM に持ち込んだ存在で、Clojure が JVM で行ったことを BEAM で試みている形だ。ユーザーベースは小さいが OTP 互換性は完璧である。

Haskell GHC 9.10/9.12 — 線形型と GHC2024

GHC 9.10/9.12 は GHC2024 をデフォルト言語版に昇格させ、Linear Types を成熟させ、型検査器の性能を大きく改善した。エフェクトシステム(effectful、Polysemy、Cleff)が mtl スタイルを急速に置き換えつつあり、GHC の推論の質も年々向上している。

{-# LANGUAGE GADTs #-}

{-# LANGUAGE TypeFamilies #-}

module Wallet where

data Wallet = Wallet

{ owner :: String

, balance :: Int

} deriving (Show)

data Tx

= Deposit Int

| Withdraw Int

deriving (Show)

apply :: Wallet -> Tx -> Either String Wallet

apply w (Deposit n)

| n > 0 = Right w { balance = balance w + n }

| otherwise = Left "deposit must be positive"

apply w (Withdraw n)

| n <= balance w = Right w { balance = balance w - n }

| otherwise = Left "insufficient funds"

settle :: Wallet -> [Tx] -> Either String Wallet

settle = foldl (\acc tx -> acc >>= flip apply tx) . Right

Haskell の遅延評価は今でも諸刃の剣だが、IO の隔離と強力な型システムのおかげで、Standard Chartered、Mercury、Tweag といった企業が中核インフラを動かしている。Cabal と Stack の双方が活発に保守されており、2026 年には nix-flakes 連携がほぼ標準となった。

OCaml 5.x — マルチコアランタイムが解き放った潜在力

OCaml 5 はエフェクトハンドラ(effect handlers)とドメインベースの並列 GC を導入し、5.3 まで安定化が進んだ結果、ついにマルチコア OCaml が現実となった。Jane Street は自社フォークの oxcaml を運用するが、メインストリーム OCaml 5 も十分に強力である。

open Effect

open Effect.Deep

type _ Effect.t += Read : string Effect.t

| Log : string -> unit Effect.t

let interact () =

let name = perform Read in

perform (Log ("hello, " ^ name));

perform (Log "bye")

let run program input =

try_with program ()

{ effc = fun (type a) (e: a Effect.t) ->

match e with

| Read -> Some (fun (k: (a, _) continuation) -> continue k input)

| Log msg -> Some (fun k -> print_endline msg; continue k ())

| _ -> None }

let () = run interact "youngju"

上のコードは OCaml 5 のエフェクトハンドラを示している。同期 IO をエフェクトとして抽象化し、ハンドラ側で処理方法を切り替える方式は代数的エフェクトの真髄だ。Dune ビルドシステムと opam パッケージマネージャは安定的に進化し、melange は OCaml→JS コンパイルのライブなオプションとして残っている。

ReScript — OCaml の JS フレンドリーな分枝

ReScript(旧 BuckleScript / Reason)は、OCaml の型システムを React フレンドリーな構文で包んだプロジェクトである。ReScript 11/12 では V11 への移行と GenType 連携がさらに滑らかになった。JavaScript フレンドリーなキーワード(`let`、`if`、`match`)と OCaml の強力な型推論を組み合わせて React コンポーネントを書く。

type user = {

id: int,

name: string,

email: option<string>,

}

let formatUser = (u: user) =>

switch u.email {

| Some(e) => `${u.name} <${e}>`

| None => `${u.name} (no email)`

}

@react.component

let make = (~user) =>

ReScript は Rome/Biome のような代替が登場した今でも、fb-watchman と組み合わせた超高速コンパイル速度で差別化を保っている。日本では Money Forward などが ReScript 導入事例を公開している。

F# 9 + .NET 9 — エンタープライズ関数型の代表格

F# 9 は .NET 9 の上で nullable reference types の統合、computation expressions の性能改善、type provider の安定化を装備した。Jet.com が事実上の標準 F# ケーススタディだったが、2026 年には G-Research・Walmart などがデータパイプラインやトレーディングインフラに F# を導入している。

type Shape =

| Circle of radius: float

| Rectangle of width: float * height: float

| Triangle of a: float * b: float * c: float

let area shape =

match shape with

| Circle r -> System.Math.PI * r * r

| Rectangle (w, h) -> w * h

| Triangle (a, b, c) ->

let s = (a + b + c) / 2.0

sqrt (s * (s - a) * (s - b) * (s - c))

[<EntryPoint>]

let main _ =

[ Circle 1.0; Rectangle (3.0, 4.0); Triangle (3.0, 4.0, 5.0) ]

|> List.iter (fun s -> printfn "%A area=%.2f" s (area s))

F# の強みは「.NET 生態系全体をそのまま使いつつ」関数型で書ける点だ。ASP.NET Core、EF Core、Azure SDK もすべて F# から自然に使える。

Scala 3 + ZIO + Cats Effect — JVM 関数型の両輪

Scala 3.6 は enum、given/using インスタンス、opaque type alias、extension method をさらに洗練させた。JVM 関数型ライブラリは ZIO と Cats Effect の二大陣営に分かれ、ZIO 2 は throwable-free な関数型エフェクトシステムを提供する。Akka はライセンス変更後、Pekko フォークとして保守されている。

object OrderService:

enum OrderError:

case NotFound, AlreadyPaid, InsufficientFunds

case class Order(id: Long, amount: BigDecimal, paid: Boolean)

trait OrderRepo:

def find(id: Long): IO[OrderError.NotFound.type, Order]

def save(order: Order): UIO[Unit]

def pay(id: Long): ZIO[OrderRepo, OrderError, Order] =

for

repo <- ZIO.service[OrderRepo]

order <- repo.find(id)

_ <- ZIO.fail(OrderError.AlreadyPaid).when(order.paid)

paid = order.copy(paid = true)

_ <- repo.save(paid)

yield paid

ZIO の `ZIO[R, E, A]` 型は環境 R、エラー E、結果 A をすべて型シグネチャに露出する。上のコードはシグネチャを見ただけで依存とエラーの種類が分かる — 関数型エフェクトシステムの真骨頂だ。

Clojure 1.13 + ClojureScript + Babashka

Clojure 1.13 はインライン def、キーワード引数、deps.edn の改善を持ち込んだ。ClojureScript は依然として SCI(Small Clojure Interpreter)と Shadow CLJS の両側で活発で、Babashka はシェルスクリプト代替の単一バイナリ Clojure として定着した。nbb は Node.js 上の Babashka 版である。

(ns billing.core

(:require [clojure.string :as str]))

(defn line-total [{:keys [qty unit-price discount]}]

(let [base (* qty unit-price)

amount (* base (- 1 (or discount 0)))]

(Math/round (double amount))))

(defn invoice [{:keys [customer items]}]

(let [lines (map line-total items)

subtotal (reduce + lines)

vat (Math/round (double (* subtotal 0.1)))]

{:customer customer

:subtotal subtotal

:vat vat

:total (+ subtotal vat)}))

(comment

(invoice {:customer "ACME"

:items [{:qty 3 :unit-price 9900}

{:qty 1 :unit-price 49000 :discount 0.1}]}))

Clojure の魅力は REPL ドリブン開発と不変データ構造だ。Babashka のおかげで「Python の代わりに Clojure で小さなツールを書く」選択肢が現実的になった。

BEAM 三言語の比較 — Elixir vs Erlang vs Gleam

同じ BEAM の上で動く三言語は、市場で次第に分化してきている。Elixir はフルスタック開発者が最も入りやすいメタプログラミングの強者、Erlang は通信・メッセージングインフラの本拠、Gleam は型を愛する新世代のためのカードである。

- **Elixir**: Phoenix LiveView 生態系、Mix ビルド、OTP パターン、set-theoretic types プレビュー

- **Erlang**: WhatsApp/RabbitMQ/Riak のような巨大インフラ、rebar3 ビルド、伝統的 OTP

- **Gleam**: Rust 風文法、完全な型安全、Erlang/JS 両ターゲット、Lustre フロントエンド

三言語は同じ VM 内で自由に相互呼び出しできる。Erlang ライブラリを Elixir から、Gleam モジュールを Elixir からそのまま呼ぶ例が増えている。

ML ファミリーの比較 — OCaml vs F# vs ReScript

同じ ML 系統だが利用領域は明確に分かれる。

- **OCaml**: コンパイラ・静的解析・Jane Street トレーディング、Dune ビルド、opam パッケージング

- **F#**: .NET 生態系統合、Windows/Linux/macOS クロスプラットフォーム、dotnet CLI

- **ReScript**: フロントエンド React/Next.js コンパイルターゲット、npm フレンドリー、GenType

OCaml はメモリモデルが非常に軽く、コンパイル速度が速い。F# は .NET 資産をそのまま取り込める。ReScript は JS バンドルサイズが小さい。

Roc — Rust の精神を継ぐ新興関数型言語

Richard Feldman(Elm コア貢献者)が作った Roc は、「Rust の精神を関数型で」を掲げて開発中である。2026 年時点ではベータ段階だが、コンパイル速度とランタイム効率は印象的だ。プラットフォーム抽象化のおかげで、同じ Roc コードを CLI・WebAssembly・Lambda へデプロイできる。

Lean 4 — 定理証明から汎用言語へ

Lean 4 は Microsoft Research の Leonardo de Moura が主導する定理証明器であり、関数型言語でもある。mathlib の爆発的成長と、Terence Tao 教授による 2024 年の協業によって、学術界で本格的なツールとなった。2026 年には Lean 4 は単なる証明ツールを越え、コンパイラや DSL を書く汎用言語としても注目されている。

Unison — コンテンツアドレス化されたコード

Unison は関数本体のハッシュに基づいてコードを識別する。import が消え、依存解決はコンパイラレベルで完結し、名前の変更は単なるメタデータ更新となる。2026 年に Unison Share が安定化し、「Git なしのコード共有」という実験が本格的に走り始めた。

Idris 2 + Koka — 次世代の型とエフェクト

Idris 2 は依存型(dependent types)を主軸にした ML 後継であり、Koka は Microsoft Research が作ったエフェクト型付き言語である。両者とも学術色が強いが、OCaml 5 のエフェクトハンドラ、Haskell のエフェクトライブラリ、Scala の ZIO に直接影響を与えた源流でもある。

韓国・日本の導入事例

韓国では KakaoBank が一部のバックオフィスツールを Elixir/Phoenix LiveView で運用していることをカンファレンスで公開し、Toss は自社のテックブログで Elixir/OTP の学習記をしばしば取り上げている。日本では Cookpad が Ruby から Elixir へ一部サービスを移行した事例を発表しており、LINE はゲームバックエンドで Erlang/OTP を長く活用してきた。Erlang Solutions は東京にオフィスを構え、定期的に Code BEAM カンファレンスを後援している。

学習ロードマップの提案

関数型に初めて触れるなら、まず Elixir で OTP パターンを身につけ、そこから型に欲が出たら Gleam か OCaml 5 へ移り、より深い抽象に興味が湧いたら Haskell・Scala に進む、という経路が自然だ。Lean 4・Idris 2 は最後に挑戦する。F# は .NET のバックグラウンドがあるなら最速の入口だ。Clojure は REPL と即時的なフィードバックが好きなら最高の選択肢である。

関数型ライブラリのマトリクス

言語別の代表的ライブラリを一行で要約する。

- Elixir: Phoenix、LiveView、Ecto、Broadway、Oban、Ash、Nx(数値計算)

- Erlang: Cowboy、RabbitMQ、Riak、VerneMQ、ranch、lager

- Gleam: gleam_otp、gleam_http、lustre、mist、wisp

- Haskell: servant、persistent、optics、conduit、megaparsec、polysemy、effectful

- OCaml: dune、opam、lwt、async、owl(数値)、bonsai(UI)、melange

- F#: Giraffe、Saturn、FsToolkit.ErrorHandling、FParsec、Fable

- Scala 3: ZIO、Cats Effect、http4s、Doobie、Tapir、Akka/Pekko

- Clojure: Reagent、re-frame、malli、integrant、mount、next.jdbc

いずれの言語でも事実上の標準、またはそれに準ずる位置を占めている。

まとめ — 関数型は贅沢ではなく道具

2026 年の関数型は、もはや「好み」や「学界の贅沢」ではない。Elixir・Gleam は BEAM の堅牢さを現代的な DX で包み、OCaml 5 はマルチコアの潜在力を解き放ち、Scala・F#・Haskell はそれぞれの領域で産業標準ツールとして定着した。LLM 時代にコードの検証可能性が再び重要になるほど、関数型ツールを一つか二つ脇に置く習慣が、結局はチームの安全資産になる。

References

- elixir-lang.org

- phoenixframework.org

- gleam.run

- www.erlang.org

- www.haskell.org

- ocaml.org

- fsharp.org

- scala-lang.org

- clojure.org

- roc-lang.org

- lean-lang.org

- www.idris-lang.org

- koka-lang.github.io

- unison-lang.org