freelang-editor 11.7.4

package/examples/learning-session/01-grade-stats.fl

@@ -0,0 +1,49 @@
+;; 여러 반 성적 통계 비교
+
+(let [classes {"A반" [85 92 78 95 88 72 90 83 76 91]
+               "B반" [70 65 80 72 68 75 71 69 77 74]
+               "C반" [95 98 100 92 97 94 99 96 93 88]}
+
+      average (fn [scores]
+                (/ (reduce + 0 scores) (length scores)))
+
+      grade   (fn [avg]
+                (cond
+                  (>= avg 90) "A"
+                  (>= avg 80) "B"
+                  (>= avg 70) "C"
+                  (>= avg 60) "D"
+                  :else       "F"))
+
+      stats   (fn [scores]
+                (let [avg     (average scores)
+                      mx      (reduce (fn [a x] (if (> x a) x a)) 0 scores)
+                      mn      (reduce (fn [a x] (if (< x a) x a)) 100 scores)
+                      cnt80   (length (filter (fn [x] (>= x 80)) scores))]
+                  {:avg avg :max mx :min mn :cnt80 cnt80 :grade (grade avg)}))
+
+      report  (fn [name scores]
+                (let [s (stats scores)]
+                  (println (str "┌─ " name " ───────────────────"))
+                  (println (str "│  평균: " (get s :avg) "  등급: " (get s :grade)))
+                  (println (str "│  최고: " (get s :max) "  최저: " (get s :min)))
+                  (println (str "│  80점 이상: " (get s :cnt80) "명 / " (length scores) "명"))
+                  (println "└───────────────────────────")))]
+
+  (println "=== 반별 성적 통계 ===")
+  (println "")
+  (report "A반" (get classes "A반"))
+  (println "")
+  (report "B반" (get classes "B반"))
+  (println "")
+  (report "C반" (get classes "C반"))
+  (println "")
+
+  (let [all (append (get classes "A반")
+                    (append (get classes "B반")
+                            (get classes "C반")))
+        s   (stats all)]
+    (println "=== 전체 통합 ===")
+    (println (str "전체 평균: " (get s :avg)))
+    (println (str "전체 등급: " (get s :grade)))
+    (println (str "80점 이상: " (get s :cnt80) "명 / " (length all) "명"))))

package/examples/learning-session/02-class-stats.fl

@@ -0,0 +1,52 @@
+(let [a-scores [85 92 78 95 88 72 90 83 76 91]
+      b-scores [70 65 80 72 68 75 71 69 77 74]
+      c-scores [95 98 100 92 97 94 99 96 93 88]
+
+      average  (fn [scores]
+                 (/ (reduce + 0 scores) (length scores)))
+
+      grade    (fn [avg]
+                 (cond
+                   (>= avg 90) "A"
+                   (>= avg 80) "B"
+                   (>= avg 70) "C"
+                   (>= avg 60) "D"
+                   :else       "F"))
+
+      stats    (fn [scores]
+                 (let [avg   (average scores)
+                       mx    (reduce (fn [a x] (if (> x a) x a)) 0 scores)
+                       mn    (reduce (fn [a x] (if (< x a) x a)) 100 scores)
+                       cnt80 (length (filter (fn [x] (>= x 80)) scores))]
+                   {:avg avg :max mx :min mn :cnt80 cnt80 :grade (grade avg)}))
+
+      report   (fn [name scores]
+                 (let [s (stats scores)]
+                   (println (str "┌─ " name " ──────────────────"))
+                   (println (str "│  평균: " (get s :avg) "  등급: " (get s :grade)))
+                   (println (str "│  최고: " (get s :max) "  최저: " (get s :min)))
+                   (println (str "│  80점 이상: " (get s :cnt80) "명 / " (length scores) "명"))
+                   (println "└──────────────────────────")))]
+
+  (println "=== 반별 성적 통계 ===")
+  (println "")
+  (report "A반" a-scores)
+  (println "")
+  (report "B반" b-scores)
+  (println "")
+  (report "C반" c-scores)
+  (println "")
+
+  ;; 전체: 3개 반 합산 직접 계산
+  (let [total-sum   (+ (reduce + 0 a-scores)
+                       (reduce + 0 b-scores)
+                       (reduce + 0 c-scores))
+        total-cnt   (+ (length a-scores) (length b-scores) (length c-scores))
+        total-avg   (/ total-sum total-cnt)
+        total-cnt80 (+ (length (filter (fn [x] (>= x 80)) a-scores))
+                       (length (filter (fn [x] (>= x 80)) b-scores))
+                       (length (filter (fn [x] (>= x 80)) c-scores)))]
+    (println "=== 전체 통합 ===")
+    (println (str "전체 평균: " total-avg))
+    (println (str "전체 등급: " (grade total-avg)))
+    (println (str "80점 이상: " total-cnt80 "명 / " total-cnt "명"))))

