🗺 유니슨 둘러보기 · Unison 프로그래밍 언어

이 문서는 유니슨(Unison) 코드를 작성하는 기본 워크플로를 단계별로 안내합니다. 진행하면서 유니슨 핵심 언어와 그 문법의 여러 조각을 함께 소개합니다. 궁금한 점이 있거나 더 깊이 배우고 싶다면 유니슨 언어 문서를 참고하세요.

이 가이드는 이미 퀵스타트 가이드의 단계를 따라 완료했고, 핵심 아이디어를 한 번 훑어보았다고 가정합니다.

Part 1: 👋 유니슨 코드베이스 매니저 만나기

유니슨 코드베이스 매니저(Unison Codebase Manager), 줄여서 UCM은 유니슨 프로그래밍 언어를 실행하고, 작성한 유니슨 코드와 상호작용할 수 있게 해 주는 커맨드라인 도구입니다. UCM은 유니슨 코드베이스와 상호작용하는 인터페이스 역할을 합니다.

UCM의 주요 역할은 다음과 같습니다:

• 새 코드의 타입 검사 및 컴파일
• 유니슨 정의의 구성, 탐색, 검색
• 코드베이스 상태 저장
• 유니슨 프로그램 및 유니슨 바이너리 실행
• 유니슨 라이브러리 퍼블리시 및 설치

💡 기억해 두세요: 유니슨 코드는 텍스트 기반 파일 내용으로 저장되지 않습니다. 그렇기 때문에 유니슨 프로그램을 변경하고 실행하기 위해 이런 도구가 필요합니다.

UCM 실행하기

터미널에서 ucm 을 입력해 시작합니다. 기본적으로 ucm 은 홈 디렉터리에 코드베이스를 새로 만들거나 기존 것을 엽니다.

다음은 유니슨 코드베이스 매니저가 시작되면서 새 코드베이스를 초기화하는 모습입니다:

text
Now starting the Unison Codebase Manager (UCM)...

[…] 

Get started:

  📖 Type help to list all commands, or help <cmd> to view help for one command
  🎨 Type ui to open the Codebase UI in your default browser
  📚 Read the official docs at https://www.unison-lang.org/docs/
  🌏 Visit Unison Share at https://share.unison-lang.org to discover libraries
  👀 I'm watching for changes to .u files under ~/unisonCode

 scratch/main>

우리는 보통 코드베이스를, 우리가 코드를 변경할 때마다 수정되는 텍스트 파일들의 묶음으로 생각합니다. 하지만 유니슨에서는 코드베이스가 이 CLI의 도움을 받아 프로그래밍적으로 저장되고 갱신됩니다.

유니슨 코드베이스 포맷에는 몇 가지 중요한 특징이 있습니다:

• 항(term)과 타입은 이름뿐 아니라 구현으로 식별됩니다. 코드베이스는 항이나 타입의 문법 트리(syntax tree)에 대한 해시를 저장합니다.
• 추가 전용(append-only)입니다: 삭제를 포함한 모든 코드베이스 변경 사항은 코드베이스 상태를 나타내는 로그에 추가됩니다.
• 그 결과, 유니슨 코드베이스는 git과 독립적인 자체 버전 관리 및 동기화 개념을 가지며, 유니슨 코드의 시간에 따른 변화를 관리하고 확인하기 위한 다양한 도구 모음이 개발되어 있습니다.

새 코드베이스를 만드는 경우, 프롬프트 > 는 scratch/main 으로 표시됩니다. 이는 현재 작업 중인 프로젝트와 브랜치 이름을 나타내며, 이어서 이 두 개념을 살펴보겠습니다.

Part 2: 🗂 프로젝트 생성하기

애플리케이션마다 코드베이스를 여러 개 만드는 대신, 유니슨은 하나의 코드베이스를 "프로젝트(project)" 단위로 나눕니다. 유니슨 프로젝트는 소스 코드 저장소(repository)에 해당합니다. 프로젝트는 코드를 앱, 라이브러리, 그리고 협업이 필요할 수 있는 기타 작업으로 분리합니다. 프로젝트는 다시 독립적인 작업 흐름을 나타내는 브랜치들로 나뉩니다.

프로젝트 안에서 코드는 네임스페이스(namespace)로 묶입니다. 네임스페이스는 유니슨 항과 타입을, 컴퓨터의 디렉터리와 비슷한 트리 구조로 구성합니다. 예를 들어 math.sqrt 라는 이름은 math 네임스페이스 안의 sqrt 정의를 가리킵니다. 정의는 점(.)으로 구분되는 여러 네임스페이스 세그먼트를 가질 수 있습니다. 예: base.Optional.Some.

