freelang-editor 11.7.4

package/examples/learning-session/16-calendar.fl

@@ -0,0 +1,87 @@
+;; 달력 생성기 — 월/연도 입력 → 텍스트 달력 출력
+
+(let [;; 월 이름
+      month-names ["1월" "2월" "3월" "4월" "5월" "6월"
+                   "7월" "8월" "9월" "10월" "11월" "12월"]
+
+      ;; 윤년 판별
+      leap-year?  (fn [y]
+                    (or (and (= (- y (* (floor (/ y 4)) 4)) 0)
+                             (not (= (- y (* (floor (/ y 100)) 100)) 0)))
+                        (= (- y (* (floor (/ y 400)) 400)) 0)))
+
+      ;; 월별 일수
+      days-in-month (fn [y m]
+                      (cond
+                        (or (= m 1) (= m 3) (= m 5) (= m 7)
+                            (= m 8) (= m 10) (= m 12)) 31
+                        (or (= m 4) (= m 6) (= m 9) (= m 11)) 30
+                        (leap-year? y) 29
+                        :else 28))
+
+      ;; 첫날 요일 (Zeller 공식 — 0=일 1=월 ... 6=토)
+      first-weekday (fn [y m]
+                      (let [a  (if (< m 3) 1 0)
+                            yy (- y a)
+                            mm (+ m (if (= a 1) 10 -2))
+                            k  (- yy (* (floor (/ yy 100)) 100))
+                            j  (floor (/ yy 100))
+                            h  (- (+ 1 (floor (/ (* mm 26) 10)) k
+                                     (floor (/ k 4)) (floor (/ j 4))
+                                     (* 5 j))
+                                  (* 7 (floor (/ (+ 1 (floor (/ (* mm 26) 10)) k
+                                                    (floor (/ k 4)) (floor (/ j 4))
+                                                    (* 5 j))
+                                                 7))))]
+                        (- (+ h 6) (* 7 (floor (/ (+ h 6) 7))))))
+
+      ;; 숫자 2자리 패딩
+      pad2  (fn [n]
+               (if (< n 10) (str " " n) (str n)))
+
+      ;; 달력 한 행 출력
+      print-week (fn [days]
+                   (println (str-join (map pad2 days) " ")))
+
+      ;; 달력 생성 및 출력
+      print-calendar (fn [y m]
+                       (let [total   (days-in-month y m)
+                             start   (first-weekday y m)
+                             title   (str (get month-names (- m 1)) " " y)
+                             pad     (- 12 (floor (/ (length title) 2)))]
+                         (println (str (str-repeat " " pad) title))
+                         (println "일  월  화  수  목  금  토")
+                         (println "---------------------------")
+                         ;; 첫 주 앞 빈칸 채우기
+                         (let [first-row (concat (map (fn [_] "  ") (range start))
+                                                 (map (fn [d] (pad2 d))
+                                                      (range 1 (+ 1 (- 7 start)))))]
+                           (println (str-join first-row " ")))
+                         ;; 나머지 주
+                         (loop [day (+ 1 (- 7 start))]
+                           (if (> day total)
+                             nil
+                             (do
+                               (let [week (map (fn [d]
+                                                 (if (<= d total) (pad2 d) "  "))
+                                               (range day (+ day 7)))]
+                                 (println (str-join week " ")))
+                               (recur (+ day 7)))))
+                         (println "")))
+
+      ;; 연간 달력
+      print-year  (fn [y]
+                    (println (str "======= " y "년 달력 ======="))
+                    (println "")
+                    (map (fn [m] (print-calendar y m))
+                         (range 1 13)))]
+
+  ;; 2026년 5월, 6월
+  (print-calendar 2026 5)
+  (print-calendar 2026 6)
+
+  ;; 윤년 확인
+  (println "=== 윤년 확인 ===")
+  (map (fn [y]
+         (println (str "  " y "년: " (if (leap-year? y) "윤년" "평년"))))
+       [2020 2024 2025 2026 2100 2400]))

package/examples/learning-session/17-markdown.fl

