@lucent-lang/lucent 0.0.4

package/runtime/cpp/lucent/async.h

@@ -0,0 +1,236 @@
+// Lucent runtime — Promise<T> and async functions (C++20 coroutines).
+//
+// A Lucent `async function` is a C++ coroutine returning Promise<T>. Like
+// JavaScript, the body starts running immediately and every `await`
+// suspends, resuming later from the microtask queue (never inline), so the
+// interleaving matches JavaScript's.
+//
+// Coroutine parameters are always taken by value: a coroutine frame must not
+// hold references to its caller's locals.
+#pragma once
+
+#include <coroutine>
+#include <exception>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <tuple>
+#include <vector>
+
+#include "array.h"
+#include "core.h"
+#include "jserror.h"
+#include "scheduler.h"
+
+namespace lucent {
+
+template <class T>
+class Promise;
+
+namespace detail {
+
+template <class T>
+using Stored = std::conditional_t<std::is_void_v<T>, Undefined, T>;
+
+template <class T>
+struct PromiseState {
+  enum class Status : uint8_t { Pending, Fulfilled, Rejected };
+  Status status = Status::Pending;
+  std::optional<Stored<T>> value;
+  Error error;
+  std::vector<std::function<void()>> waiters;
+
+  void fulfill(Stored<T> v) {
+    if (status != Status::Pending) return;
+    value = std::move(v);
+    status = Status::Fulfilled;
+    flush();
+  }
+  void reject(Error e) {
+    if (status != Status::Pending) return;
+    error = std::move(e);
+    status = Status::Rejected;
+    flush();
+  }
+  /// Runs `f` as a microtask once settled. Callers hold the Lucent lock.
+  void onSettled(std::function<void()> f) {
+    if (status == Status::Pending) waiters.push_back(std::move(f));
+    else Scheduler::instance().enqueueMicrotask(std::move(f));
+  }
+
+ private:
+  void flush() {
+    auto ws = std::move(waiters);
+    waiters.clear();
+    for (auto& w : ws) Scheduler::instance().enqueueMicrotask(std::move(w));
+  }
+};
+
+template <class T>
+struct PromiseTypeBase {
+  std::shared_ptr<PromiseState<T>> state = std::make_shared<PromiseState<T>>();
+  Promise<T> get_return_object();
+  std::suspend_never initial_suspend() noexcept { return {}; }
+  // The frame frees itself when the body finishes; the Promise handle only
+  // shares the settled state.
+  std::suspend_never final_suspend() noexcept { return {}; }
+  void unhandled_exception() { state->reject(currentError(std::current_exception())); }
+};
+
+template <class T>
+struct PromiseType : PromiseTypeBase<T> {
+  void return_value(T v) { this->state->fulfill(std::move(v)); }
+};
+template <>
+struct PromiseType<void> : PromiseTypeBase<void> {
+  void return_void() { this->state->fulfill(undefined); }
+};
+
+}  // namespace detail
+
+/// Promise<T>: a handle to a settled-or-pending value. Copies share state.
+template <class T>
+class Promise {
+ public:
+  using promise_type = detail::PromiseType<T>;
+  using State = detail::PromiseState<T>;
+  using value_type = T;
+
+  Promise() : s_(std::make_shared<State>()) {}
+  explicit Promise(std::shared_ptr<State> s) : s_(std::move(s)) {}
+
+  static Promise resolved(detail::Stored<T> v) {
+    Promise p;
+    p.s_->fulfill(std::move(v));
+    return p;
+  }
+  static Promise resolved()
+    requires std::is_void_v<T>
+  {
+    Promise p;
+    p.s_->fulfill(undefined);
+    return p;
+  }
+  static Promise rejected(Error e) {
+    Promise p;
+    p.s_->reject(std::move(e));
+    return p;
+  }
+
+  void resolve(detail::Stored<T> v) const { s_->fulfill(std::move(v)); }
+  void reject(Error e) const { s_->reject(std::move(e)); }
+  bool settled() const { return s_->status != State::Status::Pending; }
+  bool fulfilled() const { return s_->status == State::Status::Fulfilled; }
+  const detail::Stored<T>& value() const { return *s_->value; }
+  const Error& error() const { return s_->error; }
+  void onSettled(std::function<void()> f) const { s_->onSettled(std::move(f)); }
+
+  // Awaitable: JavaScript never resumes an await synchronously.
+  bool await_ready() const noexcept { return false; }
+  void await_suspend(std::coroutine_handle<> h) const {
+    s_->onSettled([h]() mutable { h.resume(); });
+  }
+  T await_resume() const {
+    if (s_->status == State::Status::Rejected) throw Exception(s_->error);
+    if constexpr (!std::is_void_v<T>) return *s_->value;
+  }
+
+  const void* identity() const { return s_.get(); }
+  friend bool strictEquals(const Promise& a, const Promise& b) { return a.s_ == b.s_; }
+  friend String toJsString(const Promise&) { return String::fromLatin1("[object Promise]"); }
+
+ private:
+  std::shared_ptr<State> s_;
+};
+
+template <class T>
+Promise<T> detail::PromiseTypeBase<T>::get_return_object() {
+  return Promise<T>(state);
+}
+
+template <class T>
+struct IsPromise : std::false_type {};
+template <class T>
+struct IsPromise<Promise<T>> : std::true_type {};
+
+/// `await x` where x is not a promise.
+template <class T>
+Promise<T> resolvedPromise(T v) {
+  return Promise<T>::resolved(std::move(v));
+}
+
+namespace detail {
+/// Promise.all's bookkeeping: `out` rejects with the first input to reject,
+/// and fulfils with `finish(values)` in the reaction of the last input to
+/// fulfil. Every input is observed at once, as in JavaScript.
+template <class R, class Values, class Finish>
+struct AllState {
+  Promise<R> out;
+  Values values;
+  size_t remaining;
+  Finish finish;
+
+  template <class T>
+  void watch(const Promise<T>& p, std::optional<Stored<T>>& slot, const std::shared_ptr<AllState>& self) {
+    p.onSettled([p, &slot, self] {
+      if (!p.fulfilled()) {
+        self->out.reject(p.error());
+        return;
+      }
+      slot = p.value();
+      if (--self->remaining == 0) self->out.resolve(self->finish(self->values));
+    });
+  }
+};
+}  // namespace detail
+
+/// Promise.all over promises of one type.
+template <class T>
+Promise<Array<T>> promiseAll(Array<Promise<T>> promises) {
+  using Values = std::vector<std::optional<T>>;
+  auto finish = [](Values& vs) {
+    Array<T> r;
+    for (auto& v : vs) r.push(std::move(*v));
+    return r;
+  };
+  using State = detail::AllState<Array<T>, Values, decltype(finish)>;
+  auto st = std::make_shared<State>(State{{}, Values(promises.size()), promises.size(), finish});
+  if (st->remaining == 0) st->out.resolve(Array<T>{});
+  size_t i = 0;
+  for (const auto& p : promises.items()) st->watch(p, st->values[i++], st);
+  return st->out;
+}
+inline Promise<void> promiseAllVoid(Array<Promise<void>> promises) {
+  using Values = std::vector<std::optional<Undefined>>;
+  auto finish = [](Values&) { return undefined; };
+  using State = detail::AllState<void, Values, decltype(finish)>;
+  auto st = std::make_shared<State>(State{{}, Values(promises.size()), promises.size(), finish});
+  if (st->remaining == 0) st->out.resolve(undefined);
+  size_t i = 0;
+  for (const auto& p : promises.items()) st->watch(p, st->values[i++], st);
+  return st->out;
+}
+
+/// Promise.all over a tuple of promises of different types.
+template <class... Ts>
+Promise<std::tuple<detail::Stored<Ts>...>> promiseAllTuple(std::tuple<Promise<Ts>...> ps) {
+  using Values = std::tuple<std::optional<detail::Stored<Ts>>...>;
+  auto finish = [](Values& vs) {
+    return std::apply([](auto&... v) { return std::tuple<detail::Stored<Ts>...>{std::move(*v)...}; }, vs);
+  };
+  using State = detail::AllState<std::tuple<detail::Stored<Ts>...>, Values, decltype(finish)>;
+  auto st = std::make_shared<State>(State{{}, Values{}, sizeof...(Ts), finish});
+  if constexpr (sizeof...(Ts) == 0) {
+    st->out.resolve({});
+  } else {
+    [&]<size_t... I>(std::index_sequence<I...>) {
+      (st->watch(std::get<I>(ps), std::get<I>(st->values), st), ...);
+    }(std::index_sequence_for<Ts...>{});
+  }
+  return st->out;
+}
+
+/// `await delay(ms)` — resolves after `ms` milliseconds on the Lucent thread.
+Promise<void> delay(double ms);
+
+}  // namespace lucent

