freelang-editor 11.7.4

package/src/world-model.ts

@@ -0,0 +1,348 @@
+// world-model.ts — FreeLang v9 Phase 141: [WORLD-MODEL]
+// AI가 세계에 대한 내부 모델을 구축하고 업데이트하는 시스템
+// 엔티티, 관계, 상태, 규칙을 추적
+
+export interface Entity {
+  id: string;
+  type: string;
+  properties: Record<string, unknown>;
+  confidence: number;   // 0~1
+  lastUpdated: Date;
+}
+
+export interface Relation {
+  id: string;
+  from: string;         // Entity id
+  to: string;           // Entity id
+  type: string;         // "is-a", "has", "causes", "part-of", etc.
+  strength: number;     // 0~1
+  bidirectional: boolean;
+}
+
+export interface WorldState {
+  entities: Map<string, Entity>;
+  relations: Relation[];
+  facts: Map<string, unknown>;   // key→value 사실
+  rules: WorldRule[];
+  timestamp: Date;
+  version: number;
+}
+
+export interface WorldRule {
+  id: string;
+  condition: string;    // 조건 설명
+  consequence: string;  // 결과 설명
+  confidence: number;
+}
+
+export interface WorldUpdate {
+  type: 'add-entity' | 'update-entity' | 'remove-entity' | 'add-relation' | 'add-fact' | 'add-rule';
+  data: unknown;
+  source: string;       // 업데이트 출처
+  timestamp: Date;
+}
+
+export class WorldModel {
+  private state: WorldState;
+  private history: WorldUpdate[];
+  private _idCounter: number = 0;
+
+  constructor() {
+    this.state = {
+      entities: new Map(),
+      relations: [],
+      facts: new Map(),
+      rules: [],
+      timestamp: new Date(),
+      version: 0,
+    };
+    this.history = [];
+  }
+
+  private nextId(prefix: string = 'id'): string {
+    return `${prefix}-${++this._idCounter}-${Date.now()}`;
+  }
+
+  private recordUpdate(update: WorldUpdate): void {
+    this.history.push(update);
+    this.state.timestamp = new Date();
+    this.state.version++;
+  }
+
+  // 엔티티 추가
+  addEntity(entity: Omit<Entity, 'lastUpdated'>): Entity {
+    const e: Entity = {
+      ...entity,
+      lastUpdated: new Date(),
+    };
+    this.state.entities.set(e.id, e);
+    this.recordUpdate({
+      type: 'add-entity',
+      data: e,
+      source: 'world-model',
+      timestamp: new Date(),
+    });
+    return e;
+  }
+
+  // 엔티티 업데이트
+  updateEntity(id: string, props: Partial<Entity['properties']>): Entity | null {
+    const e = this.state.entities.get(id);
+    if (!e) return null;
+    const updated: Entity = {
+      ...e,
+      properties: { ...e.properties, ...props },
+      lastUpdated: new Date(),
+    };
+    this.state.entities.set(id, updated);
+    this.recordUpdate({
+      type: 'update-entity',
+      data: { id, props },
+      source: 'world-model',
+      timestamp: new Date(),
+    });
+    return updated;
+  }
+
+  // 엔티티 삭제
+  removeEntity(id: string): boolean {
+    const existed = this.state.entities.has(id);
+    if (!existed) return false;
+    this.state.entities.delete(id);
+    // 관련 관계도 제거
+    this.state.relations = this.state.relations.filter(
+      r => r.from !== id && r.to !== id
+    );
+    this.recordUpdate({
+      type: 'remove-entity',
+      data: { id },
+      source: 'world-model',
+      timestamp: new Date(),
+    });
+    return true;
+  }
+
+  // 엔티티 조회
+  getEntity(id: string): Entity | null {
+    return this.state.entities.get(id) ?? null;
+  }
+
+  // 관계 추가
+  addRelation(relation: Omit<Relation, 'id'>): Relation {
+    const r: Relation = {
+      ...relation,
+      id: this.nextId('rel'),
+    };
+    this.state.relations.push(r);
+    this.recordUpdate({
+      type: 'add-relation',
+      data: r,
+      source: 'world-model',
+      timestamp: new Date(),
+    });
+    return r;
+  }
+
+  // 엔티티의 관계 조회
+  getRelations(entityId: string): Relation[] {
+    return this.state.relations.filter(
+      r => r.from === entityId || (r.bidirectional && r.to === entityId)
+    );
+  }
+
+  // BFS로 두 엔티티 간 경로 찾기
+  findPath(fromId: string, toId: string): string[] {
+    if (fromId === toId) return [fromId];
+
+    const visited = new Set<string>();
+    const queue: { id: string; path: string[] }[] = [{ id: fromId, path: [fromId] }];
+
+    while (queue.length > 0) {
+      const { id, path } = queue.shift()!;
+      if (visited.has(id)) continue;
+      visited.add(id);
+
+      const neighbors = this.state.relations
+        .filter(r => r.from === id || (r.bidirectional && r.to === id))
+        .map(r => (r.from === id ? r.to : r.from));
+
+      for (const neighbor of neighbors) {
+        if (neighbor === toId) return [...path, neighbor];
+        if (!visited.has(neighbor)) {
+          queue.push({ id: neighbor, path: [...path, neighbor] });
+        }
+      }
+    }
+
+    return []; // 경로 없음
+  }
+
+  // 사실 저장
+  setFact(key: string, value: unknown): void {
+    this.state.facts.set(key, value);
+    this.recordUpdate({
+      type: 'add-fact',
+      data: { key, value },
+      source: 'world-model',
+      timestamp: new Date(),
+    });
+  }
+
+  // 사실 조회
+  getFact(key: string): unknown {
+    return this.state.facts.get(key) ?? null;
+  }
+
+  // 규칙 추가
+  addRule(rule: Omit<WorldRule, 'id'>): WorldRule {
+    const r: WorldRule = {
+      ...rule,
+      id: this.nextId('rule'),
+    };
+    this.state.rules.push(r);
+    this.recordUpdate({
+      type: 'add-rule',
+      data: r,
+      source: 'world-model',
+      timestamp: new Date(),
+    });
+    return r;
+  }
+
+  // 규칙 적용 (조건 기반으로 사실 추론)
+  applyRules(): WorldUpdate[] {
+    const applied: WorldUpdate[] = [];
+    for (const rule of this.state.rules) {
+      // 간단한 규칙 엔진: 조건과 일치하는 엔티티에 결과 적용
+      for (const [, entity] of this.state.entities) {
+        // 엔티티 타입이나 속성에서 조건 검색
+        const condLower = rule.condition.toLowerCase();
+        const entityStr = JSON.stringify(entity).toLowerCase();
+        if (entityStr.includes(condLower)) {
+          // 결과를 사실로 기록
+          const factKey = `rule:${rule.id}:${entity.id}`;
+          if (!this.state.facts.has(factKey)) {
+            this.setFact(factKey, {
+              rule: rule.id,
+              entity: entity.id,
+              consequence: rule.consequence,
+              confidence: rule.confidence * entity.confidence,
+            });
+            applied.push({
+              type: 'add-fact',
+              data: { key: factKey, consequence: rule.consequence },
+              source: `rule:${rule.id}`,
+              timestamp: new Date(),
+            });
+          }
+        }
+      }
+    }
+    return applied;
+  }
+
+  // 타입/신뢰도 기반 쿼리
+  query(type?: string, minConfidence?: number): Entity[] {
+    let results = Array.from(this.state.entities.values());
+    if (type !== undefined) {
+      results = results.filter(e => e.type === type);
+    }
+    if (minConfidence !== undefined) {
+      results = results.filter(e => e.confidence >= minConfidence);
+    }
+    return results;
+  }
+
+  // 상태 스냅샷 (깊은 복사)
+  snapshot(): WorldState {
+    return {
+      entities: new Map(
+        Array.from(this.state.entities.entries()).map(([k, v]) => [k, { ...v, properties: { ...v.properties } }])
+      ),
+      relations: this.state.relations.map(r => ({ ...r })),
+      facts: new Map(this.state.facts),
+      rules: this.state.rules.map(r => ({ ...r })),
+      timestamp: new Date(this.state.timestamp),
+      version: this.state.version,
+    };
+  }
+
+  // 두 상태 비교 → 차이 WorldUpdate 목록 반환
+  diff(other: WorldState): WorldUpdate[] {
+    const updates: WorldUpdate[] = [];
+    const now = new Date();
+
+    // 현재 상태에 없는 엔티티 (other에만 있는 것)
+    for (const [id, entity] of other.entities) {
+      if (!this.state.entities.has(id)) {
+        updates.push({ type: 'add-entity', data: entity, source: 'diff', timestamp: now });
+      }
+    }
+
+    // 현재 상태에 있지만 다른 엔티티
+    for (const [id, entity] of this.state.entities) {
+      const otherEntity = other.entities.get(id);
+      if (!otherEntity) {
+        updates.push({ type: 'remove-entity', data: { id }, source: 'diff', timestamp: now });
+      } else if (JSON.stringify(entity.properties) !== JSON.stringify(otherEntity.properties)) {
+        updates.push({ type: 'update-entity', data: { id, props: otherEntity.properties }, source: 'diff', timestamp: now });
+      }
+    }
+
+    // 새로운 관계
+    for (const rel of other.relations) {
+      const exists = this.state.relations.find(r => r.id === rel.id);
+      if (!exists) {
+        updates.push({ type: 'add-relation', data: rel, source: 'diff', timestamp: now });
+      }
+    }
+
+    // 새로운 사실
+    for (const [key, value] of other.facts) {
+      if (!this.state.facts.has(key)) {
+        updates.push({ type: 'add-fact', data: { key, value }, source: 'diff', timestamp: now });
+      }
+    }
+
+    return updates;
+  }
+
+  // 업데이트 이력 반환
+  getHistory(): WorldUpdate[] {
+    return [...this.history];
+  }
+
+  // 세계 요약 문자열 생성
+  summarize(): string {
+    const entityCount = this.state.entities.size;
+    const relationCount = this.state.relations.length;
+    const factCount = this.state.facts.size;
+    const ruleCount = this.state.rules.length;
+
+    const types = new Map<string, number>();
+    for (const e of this.state.entities.values()) {
+      types.set(e.type, (types.get(e.type) ?? 0) + 1);
+    }
+
+    const typeStr = Array.from(types.entries())
+      .map(([t, c]) => `${t}(${c})`)
+      .join(', ');
+
+    const avgConfidence = entityCount > 0
+      ? (Array.from(this.state.entities.values()).reduce((s, e) => s + e.confidence, 0) / entityCount).toFixed(2)
+      : '0.00';
+
+    return [
+      `WorldModel v${this.state.version}`,
+      `Entities: ${entityCount} [${typeStr || 'none'}]`,
+      `Relations: ${relationCount}`,
+      `Facts: ${factCount}`,
+      `Rules: ${ruleCount}`,
+      `Avg Confidence: ${avgConfidence}`,
+      `Last Updated: ${this.state.timestamp.toISOString()}`,
+    ].join(' | ');
+  }
+}
+
+// 전역 WorldModel 인스턴스
+export const globalWorldModel = new WorldModel();