UCM 콘솔에서 project.create 명령으로 새 tour 프로젝트를 만들어 봅시다.

text
scratch/main> project.create tour

   🎉 I've created the project tour.

   I'll now fetch the latest version of the base Unison library...

   🎨 Type `ui` to explore this project's code in your browser.
   🌏 Discover libraries at https://share.unison-lang.org
   📖 Use `help-topic projects` to learn more about projects.

   Write your first Unison code with UCM:

     1. Open scratch.u.
     2. Write some Unison code and save the file.
     3. In UCM, type `update` to save it to your new project.

   🎉 🥳 Happy coding!

tour/main>

프롬프트가 tour/main> 으로 바뀐 것에 주목하세요. 현재 프로젝트는 이제 tour 이고, 현재 브랜치는 /main 입니다. 이 프로젝트와 브랜치에 범위(scope)가 한정된 상태로 UCM 명령과 코드가 작동합니다.

새 프로젝트를 만들면, UCM은 자동으로 base 표준 라이브러리를 설치해 줍니다. 이 라이브러리는 lib 라는 특별한 네임스페이스에 위치합니다.

🧠

lib 네임스페이스는 UCM이 프로젝트의 모든 의존성을 설치하는 곳입니다. 항상 프로젝트 루트 바로 아래에 위치합니다.

이제 방금 내려받은 base 라이브러리를 탐색하면서, 유니슨 코드베이스를 탐색하는 방법에 익숙해져 봅시다.

Part 3: ⛵️ 유니슨 코드베이스 탐색하기

ls 명령으로 네임스페이스 안의 항과 타입 이름을 볼 수 있습니다.

text
tour/main> ls lib.base.data.List

출력은 정의들과 해당 시그니처(signature)가 번호와 함께 나열된 목록입니다.

text
tour/main> ls lib.base.data.List

1.   ++                    ([a] -> [a] -> [a])
2.   ++.                   (1 term)
3.   +:                    (a -> [a] -> [a])
[…]

유니슨 코드는 UCM을 통해 저장되기 때문에, 다음과 같은 정보를 캐시하고 조회할 수 있습니다:

• 내 함수가 호출되는 모든 위치는 어디인가?
• 특정 이름이나 타입 시그니처와 일치하는 정의는 무엇인가?
• 내가 의존하는 함수의 정확한 구현은 무엇인가?

실제로 find 와 view 명령으로 검색과 코드 보기를 직접 해 보겠습니다:

text
tour/main> find reverse

I couldn't find matches in this namespace, searching in 'lib'...

1.  lib.base.data.Graph.reverse : Graph v ->{Exception} Graph v
2.  lib.base.data.Graph.tests.reverse : [Result]
3.  lib.base.data.List.Nonempty.reverse : List.Nonempty a -> List.Nonempty a
4.  lib.base.data.List.reverse : [a] -> [a]

find 명령은 이름에 reverse 가 포함된 정의들을 찾습니다. 먼저 프로젝트 안의 우리 코드에서 검색한 다음, lib 에서 검색합니다.

text
tour/main> view List.reverse

  lib.base.data.List.reverse : [a] -> [a]
  lib.base.data.List.reverse as =
     List.foldLeft (acc a -> a +: acc) [] as

여기서는 view 명령으로 함수의 소스 코드를 살펴보았습니다.

이제 유니슨 문법을 조금 소개해 보겠습니다:

• List.reverse : [a] -> [a] 는 타입 시그니처에 대한 문법입니다. 타입 시그니처는 유니슨에서 정의 위에 작성됩니다. : 기호는 "타입이 ~이다"라고 읽습니다. 예를 들어, "reverse 의 타입은 [a] -> [a] 이다"라는 의미입니다.
• 대괄호 [ ] 는 유니슨에서 리스트(list)를 나타냅니다.
• 타입 시그니처의 소문자 변수는 어떤 다른 타입을 나타내는 일반적인 자리 표시자입니다. 타입 [a] -> [a] 는, 어떤 타입의 원소들로 이루어진 리스트를 받아서 같은 타입의 리스트를 반환하는 함수라는 뜻입니다.
• List.reverse as 는 함수의 단일 인자를 as 라는 이름으로 받는다는 뜻입니다. = 뒤에 나오는 모든 것이 함수 본문입니다. 여기서는 공백(들여쓰기)으로 구분되는 블록입니다.
• (acc a -> ..) 는 익명 함수(람다)에 대한 문법입니다.
• 함수 인자는 공백으로 구분되므로, (acc a -> ...) [] as 는 List.foldLeft 에 전달되는 세 개의 인자입니다.