package/runtime/cpp/lucent/builtins.cpp

@@ -0,0 +1,163 @@
+#include <cstdio>
+
+#include "async.h"
+#include "bytes.h"
+#include "generator.h"
+#include "console.h"
+
+#if defined(__ANDROID__)
+#include <android/log.h>
+#elif defined(__APPLE__)
+#include <os/log.h>
+#endif
+
+namespace lucent {
+
+Array<String> split(const String& s, const String& separator) { return split(s, separator, 4294967295.0); }
+
+Array<String> split(const String& s, const String& separator, double limitValue) {
+  Array<String> out;
+  double lim = std::isnan(limitValue) ? 0 : std::trunc(limitValue);
+  size_t limit = lim <= 0 ? 0 : static_cast<size_t>(std::min(lim, 4294967295.0));
+  if (limit == 0) return out;
+  size_t n = s.length(), m = separator.length();
+  if (m == 0) {
+    for (size_t i = 0; i < n && out.size() < limit; i++) out.push(String::fromCodeUnit(s.unit(i)));
+    return out;
+  }
+  size_t pos = 0;
+  for (;;) {
+    size_t at = s.find(separator, pos);
+    if (at == std::string::npos) break;
+    out.push(s.sub(pos, at));
+    if (out.size() >= limit) return out;
+    pos = at + m;
+  }
+  out.push(s.sub(pos, n));
+  return out;
+}
+
+Array<String> splitCodePoints(const String& s) {
+  Array<String> out;
+  size_t n = s.length();
+  for (size_t i = 0; i < n; i++) {
+    char16_t c = s.unit(i);
+    if (c >= 0xD800 && c <= 0xDBFF && i + 1 < n && s.unit(i + 1) >= 0xDC00 && s.unit(i + 1) <= 0xDFFF) {
+      out.push(s.sub(i, i + 2));
+      i++;
+    } else {
+      out.push(String::fromCodeUnit(c));
+    }
+  }
+  return out;
+}
+
+Bytes utf8Encode(const String& s) {
+  std::string u = s.toUtf8();
+  return Bytes::copy(reinterpret_cast<const uint8_t*>(u.data()), u.size());
+}
+
+String utf8Decode(const Bytes& b) {
+  return String::fromUtf8(std::string_view(reinterpret_cast<const char*>(b.data()), b.size()));
+}
+
+Promise<void> delay(double ms) {
+  Promise<void> p;
+  Scheduler::instance().postDelayed(ms, [p] { p.resolve(undefined); });
+  return p;
+}
+
+namespace {
+ConsoleSink& sink() {
+  static ConsoleSink s;
+  return s;
+}
+}  // namespace
+
+void setConsoleSink(ConsoleSink s) { sink() = std::move(s); }
+
+void consoleWrite(ConsoleLevel level, const String& message) {
+  if (sink()) {
+    sink()(level, message);
+    return;
+  }
+  std::string text = message.toUtf8();
+#if defined(__ANDROID__)
+  int prio = level == ConsoleLevel::Error ? ANDROID_LOG_ERROR : level == ConsoleLevel::Warn ? ANDROID_LOG_WARN : ANDROID_LOG_INFO;
+  __android_log_print(prio, "Lucent", "%s", text.c_str());
+#elif defined(__APPLE__)
+  os_log_type_t type = level == ConsoleLevel::Error ? OS_LOG_TYPE_ERROR : OS_LOG_TYPE_DEFAULT;
+  os_log_with_type(OS_LOG_DEFAULT, type, "[Lucent] %{public}s", text.c_str());
+#else
+  std::fprintf(level == ConsoleLevel::Log ? stdout : stderr, "%s\n", text.c_str());
+  std::fflush(level == ConsoleLevel::Log ? stdout : stderr);
+#endif
+}
+
+}  // namespace lucent
+
+#include "json.h"
+
+namespace lucent {
+
+void JsonWriter::quote(const String& s) {
+  static const char* hex = "0123456789abcdef";
+  out.push_back(u'"');
+  size_t n = s.length();
+  for (size_t i = 0; i < n; i++) {
+    char16_t c = s.unit(i);
+    switch (c) {
+      case u'"': out.append(u"\\\""); break;
+      case u'\\': out.append(u"\\\\"); break;
+      case u'\b': out.append(u"\\b"); break;
+      case u'\f': out.append(u"\\f"); break;
+      case u'\n': out.append(u"\\n"); break;
+      case u'\r': out.append(u"\\r"); break;
+      case u'\t': out.append(u"\\t"); break;
+      default: {
+        bool lone = false;
+        if (c >= 0xD800 && c <= 0xDBFF) {
+          lone = !(i + 1 < n && s.unit(i + 1) >= 0xDC00 && s.unit(i + 1) <= 0xDFFF);
+          if (!lone) {
+            out.push_back(c);
+            out.push_back(s.unit(++i));
+            continue;
+          }
+        } else if (c >= 0xDC00 && c <= 0xDFFF) {
+          lone = true;
+        }
+        if (c < 0x20 || lone) {
+          out.append(u"\\u");
+          out.push_back(hex[(c >> 12) & 15]);
+          out.push_back(hex[(c >> 8) & 15]);
+          out.push_back(hex[(c >> 4) & 15]);
+          out.push_back(hex[c & 15]);
+        } else {
+          out.push_back(c);
+        }
+      }
+    }
+  }
+  out.push_back(u'"');
+}
+
+Iter<String> iterOf(const String& s) { return iterOf(splitCodePoints(s)); }
+
+namespace {
+class BytesIter final : public IterObject<double> {
+ public:
+  explicit BytesIter(Bytes b) : b_(std::move(b)) {}
+  std::optional<double> next() override {
+    if (i_ >= b_.size()) return std::nullopt;
+    return b_.at(i_++);
+  }
+
+ private:
+  Bytes b_;
+  size_t i_ = 0;
+};
+}  // namespace
+
+Iter<double> iterOf(const Bytes& b) { return std::make_shared<BytesIter>(b); }
+
+}  // namespace lucent