@@ -0,0 +1,107 @@
+;; 마크다운 → HTML 변환기
+;; 지원: # 헤딩, **bold**, *italic*, `code`, - 리스트, > 인용, --- 구분선
+
+(let [;; 짝수=원문 홀수=태그로 감싸기
+      wrap-parts (fn [parts tag-open tag-close]
+                   (reduce
+                     (fn [acc i]
+                       (let [part (get parts i)
+                             odd  (= (- i (* 2 (floor (/ i 2)))) 1)]
+                         (if odd
+                           (str acc tag-open part tag-close)
+                           (str acc part))))
+                     ""
+                     (range (length parts))))
+
+      ;; **bold** 변환
+      apply-bold   (fn [s]
+                     (wrap-parts (str-split s "**") "<strong>" "</strong>"))
+
+      ;; *italic* 변환 (bold 처리 후 남은 단일 *)
+      apply-italic (fn [s]
+                     (wrap-parts (str-split s "*") "<em>" "</em>"))
+
+      ;; `code` 변환
+      apply-code   (fn [s]
+                     (wrap-parts (str-split s "`") "<code>" "</code>"))
+
+      ;; 인라인 변환 체이닝
+      inline (fn [text]
+               (-> text apply-bold apply-italic apply-code))
+
+      ;; 헤딩 판별 및 변환
+      to-heading (fn [line]
+                   (cond
+                     (str-starts-with line "### ") (str "<h3>" (inline (substring line 4)) "</h3>")
+                     (str-starts-with line "## ")  (str "<h2>" (inline (substring line 3)) "</h2>")
+                     (str-starts-with line "# ")   (str "<h1>" (inline (substring line 2)) "</h1>")
+                     :else line))
+
+      ;; 줄 → HTML
+      convert-line (fn [line]
+                     (cond
+                       (= line "")                  ""
+                       (or (= line "---")
+                           (= line "***"))          "<hr>"
+                       (str-starts-with line "# ")  (to-heading line)
+                       (str-starts-with line "## ") (to-heading line)
+                       (str-starts-with line "### ")(to-heading line)
+                       (str-starts-with line "- ")  (str "<li>" (inline (substring line 2)) "</li>")
+                       (str-starts-with line "* ")  (str "<li>" (inline (substring line 2)) "</li>")
+                       (str-starts-with line "> ")  (str "<blockquote>" (inline (substring line 2)) "</blockquote>")
+                       :else                        (if (> (length (str-trim line)) 0)
+                                                      (str "<p>" (inline line) "</p>")
+                                                      "")))
+
+      ;; 연속 <li> → <ul>로 감싸기
+      wrap-lists  (fn [lines]
+                    (let [with-end (append lines "")]
+                      (reduce
+                        (fn [state line]
+                          (let [html     (get state "html")
+                                in-list  (get state "in-list")
+                                is-li    (str-starts-with line "<li>")]
+                            (cond
+                              (and is-li (not in-list))
+                              {"html" (append (append html "<ul>") line) "in-list" true}
+                              (and (not is-li) in-list)
+                              {"html" (append (append html "</ul>") line) "in-list" false}
+                              :else
+                              {"html" (append html line) "in-list" in-list})))
+                        {"html" [] "in-list" false}
+                        with-end)))
+
+      ;; 마크다운 → HTML
+      to-html     (fn [md]
+                    (let [lines  (str-split md "\n")
+                          conv   (map convert-line lines)
+                          state  (wrap-lists conv)
+                          html   (get state "html")]
+                      (str-join (filter (fn [l] (> (length l) 0)) html) "\n")))
+
+      ;; 테스트 마크다운
+      sample (str-join
+               ["# FreeLang v11 소개"
+                ""
+                "## 주요 기능"
+                ""
+                "FreeLang은 **함수형** 언어로 *불변 데이터*를 기본으로 합니다."
+                ""
+                "### 설치 방법"
+                ""
+                "- Node.js v18 이상 필요"
+                "- 외부 npm 패키지 **불필요**"
+                "- `node bootstrap.js compile app.fl` 로 컴파일"
+                ""
+                "> 함수형 프로그래밍은 부작용을 최소화합니다."
+                ""
+                "---"
+                ""
+                "코드 품질과 `가독성`을 *동시에* 잡으세요."]
+               "\n")]
+
+  (println "=== 마크다운 입력 ===")
+  (println sample)
+  (println "")
+  (println "=== HTML 출력 ===")
+  (println (to-html sample)))

package/examples/learning-session/18-contacts.fl

