一种带有琥珀光泽与夜航感的代码块。

type Listener<T> = (state: Readonly<T>) => void;

interface Patch<T> {
  name: string;
  apply: (draft: T) => void;
}

export class OrbitStore<T extends object> {
  private state: T;
  private history: Patch<T>[] = [];
  private listeners = new Set<Listener<T>>();

  constructor(initial: T) {
    this.state = structuredClone(initial);
  }

  read() {
    return Object.freeze(structuredClone(this.state));
  }

  commit(name: string, apply: Patch<T>["apply"]) {
    const draft = structuredClone(this.state);
    apply(draft);
    this.state = draft;
    this.history.push({ name, apply });
    this.emit();
  }

  subscribe(listener: Listener<T>) {
    this.listeners.add(listener); return () => this.listeners.delete(listener);
  }

  private emit() { this.listeners.forEach(l => l(this.read())); }
}

from dataclasses import dataclass
from math import sqrt

# Pick a readable accent color by measuring distance in RGB space.
@dataclass(frozen=True)
class Swatch:
    name: str
    hex: str

    def rgb(self) -> tuple[int, int, int]:
        raw = self.hex.lstrip("#")
        return tuple(int(raw[i:i + 2], 16) for i in (0, 2, 4))

def distance(a: Swatch, b: Swatch) -> float:
    pairs = zip(a.rgb(), b.rgb())
    return sqrt(sum((x - y) ** 2 for x, y in pairs))

def choose_accent(base: Swatch, colors: list[Swatch]) -> Swatch:
    ranked = sorted(colors, key=lambda item: distance(base, item))
    candidates = [c for c in ranked if distance(base, c) > 110]
    return candidates[0] if candidates else ranked[-1]

palette = [
    Swatch("amber", "#ffb86b"),
    Swatch("lagoon", "#7bdff2"),
    Swatch("orchid", "#c792ff"),
    Swatch("rose", "#ff7a90"),
]

if __name__ == "__main__":
    paper = Swatch("paper", "#fff9ec")
    accent = choose_accent(paper, palette)
    print(f"Use {accent.name} as the spark color: {accent.hex}")

use std::collections::HashMap;

type Handler = fn(Request) -> Response;

#[derive(Clone)]
pub struct Request {
    pub path: String,
    pub body: String,
}

pub struct Response {
    pub status: u16,
    pub body: String,
}

pub struct Router {
    routes: HashMap<String, Handler>,
    fallback: Handler,
}

impl Router {
    pub fn new() -> Self {
        Self { routes: HashMap::new(), fallback: not_found }
    }

    pub fn get(mut self, path: &str, handler: Handler) -> Self {
        self.routes.insert(path.to_string(), handler);
        self
    }

    pub fn serve(&self, req: Request) -> Response {
        let handler = self.routes.get(&req.path).copied().unwrap_or(self.fallback);
        handler(req)
    }
}

fn not_found(req: Request) -> Response {
    Response { status: 404, body: format!("No route for {}", req.path) }
}