freelang-editor 11.7.4

package/examples/patterns/07-string-processing.fl

@@ -0,0 +1,86 @@
+;; 패턴 7: 문자열 처리 (String Processing)
+;; AI가 텍스트 데이터를 분석하고 변환할 때 사용
+
+;; 패턴 A: 기본 문자열 연결
+(define join-names (fn [first-name last-name]
+  (str first-name " " last-name)))
+
+;;; TEST: (join-names "John" "Doe") => "John Doe"
+
+;; 패턴 B: 문자열 대소문자 변환
+(define test-case-transform (fn []
+  (and
+    (= (upper-case "hello") "HELLO")
+    (= (lower-case "WORLD") "world"))))
+
+;;; TEST: (test-case-transform) => true
+
+;; 패턴 C: 문자열 트림
+(define clean-email (fn [email]
+  (trim email)))
+
+;;; TEST: (clean-email "  alice@example.com  ") => "alice@example.com"
+
+;; 패턴 D: 문자열 길이
+(define text-length (fn [text]
+  (length text)))
+
+;;; TEST: (text-length "hello") => 5
+
+;; 패턴 E: 부분 문자열 추출
+(define substring (fn [text start end]
+  (slice text start end)))
+
+;;; TEST: (substring "hello" 0 3) => "hel"
+
+(println (is-valid-email "alice-example.com"))
+;; → false
+
+;; 패턴 G: 복합 문자열 처리 (파싱)
+(defun parse-csv-line [line]
+  (let [parts (str-split line ",")]
+    {:name (trim (get parts 0))
+     :age (parse-number (trim (get parts 1)))
+     :email (trim (get parts 2))}))
+
+(println (parse-csv-line "Alice, 25, alice@example.com"))
+;; → {:name "Alice" :age 25 :email "alice@example.com"}
+
+;; 패턴 H: 문자열 템플릿
+(defun format-greeting [name age city]
+  (str "안녕하세요, " name "님! "
+       "나이는 " age "이고 " city "에 거주 중이신가요?"))
+
+(println (format-greeting "Alice" 25 "Seoul"))
+;; → 안녕하세요, Alice님! 나이는 25이고 Seoul에 거주 중이신가요?
+
+;; 패턴 I: 문자열 유효성 검사
+(defun is-numeric-string [s]
+  (try
+    (do
+      (parse-number s)
+      true)
+    (catch err false)))
+
+(println (is-numeric-string "123"))
+;; → true
+
+(println (is-numeric-string "abc"))
+;; → false
+
+;; 패턴 J: 문자열 분류 (카테고리)
+(defun categorize-string [s]
+  (case true
+    ((str-includes s "@") "email")
+    ((str-includes s "http") "url")
+    ((is-numeric-string s) "number")
+    (true "text")))
+
+(println (categorize-string "alice@example.com"))
+;; → email
+
+(println (categorize-string "https://example.com"))
+;; → url
+
+(println (categorize-string "12345"))
+;; → number

package/examples/patterns/08-data-transformation.fl