@@ -0,0 +1,109 @@
+;; 주소록 관리 — CRUD + 검색 + 파일 저장
+
+(let [;; 연락처 생성
+      make-contact (fn [id name phone email group]
+                     {"id" id "name" name "phone" phone
+                      "email" email "group" group})
+
+      ;; ID 기반 조회
+      find-by-id  (fn [contacts id]
+                    (first (filter (fn [c] (= (get c "id") id)) contacts)))
+
+      ;; 이름/전화/이메일 텍스트 검색
+      find-by-kw  (fn [contacts kw]
+                    (filter (fn [c]
+                              (or (str-includes (str-lower (get c "name"))  (str-lower kw))
+                                  (str-includes (str-lower (get c "email")) (str-lower kw))
+                                  (str-includes (get c "phone") kw)))
+                            contacts))
+
+      ;; 그룹 필터
+      by-group    (fn [contacts group]
+                    (filter (fn [c] (= (get c "group") group)) contacts))
+
+      ;; 추가
+      add-contact (fn [contacts contact]
+                    (append contacts contact))
+
+      ;; 수정 (id 기준)
+      update-contact (fn [contacts id field value]
+                       (map (fn [c]
+                              (if (= (get c "id") id)
+                                (assoc c field value)
+                                c))
+                            contacts))
+
+      ;; 삭제
+      delete-contact (fn [contacts id]
+                       (filter (fn [c] (not (= (get c "id") id))) contacts))
+
+      ;; 정렬 (이름 오름차순)
+      sort-by-name (fn [contacts]
+                     (sort contacts (fn [a b]
+                                      (< (str-lower (get a "name"))
+                                         (str-lower (get b "name"))))))
+
+      ;; 출력
+      print-contact (fn [c]
+                      (println (str "  [" (get c "id") "] "
+                                    (get c "name") "\t"
+                                    (get c "phone") "\t"
+                                    (get c "email") "\t"
+                                    "(" (get c "group") ")")))
+
+      ;; 초기 데이터
+      init [(make-contact 1 "김민수" "010-1234-5678" "minsoo@email.com"  "가족")
+            (make-contact 2 "이수진" "010-2345-6789" "sujin@work.com"   "직장")
+            (make-contact 3 "박지훈" "010-3456-7890" "jihun@email.com"  "친구")
+            (make-contact 4 "최유리" "010-4567-8901" "yuri@work.com"    "직장")
+            (make-contact 5 "정태양" "010-5678-9012" "sun@email.com"    "친구")
+            (make-contact 6 "한소희" "010-6789-0123" "sohee@email.com"  "가족")
+            (make-contact 7 "오민준" "010-7890-1234" "minjun@work.com"  "직장")]
+
+      ;; 다음 ID
+      next-id     (fn [contacts]
+                    (+ 1 (reduce (fn [mx c] (if (> (get c "id") mx) (get c "id") mx))
+                                 0 contacts)))]
+
+  ;; 1. 전체 목록 (이름순)
+  (println "=== 전체 연락처 (이름순) ===")
+  (map print-contact (sort-by-name init))
+  (println (str "  총 " (length init) "명"))
+  (println "")
+
+  ;; 2. 그룹별
+  (println "=== 그룹별 ===")
+  (map (fn [g]
+         (let [members (by-group init g)]
+           (println (str "  [" g "] " (length members) "명"))
+           (map (fn [c] (println (str "    " (get c "name") " " (get c "phone"))))
+                members)))
+       ["가족" "친구" "직장"])
+  (println "")
+
+  ;; 3. 키워드 검색
+  (println "=== 'work' 검색 ===")
+  (map print-contact (find-by-kw init "work"))
+  (println "")
+
+  ;; 4. CRUD 시연
+  (println "=== CRUD 시연 ===")
+
+  ;; 추가
+  (let [new-c   (make-contact (next-id init) "신예린" "010-8901-2345" "yerin@email.com" "친구")
+        added   (add-contact init new-c)]
+    (println (str "  [추가] " (get new-c "name") " → 총 " (length added) "명"))
+
+    ;; 수정
+    (let [updated (update-contact added 3 "phone" "010-9999-0000")]
+      (let [changed (find-by-id updated 3)]
+        (println (str "  [수정] 박지훈 전화: " (get changed "phone"))))
+
+      ;; 삭제
+      (let [deleted (delete-contact updated 2)]
+        (println (str "  [삭제] 이수진 제거 → 총 " (length deleted) "명"))
+
+        ;; 최종 목록
+        (println "")
+        (println "=== 최종 연락처 ===")
+        (map print-contact (sort-by-name deleted))))))