package/examples/learning-session/03-cart.fl

@@ -0,0 +1,61 @@
+;; 장바구니 — 상품 추가 / 할인 / 합계
+
+(let [products {"apple"  {:name "사과"   :price 1200 :stock 50}
+                "banana" {:name "바나나" :price 800  :stock 30}
+                "orange" {:name "오렌지" :price 1500 :stock 20}
+                "grape"  {:name "포도"   :price 3000 :stock 15}}
+
+      discounts {"vip"     0.2
+                 "member"  0.1
+                 "student" 0.05}
+
+      add-item  (fn [cart id qty]
+                  (let [p (get products id)]
+                    (if (= p nil)
+                      cart
+                      (let [cur    (get cart id {:qty 0 :product p})
+                            newqty (+ (get cur :qty) qty)]
+                        (assoc cart id {:qty newqty :product p})))))
+
+      subtotal  (fn [cart]
+                  (reduce
+                    (fn [acc item]
+                      (+ acc (* (get item :qty)
+                                (get (get item :product) :price))))
+                    0
+                    (values cart)))
+
+      discount  (fn [total grade]
+                  (let [rate (get discounts grade 0)]
+                    {:total    total
+                     :rate     rate
+                     :discount (* total rate)
+                     :final    (* total (- 1 rate))}))
+
+      print-row (fn [item]
+                  (let [p     (get item :product)
+                        qty   (get item :qty)
+                        price (get p :price)]
+                    (println (str "  " (get p :name)
+                                  " x" qty
+                                  "  @" price "원"
+                                  "  = " (* qty price) "원"))))
+
+      receipt   (fn [cart grade]
+                  (let [sub (subtotal cart)
+                        d   (discount sub grade)]
+                    (println "================================")
+                    (println "         장바구니 영수증")
+                    (println "================================")
+                    (map print-row (values cart))
+                    (println "--------------------------------")
+                    (println (str "소계:       " (get d :total) "원"))
+                    (println (str "할인(" grade "): -" (get d :discount) "원"))
+                    (println "================================")
+                    (println (str "최종합계:   " (get d :final) "원"))))]
+
+  (let [c1 (add-item {} "apple"  3)
+        c2 (add-item c1 "banana" 5)
+        c3 (add-item c2 "grape"  2)
+        c4 (add-item c3 "apple"  2)]
+    (receipt c4 "member")))

package/examples/learning-session/04-word-freq.fl