✨

view 명령을 인자 없이 입력하면, 코드베이스 정의를 찾을 수 있는 fzf 검색 인터페이스가 열립니다. 코드베이스를 빠르게 탐색하고 이름으로 정의를 찾는 좋은 방법입니다.

Part 4: 📝 유니슨 코드 작성하기

유니슨의 대화형 스크래치 파일

코드베이스 매니저는 현재 디렉터리 안의 .u 로 끝나는 모든 파일 변경을 감시합니다. 이런 파일이 저장될 때마다(이를 "스크래치 파일"이라고 부릅니다), 유니슨은 그 파일을 파싱하고 타입 검사를 수행합니다.

ucm 이 실행 중인 터미널은 그대로 두고, 선호하는 텍스트 에디터에서 scratch.u (또는 foo.u 같은 다른 이름도 괜찮습니다) 파일을 새로 여세요.

스크래치 파일에 다음 내용을 작성합니다:

unison
square : Nat -> Nat
square x =
  use Nat *
  x * x

이는 square 라는 함수를 정의합니다. 이 함수는 x 라는 인자를 받고, x 를 자기 자신과 곱한 값을 반환합니다.

use Nat * 는 어떤 * 연산자를 사용할지 지정하는 use 절입니다. 이 연산자는 lib.base 표준 라이브러리 안의 Nat 네임스페이스에 정의된 것입니다. use 절 덕분에 base.Nat 를 간단히 Nat 로, * 를 Nat.* 라고 접두사를 붙이지 않고도 사용할 수 있습니다.

파일을 저장하면, 유니슨은 이 변경을 적용할 수 있는지 여부를 알려 줍니다:

text
I found and typechecked these definitions in ~/unisoncode/scratch.u. If you do an `update`, here's how your codebase would change:

  ⍟ New definitions:

    square : Nat -> Nat

square 를 코드베이스에 저장하기 전에, 스크래치 파일 scratch.u 안에서 바로 한 번 호출해 보겠습니다. > 로 시작하는 한 줄을 추가하세요:

unison
square : Nat -> Nat
square x =
  use Nat *
  x * x

> square 4

파일을 저장하면, 유니슨은 다음과 같이 출력합니다:

text
6 | > square 4
      ⧩
      16

6번째 줄의 > square 4 는 "watch 표현식"이라고 부릅니다. 유니슨은 별도의 읽기-평가-출력 루프(REPL)를 두는 대신, watch 표현식을 사용해 코드 파일 안에서 직접 코드를 실행합니다. 스크래치 파일과 프로젝트 안에 있는 모든 것이 스코프 안에 들어오므로, 텍스트 에디터의 모든 기능을 활용하면서 코드를 작성하는 동시에 테스트할 수 있습니다.

질문: 값 계산 비용이 큰 경우에도, 저장할 때마다 모든 watch 표현식을 다시 평가해야 할까요? 유니슨은 이를 피하기 위해, 각 표현식의 해시를 키로 사용하는 캐시를 둡니다. 해시가 바뀌지 않는다면, 유니슨은 캐시된 결과를 재사용합니다. 언제든지 캐시를 지워도 문제 없습니다. .u 파일을 스프레드시트처럼 생각해 보세요 — 의존성이 바뀐 셀만 다시 계산됩니다.

🤓

이 방식이 효과적으로 동작하게 해 주는 마지막 재료는 함수형 프로그래밍입니다. 표현식에 부수효과(side effect)가 없다면, 그 결과는 결정적이며, 유니슨처럼 내용 기반(content-based) 해시를 키로 삼을 수 있다면 얼마든지 캐시할 수 있습니다. 유니슨의 타입 시스템은 이러한 watch 표현식 안에서 I/O 를 수행하거나, 평가할 때마다 결과가 달라질 수 있는 다른 작업을 할 수 없도록 막아 줍니다.

UCM이 어떻게 반응하는지 확인하기 위해, 더 많은 watch 표현식을 추가해 보세요:

unison
-- 유니슨이 무시하는 주석

> List.reverse [1,2,3,4]
> 4 + 6
> 5.0 / 2.0
> not true