package/stdlib/cache.fl

@@ -0,0 +1,42 @@
+;; stdlib/cache.fl — LRU+TTL 인메모리 캐시 래퍼 (v11.6.36)
+;; (load "stdlib/cache.fl")
+;;
+;; 내장 cache-* 함수를 감싸는 얇은 레이어.
+;; 내장 함수 직접 사용 가능 — 이 파일은 문서/편의용.
+
+;; ── 캐시 생성 ────────────────────────────────────────────────────────────────
+;; (cache-create 100)       → maxSize=100 캐시 핸들
+;; (cache-create)           → maxSize=100 기본값
+(defn make-cache [max-size]
+  (cache-create max-size))
+
+(defn make-cache-default []
+  (cache-create 100))
+
+;; ── 캐시 조작 ────────────────────────────────────────────────────────────────
+;; (cache-set ch "key" value)         → 영구 저장
+;; (cache-set ch "key" value 60000)   → TTL 60초(ms)
+;; (cache-get ch "key")               → value or nil
+;; (cache-has ch "key")               → bool
+;; (cache-del ch "key")               → bool
+;; (cache-clear ch)                   → bool
+;; (cache-stats ch)                   → {:size N :hits N :misses N :hit-rate N}
+
+;; ── 헬퍼 패턴 ────────────────────────────────────────────────────────────────
+;; get-or-set: 캐시 미스 시 fn 호출 후 결과 저장
+(defn cache-get-or-set [ch key loader]
+  (let [cached (cache-get ch key)]
+    (if (nil? cached)
+      (let [val (loader)]
+        (cache-set ch key val)
+        val)
+      cached)))
+
+;; get-or-set with TTL
+(defn cache-get-or-set-ttl [ch key ttl-ms loader]
+  (let [cached (cache-get ch key)]
+    (if (nil? cached)
+      (let [val (loader)]
+        (cache-set ch key val ttl-ms)
+        val)
+      cached)))