@@ -0,0 +1,57 @@
+;; 단어 빈도 분석기
+
+(let [text "the quick brown fox jumps over the lazy dog the fox was very quick and the dog was very lazy"
+
+      ;; 텍스트 → 단어 배열
+      words     (str-split (str-lower text) " ")
+
+      ;; 단어 빈도 맵 구성
+      count-words (fn [words]
+                    (reduce
+                      (fn [acc word]
+                        (if (= word "")
+                          acc
+                          (let [cur (get acc word 0)]
+                            (assoc acc word (+ cur 1)))))
+                      {}
+                      words))
+
+      ;; 맵 → [{:word w :count n}] 배열로 변환
+      to-entries  (fn [freq-map]
+                    (map
+                      (fn [w]
+                        {:word w :count (get freq-map w)})
+                      (keys freq-map)))
+
+      ;; 빈도 내림차순 정렬
+      sort-desc   (fn [entries]
+                    (sort entries
+                          (fn [a b]
+                            (> (get a :count) (get b :count)))))
+
+      ;; 상위 N개 추출
+      top-n       (fn [entries n]
+                    (take n entries))
+
+      ;; 결과 출력
+      print-bar   (fn [entry rank]
+                    (let [w  (get entry :word)
+                          n  (get entry :count)
+                          bar (str-repeat "█" n)]
+                      (println (str rank ". " w
+                                    (str-repeat " " (- 10 (length w)))
+                                    bar " (" n ")"))))
+
+      freq   (count-words words)
+      sorted (sort-desc (to-entries freq))
+      top    (top-n sorted 8)]
+
+  (println (str "분석 텍스트: \"" text "\""))
+  (println (str "총 단어 수: " (length words)))
+  (println (str "고유 단어 수: " (length (keys freq))))
+  (println "")
+  (println "=== 상위 8개 단어 ===")
+  (map
+    (fn [pair]
+      (print-bar (first pair) (+ (last pair) 1)))
+    (zip top (range (length top)))))

package/examples/learning-session/05-todo.fl

@@ -0,0 +1,69 @@
+;; 할 일 목록 — 추가 / 완료 / 필터 / 우선순위
+
+(let [;; 할 일 생성
+      make-todo  (fn [id title priority]
+                   {:id id :title title :priority priority :done false})
+
+      ;; 완료 처리
+      complete   (fn [todos id]
+                   (map (fn [t]
+                          (if (= (get t :id) id)
+                            (assoc t :done true)
+                            t))
+                        todos))
+
+      ;; 우선순위별 필터
+      by-priority (fn [todos p]
+                    (filter (fn [t] (= (get t :priority) p)) todos))
+
+      ;; 미완료만 필터
+      pending    (fn [todos]
+                   (filter (fn [t] (= (get t :done) false)) todos))
+
+      ;; 완료만 필터
+      done       (fn [todos]
+                   (filter (fn [t] (= (get t :done) true)) todos))
+
+      ;; 출력
+      print-todo (fn [t]
+                   (let [check (if (get t :done) "✓" "○")
+                         pri   (get t :priority)
+                         badge (cond
+                                 (= pri "high")   "[!]"
+                                 (= pri "medium") "[-]"
+                                 :else            "[ ]")]
+                     (println (str check " " badge " " (get t :title)))))
+
+      ;; 요약
+      summary    (fn [todos]
+                   (let [total   (length todos)
+                         done-cnt (length (done todos))
+                         pct     (if (= total 0) 0
+                                   (/ (* done-cnt 100) total))]
+                     (println (str "진행: " done-cnt "/" total " (" pct "%)"))))
+
+      ;; 초기 데이터
+      todos [(make-todo 1 "FreeLang 예제 작성"     "high")
+             (make-todo 2 "버그 수정 목록 정리"     "high")
+             (make-todo 3 "블로그 포스팅"           "medium")
+             (make-todo 4 "테스트 코드 작성"        "medium")
+             (make-todo 5 "문서 업데이트"           "low")
+             (make-todo 6 "gogs 푸시"              "low")]
+
+      ;; 1, 3번 완료 처리
+      todos2 (-> todos
+                 (complete 1)
+                 (complete 3))]
+
+  (println "=== 전체 할 일 ===")
+  (map print-todo todos2)
+  (println "")
+  (summary todos2)
+
+  (println "")
+  (println "=== 미완료 ===")
+  (map print-todo (pending todos2))
+
+  (println "")
+  (println "=== 높은 우선순위 ===")
+  (map print-todo (by-priority todos2 "high")))

package/examples/learning-session/06-library.fl

