Gleam의 단순한 문법, 강력한 타입 시스템, BEAM과 OTP의 동시성 모델, 그리고 장단점을 살펴봅니다.
최근에 쓴 프로그래밍 언어에 대한 불평을 읽었다면, 내가 Gleam에 꽤 관심을 두고 있다는 것을 알 것이다. Gleam은 Erlang VM인 BEAM을 대상으로 하는 함수형 언어이며,1 단순한 문법과 더 넓은 BEAM 생태계(Erlang 및 Elixir)와의 상호운용성을 갖추고 있다. 흥미롭게도 Gleam은 JavaScript도 대상으로 삼을 수 있다. 즉, Gleam은 JavaScript로 컴파일되어 Node.js를 통해 실행될 수 있다.
나는 주로 취미 프로젝트에 Rust를 사용해 왔는데, 현재로서는 코딩을 정말 즐겁게 만들어 주는 유일한 언어다. Gleam도 그 갈증을 채워 주었다. Rust _애호가_라면 몇 가지 핵심적인 차이점을 제외하고 Gleam이 친숙하게 느껴질 것이다. 내가 작성하는 코드의 80%는 문법을 약간 찾아 바꾸기만 하면 Rust에 복사해 붙여 넣어도 컴파일될 것 같다.
이 글은 언어를 망라해 소개하지는 않는다. 더 알고 싶다면 훌륭한 대화형 둘러보기를 추천한다. 30분도 안 되어 Gleam의 감을 충분히 잡을 수 있을 것이다.
Gleam은 홈페이지에서 “친근한, 타입 안전한, 확장 가능한 시스템을 만들기 위한 언어!”라고 소개된다(강조는 원문에 있다). 이는 Gleam의 핵심을 잘 전달한다.
문법은 매우 단순하며, 복잡한 부분 대부분은 Erlang 런타임이 숨겨 준다. 원하지 않는 한 실제로 런타임과 상호작용할 필요가 없다! 물론 Gleam은 함수형 언어이므로, 평생 C 계열의 명령형 세계에서 살아왔다면 처음에는 조금 어렵게 느껴질 수 있다. 하지만 다른 함수형 언어(OCaml, Haskell, Erlang)와 비교하면 Gleam이 훨씬 단순하다는 것을 금방 알게 된다. 조금 사용해 보면, 일부가 빠져 있고 명령형 부분은 전혀 없는 Rust의 함수형 요소 전부처럼 느껴진다.
예제 코드부터 시작해 보자.
Gleam
// Omitted imports
pub fn main() {
let total =
"1,X,5,6" // String
|> string.split(on: ",") // List(String)
|> list.map(int.parse) // List(Result(Int, Nil))
|> result.values // List(Int), the invalid entries are dropped
|> list.reduce(fn(acc, x) { acc + x }) // Result(Int, Nil)
|> result.unwrap(0) // Int
echo total // 12
}
Rust
fn main() {
let total = "1,X,5,6" // &str
.split(",")
.map(|s| s.parse::<i64>())
.filter_map(Result::ok)
// Could have used .sum() here
.reduce(|acc, x| acc + x)
.unwrap_or(0);
println!("{}", total); // 12
}
조금 뜯어보면 Gleam의 몇 가지 특성을 볼 수 있다.
mut 키워드나 그와 비슷한 것은 없다). 여기서 연결된 함수는 모두 새 요소를 반환한다.2 새 let으로 바인딩을 가릴 수는 있으며, 이것이 값을 “갱신”하는 방식이다.|>(타이핑된 |>)는 데이터에 함수를 연결하는 데 쓰이는 파이프 연산자다. 주요 제약은 파이프로 전달되는 변수가 파이프 안 함수의 첫 번째 인수여야 한다는 점이다.Result 모나드의 일부인 값일 뿐이다.3Rust 코드 조각과 비교하면, 몇 가지 명명 선택을 제외하고는 상당히 비슷해 보인다. 이 예제에서 주요 차이는 वास्तव로 파이핑 문법과 체이닝 문법이다. Gleam 타입에는 메서드가 없으므로 대신 파이핑을 사용한다.
파이핑 연산자 |>는 이 글에서 만나게 될 Gleam의 마스코트 기능 세 가지 중 첫 번째다. 나머지 둘은 use 패턴과 꼬리 호출 최적화다.
JavaScript를 많이 작성했다면, 여러 콜백을 서로 중첩할 때 생기는 들여쓰기 증가에 익숙할지도 모른다.
someFunc(arg, function(param) {
someOtherFunc(param, function(otherParam) {
// ...
})
})
Gleam에서는 많은 함수가 콜백을 기대한다. 예를 들어 리소스에 대한 접근을 제어하고 프로세스가 끝났을 때 정리하기 위해서다(데이터베이스 연결 닫기, 파일 핸들 해제 등). 이런 콜백 탑을 피하기 위해 Gleam은 문법적 설탕을 제공한다. use param <- some_func(arg)는 some_func(arg, fn(param) { ... })와 같다. 콜백은 언제나 함수의 마지막 인수여야 한다. 이는 첫 번째 인수를 채우는 |>와 반대다.
use 사용
use param <- some_func(arg)
use other_param <- some_other_func(param)
echo other_param
use 미사용
some_func(arg, fn(param) {
some_other_func(param, fn(other_param) {
echo other_param
})
})
익숙하지 않다면 이것은 정말 당황스러울 수 있다. 먼저 알아야 할 점은 Gleam에는 반복문이 없다는 것이다! 다시 말하지만, OCaml이나 Haskell을 써 본 적이 있다면 놀랍지 않을 것이다. 98%의 경우,4 반복문은 제한된 횟수의 반복에 대한 단순한 연산이다. 리스트나 집합에 대한 for 반복문을 생각하면 된다. Rust에서는 정확한 for 반복문을 쓰는 명령형 방식과 반복자 연산 조합을 쓰는 더 함수형 방식, 늘 두 가지 방법이 있는 바로 그런 종류다. 앞 절의 코드 예제를 보면 Gleam은 두 번째 방식을 사용하며, 리스트, 집합, 튜플, 문자열 등 무엇이든 순회할 수 있는 풍부한 함수를 갖추고 있음을 알 수 있다.
하지만 더 복잡한 것이 필요하다면? 나머지 2%는 어떻게 할까? 이때는 재귀를 사용한다! 이를 잘 보여 주는 단순한 알고리즘으로 최대공약수(GCD)를 계산하는 유클리드 알고리즘이 있다. 아래에는 Rust 반복 예제와 Gleam 재귀 예제가 있다.
Rust
fn gcd(mut a: u64, mut b: u64) -> u64 {
while b != 0 {
let remainder = a % b;
a = b;
b = remainder;
}
a
}
Gleam
fn gcd(a: Int, b: Int) -> Int {
case b {
0 -> a
_ -> gcd(b, a % b)
}
}
물론 Rust에서도 재귀 버전을 작성할 수 있지만, 대개 그리 좋은 생각은 아니다. 명령형 언어에서 재귀는 빠르게 통제 불능이 될 수 있다. 호출마다 새 스택 프레임이 추가되고, 깊은 재귀 함수는 스택을 소진할 수 있다(악명 높은 스택 오버플로).
BEAM에는 고정 크기 스택이 없으므로, 통제되지 않는 재귀는 프로세스가 종료될 때까지 힙 메모리를 대신 소모한다. 하지만 핵심은 같다. 깊은 재귀는 문제를 뜻한다. 이를 피하기 위해 함수형 언어 컴파일러는 재귀 호출이 함수가 수행하는 마지막 작업일 때 적용되는 꼬리 호출 최적화(TCO)라는 기법을 구현한다. 그러면 새 스택 프레임을 쌓는 대신 기존 프레임을 재사용하므로, 명령형 while 반복문에 가까운 성능을 낸다.5
이 표어 부분은 주로 명백한 질문인 “왜 Gleam이고 Elixir는 아닌가?”(또 다른 Erlang 기반 언어)에 답하기 위한 것이다. Elixir는 동적 타입 언어인 반면(이제 점진적 타이핑도 지원한다!), Gleam은 강력한 타입 시스템을 지닌 정적 타입 언어로 만들어졌다. 강력한 타입은 그 존재 이유다.
Gleam의 type은 Rust의 enum과 struct 개념을 모두 아우른다.
Gleam
// A usual enum
type Directions {
Left
Right
}
// A 'struct-like' type
type Person {
Person(name: String, age: Int)
}
// A combination of both
type MyError {
Missing
InvalidQuery(String)
}
Rust
enum Directions {
Left,
Right
}
struct Person {
name: String,
age: i64
}
enum MyError {
Missing,
InvalidQuery(String)
}
Gleam 타입은 대수적 데이터 타입이므로 원하지 않는 상태가 불가능하도록 보장하는 데 매우 유용하다. 조금 뒤에 관련될 Gleam의 큰 장점은 BEAM 가상 머신과 JavaScript 모두로 컴파일된다는 점이다. 따라서 두 대상의 서로 다른 애플리케이션에서 이러한 강력한 타입 정의를 공유할 수 있다. 특히 웹 애플리케이션이 BEAM 앱과 통신해야 할 때 편리하다.
물론 이는 Erlang VM인 BEAM을 가리킨다. 네이티브 시스템을 대상으로 하는 언어(Rust, Go, C++)와 달리 VM은 시스템과 프로그램 사이에 추가 추상화 계층을 제공한다. BEAM의 경우 이 계층은 빠른 속도를 유지하면서 동시 프로세스와 장애를 처리하는 데 유난히 뛰어나다.
Gleam은 이를 잘 활용하며, 동시성 프로그램은 다음과 같이 보인다.
// Omitted imports
pub fn main() {
let order_number_and_amounts = [
#(101, 100),
#(102, 200),
#(103, 300)
]
order_number_and_amounts
|> list.each(fn(x) {
let #(order_no, amount) = x
let order_description = "Order #" <> int.to_string(order_no)
// Spawn unlinked: a crashing worker must not take the parent down.
process.spawn_unlinked(fn() {
// 101 and 103 will succeed, 102 will crash
process_order(order_description, amount)
})
})
io.println("All orders dispatched!")
// Keep the parent alive until the children have had time to run.
process.sleep(10)
}
fn process_order(order: String, amount: Int) {
process.sleep(1)
case amount {
200 -> panic as "Payment failed!"
_ -> io.println(order <> " processed successfully")
}
}
// Stdout
// ----
// All orders dispatched!
// Order #101 processed successfully
// Order #103 processed successfully
이 코드에서 얻어야 할 점은 프로세스를 처리하는 주체가 BEAM이라는 것이다.
process.spawn_unlinked 호출은 생성자와 연결되지 않은 새 프로세스를 시작한다. 따라서 주문 102가 충돌해도 부모나 형제 프로세스는 영향을 받지 않는다. 일반 process.spawn를 사용했다면 자식은 호출자에 연결되고, 그 panic은 프로그램 전체를 종료했을 것이다. 자세히 보면 자식 프로세스가 끝나기 전에 부모가 종료되지 않도록 process.sleep(10)도 추가했다. 이는 지연 시간이 추측일 뿐이고 더 느린 자식은 여전히 중간에 끊길 수 있으므로 임시방편이다.
다행히 BEAM의 큰 장점은 프로세스 간 통신이 매우 쉽다는 것이며, 다음 코드 조각이 이를 잘 보여 준다.
// Omitted imports
pub type PaymentError {
PaymentFailed
}
pub fn main() {
let parent = process.new_subject()
let orders = [
#(101, False),
#(102, True),
#(103, False)
]
orders
|> list.each(fn(x) {
let #(order_no, should_fail) = x
process.spawn(fn() {
// Simulate processing time
process.sleep(1000)
// 101 and 103 succeed, 102 fails
let res = case should_fail {
True -> Error(PaymentFailed)
False -> Ok(Nil)
}
process.send(parent, #(order_no, res))
})
})
io.println("All orders dispatched!")
receive_results(list.length(orders), parent)
}
fn receive_results(
remaining: Int,
parent: process.Subject(#(Int, Result(Nil, PaymentError))),
) -> Nil {
case remaining {
0 -> Nil
_ -> {
let #(order_no, res) = process.receive_forever(parent)
let status = case res {
Ok(_) -> "successful"
Error(_) -> "failed"
}
io.println(
"Processing of order #" <> int.to_string(order_no) <> " " <> status <> "!",
)
receive_results(remaining - 1, parent)
}
}
}
// Stdout
// ----
// All orders dispatched!
// Processing of order #103 successful!
// Processing of order #102 failed!
// Processing of order #101 successful!
//
// The order of the last three lines depends on scheduling.
위 단락에서는 메시지 전달로 통신하는 동시성 프로그램에 BEAM 가상 머신이 얼마나 뛰어난지 간략히 보였다. Go에 익숙하다면, 이는 Go가 _고루틴_으로 같은 문제를 처리하는 방식과 비슷하다. 하지만 Erlang과 함께 제공되는 라이브러리 집합인 OTP(Open Telecom Platform)는 그보다 강력하다. 내장된 감독자-액터 패러다임을 제공하며, 전체 애플리케이션을 중단시키지 않고 충돌할 수 있는 확장 가능하고 동시적인 서비스를 만들 수 있게 한다.
간단히 말해 OTP는 상태를 보유하고 메시지로 서로 통신하는 가벼운 프로세스인 _액터_를 제공한다(위 예제와 같다). 이것이 _감독자_와 짝을 이루면, 개별 액터가 충돌해도 전체 애플리케이션은 더 견고해진다. 감독자가 프로세스를 감시하고 필요에 따라 재시작하기 때문이다. 액터 그룹을 동적으로 시작하거나 중지하는 데도 도움이 된다.
이 글을 읽으며 “어, 이거 Kubernetes를 쓸 때와 아주 비슷한데”라고 생각한다면, 당신만 그런 것이 아니다. OTP 모델은 Kubernetes의 컨트롤러-파드 아키텍처와 매우 비슷하며 같은 문제 다수를 해결한다.6 하지만 내 경험상 Kubernetes를 사용하는 워크플로 상당수는 실제로 클러스터가 필요하지 않은데도, 분산 환경이라는 추가 이점 때문에 클러스터를 사용한다(그리고 비용이 많이 든다!). 그런 경우 OTP는 정말 흥미로운 대안을 제공한다.
구체적인 예를 들어 보자. 지나치게 자세히 설명하지는 않겠지만, 우리 팀에는 다른 프로세스를 처리하는 수작업 Go 작업 스케줄러를 포함하는 흔한 구성 방식이 있다.
스케줄러, 각 워커, 사용자 인터페이스는 모두 Kubernetes가 관리하는 클러스터 내부의 파드다. 솔직히 잘 작동하지만 복잡성도 많이 늘어난다. 우선 이 서비스 대부분은 서로 이렇게까지 격리될 필요가 없다. 그 결과 서로 다른 서비스 간 통신을 위해 여러 곳에 중복된 REST API가 필요하다.
이를 Gleam 애플리케이션 안에서 재구성하고 싶다면 어떨까? Gleam이 빛날 부분은 두 곳이다.
다음은 수정된 아키텍처다.
BEAM 애플리케이션 안에서 모든 액터는 메시지로 통신한다.
따라서 별도 파드에서 여러 애플리케이션의 배포를 처리하는 대신, OTP가 하나의 VM 안에서 모든 프로세스 관리를 처리하게 할 수 있다(스케줄링 부분에 대해서).
앞서 언급했듯 Gleam의 큰 장점 중 하나는 JavaScript로 컴파일된다는 것이다. 따라서 중복 API를 동기화하는 대신 사용자 인터페이스와 작업 스케줄러 사이에서 공유 타입 정의를 묶을 수 있다.
shared/job.gleam
pub type JobStatus {
Pending
Running
Completed
Failed
}
pub type Job {
Job(
id: String,
name: String,
status: JobStatus,
)
}
pub type CreateJobRequest {
CreateJobRequest(name: String)
}
pub fn new_job(id: String, request: CreateJobRequest) -> Job {
Job(
id: id,
name: request.name,
status: Pending,
)
}
frontend.gleam
import gleam/json
import shared/job.{type CreateJobRequest, CreateJobRequest}
// `create_job_encoder` lives in shared/job; `client` is your HTTP client
// of choice (gleam_httpc on the BEAM, gleam/fetch in the browser).
pub fn submit_job(name: String) {
let request = CreateJobRequest(name: name)
let body = json.to_string(
job.create_job_encoder(request),
)
// POST /api/jobs
client.post(
"/api/jobs",
body,
)
}
server.gleam
import shared/job.{type CreateJobRequest, type Job}
// `Database`, `DatabaseError` and `generate_id` stand in for your
// database layer and ID generator.
pub fn create_job_handler(
request: CreateJobRequest,
db: Database,
) -> Result(Job, DatabaseError) {
let id = generate_id()
let created_job = job.new_job(id, request)
// Persist as Pending in PostgreSQL.
database.insert_job(db, created_job)
|> result.map(fn(_) { created_job })
}
모든 언어에는 결함이 있으며, 이제 Gleam에 관한 솔직한 의견을 말할 때다. 아직 이 언어 경험이 많다고 주장하지는 않으므로, 이 불만 중 무엇이든 부당하게 느껴진다면 나를 바로잡아도 좋다. 지금까지 내가 알아차린 점은 다음과 같다.
물론 이것은 매우 편향된 이야기다. 언어 자체의 많은 결함을 내가 놓치고 있다고 생각하며, 그런 결함은 신혼 기간이 끝나면 드러날 것이다. 하지만 지금은 Gleam을 아주 즐겁게 사용하고 있으며, 여러분도 꼭 한번 사용해 보기를 권할 수밖에 없다! 나처럼 무척 재미있게 느낄 것이라 확신한다!
나처럼 이것이 별 의미로 다가오지 않는다면, Erlang 역시 함수형 언어이며, 약 40년 된 훨씬 오래된 언어다. 주된 용도는 통신 시스템이었다. BEAM은 분산형, 동시성, 장애 허용 시스템에서 빛난다(그러니 당연히 통신 분야에서).↩︎
불변 언어에 관한 중요한 점 하나는 let new_list = list.take([1, 2, 3], 2) 같은 작업을 할 때 데이터를 _복사_하는 것이 아니라는 점이다(그것은 매우 낭비적일 것이다). 대신 두 변수의 공통 데이터는 메모리의 같은 위치에서 온다.↩︎
Gleam은 gleam/option을 통해 Option 모나드도 제공하지만, Rust와 달리 다소 권장되지 않으며 가능하면 단순한 Result(T, Nil)이 선호된다. 이것이 Gleam의 reduce가 Result(T, Nil)을 반환하는 반면 Rust는 Option<T>를 반환하는 이유다.↩︎
이는 완전히 지어낸 통계지만, 현실과 크게 동떨어지지 않았다고 느낀다.↩︎
Rust는 TCO를 보장하지 않는다. LLVM이 때때로 형제 호출 최적화를 적용하지만, 의존할 수 있는 대상은 아니며 명시적 꼬리 호출도 여전히 불안정하다. Rust는 반복문도 제공하므로, 명령형 스타일이 일반적으로 더 안전한 선택이다. TCO는 성능에 결정적이므로 함수형 언어의 컴파일러는 보통 이 부분을 훨씬 더 적극적으로 처리한다.↩︎
주요 차이는 वास्तव로 격리에 관한 것이다. OTP 노드는 단일 OS 프로세스이고 그 위의 모든 액터는 같은 메모리를 공유한다. 반면 Kubernetes는 각 파드에 자체 컨테이너를 제공하고 클러스터의 여러 머신에 분산한다. Erlang은 여러 노드를 함께 클러스터링하는 방법을 알고 있지만, OTP에는 클러스터 스케줄러, 배치 기능, 컨테이너 격리가 없다. 여전히 직접 노드를 배포하고 배치해야 한다.↩︎
Gleam의 정확한 나이는 논쟁의 여지가 있다. Wikipedia에 따르면 Gleam은 처음 2016년에 만들어졌지만, 번호 버전 관리를 도입한 2019년부터야 “진지한” 시도라고 여길 수 있으며 2024년에야 버전 1.0.0에 도달했다.↩︎