package/stdlib/csv.fl

@@ -0,0 +1,38 @@
+;; FreeLang stdlib — csv.fl (CSV 파싱/직렬화)
+;; (load "stdlib/csv.fl")
+;;
+;; 내장 함수 (eval-builtins → stdlib-data.ts):
+;;   csv-parse       — [[string]] 반환, quoted fields 완전 지원
+;;   csv-parse-map   — [{header: val}] 반환
+;;   csv-stringify   — rows → CSV 문자열
+;;
+;; 이 파일은 FL 레벨 유틸리티 함수 제공
+
+;; CSV 첫 행(헤더)만 반환
+(defn csv-headers [text]
+  (first (csv-parse text)))
+
+;; CSV를 파싱해 헤더 제외 데이터 행만 반환
+(defn csv-data-rows [text]
+  (rest (csv-parse text)))
+
+;; 헤더 + 데이터 rows를 CSV로 직렬화
+(defn csv-from-maps [headers maps]
+  (let [header-row [headers]
+        data-rows (map (fn [m] (map (fn [h] (get m h)) headers)) maps)]
+    (csv-stringify (append header-row data-rows))))
+
+;; CSV 행 수 (헤더 제외)
+(defn csv-row-count [text]
+  (length (csv-data-rows text)))
+
+;; 특정 컬럼만 추출 → [{col: val}]
+(defn csv-select [text col-names]
+  (let [rows (csv-parse-map text)]
+    (map (fn [row]
+      (reduce (fn [acc col] (assoc acc col (get row col))) {} col-names))
+      rows)))
+
+;; CSV에서 특정 컬럼 필터링
+(defn csv-filter [text col pred-fn]
+  (filter (fn [row] (pred-fn (get row col))) (csv-parse-map text)))