@@ -0,0 +1,76 @@
+;; 도서관 검색 시스템 — 텍스트 검색 + 정렬 + 필터
+
+(let [;; 도서 데이터
+      books [{"id" 1 "title" "FreeLang 입문"         "author" "김철수" "year" 2024 "genre" "프로그래밍" "rating" 4.8}
+             {"id" 2 "title" "함수형 프로그래밍 실전"  "author" "이영희" "year" 2023 "genre" "프로그래밍" "rating" 4.5}
+             {"id" 3 "title" "Lisp의 힘"              "author" "박민준" "year" 2022 "genre" "프로그래밍" "rating" 4.2}
+             {"id" 4 "title" "데이터 과학 with Python" "author" "최수진" "year" 2024 "genre" "데이터"     "rating" 4.6}
+             {"id" 5 "title" "알고리즘 문제 풀기"      "author" "정다혜" "year" 2021 "genre" "알고리즘"   "rating" 4.3}
+             {"id" 6 "title" "함수형 사고방식"         "author" "김철수" "year" 2023 "genre" "프로그래밍" "rating" 4.7}
+             {"id" 7 "title" "클린 코드"               "author" "로버트 마틴" "year" 2020 "genre" "소프트웨어" "rating" 4.9}
+             {"id" 8 "title" "프로그래밍 언어 이론"    "author" "이영희" "year" 2022 "genre" "프로그래밍" "rating" 4.1}]
+
+      ;; 제목/저자 텍스트 검색
+      find-books (fn [books keyword]
+                   (filter (fn [b]
+                             (or (str-includes (get b "title")  keyword)
+                                 (str-includes (get b "author") keyword)))
+                           books))
+
+      ;; 장르 필터
+      by-genre   (fn [books genre]
+                   (filter (fn [b] (= (get b "genre") genre)) books))
+
+      ;; 연도 범위 필터
+      by-year    (fn [books from to]
+                   (filter (fn [b]
+                             (and (>= (get b "year") from)
+                                  (<= (get b "year") to)))
+                           books))
+
+      ;; 평점 높은 순 정렬
+      sort-rating (fn [books]
+                    (sort books (fn [a b] (> (get a "rating") (get b "rating")))))
+
+      ;; 연도 최신순 정렬
+      sort-year   (fn [books]
+                    (sort books (fn [a b] (> (get a "year") (get b "year")))))
+
+      ;; 도서 출력
+      print-book (fn [b]
+                   (println (str "  [" (get b "id") "] "
+                                 (get b "title")
+                                 " / " (get b "author")
+                                 " (" (get b "year") ")"
+                                 " ★" (get b "rating"))))
+
+      ;; 결과 출력 헬퍼
+      show       (fn [label books]
+                   (println label)
+                   (if (= (length books) 0)
+                     (println "  (결과 없음)")
+                     (map print-book books))
+                   (println (str "  → " (length books) "권"))
+                   (println ""))]
+
+  ;; 1. 전체 목록 (평점순)
+  (show "=== 전체 도서 (평점순) ===" (sort-rating books))
+
+  ;; 2. 키워드 검색
+  (show "=== '함수형' 검색 ===" (find-books books "함수형"))
+
+  ;; 3. 저자 검색
+  (show "=== 저자 '이영희' 검색 ===" (find-books books "이영희"))
+
+  ;; 4. 장르 필터
+  (show "=== 장르: 프로그래밍 ===" (sort-rating (by-genre books "프로그래밍")))
+
+  ;; 5. 연도 범위 + 최신순
+  (show "=== 2022~2024 최신순 ===" (sort-year (by-year books 2022 2024)))
+
+  ;; 6. 복합 검색 — 파이프로 체이닝
+  (show "=== 프로그래밍 장르 중 2022년 이후 평점순 ==="
+        (-> books
+            (by-genre "프로그래밍")
+            (by-year 2022 2025)
+            sort-rating)))

package/examples/learning-session/07-currency.fl