package/examples/learning-session/19-json-serializer.fl

@@ -0,0 +1,86 @@
+;; JSON 직렬화기 — FreeLang 값 → JSON 문자열 (pretty-print 지원)
+
+(let [;; 문자열 이스케이프
+      escape-str (fn [s]
+                   (let [s1 (str-replace s "\\" "\\\\")
+                         s2 (str-replace s1 "\"" "\\\"")
+                         s3 (str-replace s2 "\n" "\\n")
+                         s4 (str-replace s3 "\t" "\\t")]
+                     s4))
+
+      ;; 들여쓰기 생성
+      indent (fn [depth]
+               (str-repeat "  " depth))
+
+      ;; 값 → JSON (재귀)
+      to-json (fn [val depth]
+                (cond
+                  (= val nil)    "null"
+                  (= val true)   "true"
+                  (= val false)  "false"
+                  (number? val)  (str val)
+                  (string? val)  (str "\"" (escape-str val) "\"")
+                  (array? val)
+                  (if (= (length val) 0)
+                    "[]"
+                    (let [inner (str-join
+                                  (map (fn [item]
+                                         (str (indent (+ depth 1))
+                                              (to-json item (+ depth 1))))
+                                       val)
+                                  ",\n")]
+                      (str "[\n" inner "\n" (indent depth) "]")))
+                  (map? val)
+                  (let [pairs (map
+                                (fn [k]
+                                  (str (indent (+ depth 1))
+                                       "\"" k "\": "
+                                       (to-json (get val k) (+ depth 1))))
+                                (keys val))]
+                    (if (= (length pairs) 0)
+                      "{}"
+                      (str "{\n"
+                           (str-join pairs ",\n")
+                           "\n" (indent depth) "}")))
+                  :else (str "\"" (str val) "\"")))
+
+      ;; 최상위 진입
+      json (fn [val] (to-json val 0))
+
+      ;; 테스트 데이터
+      person {"name" "김민수"
+              "age"  29
+              "active" true
+              "score" 98.5
+              "tags" ["개발자" "FreeLang" "함수형"]
+              "address" {"city" "서울"
+                         "zip"  "04523"}}
+
+      products [{"id" 1 "name" "노트북" "price" 1500000 "stock" 12}
+                {"id" 2 "name" "마우스" "price" 35000  "stock" 0}
+                {"id" 3 "name" "키보드" "price" 89000  "stock" 5}]
+
+      config {"version" "1.0.0"
+              "debug" false
+              "limits" {"max-conn" 100 "timeout" 30}
+              "features" ["auth" "cache" "logging"]
+              "meta" nil}]
+
+  (println "=== person ===")
+  (println (json person))
+  (println "")
+
+  (println "=== products ===")
+  (println (json products))
+  (println "")
+
+  (println "=== config ===")
+  (println (json config))
+  (println "")
+
+  ;; 엣지 케이스
+  (println "=== 엣지 케이스 ===")
+  (println (str "null:   " (json nil)))
+  (println (str "빈 배열: " (json [])))
+  (println (str "빈 맵:  " (json {})))
+  (println (str "이스케이프: " (json "안녕 \"world\"\n탭\t끝"))))

package/examples/learning-session/20-template.fl