package/stdlib/date-ext.fl

@@ -0,0 +1,68 @@
+;; stdlib/date-ext.fl — 날짜 확장 유틸리티
+
+(defn date-now-ms []
+  ;; 현재 타임스탬프(ms) 반환
+  (now-ms))
+
+(defn date-diff-days [ts1 ts2]
+  ;; 두 타임스탬프(ms) 간 차이를 일수로 반환 (절대값)
+  ;; (date-diff-days (now-ms) (+ (now-ms) 86400000)) → 1
+  (floor (/ (abs (- ts2 ts1)) 86400000)))
+
+(defn date-add-days [ts days]
+  ;; 타임스탬프에 days일 추가
+  ;; (date-add-days (now-ms) 7) → 7일 뒤 ms
+  (+ ts (* days 86400000)))
+
+(defn date-start-of-day [ts]
+  ;; 해당 날짜의 00:00:00 타임스탬프
+  (* (floor (/ ts 86400000)) 86400000))
+
+(defn date-format-ko [ts]
+  ;; 타임스탬프를 한국어 날짜 포맷으로 반환
+  ;; → "2026년 5월 12일"
+  (let [parts (date-parts ts)]
+    (str (get parts "year") "년 "
+         (get parts "month") "월 "
+         (get parts "day") "일")))
+
+(defn date-format-ko-full [ts]
+  ;; "2026년 5월 12일 오전 9시 30분"
+  (let [parts (date-parts ts)
+        hour (get parts "hour")
+        ampm (if (< hour 12) "오전" "오후")
+        h12 (if (= hour 0) 12 (if (> hour 12) (- hour 12) hour))]
+    (str (get parts "year") "년 "
+         (get parts "month") "월 "
+         (get parts "day") "일 "
+         ampm " " h12 "시 "
+         (get parts "minute") "분")))
+
+(defn date-iso [ts]
+  ;; ISO 8601 형식 반환 "2026-05-12"
+  (let [parts (date-parts ts)]
+    (str (get parts "year") "-"
+         (str-pad-left (str (get parts "month")) 2 "0") "-"
+         (str-pad-left (str (get parts "day")) 2 "0"))))
+
+(defn date-past? [ts]
+  ;; 해당 타임스탬프가 현재보다 과거인지
+  (< ts (now-ms)))
+
+(defn date-future? [ts]
+  ;; 해당 타임스탬프가 현재보다 미래인지
+  (> ts (now-ms)))
+
+(defn date-ago [ts]
+  ;; "N일 전", "N시간 전", "방금" 같은 상대 표현
+  (let [diff (- (now-ms) ts)
+        days (floor (/ diff 86400000))
+        hours (floor (/ diff 3600000))
+        mins (floor (/ diff 60000))]
+    (cond
+      [(>= days 365) (str (floor (/ days 365)) "년 전")]
+      [(>= days 30)  (str (floor (/ days 30)) "달 전")]
+      [(>= days 1)   (str days "일 전")]
+      [(>= hours 1)  (str hours "시간 전")]
+      [(>= mins 1)   (str mins "분 전")]
+      [true          "방금"])))