@@ -0,0 +1,92 @@
+;; 패턴 8: 데이터 변환 (Data Transformation)
+;; AI가 한 형식에서 다른 형식으로 데이터를 변환할 때 사용
+
+;; 패턴 A: 배열 → 맵 (키-값 쌍으로 변환)
+(define array-to-map (fn [items]
+  (reduce (fn [acc item]
+    (map-set acc (str (length acc)) item))
+    {}
+    items)))
+
+;;; TEST: (get (array-to-map ["a" "b"]) "0") => "a"
+
+;; 패턴 B: 맵 → 배열 (값 추출)
+(define map-to-values (fn [m]
+  (values m)))
+
+;;; TEST: (length (map-to-values {:name "Alice" :age 25})) => 2
+
+;; 패턴 C: 배열 평탄화 (한 수준)
+(define flatten-one-level (fn [nested]
+  (reduce (fn [acc item]
+    (if (array? item) (append acc item) (append acc [item])))
+    []
+    nested)))
+
+;;; TEST: (flatten-one-level [1 [2 3] 4]) => [1 2 3 4]
+
+;; 패턴 D: 배열 조합
+(define combine-arrays (fn [arr1 arr2]
+  (append arr1 arr2)))
+
+;;; TEST: (combine-arrays [1 2] [3 4]) => [1 2 3 4]
+
+;; 패턴 E: 맵 병합
+(define merge-maps (fn [m1 m2]
+  (reduce (fn [acc key]
+    (map-set acc key (get m2 key)))
+    m1
+    (keys m2))))
+      profile {:age 25 :city "Seoul"}
+      merged (merge-user-data user profile)]
+  (println merged))
+;; → {:id 1 :name "Alice" :age 25 :city "Seoul"}
+
+;; 패턴 F: 필드 선택 (Pick)
+(defun pick-fields [obj fields]
+  (reduce (fn [acc field]
+    (let [[merged acc]] (map-set merged :grade "A")))
+   {}
+   fields))
+
+(let [user {:id 1 :name "Alice" :age 25 :email "alice@example.com" :password "secret"}
+      selected (pick-fields user [:id :name :email])]
+  (println selected))
+;; → {:id 1 :name "Alice" :email "alice@example.com"}
+
+;; 패턴 G: 필드 제외 (Omit)
+(defun omit-fields [obj fields]
+  (let [all-keys (keys obj)
+        keep-keys (filter (fn [k]
+          (not (in-array k fields)))
+          all-keys)]
+    (pick-fields obj keep-keys)))
+
+;; 패턴 H: 데이터 정규화 (Normalize)
+(defun normalize-user [raw-user]
+  {:id (get raw-user :id)
+   :name (trim (get raw-user :name))
+   :email (lower-case (trim (get raw-user :email)))
+   :age (parse-number (get raw-user :age))
+   :is-active (if (get raw-user :status) true false)})
+
+;; 패턴 I: 조건부 변환
+(defun apply-discount [products discount-rate]
+  (map (fn [product]
+    (let [original-price (get product :price)]
+      (merge product {
+        :original-price original-price
+        :discounted-price (* original-price (- 1 discount-rate))
+        :discount-amount (* original-price discount-rate)})))
+   products))
+
+(let [products [{:id 1 :name "Apple" :price 100}
+                {:id 2 :name "Banana" :price 200}]]
+  (println (apply-discount products 0.1)))
+
+;; 패턴 J: 요약 (Summary)
+(defun summarize-users [users]
+  {:total (length users)
+   :average-age (/ (reduce (fn [acc u] (+ acc (get u :age))) 0 users) (length users))
+   :names (map (fn [u] (get u :name)) users)
+   :by-city (group-by-field users :city)})

package/examples/patterns/09-decision-logic.fl

@@ -0,0 +1,122 @@
+;; 패턴 9: 의사결정 로직 (Decision Logic)
+;; AI가 조건부 처리와 분기를 할 때 사용
+
+;; 패턴 A: 기본 if-else (cond 버전)
+(define get-grade (fn [score]
+  (cond
+    [(>= score 90) "A"]
+    [(>= score 80) "B"]
+    [(>= score 70) "C"]
+    [true "F"])))
+
+;;; TEST: (get-grade 85) => "B"
+;;; TEST: (get-grade 92) => "A"
+
+;; 패턴 B: 다중 조건 (and/or)
+(define is-eligible (fn [age income]
+  (and
+    (>= age 18)
+    (>= income 30000))))
+
+;;; TEST: (is-eligible 25 50000) => true
+;;; TEST: (is-eligible 17 50000) => false
+
+;; 패턴 C: cond 문 (다중 분기)
+(define process-status (fn [status]
+  (cond
+    [(= status "pending") "대기 중입니다"]
+    [(= status "approved") "승인되었습니다"]
+    [(= status "rejected") "거절되었습니다"]
+    [true "상태를 알 수 없습니다"])))
+
+;;; TEST: (process-status "approved") => "승인되었습니다"
+
+;; 패턴 D: 중첩된 조건
+(define calculate-shipping (fn [weight domestic]
+  (if (<= weight 5)
+    (if domestic 5000 10000)
+    (if domestic 7500 15000))))
+
+;;; TEST: (calculate-shipping 3 true) => 5000
+;;; TEST: (calculate-shipping 10 true) => 7500
+
+(println (calculate-shipping-cost 10 "international"))
+;; → 15000
+
+;; 패턴 E: 기본값 처리
+(defun get-user-info [user field default-value]
+  (let [value (get user field)]
+    (if (nil? value)
+      default-value
+      value)))
+
+(println (get-user-info {:name "Alice"} :name "Unknown"))
+;; → Alice
+
+(println (get-user-info {:name "Bob"} :age 0))
+;; → 0
+
+;; 패턴 F: 조건부 필터링
+(defun filter-by-criteria [items min-age max-age status]
+  (filter (fn [item]
+    (and
+      (>= (get item :age) min-age)
+      (<= (get item :age) max-age)
+      (if (nil? status)
+        true
+        (= (get item :status) status))))
+   items))
+
+;; 패턴 G: 조건부 변환
+(defun classify-user [user]
+  (let [age (get user :age)
+        income (get user :income)]
+    (merge user {
+      :category (case true
+        ((< age 18) "minor")
+        ((>= age 65) "senior")
+        (true "adult"))
+      :income-level (case true
+        ((< income 30000) "low")
+        ((< income 100000) "medium")
+        (true "high"))})))
+
+(println (classify-user {:age 25 :income 50000}))
+;; → {...:category "adult" :income-level "medium"}
+
+;; 패턴 H: 우선순위 기반 선택
+(defun select-best-offer [offers]
+  (reduce (fn [best offer]
+    (if (> (get offer :value) (get best :value))
+      offer
+      best))
+   (get offers 0)
+   (drop 1 offers)))
+
+;; 패턴 I: 조건부 액션
+(defun process-order [order]
+  (let [total (get order :total)
+        status (if (> total 100000)
+         "requires-approval"
+         (if (> total 50000)
+          "needs-review"
+          "auto-approve"))]
+    (let [[merged order]] (map-set merged :grade "A"))))
+
+;; 패턴 J: early return (throw 사용)
+(defun validate-user [user]
+  ;; 각 조건을 순차적으로 확인
+  (if (nil? user)
+    (throw "User is required"))
+  (if (nil? (get user :name))
+    (throw "Name is required"))
+  (if (< (get user :age) 18)
+    (throw "User must be 18 or older"))
+  (if (nil? (get user :email))
+    (throw "Email is required"))
+  ;; 모든 검증 통과
+  user)
+
+(try
+  (validate-user {:name "Alice" :age 25 :email "alice@example.com"})
+  (catch err (println "검증 실패:" err)))

