;; main.tpz - 간단한 "Hello, World!" Topaz 프로그램

;; 콘솔에 출력하는 main 프로세스(함수)를 정의합니다.
;; Topaz는 S-표현식을 사용합니다: (연산자 인자1 인자2 ...)
;; $는 정의에 사용됩니다. λ는 익명 프로세스를 생성합니다.
($ main
  (λ () ;; 인자를 받지 않는 프로세스
    (io:print "Hello, Topaz World!") ;; io 모듈의 print 함수
  )
)

;; main 프로세스를 실행하려면 (Topaz 런타임 환경에 따라 'main' 프로세스는
;; 암시적으로 실행되거나 명시적으로 호출될 수 있습니다):
;; (main)

# 가상 패키지 매니저 사용 예시
# $ cool_package_manager install topaz-sdk

# 또는 바이너리를 다운로드하여 설정하는 예시
# $ wget [https://topaz.ooo/downloads/topaz-sdk-v0.1.0.tar.gz](https://topaz.ooo/downloads/topaz-sdk-v0.1.0.tar.gz) 
# $ tar -xzf topaz-sdk-v0.1.0.tar.gz
# $ export PATH=$(pwd)/topaz-sdk/bin:$PATH

;; hello.tpz
;; Topaz의 세계로 떠나는 당신의 첫 모험!

;; Topaz에서 연산은 일반적으로 (연산자 인자1 인자2 ...) 형식으로 작성됩니다.
;; io:print는 콘솔에 텍스트를 출력하는 io 모듈의 함수입니다.
(io:print "Hello from Topaz!")

# 이 명령어는 Topaz 런타임이나 인터프리터에 따라 달라집니다
topaz run hello.tpz 

Hello from Topaz!

my_topaz_project/
├── src/                     # 소스 파일
│   ├── main.tpz             # 애플리케이션의 주 진입점
│   └── lib/                 # 재사용 가능한 라이브러리 코드 또는 모듈
│       └── utils.tpz        # 유틸리티 모듈 예시
├── topaz_project.toml       # (가상) 프로젝트 명세 파일: 의존성, 설정 등
├── .gitignore               # Git 무시 파일
└── README.md                # 프로젝트 설명

;; 파일: src/utils.tpz
;; 간단한 유틸리티 모듈.

(MODULE utils
  (EXPORT add greet)

  ;; 'a'와 'b' 두 인자를 받는 'add' 프로세스를 정의합니다.
  ($ add 
    (λ (a b) 
      (+ a b) ;; '+'는 핵심 연산입니다
    )
  )

  ;; 또 다른 유틸리티
  ($ greet
    (λ (name)
      (string:concat "Hello, " name "!") ;; 문자열 결합을 위한 string:concat
    )
  )
)

;; 파일: src/main.tpz
;; 다른 모듈의 함수를 사용하는 것을 보여줍니다.

;; utils 모듈을 u 라는 별칭으로 가져옵니다
(IMPORT utils :as u)

($ main
  (λ ()
    ($ result (u:add 5 3))
    (io:print 
      (string:concat "5 + 3 = " (core:to-string result))
    )
  )
)

;; (main) ;; main 프로세스를 실행하려면

;; 파일에서 텍스트 읽기
($ file-path "data/input.txt")
($ content-result (io:read-text-file file-path)) ;; 연산은 Result 타입을 반환합니다

;; Result 타입 처리와 함께 IF 사용하기
(IF (result:is-ok content-result)
  (io:print (string:concat "파일 내용: " (result:get-value content-result)))
  (io:print (string:concat "파일 읽기 오류: " (result:get-error content-result)))
)

;; 파일에 텍스트 쓰기
($ output-path "data/output.txt")
($ write-status (io:write-text-file output-path "Hello from Topaz file I/O!"))

(IF (result:is-ok write-status)
  (io:print "파일에 성공적으로 썼습니다.")
  (io:print "파일 쓰기 오류.")
)