package/stdlib/log.fl

@@ -0,0 +1,44 @@
+;; stdlib/log.fl — 구조화 로그 유틸리티 (v11.6.36)
+;; (load "stdlib/log.fl")
+;;
+;; 사용법:
+;;   (log-info "user.login" {:userId 1 :ip "1.2.3.4"})
+;;   (log-warn "rate.limit" {:current 90 :limit 100})
+;;   (log-error "db.fail" {:err "timeout"})
+;;   (log-debug "cache.miss" {:key "x"})  ;; FL_DEBUG=1 환경변수 필요
+;;   (log-to-file! "app.log")             ;; 이후 로그를 파일에도 기록
+
+;; ── 내부 상태 ────────────────────────────────────────────────────────────────
+(define *log-file* nil)
+
+(defn log-to-file! [path]
+  (define *log-file* path))
+
+;; ── 내부 포맷터 ───────────────────────────────────────────────────────────────
+(defn -log-format [level event ctx]
+  (let [ts (now-ms)
+        entry {:ts ts :level level :event event :ctx ctx}]
+    (json-stringify entry)))
+
+(defn -log-write [level event ctx]
+  (let [line (-log-format level event ctx)]
+    (println line)
+    (if (not (nil? *log-file*))
+      (file-append-line *log-file* line)
+      nil)))
+
+;; ── 공개 API ─────────────────────────────────────────────────────────────────
+(defn log-info [event ctx]
+  (-log-write "INFO" event ctx))
+
+(defn log-warn [event ctx]
+  (-log-write "WARN" event ctx))
+
+(defn log-error [event ctx]
+  (-log-write "ERROR" event ctx))
+
+(defn log-debug [event ctx]
+  (let [debug-env (fl-env-get "FL_DEBUG" "")]
+    (if (= debug-env "1")
+      (-log-write "DEBUG" event ctx)
+      nil)))

package/stdlib/math-ext.fl

@@ -0,0 +1,57 @@
+;; FreeLang stdlib — math-ext.fl (확장 수학/통계 함수)
+;; (load "stdlib/math-ext.fl")
+;;
+;; math-sum / math-mean / math-median / math-variance / math-stddev
+;; math-min / math-max / math-range / math-percentile
+;; math-normalize / math-clamp
+
+(defn math-sum [xs]
+  (reduce + 0 xs))
+
+(defn math-mean [xs]
+  (if (empty? xs) nil
+    (/ (math-sum xs) (length xs))))
+
+(defn math-median [xs]
+  (let [s (sort xs)
+        n (length s)
+        m (quot n 2)]
+    (if (= (% n 2) 0)
+      (/ (+ (nth s (- m 1)) (nth s m)) 2)
+      (nth s m))))
+
+(defn math-variance [xs]
+  (let [n (length xs)
+        mu (math-mean xs)]
+    (if (nil? mu) nil
+      (/ (reduce + 0 (map (fn [x] (pow (- x mu) 2)) xs)) n))))
+
+(defn math-stddev [xs]
+  (let [v (math-variance xs)]
+    (if (nil? v) nil (sqrt v))))
+
+(defn math-min [xs]
+  (reduce (fn [a b] (if (< a b) a b)) (first xs) (rest xs)))
+
+(defn math-max [xs]
+  (reduce (fn [a b] (if (> a b) a b)) (first xs) (rest xs)))
+
+(defn math-range [xs]
+  (- (math-max xs) (math-min xs)))
+
+(defn math-percentile [xs p]
+  (let [s (sort xs)
+        n (length s)
+        idx (floor (* (/ p 100.0) (- n 1)))]
+    (nth s (min idx (- n 1)))))
+
+(defn math-clamp [v lo hi]
+  (max lo (min hi v)))
+
+(defn math-normalize [xs]
+  (let [lo (math-min xs)
+        hi (math-max xs)
+        r (- hi lo)]
+    (if (= r 0)
+      (map (fn [x] 0) xs)
+      (map (fn [x] (/ (- x lo) r)) xs))))

