Codex · 代码展示

# neural_dream.py — 一个会做梦的小神经网络
from dataclasses import dataclass
from typing import Callable, List
import math
import random

@dataclass
class Neuron:
    weights: List[float]
    bias: float = 0.0

    def fire(self, inputs: List[float]) -> float:
        z = sum(w * x for w, x in zip(self.weights, inputs)) + self.bias
        return 1.0 / (1.0 + math.exp(-z))

def dream(layers: List[List[Neuron]], seed: List[float]) -> List[float]:
    """从一粒种子开始，让网络层层做梦。"""
    signal = seed
    for depth, layer in enumerate(layers):
        signal = [n.fire(signal) for n in layer]
        print(f"层 {depth}: {[round(s, 3) for s in signal]}")
    return signal

def build(shape: List[int]) -> List[List[Neuron]]:
    return [
        [Neuron([random.gauss(0, 1) for _ in range(shape[i])])
         for _ in range(shape[i + 1])]
        for i in range(len(shape) - 1)
    ]

if __name__ == "__main__":
    random.seed(42)
    brain = build([3, 5, 4, 2])
    result = dream(brain, seed=[0.8, 0.1, 0.5])
    print("梦醒了：", result)

// garden.rs — 用所有权模型经营一座花园
use std::collections::HashMap;
use std::fmt;

#[derive(Debug, Clone)]
enum Plant {
    Rose(u8),      // 花瓣数
    Bamboo,
    Moss { wet: bool },
}

impl fmt::Display for Plant {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Plant::Rose(n) => write!(f, "🌹×{}", n),
            Plant::Bamboo    => write!(f, "🎋"),
            Plant::Moss { wet } =>
                write!(f, "{}", if *wet { "🌿" } else { "🍂" }),
        }
    }
}

struct Garden {
    plots: HashMap<String, Plant>,
}

impl Garden {
    fn new() -> Self { Self { plots: HashMap::new() } }

    fn plant(&mut self, name: &str, p: Plant) {
        self.plots.insert(name.into(), p);
    }

    fn walk(&self) {
        for (spot, plant) in &self.plots {
            println!("在 {} 看到 {}", spot, plant);
        }
    }
}

fn main() {
    let mut g = Garden::new();
    g.plant("东角", Plant::Rose(12));
    g.plant("石径", Plant::Moss { wet: true });
    g.plant("围墙", Plant::Bamboo);
    g.walk();
}

// tide.ts — 一个极简的响应式状态容器
type Listener<T> = (next: T, prev: T) => void;

interface Tide<T> {
  get(): T;
  set(value: T | ((prev: T) => T)): void;
  subscribe(fn: Listener<T>): () => void;
}

export function createTide<T>(initial: T): Tide<T> {
  let current = initial;
  const listeners = new Set<Listener<T>>();

  return {
    get() { return current; },
    set(value) {
      const next = typeof value === "function"
        ? (value as (p: T) => T)(current)
        : value;
      if (Object.is(next, current)) return;
      const prev = current;
      current = next;
      listeners.forEach((fn) => fn(next, prev));
    },
    subscribe(fn) {
      listeners.add(fn);
      return () => listeners.delete(fn);
    },
  };
}

// 使用示例
const counter = createTide(0);
const stop = counter.subscribe((n, p) =>
  console.log(`潮水 ${p} → ${n}`)
);

counter.set(1);
counter.set((n) => n + 2);
counter.set(9);
stop();