@@ -0,0 +1,99 @@
+;; 환율 계산기 — map 변환 + 소수점 처리 + 정렬
+
+(let [;; 환율 데이터 (KRW 기준)
+      rates {"USD" 1350.5
+             "EUR" 1462.3
+             "JPY" 9.12
+             "GBP" 1710.8
+             "CNY" 186.4
+             "CAD" 994.2
+             "AUD" 876.5
+             "CHF" 1521.0}
+
+      ;; 소수점 n자리 반올림
+      round-to   (fn [n places]
+                   (let [factor (reduce * 1 (map (fn [_] 10) (range places)))]
+                     (/ (round (* n factor)) factor)))
+
+      ;; KRW → 외화 변환
+      krw-to     (fn [krw code]
+                   (let [rate (get rates code)]
+                     (if (= rate nil)
+                       nil
+                       (round-to (/ krw rate) 2))))
+
+      ;; 외화 → KRW 변환
+      to-krw     (fn [amount code]
+                   (let [rate (get rates code)]
+                     (if (= rate nil)
+                       nil
+                       (round-to (* amount rate) 0))))
+
+      ;; 숫자 천 단위 콤마
+      fmt-num    (fn [n]
+                   (let [s     (str (round-to n 2))
+                         parts (str-split s ".")]
+                     (let [int-part (first parts)
+                           dec-part (if (> (length parts) 1) (str "." (get parts 1)) "")]
+                       (str int-part dec-part))))
+
+      ;; 단일 통화 출력
+      print-rate (fn [code]
+                   (let [rate (get rates code)
+                         per1 (round-to (/ 1 rate) 6)]
+                     (println (str "  " code " : "
+                                   "1 " code " = " rate " KRW  |  "
+                                   "1,000 KRW = " (round-to (/ 1000 rate) 4) " " code))))
+
+      ;; 환전 결과 출력
+      show-convert (fn [amount from to]
+                     (let [krw    (if (= from "KRW") amount (to-krw amount from))
+                           result (if (= to "KRW") krw (krw-to krw to))]
+                       (println (str "  " amount " " from
+                                     " → " result " " to))))]
+
+  ;; 1. 환율표
+  (println "=== 환율표 (KRW 기준) ===")
+  (map print-rate ["USD" "EUR" "JPY" "GBP" "CNY" "CAD" "AUD" "CHF"])
+  (println "")
+
+  ;; 2. KRW → 각국 통화 변환
+  (println "=== 100,000 KRW 환전 ===")
+  (map (fn [code]
+         (let [result (krw-to 100000 code)]
+           (println (str "  100,000 KRW = " result " " code))))
+       ["USD" "EUR" "JPY" "GBP" "CNY"])
+  (println "")
+
+  ;; 3. 외화 → KRW
+  (println "=== 외화 → KRW ===")
+  (show-convert 100 "USD" "KRW")
+  (show-convert 100 "EUR" "KRW")
+  (show-convert 10000 "JPY" "KRW")
+  (show-convert 50 "GBP" "KRW")
+  (println "")
+
+  ;; 4. 교차 환율 (USD ↔ EUR)
+  (println "=== 교차 환율 ===")
+  (let [usd-krw (get rates "USD")
+        eur-krw (get rates "EUR")
+        usd-to-eur (round-to (/ usd-krw eur-krw) 4)
+        eur-to-usd (round-to (/ eur-krw usd-krw) 4)]
+    (println (str "  1 USD = " usd-to-eur " EUR"))
+    (println (str "  1 EUR = " eur-to-usd " USD")))
+  (println "")
+
+  ;; 5. 강세/약세 통화 순위 (KRW 대비)
+  (println "=== 고가 통화 순위 (KRW 대비) ===")
+  (let [pairs [["GBP" (get rates "GBP")]
+               ["EUR" (get rates "EUR")]
+               ["CHF" (get rates "CHF")]
+               ["USD" (get rates "USD")]
+               ["CAD" (get rates "CAD")]
+               ["AUD" (get rates "AUD")]
+               ["CNY" (get rates "CNY")]
+               ["JPY" (get rates "JPY")]]
+        sorted (sort pairs (fn [a b] (> (get a 1) (get b 1))))]
+    (map (fn [pair]
+           (println (str "  " (get pair 0) " : " (get pair 1) " KRW")))
+         sorted)))