package/stdlib/number-ext.fl

@@ -0,0 +1,47 @@
+;; stdlib/number-ext.fl — 숫자 확장 유틸리티
+
+(defn num-format [n]
+  ;; 천단위 쉼표 포맷
+  ;; (num-format 1234567) → "1,234,567"
+  (let [s (str (floor n))
+        parts (str-split s ".")]
+    (let [int-part (nth parts 0)
+          chars (reverse (str-split int-part ""))
+          grouped (map-indexed (fn [i c] (if (and (> i 0) (= (% i 3) 0)) (str "," c) c)) chars)]
+      (join (reverse grouped) ""))))
+
+(defn num-pad [n width]
+  ;; 앞에 0을 채워 width 자리로 맞춤
+  ;; (num-pad 42 5) → "00042"
+  (str-pad-left (str n) width "0"))
+
+(defn num-clamp [n lo hi]
+  ;; n을 lo~hi 범위로 제한 (clamp 별칭)
+  (max lo (min hi n)))
+
+(defn num-percent [part total]
+  ;; 백분율 반환 (소수점 1자리)
+  ;; (num-percent 3 4) → 75.0
+  (if (= total 0) 0 (* 100.0 (/ part total))))
+
+(defn num-to-ordinal [n]
+  ;; 영어 서수 반환
+  ;; (num-to-ordinal 1) → "1st"
+  (let [mod10 (% n 10)
+        mod100 (% n 100)]
+    (cond
+      [(and (= mod10 1) (not= mod100 11)) (str n "st")]
+      [(and (= mod10 2) (not= mod100 12)) (str n "nd")]
+      [(and (= mod10 3) (not= mod100 13)) (str n "rd")]
+      [true (str n "th")])))
+
+(defn num-sign [n]
+  ;; 양수 "+N", 음수 "-N", 0 "0"
+  (cond
+    [(> n 0) (str "+" n)]
+    [(< n 0) (str n)]
+    [true "0"]))
+
+(defn num-in-range? [n lo hi]
+  ;; n이 lo<=n<=hi 범위인지 확인
+  (and (>= n lo) (<= n hi)))

package/stdlib/queue.fl

@@ -0,0 +1,57 @@
+;; FreeLang stdlib — queue.fl (불변 큐/스택)
+;; (load "stdlib/queue.fl")
+;;
+;; Queue (FIFO): queue-create / queue-push / queue-pop / queue-peek / queue-size / queue-empty? / queue->list
+;; Stack (LIFO): stack-create / stack-push / stack-pop / stack-peek / stack-size / stack-empty? / stack->list
+
+;; ── Queue (FIFO) ─────────────────────────────────────────────────
+
+(defn queue-create []
+  {:items [] :size 0})
+
+(defn queue-push [q item]
+  {:items (append (get q :items) item) :size (inc (get q :size))})
+
+(defn queue-pop [q]
+  (let [items (get q :items)]
+    (if (empty? items)
+      {:val nil :queue q}
+      {:val (first items) :queue {:items (rest items) :size (dec (get q :size))}})))
+
+(defn queue-peek [q]
+  (first (get q :items)))
+
+(defn queue-size [q]
+  (get q :size))
+
+(defn queue-empty? [q]
+  (= (get q :size) 0))
+
+(defn queue->list [q]
+  (get q :items))
+
+;; ── Stack (LIFO) ──────────────────────────────────────────────────
+
+(defn stack-create []
+  {:items [] :size 0})
+
+(defn stack-push [s item]
+  {:items (append (get s :items) item) :size (inc (get s :size))})
+
+(defn stack-pop [s]
+  (let [items (get s :items)]
+    (if (empty? items)
+      {:val nil :stack s}
+      {:val (last items) :stack {:items (butlast items) :size (dec (get s :size))}})))
+
+(defn stack-peek [s]
+  (last (get s :items)))
+
+(defn stack-size [s]
+  (get s :size))
+
+(defn stack-empty? [s]
+  (= (get s :size) 0))
+
+(defn stack->list [s]
+  (get s :items))