package/runtime/cpp/lucent/bytes.h

@@ -0,0 +1,129 @@
+// Lucent runtime — Uint8Array.
+#pragma once
+
+#include <cmath>
+#include <cstdint>
+#include <memory>
+#include <vector>
+
+#include "array.h"
+#include "core.h"
+#include "jsstring.h"
+
+namespace lucent {
+
+/// A Uint8Array: a view (offset, length) over a shared byte buffer.
+/// `subarray` shares the buffer; `slice` copies, as in JavaScript.
+class Bytes {
+ public:
+  Bytes() : buf_(std::make_shared<std::vector<uint8_t>>()) {}
+  explicit Bytes(double length) {
+    if (!(length >= 0) || std::trunc(length) != length || length > 2147483647.0) throwRangeError("Invalid typed array length");
+    buf_ = std::make_shared<std::vector<uint8_t>>(static_cast<size_t>(length));
+    len_ = static_cast<size_t>(length);
+  }
+  explicit Bytes(std::vector<uint8_t> data) : buf_(std::make_shared<std::vector<uint8_t>>(std::move(data))) { len_ = buf_->size(); }
+  static Bytes fromArray(const Array<double>& values) {
+    std::vector<uint8_t> out;
+    out.reserve(values.size());
+    for (double v : values.items()) out.push_back(toUint8(v));
+    return Bytes(std::move(out));
+  }
+  static Bytes copy(const uint8_t* data, size_t n) { return Bytes(std::vector<uint8_t>(data, data + n)); }
+
+  static uint8_t toUint8(double v) { return static_cast<uint8_t>(toUint32(v) & 0xFF); }
+
+  size_t size() const { return len_; }
+  double length() const { return static_cast<double>(len_); }
+  double byteLength() const { return length(); }
+  uint8_t* data() { return buf_->data() + off_; }
+  const uint8_t* data() const { return buf_->data() + off_; }
+
+  Opt<double> get(double index) const {
+    if (index >= 0 && index < static_cast<double>(len_) && std::trunc(index) == index) return static_cast<double>(data()[static_cast<size_t>(index)]);
+    return undefined;
+  }
+  double at(size_t i) const { return static_cast<double>(data()[i]); }
+  /// Out-of-range writes are ignored, as for typed arrays in JavaScript.
+  void set(double index, double value) {
+    if (index >= 0 && index < static_cast<double>(len_) && std::trunc(index) == index) data()[static_cast<size_t>(index)] = toUint8(value);
+  }
+  void setFrom(const Bytes& src, double offset = 0) {
+    if (!(offset >= 0) || static_cast<size_t>(offset) + src.len_ > len_) throwRangeError("offset is out of bounds");
+    std::vector<uint8_t> tmp(src.data(), src.data() + src.len_);
+    std::copy(tmp.begin(), tmp.end(), data() + static_cast<size_t>(offset));
+  }
+  void setFrom(const Array<double>& src, double offset = 0) {
+    if (!(offset >= 0) || static_cast<size_t>(offset) + src.size() > len_) throwRangeError("offset is out of bounds");
+    size_t o = static_cast<size_t>(offset);
+    for (size_t i = 0; i < src.size(); i++) data()[o + i] = toUint8(src.at(i));
+  }
+  Bytes subarray(double start) const { return subarray(start, length()); }
+  Bytes subarray(double start, double end) const {
+    size_t a = detail::relativeIndex(start, len_), b = detail::relativeIndex(end, len_);
+    Bytes v = *this;
+    v.off_ = off_ + a;
+    v.len_ = b > a ? b - a : 0;
+    return v;
+  }
+  Bytes slice() const { return copy(data(), len_); }
+  Bytes slice(double start) const { return slice(start, length()); }
+  Bytes slice(double start, double end) const {
+    size_t a = detail::relativeIndex(start, len_), b = detail::relativeIndex(end, len_);
+    return b > a ? copy(data() + a, b - a) : Bytes();
+  }
+  Bytes& fill(double v) {
+    std::fill(data(), data() + len_, toUint8(v));
+    return *this;
+  }
+  double indexOf(double v) const {
+    for (size_t i = 0; i < len_; i++) {
+      if (static_cast<double>(data()[i]) == v) return static_cast<double>(i);
+    }
+    return -1;
+  }
+  bool includes(double v) const { return indexOf(v) >= 0; }
+  template <class F>
+  void forEach(F&& f) const {
+    for (size_t i = 0; i < len_; i++) invokeCallback(f, at(i), static_cast<double>(i), *this);
+  }
+  template <class F>
+  Bytes map(F&& f) const {
+    std::vector<uint8_t> out(len_);
+    for (size_t i = 0; i < len_; i++) out[i] = toUint8(invokeCallback(f, at(i), static_cast<double>(i), *this));
+    return Bytes(std::move(out));
+  }
+  template <class U, class F>
+  U reduce(F&& f, U init) const {
+    for (size_t i = 0; i < len_; i++) init = U(invokeCallback(f, init, at(i), static_cast<double>(i), *this));
+    return init;
+  }
+  String join(const String& sep = String::fromLatin1(",")) const {
+    String out;
+    for (size_t i = 0; i < len_; i++) {
+      if (i > 0) out += sep;
+      out += numberToString(at(i));
+    }
+    return out;
+  }
+  Array<double> toArray() const {
+    std::vector<double> out(len_);
+    for (size_t i = 0; i < len_; i++) out[i] = at(i);
+    return Array<double>(std::move(out));
+  }
+
+  const void* identity() const { return this->buf_.get(); }
+  friend bool strictEquals(const Bytes& a, const Bytes& b) { return a.buf_ == b.buf_ && a.off_ == b.off_ && a.len_ == b.len_; }
+  friend String toJsString(const Bytes& b) { return b.join(); }
+
+ private:
+  std::shared_ptr<std::vector<uint8_t>> buf_;
+  size_t off_ = 0;
+  size_t len_ = 0;
+};
+
+/// TextEncoder().encode / TextDecoder().decode for UTF-8.
+Bytes utf8Encode(const String& s);
+String utf8Decode(const Bytes& b);
+
+}  // namespace lucent