package/examples/learning-session/08-csv-grades.fl

@@ -0,0 +1,104 @@
+;; 성적 CSV 파서 — 문자열 파싱 + reduce 통계
+
+(let [;; CSV 파일 읽기
+      raw      (file-read "/tmp/grades.csv")
+
+      ;; 줄 단위로 분리, 빈 줄 제거
+      lines    (filter (fn [l] (> (length l) 0))
+                       (str-split raw "\n"))
+
+      ;; 헤더 파싱
+      header   (str-split (first lines) ",")
+
+      ;; 데이터 줄 파싱 → 맵 리스트
+      parse-row (fn [line]
+                  (let [cols (str-split line ",")]
+                    (reduce (fn [acc i]
+                              (assoc acc (get header i)
+                                     (if (= i 0)
+                                       (get cols i)
+                                       (str-to-num (get cols i)))))
+                            {}
+                            (range (length cols)))))
+
+      rows     (map parse-row (rest lines))
+
+      ;; 과목 목록 (헤더에서 이름 제외)
+      subjects (rest header)
+
+      ;; 소수점 반올림
+      round-to (fn [n p]
+                 (let [f (reduce * 1 (map (fn [_] 10) (range p)))]
+                   (/ (round (* n f)) f)))
+
+      ;; 평균 계산
+      avg      (fn [nums]
+                 (/ (reduce + 0 nums) (length nums)))
+
+      ;; 학생별 총점 / 평균
+      with-stats (fn [row]
+                   (let [scores (map (fn [s] (get row s)) subjects)
+                         total  (reduce + 0 scores)
+                         mean   (round-to (/ total (length scores)) 1)]
+                     (assoc (assoc row "total" total) "avg" mean)))
+
+      ;; 등급
+      grade    (fn [avg]
+                 (cond
+                   (>= avg 90) "A"
+                   (>= avg 80) "B"
+                   (>= avg 70) "C"
+                   (>= avg 60) "D"
+                   :else       "F"))
+
+      ;; 통계가 붙은 전체 데이터
+      data     (map with-stats rows)
+
+      ;; 정렬 (총점 높은 순)
+      ranked   (sort data (fn [a b] (> (get a "total") (get b "total"))))
+
+      ;; 학생 한 줄 출력
+      print-row (fn [i row]
+                  (println (str (+ i 1) "위  "
+                                (get row "이름") "\t"
+                                "총점:" (get row "total") "  "
+                                "평균:" (get row "avg") "  "
+                                "등급:" (grade (get row "avg")))))
+
+      ;; 과목별 최고/최저/평균
+      subject-stats (fn [s]
+                      (let [vals   (map (fn [r] (get r s)) data)
+                            mx     (reduce (fn [a x] (if (> x a) x a)) 0 vals)
+                            mn     (reduce (fn [a x] (if (< x a) x a)) 100 vals)
+                            mean   (round-to (avg vals) 1)]
+                        (println (str "  " s "\t최고:" mx "  최저:" mn "  평균:" mean))))]
+
+  ;; 1. 성적 순위
+  (println "=== 성적 순위 ===")
+  (map (fn [pair] (print-row (first pair) (get pair 1)))
+       (map (fn [i] [i (get ranked i)]) (range (length ranked))))
+  (println "")
+
+  ;; 2. 과목별 통계
+  (println "=== 과목별 통계 ===")
+  (map subject-stats subjects)
+  (println "")
+
+  ;; 3. 등급 분포
+  (println "=== 등급 분포 ===")
+  (let [grades (map (fn [r] (grade (get r "avg"))) data)
+        count-grade (fn [g] (length (filter (fn [x] (= x g)) grades)))]
+    (map (fn [g]
+           (let [cnt (count-grade g)]
+             (if (> cnt 0)
+               (println (str "  " g "등급: " cnt "명")))))
+         ["A" "B" "C" "D" "F"]))
+  (println "")
+
+  ;; 4. 전체 평균
+  (println "=== 전체 ===")
+  (let [all-avgs (map (fn [r] (get r "avg")) data)
+        overall  (round-to (avg all-avgs) 1)]
+    (println (str "  전체 평균: " overall))
+    (println (str "  최우수: " (get (first ranked) "이름")
+                  " (" (get (first ranked) "total") "점)"))))