;; 실패할 수 있는 함수, Result 타입을 반환합니다
($ safe-divide 
  (λ (numerator denominator)
    (IF (= denominator 0)
      (result:err "0으로 나누기 오류!") ;; 실패를 위한 result:err 생성자
      (result:ok (/ numerator denominator)) ;; 성공을 위한 result:ok 생성자
    )
  )
)

($ operation-result (safe-divide 10 2))
;; ($ operation-result (safe-divide 10 0)) ;; 오류 케이스를 테스트하려면

;; 결과 처리하기
(IF (result:is-ok operation-result)
  (io:print (string:concat "결과: " (core:to-string (result:get-value operation-result))))
  (io:print (string:concat "오류: " (result:get-error operation-result)))
)

;; "작업자" 역할을 하는 프로세스를 정의합니다
($ my-worker-process 
  (λ (message-channel)
    ;; 메시지를 받기 위한 루프
    (concurrent:loop
      ($ received-message (concurrent:receive message-channel))
      (io:print (string:concat "작업자가 받음: " received-message))
      ;; ... 어떤 작업을 수행 ...
    )
  )
)

;; 작업자 생성
($ worker-channel (concurrent:create-channel))
(concurrent:spawn (my-worker-process worker-channel))

;; 작업자에게 메시지 보내기
(concurrent:send worker-channel "작업 A")

;; 아톰 (Atoms):
42                     ;; 정수 (Integer)
3.14159                ;; 부동 소수점 수 (Floating-point number)
"Hello, Topaz"         ;; 문자열 (String)
:my-symbol             ;; 심볼 (Symbol)
is-ready?              ;; 식별자 (Identifier, 아톰이 될 수도 있음)
#true                  ;; 불리언 true 리터럴
#false                 ;; 불리언 false 리터럴
NULL_SIG               ;; 특수한 Null 시그널 값

;; 리스트 (Lists, 이 또한 S-표현식입니다):
(+ 10 20)              ;; 간단한 연산: 연산자 뒤에 인자들이 옴
($ x 100)              ;; 정의: 특수 구문, 식별자, 표현식
(λ (a b) (+ a b))      ;; 람다 (익명 프로세스) 정의

;; 이것은 한 줄 전체 주석입니다.
($ pi 3.14159) ;; 이 주석은 같은 줄의 표현식 뒤에 옵니다.

$ my-variable 10
$ process? (λ (x) (> x 0))
$ update-state! (λ (s) (;;... 
                    ))

($ age 30)
($ message "Welcome to Topaz")
($ sum (+ 15 27)) ;; sum은 42에 바인딩됨

;; 이름 있는 프로세스(함수) 정의하기
($ add-numbers
  (λ (x y) 
    (+ x y)
  )
)

(+ 1 2 3)                   ;; 6으로 평가됨
(CONCAT "Topaz " "is " "fun!") ;; "Topaz is fun!"으로 평가됨
(> 10 5)                    ;; 불리언 컨텍스트에서 true(1)로 평가됨

;; 위에서 정의한 'add-numbers' 프로세스 사용하기
(add-numbers 100 200)       ;; 300으로 평가됨