package/examples/patterns/10-agent-orchestration.fl

@@ -0,0 +1,184 @@
+;; 패턴 10: 작업 큐 및 오케스트레이션
+;; AI 에이전트가 복잡한 작업을 순차 실행할 때 사용
+
+;; 초기 에이전트 상태
+(define initial-agent {:id "a1" :status "idle" :queue [] :results []})
+
+;; 패턴 A: 작업 추가 (enqueue)
+(define enqueue-task (fn [agent task]
+  (map-set agent :queue (append (get agent :queue) [task]))))
+
+;;; TEST: (length (get (enqueue-task initial-agent {:name "task1"}) :queue)) => 1
+
+;; 패턴 B: 다음 작업 추출 (dequeue)
+(define dequeue-task (fn [agent]
+  (let [q (get agent :queue)]
+    (if (> (length q) 0)
+      {:agent (map-set agent :queue (slice q 1 (length q)))
+       :task (first q)}
+      {:agent agent :task nil}))))
+
+;;; TEST: (nil? (get (dequeue-task initial-agent) :task)) => true
+
+;; 패턴 C: 작업 순차 실행
+(define process-queue (fn [agent max-tasks]
+  (let [tasks (get agent :queue)]
+    (if (> (length tasks) 0)
+      (let [processed (reduce (fn [acc _]
+                               (let [dequeued (dequeue-task acc)]
+                                 (map-set (get dequeued :agent) :results
+                                         (append (get acc :results) [(get dequeued :task)]))))
+                             agent
+                             (slice tasks 0 (min max-tasks (length tasks))))]
+        processed)
+      agent))))
+
+;; 패턴 D: 결과 조회
+(define get-results (fn [agent]
+  (get agent :results)))
+
+;;; TEST: (length (get-results {:results [{:name "t1"} {:name "t2"}]})) => 2
+
+;; 헬퍼: min 함수
+(define min (fn [a b]
+  (if (< a b) a b)))
+          :current-task nil
+          :context (merge (get state :context) {:last-result result})}))
+      (catch err
+        ;; 작업 실패
+        (merge state {
+          :failed-tasks (+ (get state :failed-tasks)
+                          [{:task task :error (str err) :failed-at (now-ms)}])
+          :current-task nil
+          :status "failed"}))))
+
+  ;; ========================================
+  ;; 패턴 C: 조건부 작업 흐름
+  ;; ========================================
+  (defun should-continue [state]
+    (let [status (get state :status)]
+      (and (not (= status "failed"))
+           (> (length (get state :task-queue)) 0))))
+
+  ;; ========================================
+  ;; 패턴 D: 에이전트 실행 루프
+  ;; ========================================
+  (defun run-agent [initial-state]
+    (defun execute-loop [state]
+      (if (should-continue state)
+        (let [dequeued (dequeue-task state)
+              next-state (get dequeued :state)
+              task (get dequeued :task)]
+          (if (nil? task)
+            next-state
+            (let [executed-state (execute-task next-state task)]
+              (execute-loop (merge executed-state {
+                :metadata (merge (get executed-state :metadata)
+                               {:last-updated-at (now-ms)})})))))
+        state))
+    (execute-loop initial-state))
+
+  ;; ========================================
+  ;; 패턴 E: 컨텍스트 관리
+  ;; ========================================
+  (defun save-context [state key value]
+    (merge state {
+      :context (merge (get state :context) {(str key) value})}))
+
+  (defun get-context [state key]
+    (get (get state :context) (str key)))
+
+  ;; ========================================
+  ;; 패턴 F: 결과 수집
+  ;; ========================================
+  (defun get-execution-summary [state]
+    {:total-tasks (+ (length (get state :completed-tasks))
+                    (length (get state :failed-tasks)))
+     :completed (length (get state :completed-tasks))
+     :failed (length (get state :failed-tasks))
+     :success-rate (if (= (+ (length (get state :completed-tasks))
+                           (length (get state :failed-tasks))) 0)
+                   0
+                   (/ (length (get state :completed-tasks))
+                     (+ (length (get state :completed-tasks))
+                       (length (get state :failed-tasks)))))
+     :status (get state :status)
+     :context (get state :context)})
+
+  ;; ========================================
+  ;; 패턴 G: 병렬 작업 (간단한 버전)
+  ;; ========================================
+  (defun execute-tasks-in-parallel [state tasks]
+    (let [results (map (fn [task]
+      (try
+        (execute-task state task)
+        (catch err {:error (str err) :task task})))
+      tasks)]
+      results))
+
+  ;; ========================================
+  ;; 실행 예제
+  ;; ========================================
+  (let [initial-state agent-state
+        ;; 작업 큐에 추가
+        state1 (enqueue-task initial-state
+          {:type "fetch-data" :data {:url "https://api.example.com/users"}})
+        state2 (enqueue-task state1
+          {:type "process-data" :data {:items []}})
+        state3 (enqueue-task state2
+          {:type "save-data" :data {:path "output.json" :content "results"}})
+
+        ;; 에이전트 실행
+        final-state (run-agent (let [[merged state3]] (map-set merged :grade "A")))
+
+        ;; 결과 요약
+        summary (get-execution-summary final-state)]
+
+    (println "에이전트 실행 완료")
+    (println summary)))
+
+;; ========================================
+;; 패턴 H: 에러 복구 전략
+;; ========================================
+(defun execute-with-retry [state task max-attempts]
+  (defun retry-helper [attempt]
+    (if (> attempt max-attempts)
+      (throw (str "Task failed after " max-attempts " attempts"))
+      (try
+        (execute-task state task)
+        (catch err
+          (do
+            (println "재시도 " attempt "실패, 다시 시도 중...")
+            (retry-helper (+ attempt 1)))))))
+  (retry-helper 1))
+
+;; ========================================
+;; 패턴 I: 작업 의존성 관리
+;; ========================================
+(defun execute-with-dependencies [state task dependencies]
+  ;; 모든 의존 작업 완료 확인
+  (let [completed-task-ids (map (fn [t]
+    (get t :task-id))
+    (get state :completed-tasks))
+        all-deps-met (reduce (fn [acc dep]
+          (and acc (in-array dep completed-task-ids)))
+         true
+         dependencies)]
+    (if all-deps-met
+      (execute-task state task)
+      (throw "Dependencies not met"))))
+
+;; ========================================
+;; 패턴 J: 에이전트 모니터링
+;; ========================================
+(defun get-agent-health [state]
+  (let [total-tasks (+ (length (get state :completed-tasks))
+                      (length (get state :failed-tasks)))
+        completed (length (get state :completed-tasks))
+        failed (length (get state :failed-tasks))
+        success-rate (if (= total-tasks 0) 0 (/ completed total-tasks))]
+    {:healthy (and (= failed 0) (> success-rate 0.9))
+     :status (get state :status)
+     :task-count total-tasks
+     :success-rate success-rate
+     :failed-count failed}))