package/runtime/cpp/lucent/console.h

@@ -0,0 +1,17 @@
+// Lucent runtime — console.log / warn / error.
+#pragma once
+
+#include <functional>
+
+#include "jsstring.h"
+
+namespace lucent {
+
+enum class ConsoleLevel { Log, Warn, Error };
+using ConsoleSink = std::function<void(ConsoleLevel, const String&)>;
+
+/// Replaces the platform log (os_log / logcat / stdout), e.g. in tests.
+void setConsoleSink(ConsoleSink sink);
+void consoleWrite(ConsoleLevel level, const String& message);
+
+}  // namespace lucent

package/runtime/cpp/lucent/core.h

@@ -0,0 +1,129 @@
+// Lucent runtime — core value model.
+//
+// Every Lucent value is one of:
+//   * a primitive held by value: double (number), bool (boolean), String
+//     (an immutable, shared UTF-16 string);
+//   * a handle to a shared heap object (Array, Map, Set, Dict, Bytes, Fn,
+//     Promise, and Ref<T> for structs and classes). Copying a handle aliases
+//     the object, exactly like assigning an object in JavaScript;
+//   * Opt<T> for `T | undefined | null`, and Union<...> for other unions.
+//
+// Objects are reference counted. There is no cycle collector: a cycle of
+// strong references is kept alive until the process ends.
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <type_traits>
+#include <utility>
+#include <variant>
+
+namespace lucent {
+
+template <class T>
+using Ref = std::shared_ptr<T>;
+
+/// Base of every struct and class instance.
+struct Object : std::enable_shared_from_this<Object> {
+  virtual ~Object() = default;
+  /// Stable identity handed to JavaScript the first time the object crosses
+  /// the boundary (0 = never crossed). Only touched on the JS thread.
+  uint64_t jsIdentity = 0;
+};
+
+struct Undefined {
+  friend constexpr bool operator==(Undefined, Undefined) { return true; }
+};
+struct Null {
+  friend constexpr bool operator==(Null, Null) { return true; }
+};
+inline constexpr Undefined undefined{};
+inline constexpr Null null{};
+
+[[noreturn]] void throwTypeError(const char* message);
+[[noreturn]] void throwRangeError(const char* message);
+
+/// Placed where TypeScript proved control cannot reach (e.g. after an
+/// exhaustive switch). Throws instead of running off the end of a function.
+[[noreturn]] inline void unreachable() { throwTypeError("Reached code the type checker proved unreachable"); }
+
+/// `T | undefined | null`. Remembers which of the two absent values it holds
+/// so `x === null` and `x === undefined` behave as in JavaScript.
+template <class T>
+class Opt {
+ public:
+  using ValueType = T;
+  enum class State : uint8_t { Undefined, Null, Value };
+
+  Opt() = default;
+  Opt(Undefined) {}
+  Opt(Null) : state_(State::Null) {}
+  Opt(const T& v) : value_(v), state_(State::Value) {}
+  Opt(T&& v) : value_(std::move(v)), state_(State::Value) {}
+  template <class U,
+            std::enable_if_t<!std::is_same_v<std::decay_t<U>, Opt> &&
+                                 !std::is_same_v<std::decay_t<U>, T> &&
+                                 !std::is_same_v<std::decay_t<U>, Undefined> &&
+                                 !std::is_same_v<std::decay_t<U>, Null> &&
+                                 std::is_constructible_v<T, U&&>,
+                             int> = 0>
+  Opt(U&& v) : value_(T(std::forward<U>(v))), state_(State::Value) {}
+
+  bool has() const { return state_ == State::Value; }
+  bool isUndefined() const { return state_ == State::Undefined; }
+  bool isNull() const { return state_ == State::Null; }
+  State state() const { return state_; }
+
+  /// The `!` operator: a checked unwrap.
+  const T& value() const {
+    if (state_ != State::Value) throwTypeError(state_ == State::Null ? "Unexpected null value" : "Unexpected undefined value");
+    return *value_;
+  }
+  T& value() {
+    if (state_ != State::Value) throwTypeError(state_ == State::Null ? "Unexpected null value" : "Unexpected undefined value");
+    return *value_;
+  }
+  /// Unchecked access after a narrowing check the compiler has proven.
+  const T& get() const { return *value_; }
+  T& get() { return *value_; }
+
+  template <class U>
+  T valueOr(U&& fallback) const {
+    return has() ? *value_ : T(std::forward<U>(fallback));
+  }
+
+ private:
+  std::optional<T> value_;
+  State state_ = State::Undefined;
+};
+
+template <class T>
+struct IsOpt : std::false_type {};
+template <class T>
+struct IsOpt<Opt<T>> : std::true_type {};
+
+template <class T>
+struct IsRef : std::false_type {};
+template <class T>
+struct IsRef<std::shared_ptr<T>> : std::true_type {};
+
+template <class... Ts>
+using Union = std::variant<Ts...>;
+
+/// Boxes a local that a closure captures and later mutates, so the closure and
+/// the enclosing function share one variable, as in JavaScript.
+template <class T>
+class Box {
+ public:
+  Box() : p_(std::make_shared<T>()) {}
+  explicit Box(T v) : p_(std::make_shared<T>(std::move(v))) {}
+  T& operator*() const { return *p_; }
+  T* operator->() const { return p_.get(); }
+
+ private:
+  std::shared_ptr<T> p_;
+};
+
+}  // namespace lucent