package/examples/learning-session/09-calc-repl.fl

@@ -0,0 +1,92 @@
+;; 계산기 REPL — loop + readline + 수식 파서
+;; 사용법: printf "2 + 3\n10 * 4\nquit\n" | node calc.js
+
+(let [;; 토큰화: "10 + 3 * 2" → ["10" "+" "3" "*" "2"]
+      tokenize  (fn [s]
+                  (filter (fn [t] (> (length t) 0))
+                          (str-split (str-trim s) " ")))
+
+      ;; 문자열이 숫자인지 확인
+      num-str?  (fn [s]
+                  (not (= (str-to-num s) nil)))
+
+      ;; 단일 연산
+      apply-op  (fn [a op b]
+                  (cond
+                    (= op "+") (+ a b)
+                    (= op "-") (- a b)
+                    (= op "*") (* a b)
+                    (= op "/") (if (= b 0) nil (/ a b))
+                    (= op "%") (if (= b 0) nil (- a (* (floor (/ a b)) b)))
+                    :else nil))
+
+      ;; 좌→우 평가 (같은 우선순위끼리만)
+      eval-pass (fn [tokens ops]
+                  (if (<= (length tokens) 1)
+                    tokens
+                    (let [a  (str-to-num (get tokens 0))
+                          op (get tokens 1)
+                          b  (str-to-num (get tokens 2))]
+                      (if (and (not (= a nil))
+                               (not (= b nil))
+                               (str-includes ops op))
+                        (let [r (apply-op a op b)
+                              rest-toks (slice tokens 3 (length tokens))]
+                          (eval-pass (concat [(str r)] rest-toks) ops))
+                        ;; 이 연산자 건너뜀 — 다음 위치로
+                        (concat [(get tokens 0) (get tokens 1)]
+                                (eval-pass (slice tokens 2 (length tokens)) ops))))))
+
+      ;; 수식 계산 (우선순위: * / 먼저, 그 다음 + -)
+      calc      (fn [input]
+                  (let [tokens (tokenize input)]
+                    (if (< (length tokens) 3)
+                      (if (= (length tokens) 1)
+                        (str-to-num (get tokens 0))
+                        nil)
+                      (let [after-mul (eval-pass tokens "*/")
+                            result    (eval-pass after-mul "+-")]
+                        (if (= (length result) 1)
+                          (str-to-num (get result 0))
+                          nil)))))
+
+      ;; 히스토리 출력
+      show-history (fn [hist]
+                     (if (= (length hist) 0)
+                       (println "  (기록 없음)")
+                       (map (fn [h]
+                              (println (str "  " (get h "expr") " = " (get h "result"))))
+                            hist)))]
+
+  (println "FreeLang 계산기 v1.0")
+  (println "명령: quit / history / clear")
+  (println "예시: 2 + 3   10 * 4 - 2   100 / 4 + 5 * 2")
+  (println "")
+
+  (loop [history []]
+    (let [input (readline "> ")]
+      (cond
+        (= input nil)       (do (println "") (println "EOF — 종료"))
+        (= input "quit")    (do
+                               (println "")
+                               (println "=== 계산 기록 ===")
+                               (show-history history)
+                               (println "안녕히 가세요!"))
+        (= input "history") (do
+                               (println "=== 계산 기록 ===")
+                               (show-history history)
+                               (println "")
+                               (recur history))
+        (= input "clear")   (do
+                               (println "  기록 초기화")
+                               (recur []))
+        (= input "")        (recur history)
+        :else
+        (let [result (calc input)]
+          (if (= result nil)
+            (do
+              (println "  오류: 인식할 수 없는 수식 (예: 2 + 3)")
+              (recur history))
+            (do
+              (println (str "  = " result))
+              (recur (append history {"expr" input "result" result})))))))))