코드 테스트하기

이제 square 함수에 대한 테스트를 추가해 보겠습니다:

unison
test> square.tests.ex1 =
 verify do ensureEqual (square 4) 16

• test> 는 square.tests.ex1 이라는 이름의 테스트 watch 표현식을 도입합니다.

  • 관례상, 정의 foo 에 대한 테스트는 foo.tests 아래에 둡니다. 그렇지 않더라도 이름 square.tests.ex1 자체에 특별한 의미가 있는 것은 아닙니다.

• test.verify 는 테스트 대상 함수를 예상 결과와 함께 호출하는 지연 계산을 기대합니다.

  • do 는 지연 계산을 시작합니다. 인자가 없는 함수, 즉 () -> a 처럼, 결과를 나중에(lazily) 반환하는 함수라고 생각하면 됩니다.

• test.ensureEqual 은 두 값이 서로 다르면 Exception 을 발생시켜 테스트를 실패하게 합니다.

파일을 저장하면, UCM은 다음과 같이 응답합니다:

text
8 | test> square.tests.ex1 =
       verify do ensureEqual (square 4) 16

✅ Passed

속성 기반(property-based) 테스트

이제 이 함수를 조금 더 철저하게 테스트해 봅시다. square 는 모든 a, b 에 대해 square a * square b == square (a * b) 라는 속성을 가져야 합니다. 유니슨 테스트 라이브러리는 이런 속성 기반(property-based) 테스트 작성을 지원합니다. 아래에는 새 문법이 조금 등장하는데, 뒤에서 설명합니다:

unison
test> square.tests.prop1 =
   verify do
     Each.repeat 100
     a = Random.natIn 0 100
     b = Random.natIn 0 100
     ensure (square a * square b == square (a * b))

이 코드는 Each 와 Random 능력(ability)을 사용해 다양한 입력으로 함수를 테스트합니다. Each 는 100개의 Random 숫자를 생성하는 데 사용되며, 테스트는 그 값들을 검증합니다.

문법 설명

• = 뒤에 시작되는 유니슨 코드 블록에는 같은 들여쓰기 수준의 바인딩(a = …)을 여러 개 둘 수 있습니다. 마지막 표현식(ensure (square …))이 그 블록의 결과입니다.
• do 키워드는 공백으로 경계가 정해지는 지연 계산 코드 블록을 시작합니다.

스크래치 파일을 저장해, 이 속성 테스트가 성공하는지 확인하세요.

Part 5: ➕➖ 코드 추가와 업데이트

square 함수와 그 테스트들은 아직 코드베이스의 일부가 아닙니다. 지금까지는 스크래치 파일 안에만 존재합니다. 이제 이들을 추가해 보겠습니다. UCM으로 돌아가서 update 를 입력합니다:

text
tour/main> update

  ⍟ I've added these definitions:

    square             : Nat -> Nat
    square.tests.ex1   : [Result]
    square.tests.prop1 : [Result]

UCM에서 view square.tests.prop1 을 입력해 보세요.

text
tour/main> view square.tests.prop1

square.tests.prop1 : [Result]
square.tests.prop1 = test.verify do
  use Nat * ==
  use Random natIn
  Each.repeat 100
  a = natIn 0 100
  b = natIn 0 100
  ensure (square a * square b == square (a * b))

유니슨은 코드를 렌더링할 때 정확한 use 문을 삽입하고, 자체 pretty-print 규칙에 따라 포맷팅합니다.

UCM 프롬프트에서 test 를 입력해 테스트 스위트를 "실행"해 보세요:

text
tour/main> test

  Cached test results (`help testcache` to learn more)

  ◉ square.tests.ex1      : Passed
  ◉ square.tests.prop1    : Passed

  ✅ 2 test(s) passing

  Tip: Use view square.tests.ex1 to view the source of a test.

콘솔에는 테스트 결과가 출력되지만, 실제로 코드를 다시 실행한 것은 아닙니다! 테스트는 이전에 이미 실행되었고, 유니슨 해시에 따라 캐시되어 있습니다. 유니슨 같은 순수 함수형 언어에서, 이런 테스트들은 결정적이기 때문에, 그들이 의존하는 코드가 바뀌기 전까지는 실제로 다시 실행되지 않습니다.

항 이동 및 이름 변경

이제 square 와 그 테스트들을 move 명령으로 프로젝트의 다른 위치로 옮겨 봅시다. move 는 재귀적으로 작동하므로, 항과 square 네임스페이스 안의 모든 것들을 새 이름으로 옮깁니다.

