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의 effect handlers 기반 병렬성, Haskell의 STM, Scala의 ZIO·Cats Effect — 함수형 계열의 동시성 모델은 2026년 다시 한 번 주류 선택지로 올라섰다.

Elixir 1.18 — set-theoretic types 프리뷰의 충격

2025년 말부터 출시된 Elixir 1.18은 José Valim과 GuilLambda Sá가 주도한 set-theoretic types(집합론적 타입) 프리뷰를 더 본격적으로 통합했다. 함수 시그니처에 타입을 선언하지 않아도 컴파일러가 함수 사용처를 분석해서 유니온 타입을 추론하는 방식이다. Dialyzer와 달리 incremental하게 작동하며 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 디프를 전송하는 방식은 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, 실시간 푸시, optimistic UI 갱신을 한 파일 안에서 처리한다는 것이다. 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는 분산 트랜잭션 DB로 ETS 위에 ACID를 얹는다.

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에서 메시지를 받아 batch 처리하며, 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는 declarative한 풀스택 백엔드 도구로 자리잡았고, 2026년에는 LiveView와의 통합이 한층 매끄러워졌다. ash_admin이 generate하는 관리자 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의 actor 모델을 그대로 쓰면서 컴파일 타임에 타입을 검증"한다는 점이다. Phoenix LiveView 같은 메타프레임워크는 아직 없지만, Lustre가 빠르게 그 자리를 채우고 있다.

LFE (Lisp Flavored Erlang) — 작지만 단단한 생태계

LFE는 Robert Virding(Erlang 공동 창시자)이 만든 Lisp 방언으로 BEAM 위에서 동작한다. macro 시스템과 동형성(homoiconicity)을 BEAM에 가져온다는 점에서, Clojure가 JVM에서 한 일을 BEAM에서 시도하는 셈이다. 사용자 베이스는 작지만 OTP 호환성은 완벽하다.

Haskell GHC 9.10/9.12 — 선형 타입과 GHC2024

GHC 9.10/9.12는 GHC2024 디폴트 언어 확장, 선형 타입(LinearTypes) 성숙, 그리고 type checker 성능 개선이 주요 변화다. Effects 시스템(effectful, Polysemy, Cleff)이 mtl 스타일을 빠르게 대체하고 있고, GHC가 제공하는 inference 품질은 매년 향상되고 있다.

{-# 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의 lazy evaluation은 여전히 양날의 검이지만, 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의 effect handlers를 보여준다. 동기적 IO를 effect로 추상화하고 핸들러에서 처리 방식을 바꾸는 방식은 algebraic effects의 진수다. 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-driven 개발과 immutable data structure다. 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년에는 베타 단계지만 컴파일 속도와 런타임 효율이 인상적이다. Platform 추상화 덕분에 같은 Roc 코드를 CLI·WebAssembly·Lambda에 배포할 수 있다.

Lean 4 — 정리 증명에서 범용 언어로

Lean 4는 마이크로소프트 리서치 Leonardo de Moura가 주도하는 정리 증명기이자 함수형 언어다. mathlib의 폭발적 성장과 함께, 2024년 Tao 교수의 협업으로 학계에서 본격적인 도구가 됐다. 2026년에는 Lean 4가 단순 증명 도구를 넘어 컴파일러·DSL 작성용 범용 언어로도 떠올랐다.

Unison — 콘텐츠 주소화된 코드

Unison은 함수 본문의 해시를 기반으로 코드를 식별한다. import가 사라지고, 의존성 해결이 컴파일러 수준에서 해결된다. 이름 변경은 단순 메타데이터 변경일 뿐이다. 2026년 Unison Share가 안정화되면서 "Git 없는 코드 공유"라는 실험이 본격화됐다.

Idris 2 + Koka — 차세대 타입과 effect

Idris 2는 의존 타입(dependent types)을 주력으로 하는 ML 후계자이고, Koka는 Microsoft Research가 만든 effect typing 언어다. 두 언어 모두 학계 색채가 강하지만, OCaml 5의 effect handlers, Haskell의 effects 라이브러리, 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