($ is-enabled #true)
($ has-errors #false)

($ current-status :pending)

($ empty-vec [])
($ primes [2 3 5 7 11])
($ mixed-data [10 "label" :option-a])

($ empty-map (#))
($ point (# :x 10 :y 20))
($ config (# "host" "localhost" "port" 8080 :retries 3))

($ no-result NULL_SIG)

($ user-age 25)
($ access-level (IF (>= user-age 18) 
                   :adult 
                   :minor)) ;; access-level은 :adult가 됨

($ temperature 15)
($ weather-advice (IF (< temperature 0)
                     "아주 따뜻한 코트를 입으세요!"
                     (IF (< temperature 15)
                        "가벼운 재킷이면 충분해요."
                        "쾌적한 날씨를 즐기세요!"
                     )
                  ))

;; 숫자를 제곱하는 프로세스
(λ (n) (* n n))

;; $를 사용하여 람다로 정의된 프로세스에 이름 부여하기
($ square (λ (n) (* n n)))
(square 7) ;; 49로 평가됨

($ create-greeter 
  (λ (greeting)
    (λ (name) (string:concat greeting ", " name "!"))
  )
)
($ hello-greeter (create-greeter "Hello"))
(hello-greeter "Topaz Developer") ;; "Hello, Topaz Developer!"로 평가됨

;; x와 y 좌표를 갖는 Point 타입 정의
(DEFINE-TYPE Point (# :x Float :y Float))

;; 타입 구조와 일치하는 맵 리터럴을 사용하여 인스턴스 생성
($ origin (# :x 0.0 :y 0.0))
($ point1 (# :x 10.5 :y -5.0))

;; 여러 필드 타입을 갖는 Person 타입 정의
(DEFINE-TYPE Person (# :name String :age Integer :active Boolean))
($ user (# :name "Alice" :age 30 :active #true))

;; 색상 열거형 정의
(DEFINE-ENUM Color :RED :GREEN :BLUE)

;; 상태 열거형 정의
(DEFINE-ENUM Status :PENDING :COMPLETED :FAILED :CANCELLED)

;; 열거형 값 사용
($ my-color :RED)
($ task-status :PENDING)

;; 모든 타입 T와 함께 작동하는 제네릭 항등 함수
($ identity
  (λ [T] (value: T)
    value
  )
)

;; 벡터의 첫 번째 요소를 가져오는 제네릭 함수
($ first-element
  (λ [E] (vec: (Vector E))
    (vector:first vec)
  )
)

;; 제네릭 함수 사용
($ num-result (identity 42))           ;; T는 Integer로 추론됨
($ str-result (identity "hello"))      ;; T는 String으로 추론됨
($ first-num (first-element [1 2 3]))  ;; E는 Integer로 추론됨

(MODULE 모듈-이름
  (EXPORT 식별자1 식별자2 ...)
  
  ;; ... 정의를 포함한 모듈 본문 ...
)

(MODULE math
  (EXPORT PI add square)

  ($ PI 3.14159)
  ($ add (λ (a b) (+ a b)))
  ($ square (λ (n) (* n n)))
  ($ private-helper (λ () ...)) ;; 내보내지 않음, 내부 전용
)

;; math 모듈에서 특정 심볼 가져오기
(IMPORT math (add PI))
(io:print (core:to-string (+ (add 5 10) PI)))

;; math 모듈을 별칭으로 가져오기 (권장 방식)
(IMPORT math :as m)
(io:print (core:to-string (m:add (m:square 5) m:PI)))

;; 조건이 참일 때만 본문을 실행하는 'when' 매크로 정의
(DEFMACRO when (condition body-expressions...)
  `(IF ,condition
     (BEGIN ,@body-expressions)
     NULL_SIG
   )
)

;; 'when' 매크로 사용
($ x 10)
(when (> x 5)
  (io:print "x는 5보다 큽니다")
  (io:print "이것도 실행됩니다")
)

;; 'unless' 매크로 정의 (when의 반대)
(DEFMACRO unless (condition body-expressions...)
  `(IF ,condition
     NULL_SIG
     (BEGIN ,@body-expressions)
   )
)

(IMPORT string :as str)
(IMPORT vector :as vec)

($ numbers [1 2 3 4 5])
($ doubled (vec:map (λ (n) (* n 2)) numbers))
($ result-string (str:concat "두 배 결과: " (core:to-string doubled)))
(io:print result-string)

;; 숫자는 표기법에 따라 추론됩니다
($ age 30)          ;; 정수(Integer)로 추론됨
($ count -100)       ;; 정수(Integer)로 추론됨
($ price 19.99)      ;; 부동 소수점 수(Float)로 추론됨
($ pi 3.1415926535)  ;; 부동 소수점 수(Float)로 추론됨

;; 정밀도나 크기가 중요한 특정 시나리오를 위해
;; 향후 확장 기능에서 명시적인 타입 힌트나 접미사를 허용할 수 있지만,
;; 일반적인 사용에는 타입 추론이 선호됩니다.

;; 불리언 리터럴
($ is-active #true)       ;; 불리언 true
($ has-permission #false) ;; 불리언 false

;; 조건 표현식에서 불리언 사용하기
(IF is-active
  (io:print "시스템이 활성 상태입니다")
  (io:print "시스템이 비활성 상태입니다")
)

;; 불리언 연산
($ both-true (AND #true #true))    ;; #true로 평가됨
($ either-true (OR #false #true))  ;; #true로 평가됨
($ negated (NOT #true))            ;; #false로 평가됨

($ name "Topaz Language")
($ message "Hello, Topaz! 👋")
($ empty-string "")
($ greeting (string:concat "Hello, " name))

($ mode :edit)          ;; 키워드와 같은 심볼
($ status 'pending)       ;; 다른 스타일의 심볼
($ first-name 'firstName) ;; 식별자로 사용된 심볼

($ empty-vector [])
($ numbers [1 2 3 4 5])      ;; 정수 벡터
($ strings ["hello" "world" "topaz"]) ;; 문자열 벡터
($ nested-vector [1 [2 3] 4])

;; vector 모듈을 사용한 벡터 연산
($ doubled (vector:map (λ (x) (* x 2)) numbers))
($ first-item (vector:first numbers))  ;; 1을 가져옴
($ rest-items (vector:rest numbers))   ;; [2 3 4 5]를 가져옴

($ empty-map (#))
($ user-profile 
  (# 
    :name "Jamie Yoon" 
    :role "CTO" 
    :active #true 
    :projects ["Topaz" "Studio Haze"]
  )
)
($ config (# "version" "1.0.2" "debug-mode" #false)) ;; 문자열 키와 불리언 값

;; map 모듈을 사용한 맵 연산
($ user-name (map:get user-profile :name))  ;; "Jamie Yoon"을 가져옴
($ updated-profile (map:assoc user-profile :active #false))  ;; 값이 업데이트된 새 맵을 반환함

($ add 
  (λ (a b) 
    (+ a b)
  )
)
($ my-adder add) ;; 프로세스를 다른 변수에 할당
(io:print (core:to-string (my-adder 10 20))) ;; 30을 출력

($ no-value NULL_SIG)

($ do-something-that-returns-nothing
  (λ () 
    (io:print "작업 수행 중...")
    ;; 명시적인 반환이 없으므로 NULL_SIG를 생성함
  )
)
($ result (do-something-that-returns-nothing))
;; 여기서 'result'는 NULL_SIG를 가짐

;; 부동 소수점 좌표를 갖는 Point 타입 정의
(DEFINE-TYPE Point (# :x Float :y Float))

;; 여러 필드 타입을 갖는 Person 타입 정의
(DEFINE-TYPE Person (# :name String :age Integer :active Boolean))

;; 다른 사용자 정의 타입을 사용하여 중첩 타입 정의
(DEFINE-TYPE Rectangle (# :top-left Point :bottom-right Point))

;; 타입 구조와 일치하는 맵 리터럴을 사용하여 인스턴스 생성
($ origin (# :x 0.0 :y 0.0))  ;; 타입: Point
($ user (# :name "Alice" :age 30 :active #true))  ;; 타입: Person
($ rect (# :top-left origin :bottom-right (# :x 10.0 :y 10.0)))  ;; 타입: Rectangle

;; 기본 열거형 정의
(DEFINE-ENUM Color :RED :GREEN :BLUE :YELLOW)
(DEFINE-ENUM Status :PENDING :IN_PROGRESS :COMPLETED :FAILED :CANCELLED)
(DEFINE-ENUM Direction :NORTH :SOUTH :EAST :WEST)

;; 열거형 값 사용
($ current-color :RED)
($ task-status :IN_PROGRESS)
($ facing :NORTH)

;; 열거형은 조건 논리와 잘 작동함
(IF (= current-color :RED)
  (io:print "정지!")
  (io:print "진행")
)

;; 모든 타입 T와 함께 작동하는 제네릭 함수
($ identity
  (λ [T] (value: T)
    value
  )
)

;; 모든 요소 타입 E의 벡터를 위한 제네릭 함수
($ vector-length
  (λ [E] (vec: (Vector E))
    (vector:length vec)
  )
)

;; 타입 매개변수를 사용하여 제네릭 데이터 구조를 정의할 수 있음
;; 참고: 제네릭 타입 정의를 위한 정확한 구문은 향후 언어 확장의 일부입니다
;; (DEFINE-TYPE Maybe [T] (# :some T | :none NULL_SIG))  ;; 미래 구문 예시

;; 패턴 매칭 및 필드 접근 (맵 연산 사용)
($ get-person-info
  (λ (person: Person)
    ($ name (map:get person :name))
    ($ age (map:get person :age))
    (string:concat name " is " (core:to-string age) " years old")
  )
)

;; 타입-안전 연산
($ calculate-distance
  (λ (p1: Point p2: Point)
    ($ dx (- (map:get p2 :x) (map:get p1 :x)))
    ($ dy (- (map:get p2 :y) (map:get p1 :y)))
    (math:sqrt (+ (* dx dx) (* dy dy)))
  )
)

;; 함수 사용하기
($ alice (# :name "Alice" :age 30 :active #true))
($ point1 (# :x 0.0 :y 0.0))
($ point2 (# :x 3.0 :y 4.0))

(io:print (get-person-info alice))  ;; "Alice is 30 years old"
(io:print (core:to-string (calculate-distance point1 point2)))  ;; "5.0"

($ 프로세스_이름
  (λ (매개변수_1 매개변수_2 ...)
    ;; 여기에 본문 표현식이 들어갑니다.
    ;; 마지막 표현식의 결과가 반환됩니다.
  )
)

;; 두 숫자를 더하는 간단한 프로세스
($ add
  (λ (x y)
    (+ x y)
  )
)

;; 프로세스 호출은 다른 연산과 동일합니다
(add 5 10) ;; 15로 평가됩니다

($ greeting-process (λ (name) (CONCAT "Hello, " name)))
($ say-hello greeting-process) ;; 프로세스 값을 새로운 식별자에 할당

(say-hello "Topaz") ;; "Hello, Topaz"로 평가됩니다

;; 다른 프로세스 'f'와 값 'v'를 인자로 받아,
;; 'v'에 'f'를 적용하는 프로세스
($ apply-it
  (λ (f v)
    (f v)
  )
)

($ square (λ (n) (* n n)))

;; 여기서 'square' 프로세스를 인자로 전달합니다.
(apply-it square 10) ;; 100으로 평가됩니다

;; 제네릭 고차 함수 예시
($ compose
  (λ [A B C] (f: (Process B C) g: (Process A B))
    (λ (x: A)
      (f (g x))
    )
  )
)

;; 이 프로세스는 단지 값을 반환하는 것이 아니라 새로운 프로세스를 반환합니다.
($ make-adder
  (λ (amount-to-add)
    ;; 이 내부 람다가 반환되는 부분입니다.
    (λ (n)
      (+ n amount-to-add)
    )
  )
)

;; adder의 특화된 버전을 만듭니다.
($ add-five (make-adder 5))
($ add-ten (make-adder 10))

(add-five 100) ;; 105로 평가됩니다
(add-ten 100)  ;; 110으로 평가됩니다

;; 숫자의 팩토리얼을 계산하는 재귀 프로세스
($ factorial
  (λ (n)
    (IF (<= n 1)
      1 ;; 기본 케이스: 0 또는 1의 팩토리얼은 1입니다.
      (* n (factorial (- n 1))) ;; 재귀 단계: n * factorial(n-1).
    )
  )
)

(factorial 5) ;; 120으로 평가됩니다 (5 * 4 * 3 * 2 * 1)

;; 더 나은 성능을 위한 꼬리 재귀 버전
($ factorial-tail
  (λ (n)
    ($ factorial-helper
      (λ (n acc)
        (IF (<= n 1)
          acc
          (factorial-helper (- n 1) (* n acc))
        )
      )
    )
    (factorial-helper n 1)
  )
)

;; 제네릭 항등 함수
($ identity
  (λ [T] (value: T)
    value
  )
)

;; 벡터를 위한 제네릭 map 함수
($ vector-map
  (λ [A B] (f: (Process A B) vec: (Vector A))
    ;; 구현은 표준 라이브러리에서 제공될 것입니다
    (vector:map f vec)
  )
)

;; 타입 추론과 함께 사용
($ numbers [1 2 3 4])
($ doubled (vector-map (λ (x) (* x 2)) numbers))  ;; A=Integer, B=Integer로 추론됨

;; 커링된 덧셈 함수
($ add-curried
  (λ (x)
    (λ (y)
      (+ x y)
    )
  )
)

;; 부분 적용을 통해 특화된 함수 생성
($ add-five (add-curried 5))
($ add-ten (add-curried 10))

(io:print (core:to-string (add-five 7)))   ;; "12"를 출력
(io:print (core:to-string (add-ten 20)))   ;; "30"을 출력

($ temperature 25)

($ clothing-advice
  (IF (> temperature 20)
    "따뜻하니, 티셔츠를 입으세요!"
    "쌀쌀하니, 재킷을 고려해보세요."
  )
)
;; clothing-advice의 값은 "따뜻하니, 티셔츠를 입으세요!" 입니다.

;; 중첩된 조건문
($ grade 85)
($ letter-grade
  (IF (>= grade 90)
    "A"
    (IF (>= grade 80)
      "B"
      (IF (>= grade 70)
        "C"
        "F"
      )
    )
  )
)

($ sum-vector
  (λ (vec)
    (IF (vector:is-empty vec)
      0 ;; 기본 케이스: 빈 벡터의 합은 0
      (+ (vector:first vec) (sum-vector (vector:rest vec))) ;; 재귀 단계
    )
  )
)

(sum-vector [10 20 30 40]) ;; 100으로 평가됩니다

($ numbers [1 2 3 4 5])

;; MAP: 모든 요소에 프로세스를 적용하여 결과로 새로운 벡터를 반환합니다.
($ squared (vector:map (λ (n) (* n n)) numbers))
;; squared의 값은 [1 4 9 16 25] 입니다.

;; FILTER: 특정 조건을 만족하는 요소만 포함하는 새로운 벡터를 반환합니다.
($ evens (vector:filter (λ (n) (= (% n 2) 0)) numbers))
;; evens의 값은 [2 4] 입니다.

;; REDUCE: 프로세스를 반복적으로 적용하여 모든 요소를 단일 값으로 결합합니다.
($ sum (vector:reduce + 0 numbers)) ;; 초기값 0으로 시작합니다.
;; sum의 값은 15 입니다.

;; 평가 순서를 더 세밀하게 제어하기 위한 FOLD-LEFT와 FOLD-RIGHT
($ concatenated (vector:fold-left string:concat "" ["Hello" " " "Topaz" "!"]))
;; concatenated의 값은 "Hello Topaz!" 입니다.

;; 조건이 참일 때만 본문을 실행하는 'when' 매크로 정의
(DEFMACRO when (condition body-expressions...)
  `(IF ,condition
     (BEGIN ,@body-expressions)
     NULL_SIG
   )
)

;; 'when' 매크로 사용
($ x 10)
(when (> x 5)
  (io:print "x는 5보다 큽니다")
  (io:print "이것도 실행됩니다")
)

;; 'unless' 매크로 정의 (when의 반대)
(DEFMACRO unless (condition body-expressions...)
  `(IF ,condition
     NULL_SIG
     (BEGIN ,@body-expressions)
   )
)

;; 여러 조건을 위한 'cond' 매크로 정의 (Lisp의 cond와 유사)
(DEFMACRO cond (clauses...)
  ;; 구현은 중첩된 IF 표현식으로 확장될 것입니다
  ;; 이것은 단순화된 개념적 예시입니다
  `(IF ,(first (first clauses))
     ,(second (first clauses))
     (cond ,@(rest clauses))
   )
)

;; cond 매크로 사용
($ grade 85)
($ letter (cond
  ((>= grade 90) "A")
  ((>= grade 80) "B")
  ((>= grade 70) "C")
  (#true "F")  ;; 기본 케이스
))

;; Result 타입을 처리하기 위한 미래의 MATCH 표현식
(MATCH some-result
  ((result:ok value) (io:print (string:concat "성공! 값: " value)))
  ((result:err message) (io:print (string:concat "실패! 이유: " message)))
)

;; 사용자 정의 타입에 대한 패턴 매칭
(MATCH user-input
  ((# :type :login :username u :password p) (authenticate u p))
  ((# :type :logout :session-id sid) (logout sid))
  ((# :type :unknown) (io:print "알 수 없는 명령어"))
)

;; Result 타입을 반환하는 "안전한 나눗셈" 프로세스
($ safe-divide
  (λ (numerator denominator)
    (IF (= denominator 0)
      (result:err "0으로 나누기는 허용되지 않습니다.") ;; 실패 시 오류 반환
      (result:ok (/ numerator denominator))           ;; 성공 시 값과 함께 성공 반환
    )
  )
)

($ result1 (safe-divide 10 2))  ;; (result:ok 5)로 평가됨
($ result2 (safe-divide 10 0))  ;; (result:err "0으로 나누기는 허용되지 않습니다.")로 평가됨

($ handle-division-result
  (λ (result)
    (IF (result:is-ok result) ;; 결과가 성공인지 확인
      (io:print (string:concat "성공! 값은: " (string:to-string (result:get-value result))))
      (io:print (string:concat "오류가 발생했습니다: " (result:get-error result)))
    )
  )
)

(handle-division-result result1) ;; "성공! 값은: 5"를 출력
(handle-division-result result2) ;; "오류가 발생했습니다: 0으로 나누기는 허용되지 않습니다."를 출력

;; 가상의 'result:then' 프로세스는 Result와 다른 프로세스를 인자로 받습니다.
;; Result가 OK일 경우에만 프로세스를 적용합니다.
;; Result가 ERR이면, 오류를 그대로 전달합니다.
($ first-step (safe-divide 100 2)) ;; -> (result:ok 50)
($ second-step (result:then first-step (λ (value) (safe-divide value 5)))) ;; -> (result:ok 10)
($ final-result (result:then second-step (λ (value) (safe-divide value 10)))) ;; -> (result:ok 1)

;; 이제 오류를 발생시켜 봅시다.
($ failing-step (result:then first-step (λ (value) (safe-divide value 0)))) ;; -> (result:err "0으로 나누기...")
($ final-result-with-error (result:then failing-step (λ (value) (safe-divide value 2))))
;; 마지막 단계는 절대 실행되지 않습니다. 최종 결과는 여전히 첫 번째 오류입니다.
;; final-result-with-error는 (result:err "0으로 나누기...") 입니다.

($ my-config (# :host "topaz.ooo" :port 80))

;; Option 타입을 반환할 수 있는 안전한 맵 조회
($ get-port (map:get my-config :port))      ;; 개념적인 (option:some 80)으로 평가됨
($ get-user (map:get my-config :user))      ;; 개념적인 (option:none)으로 평가됨

(IF (option:is-some get-user)
  (io:print "설정에서 사용자를 찾았습니다.")
  (io:print "설정에서 사용자를 찾을 수 없습니다.")
)