An embeddable Clojure-inspired Lisp.
Written in portable C99.

Host objects are wrapped as type-tagged handles with automatic GC cleanup. The API uses direct value pointers rather than stack indices, so there is no stack balancing and no off-by-one indexing errors. Data returned to the script is immutable. The script cannot mutate your state through the values you hand it, and you never need to defensively copy data at the boundary.

// Wrap a C++ object as a mino handle.
static mino_val_t *source_new(mino_state_t *S, mino_val_t *,
                              mino_val_t *, void *) {
    auto *src = new EventSource;
    src->events.push_back(make_event(S, "temp", "sensor-01", 21.3));
    src->events.push_back(make_event(S, "temp", "sensor-02", 19.8));
    // ...
    return mino_handle_ex(S, src, "EventSource",
        [](void *p, const char *) { delete (EventSource *)p; });
}

// Return the next event as a mino map, or nil.
static mino_val_t *source_next(mino_state_t *S, mino_val_t *target,
                               mino_val_t *, void *) {
    auto *src = (EventSource *)mino_handle_ptr(target);
    if (src->cursor >= src->events.size())
        return mino_nil(S);
    return src->events[src->cursor++];
}

The scripter writes processing rules without knowing anything about C++. Every value flowing through the pipeline is immutable with structural sharing, so there are no aliasing bugs and no "who mutated my table" surprises. Keywords like :device double as data accessors. The set #{:temp} is used directly as a filter predicate because collections are callable. drain recurses in constant stack space via automatic tail-call optimization. Change the processing logic without recompiling.

;; Consume all events into a vector via self-recursion.
(defn drain [source acc]
  (let [evt (.next source)]
    (if (nil? evt)
      acc
      (drain source (conj acc evt)))))

;; Summarize a [device readings] group.
(defn summarize [[device readings]]
  [device {:count (count readings)
           :avg   (/ (reduce + (map :value readings))
                     (count readings))}])

;; Filter, group, summarize.
(defn analyze [events type-filter]
  (->> events
       (filter #(type-filter (:type %)))
       (group-by :device)
       (map summarize)
       (into (sorted-map))))

(let [events (drain (new EventSource) [])]
  (analyze events #{:temp}))
;; => {"sensor-01" {:count 4, :avg 22.0}
;;     "sensor-02" {:count 3, :avg 19.9}}