text
tour/main> move square mySquare

  Done.

이후, 인자 없이 find 를 사용하면 현재 네임스페이스 아래의 모든 정의를 볼 수 있습니다:

text
tour/main> find

  1. mySquare : Nat -> Nat
  2. mySquare.tests.ex1 : [Result]
  3. mySquare.tests.prop1 : [Result]

다시 test 를 실행해 보면, 여전히 테스트 결과가 캐시되어 있는 것을 볼 수 있습니다! 정의는 이름이 아니라 구현에 의해 식별되기 때문입니다.

text
tour/main> test

  Cached test results (`help testcache` to learn more)

  ◉ mySquare.tests.ex1       : Passed
  ◉ mySquare.tests.prop1     : Passed

  ✅ 2 test(s) passing

기존 정의 업데이트하기

이제 mySquare 함수의 구현을 바꿔 보겠습니다.

스크래치 파일 scratch.u 맨 위에 새 줄을 만들고 대시 세 개, --- 를 입력합니다. 이를 폴드(fold)라고 부릅니다. --- 아래에 있는 모든 내용은 UCM이 무시합니다.

그런 다음 UCM에서 edit mySquare 를 입력합니다:

text
tour/main> edit mySquare

  ☝️

  I added 1 definition to the top of ~/unisoncode/scratch.u

  You can edit them there, then run `update` to replace the definitions currently in this branch.

이 명령은 mySquare 의 pretty-print된 정의를 스크래치 파일 맨 앞에 추가합니다.

이제 mySquare x 를, 재미 삼아, 처음 x 개의 홀수의 합으로 정의해 보겠습니다. (이 방식이 원래 제곱과 같은 결과를 주는 이유에 대한 멋진 기하학적 설명이 있습니다.)

unison
use base

mySquare : Nat -> Nat
mySquare x =
  sum (map (x -> x * 2 + 1) (range 0 x))

sum : [Nat] -> Nat
sum = foldLeft (+) 0

파일을 저장하면, UCM은 mySquare 를 업데이트해도 괜찮다는 메시지를 표시할 것입니다:

text
I found and typechecked these definitions in ~/unisoncode/scratch.u. If you
run `update`, here's how your codebase would change:

    ⍟ These new definitions are ok to `update`:

      sum : [Nat] -> Nat

    ⍟ These names already exist. You can `update` them to your new definition:

      mySquare : Nat -> Nat

이제 실제로 update 를 실행해 봅시다:

text
tour/main> update

  ⍟ I've added these definitions:

    sum : [Nat] -> Nat

  ⍟ I've updated these names to your new definition:

    mySquare : Nat -> Nat

update 시 영향받은 테스트만 다시 실행

테스트를 다시 실행해야 하는지 여부를 판단하는 의존성 추적은 100% 정확하며, 개별 정의 단위로 추적됩니다.

이제 다시 test 명령을 실행하면, 실제로 의존성이 변경되었기 때문에 테스트가 더 이상 캐시되지 않습니다:

text
tour/main> test

  ✅

    New test results:

  ◉ mySquare.tests.ex1      : Passed
  ◉ mySquare.tests.prop1    : Passed

  ✅ 2 test(s) passing

  Tip: Use view 1 to view the source of a test.

Part 6: 🤝 코드 공유와 유니슨 라이브러리 설치

🎉

마지막으로 해야 할 일은 유니슨 셰어(Unison Share)에 가입하는 것입니다. 유니슨 셰어는 유니슨을 위한 코드 호스팅 플랫폼으로, 자신의 코드에 대한 협업을 관리하고 새 유니슨 라이브러리를 발견하는 곳입니다. Unison Share로 이동해, 로컬 코드베이스를 코드 호스팅에 연결하는 방법을 안내에 따라 진행하세요!

코드는 유니슨의 자체 코드 호스팅 솔루션인 Unison Share에 push 명령으로 퍼블리시되며, 라이브러리는 lib.install 명령으로 설치됩니다. 의존성을 관리하거나 코드를 퍼블리시하기 위해 별도의 도구가 필요하지 않습니다. Unison Share 상의 코드 호스팅과 상호작용하는 기능은 전부 UCM에 내장되어 있습니다.

유니슨 둘러보기를 마친 것을 축하합니다! 이제 유니슨 코드를 직접 작성할 준비가 되었습니다. 무엇을 만들어 낼지 기대하고 있습니다! 🥳