@@ -0,0 +1,201 @@
+;; 미니 템플릿 엔진 — {{변수}}, {{#if}}, {{#each}}, {{#unless}}
+
+(let [;; 토큰 타입: "text" | "var" | "if" | "else" | "end" | "each" | "unless"
+      ;; 템플릿 문자열 → 토큰 배열
+      tokenize (fn [tmpl]
+                 (loop [s tmpl tokens []]
+                   (let [pos (str-index-of s "{{")]
+                     (if (= pos -1)
+                       (if (> (length s) 0)
+                         (append tokens {"type" "text" "val" s})
+                         tokens)
+                       (let [pre  (substring s 0 pos)
+                             rest (substring s (+ pos 2))
+                             end  (str-index-of rest "}}")
+                             tag  (str-trim (substring rest 0 end))
+                             after (substring rest (+ end 2))
+                             tokens2 (if (> (length pre) 0)
+                                       (append tokens {"type" "text" "val" pre})
+                                       tokens)
+                             tok  (cond
+                                    (str-starts-with tag "#if ")
+                                    {"type" "if"     "val" (substring tag 4)}
+                                    (str-starts-with tag "#each ")
+                                    {"type" "each"   "val" (substring tag 6)}
+                                    (str-starts-with tag "#unless ")
+                                    {"type" "unless" "val" (substring tag 8)}
+                                    (= tag "#else")
+                                    {"type" "else"   "val" ""}
+                                    (= tag "/if")
+                                    {"type" "end-if"   "val" ""}
+                                    (= tag "/each")
+                                    {"type" "end-each" "val" ""}
+                                    (= tag "/unless")
+                                    {"type" "end-unless" "val" ""}
+                                    :else
+                                    {"type" "var" "val" tag})]
+                         (recur after (append tokens2 tok)))))))
+
+      ;; 컨텍스트에서 점 경로로 값 가져오기 (예: "user.name")
+      get-path (fn [ctx path]
+                 (loop [parts (str-split path ".") val ctx]
+                   (if (or (= (length parts) 0) (= val nil))
+                     val
+                     (recur (rest parts) (get val (first parts))))))
+
+      ;; truthy 판별
+      truthy? (fn [v]
+                (and (not (= v nil))
+                     (not (= v false))
+                     (not (= v ""))
+                     (not (and (array? v) (= (length v) 0)))))
+
+      ;; 토큰 배열 + 컨텍스트 → 렌더링
+      ;; state: {"out" "" "i" 0}
+      render-tokens (fn [tokens ctx]
+                      (loop [i 0 out ""]
+                        (if (>= i (length tokens))
+                          out
+                          (let [tok  (get tokens i)
+                                type (get tok "type")
+                                val  (get tok "val")]
+                            (cond
+                              (= type "text")
+                              (recur (+ i 1) (str out val))
+
+                              (= type "var")
+                              (let [v (get-path ctx val)]
+                                (recur (+ i 1) (str out (if (= v nil) "" (str v)))))
+
+                              (= type "if")
+                              (let [cond-val (truthy? (get-path ctx val))
+                                    ;; if 블록 범위 찾기: end-if 또는 else 까지
+                                    block (loop [j (+ i 1) depth 0 then-toks [] else-toks [] in-else false]
+                                            (if (>= j (length tokens))
+                                              {"then" then-toks "else" else-toks "end" j}
+                                              (let [t (get tokens j)
+                                                    tt (get t "type")]
+                                                (cond
+                                                  (and (= tt "end-if") (= depth 0))
+                                                  {"then" then-toks "else" else-toks "end" (+ j 1)}
+                                                  (and (= tt "else") (= depth 0))
+                                                  (recur (+ j 1) depth then-toks else-toks true)
+                                                  (or (= tt "if") (= tt "each") (= tt "unless"))
+                                                  (if in-else
+                                                    (recur (+ j 1) (+ depth 1) then-toks (append else-toks t) false)
+                                                    (recur (+ j 1) (+ depth 1) (append then-toks t) else-toks false))
+                                                  (or (= tt "end-if") (= tt "end-each") (= tt "end-unless"))
+                                                  (if in-else
+                                                    (recur (+ j 1) (- depth 1) then-toks (append else-toks t) true)
+                                                    (recur (+ j 1) (- depth 1) (append then-toks t) else-toks false))
+                                                  :else
+                                                  (if in-else
+                                                    (recur (+ j 1) depth then-toks (append else-toks t) true)
+                                                    (recur (+ j 1) depth (append then-toks t) else-toks false))))))
+                                    branch (if cond-val (get block "then") (get block "else"))
+                                    result (render-tokens branch ctx)]
+                                (recur (get block "end") (str out result)))
+
+                              (= type "unless")
+                              (let [cond-val (not (truthy? (get-path ctx val)))
+                                    block (loop [j (+ i 1) depth 0 body []]
+                                            (if (>= j (length tokens))
+                                              {"body" body "end" j}
+                                              (let [t (get tokens j)
+                                                    tt (get t "type")]
+                                                (cond
+                                                  (and (= tt "end-unless") (= depth 0))
+                                                  {"body" body "end" (+ j 1)}
+                                                  (or (= tt "if") (= tt "each") (= tt "unless"))
+                                                  (recur (+ j 1) (+ depth 1) (append body t))
+                                                  (or (= tt "end-if") (= tt "end-each") (= tt "end-unless"))
+                                                  (recur (+ j 1) (- depth 1) (append body t))
+                                                  :else
+                                                  (recur (+ j 1) depth (append body t))))))
+                                    result (if cond-val (render-tokens (get block "body") ctx) "")]
+                                (recur (get block "end") (str out result)))
+
+                              (= type "each")
+                              (let [items (get-path ctx val)
+                                    block (loop [j (+ i 1) depth 0 body []]
+                                            (if (>= j (length tokens))
+                                              {"body" body "end" j}
+                                              (let [t (get tokens j)
+                                                    tt (get t "type")]
+                                                (cond
+                                                  (and (= tt "end-each") (= depth 0))
+                                                  {"body" body "end" (+ j 1)}
+                                                  (or (= tt "if") (= tt "each") (= tt "unless"))
+                                                  (recur (+ j 1) (+ depth 1) (append body t))
+                                                  (or (= tt "end-if") (= tt "end-each") (= tt "end-unless"))
+                                                  (recur (+ j 1) (- depth 1) (append body t))
+                                                  :else
+                                                  (recur (+ j 1) depth (append body t))))))
+                                    body  (get block "body")
+                                    result (if (or (= items nil) (not (array? items)))
+                                             ""
+                                             (str-join
+                                               (map (fn [item]
+                                                      (let [item-ctx (if (map? item)
+                                                                       (assoc item "@parent" ctx)
+                                                                       {"." item "@parent" ctx})]
+                                                        (render-tokens body item-ctx)))
+                                                    items)
+                                               ""))]
+                                (recur (get block "end") (str out result)))
+
+                              :else
+                              (recur (+ i 1) out))))))
+
+      ;; 최상위 render
+      render (fn [tmpl ctx]
+               (render-tokens (tokenize tmpl) ctx))
+
+      ;; ── 테스트 ──
+
+      ;; 1. 기본 변수 치환
+      t1 "안녕하세요, {{name}}님! 나이: {{age}}세"
+      c1 {"name" "김민수" "age" 29}
+
+      ;; 2. 조건 (if/else)
+      t2 "상태: {{#if active}}활성{{#else}}비활성{{/if}} | 점수: {{#if score}}{{score}}점{{/if}}"
+      c2a {"active" true  "score" 95}
+      c2b {"active" false "score" 0}
+
+      ;; 3. unless
+      t3 "{{#unless error}}정상 처리 완료{{/unless}}{{#if error}}오류: {{error}}{{/if}}"
+      c3a {"error" nil}
+      c3b {"error" "연결 실패"}
+
+      ;; 4. each 반복
+      t4 "장바구니:\n{{#each items}}- {{name}}: {{price}}원\n{{/each}}합계 확인 요망"
+      c4 {"items" [{"name" "노트북" "price" 1500000}
+                   {"name" "마우스" "price" 35000}
+                   {"name" "키보드" "price" 89000}]}
+
+      ;; 5. 중첩 (if 안에 each)
+      t5 "{{#if users}}사용자 목록:\n{{#each users}}  - {{name}}\n{{/each}}{{/if}}{{#unless users}}사용자 없음{{/unless}}"
+      c5a {"users" [{"name" "Alice"} {"name" "Bob"} {"name" "Charlie"}]}
+      c5b {"users" []}]
+
+  (println "=== 1. 변수 치환 ===")
+  (println (render t1 c1))
+  (println "")
+
+  (println "=== 2. if/else 조건 ===")
+  (println (render t2 c2a))
+  (println (render t2 c2b))
+  (println "")
+
+  (println "=== 3. unless ===")
+  (println (render t3 c3a))
+  (println (render t3 c3b))
+  (println "")
+
+  (println "=== 4. each 반복 ===")
+  (println (render t4 c4))
+  (println "")
+
+  (println "=== 5. 중첩 ===")
+  (println (render t5 c5a))
+  (println (render t5 c5b)))