valeri/src/common.hpp

#pragma once

#include <concepts>
#include <cstdint>
#include <cstring>
#include <iostream>

#include "arena.hpp"
#include "error.hpp"
#include "opcode.hpp"
#include "pod.hpp"
#include "utf8.hpp"

// Forward declarations

class Value;
class String;
class Nil;
class Int64;
class Float;
class Bool;
class String;
class Symbol;
class Syntax;
class Pair;
class Array;
class ByteArray;
class Writer;
class Opcode;
class Stack;
class Function;

short cmp_tag(Tag lhs, Tag rhs);

class Object {
 public:
  virtual Tag tag() const = 0;
  virtual Result<Value> copy_value() const = 0;
  virtual PodObject* pod() const = 0;
  virtual void move(Object*) = 0;
  virtual ~Object() = default;

  virtual Result<short> cmp(const Object&) const = 0;
  virtual Result<short> cmp(const Nil&) const {
    return cmp_tag(tag(), Tag::Nil);
  }
  virtual Result<short> cmp(const Int64&) const {
    return cmp_tag(tag(), Tag::Int64);
  }
  virtual Result<short> cmp(const Float&) const {
    return cmp_tag(tag(), Tag::Float);
  }
  virtual Result<short> cmp(const Bool&) const {
    return cmp_tag(tag(), Tag::Bool);
  }
  virtual Result<short> cmp(const String&) const {
    return cmp_tag(tag(), Tag::String);
  }
  virtual Result<short> cmp(const Symbol&) const {
    return cmp_tag(tag(), Tag::Symbol);
  }
  virtual Result<short> cmp(const Syntax&) const {
    return cmp_tag(tag(), Tag::Syntax);
  }
  virtual Result<short> cmp(const Pair&) const {
    return cmp_tag(tag(), Tag::Pair);
  }
  virtual Result<short> cmp(const Array&) const {
    return cmp_tag(tag(), Tag::Array);
  }
  virtual Result<short> cmp(const ByteArray&) const {
    return cmp_tag(tag(), Tag::ByteArray);
  }
  virtual Result<short> cmp(const Opcode& rhs) const {
    return cmp_tag(tag(), Tag::Opcode);
  }
  virtual Result<short> cmp(const Function& rhs) const {
    return cmp_tag(tag(), Tag::Opcode);
  }
  virtual Result<short> cmp(const char* rhs) const {
    return ERROR(NotImplemented);
  }
  virtual Result<short> cmp(const Stack& rhs) const {
    return ERROR(NotImplemented);
  }

  virtual Result<Value> add(const Object&) const;
  virtual Result<Value> add(const Int64&) const;

  virtual Result<Value> sub(const Object&) const;
  virtual Result<Value> sub_inv(const Int64&) const;

  virtual Result<Value> mul(const Object&) const;
  virtual Result<Value> mul(const Int64&) const;

  virtual Result<Value> div(const Object&) const;
  virtual Result<Value> div_inv(const Int64&) const;

  virtual Result<Value> get(const Value& key) const;

  Object() = default;
  Object(const Object&) = delete;
};

class Nil : public Object {
 public:
  Nil() {}
  Nil(Nil&& rhs) : _value(std::move(rhs._value)) {}
  Nil(GcRoot<PodNil>&& val) : _value(std::move(val)) {}

  virtual Tag tag() const final { return Tag::Nil; }
  virtual PodObject* pod() const final { return _value.get(); }

  virtual Result<short> cmp(const Object& rhs) const final {
    return -TRY(rhs.cmp(*this));
  }
  virtual Result<short> cmp(const Nil& rhs) const final { return 0; }

  static Result<Nil> create(PodNil* obj) { return Nil(TRY(MkGcRoot(obj))); }

  static Result<Nil> create() {
    auto pod = TRY(arena_alloc<PodNil>());
    pod->header.tag = Tag::Nil;

    return Nil(TRY(MkGcRoot(pod)));
  }

  virtual Result<Value> copy_value() const final;
  Result<Nil> copy() const;

  virtual void move(Object* obj) final { new (obj) Nil(std::move(_value)); }

 private:
  GcRoot<PodNil> _value;
};

class Array : public Object {
 public:
  Array() {}
  Array(Array&& rhs) : _value(std::move(rhs._value)) {}
  Array(GcRoot<PodArray>&& val) : _value(std::move(val)) {}

  Array& operator=(Array&& rhs) {
    _value = std::move(rhs._value);
    return *this;
  }

  virtual Tag tag() const final { return Tag::Array; }
  virtual PodObject* pod() const final { return _value.get(); }
  virtual Result<short> cmp(const Object& rhs) const final {
    return -TRY(rhs.cmp(*this));
  }
  virtual Result<short> cmp(const Array& rhs) const final { return 0; }

  virtual void move(Object* obj) final { new (obj) Array(std::move(_value)); }

  static Result<Array> create(PodArray* obj) {
    return Array(TRY(MkGcRoot(obj)));
  }

  static Result<Array> create() {
    auto pod = TRY(arena_alloc<PodArray>());
    pod->header.tag = Tag::Array;

    pod->size = 0;

    return Array(TRY(MkGcRoot(pod)));
  }

  uint64_t size() const { return _value->size; }
  virtual Result<Value> copy_value() const final;
  Result<Array> copy() const;

  Result<Value> get(uint64_t idx) const;
  virtual Result<Value> get(const Value& key) const final;

  Result<Array> append(const Value& rhs) const;
  template <class V>
  Result<Array> append(const V& value) const;

  Result<Array> concat(Array& rhs) {
    uint64_t rhs_size = rhs.size();
    uint64_t lhs_size = size();
    uint64_t res_size = lhs_size + rhs_size;

    auto pod = TRY(arena_alloc<PodArray>(res_size * sizeof(PodObject*)));
    pod->size = res_size;
    for (uint64_t i = 0; i < size(); i++) {
      pod->data[i] = _value->data[i].get();
    }
    for (uint64_t i = 0; i < rhs.size(); i++) {
      pod->data[lhs_size + i] = rhs._value->data[i].get();
    }

    return Array(TRY(MkGcRoot(pod)));
  }

  Result<Array> slice(uint64_t start, uint64_t end) {
    if (start > end) return ERROR(IndexOutOfRange);
    uint64_t res_size = end - start;
    auto pod = TRY(arena_alloc<PodArray>(res_size * sizeof(PodObject*)));
    pod->size = res_size;
    for (uint64_t i = 0; i < end - start; i++) {
      pod->data[i] = _value->data[start + i];
    }

    return Array(TRY(MkGcRoot(pod)));
  }

 private:
  GcRoot<PodArray> _value;
};

class ByteArray : public Object {
 public:
  ByteArray() {}
  ByteArray(ByteArray&& rhs) : _value(std::move(rhs._value)) {}
  ByteArray(GcRoot<PodByteArray>&& val) : _value(std::move(val)) {}

  ByteArray& operator=(ByteArray&& rhs) {
    _value = std::move(rhs._value);
    return *this;
  }

  virtual Tag tag() const final { return Tag::ByteArray; }
  virtual PodObject* pod() const final { return _value.get(); }
  virtual Result<short> cmp(const Object& rhs) const final {
    return -TRY(rhs.cmp(*this));
  }
  virtual Result<short> cmp(const ByteArray& rhs) const final { return 0; }

  virtual void move(Object* obj) final {
    new (obj) ByteArray(std::move(_value));
  }

  static Result<ByteArray> create(PodByteArray* obj) {
    return ByteArray(TRY(MkGcRoot(obj)));
  }
  static Result<ByteArray> create(char* chars, int64_t size) {
    auto pod = TRY(arena_alloc<PodByteArray>(size * sizeof(char)));
    pod->header.tag = Tag::ByteArray;

    memcpy(pod->data, chars, size * sizeof(char32_t));
    pod->size = size;

    return ByteArray(TRY(MkGcRoot(pod)));
  }

  static Result<ByteArray> create(const char* str) {
    uint64_t size = strlen(str);
    auto pod = TRY(arena_alloc<PodByteArray>(size * sizeof(char32_t)));
    pod->header.tag = Tag::ByteArray;

    memcpy(pod->data, str, size);
    pod->size = size;

    return ByteArray(TRY(MkGcRoot(pod)));
  }

  static Result<ByteArray> create(const String& str);

  uint64_t size() const { return _value->size; }
  virtual Result<Value> copy_value() const final;
  Result<ByteArray> copy() const;

  Result<char> operator[](uint64_t idx) const {
    if (idx >= _value->size) return ERROR(IndexOutOfRange);
    return _value->data[idx];
  }

  Result<ByteArray> concat(const char* rhs) {
    uint64_t rhs_size = strlen(rhs);
    uint64_t lhs_size = size();
    uint64_t res_size = lhs_size + rhs_size;

    auto pod = TRY(arena_alloc<PodByteArray>(res_size * sizeof(char)));
    pod->size = res_size;
    memcpy(pod->data, _value->data, sizeof(char) * lhs_size);
    memcpy(pod->data, rhs + lhs_size, sizeof(char) * rhs_size);

    return ByteArray(TRY(MkGcRoot(pod)));
  }

  Result<ByteArray> concat(const char* rhs, uint64_t rhs_size) {
    uint64_t lhs_size = size();
    uint64_t res_size = lhs_size + rhs_size;

    auto pod = TRY(arena_alloc<PodByteArray>(res_size * sizeof(char)));
    pod->size = res_size;
    memcpy(pod->data, _value->data, sizeof(char) * lhs_size);
    memcpy(pod->data, rhs + lhs_size, sizeof(char) * rhs_size);

    return ByteArray(TRY(MkGcRoot(pod)));
  }

  Result<ByteArray> concat(ByteArray& rhs) {
    uint64_t rhs_size = rhs.size();
    uint64_t lhs_size = size();
    uint64_t res_size = lhs_size + rhs_size;

    auto pod = TRY(arena_alloc<PodByteArray>(res_size * sizeof(char)));
    pod->size = res_size;
    memcpy(pod->data, _value->data, sizeof(char) * lhs_size);
    memcpy(pod->data + lhs_size, rhs._value->data, sizeof(char) * rhs_size);

    return ByteArray(TRY(MkGcRoot(pod)));
  }

  Result<ByteArray> slice(uint64_t start, uint64_t end) {
    if (start > end) return ERROR(IndexOutOfRange);
    uint64_t res_size = end - start;
    auto pod = TRY(arena_alloc<PodByteArray>(res_size * sizeof(char)));
    pod->size = res_size;
    memcpy(pod->data, _value->data + start, sizeof(char) * res_size);

    return ByteArray(TRY(MkGcRoot(pod)));
  }

 private:
  GcRoot<PodByteArray> _value;
};

class Dict : public Object {
 public:
  friend class Writer;
  Dict() {}
  Dict(Dict&& rhs) : _value(std::move(rhs._value)) {}
  Dict(GcRoot<PodDict>&& val) : _value(std::move(val)) {}

  Dict& operator=(Dict&& rhs) {
    _value = std::move(rhs._value);
    return *this;
  }

  virtual Tag tag() const final { return Tag::Dict; }
  virtual PodObject* pod() const final { return _value.get(); }
  virtual Result<short> cmp(const Object& rhs) const final {
    return -TRY(rhs.cmp(*this));
  }
  virtual Result<short> cmp(const Dict& rhs) const final;

  virtual void move(Object* obj) final { new (obj) Dict(std::move(_value)); }

  static Result<Dict> create(PodDict* obj) { return Dict(TRY(MkGcRoot(obj))); }

  static Result<Dict> create() {
    auto pod = TRY(arena_alloc<PodDict>());
    pod->header.tag = Tag::Dict;

    pod->size = 0;

    return Dict(TRY(MkGcRoot(pod)));
  }

  virtual Result<Value> copy_value() const final;
  Result<Dict> copy() const;

  virtual Result<Value> get(const Value& key) const final;

  Result<Dict> insert(const Value& key, const Value& value);

  template <class K, class V>
  Result<Dict> insert(const K& key, const V& value);

  Result<Dict> concat(Dict& rhs) {
    uint64_t rhs_size = rhs.size();
    uint64_t lhs_size = size();
    uint64_t res_size = lhs_size + rhs_size;

    auto pod = TRY(arena_alloc<PodDict>(2 * res_size * sizeof(PodObject*)));
    pod->size = res_size;

    for (uint64_t i = 0; i < 2 * size(); i++) {
      pod->data[i] = _value->data[i];
    }
    for (uint64_t i = 2 * size(); i < 2 * rhs.size(); i++) {
      pod->data[i] = rhs._value->data[i];
    }

    return Dict(TRY(MkGcRoot(pod)));
  }

 private:
  Result<uint64_t> find(const Value& key) const;

  uint64_t size() const { return _value->size; }
  GcRoot<PodDict> _value;
};

class String : public Object {
 public:
  String() {}
  String(String&& rhs) : _value(std::move(rhs._value)) {}
  String(GcRoot<PodString>&& val) : _value(std::move(val)) {}

  String& operator=(String&& rhs) {
    _value = std::move(rhs._value);
    return *this;
  }

  virtual Tag tag() const final { return Tag::String; }
  virtual PodObject* pod() const final { return _value.get(); }
  virtual Result<short> cmp(const Object& rhs) const final {
    return -TRY(rhs.cmp(*this));
  }
  virtual Result<short> cmp(const String& rhs) const final {
    auto lsize = size();
    auto rsize = rhs.size();
    uint64_t i = 0;
    uint64_t j = 0;
    while (1) {
      if (i == lsize && j == lsize) return 0;

      short cmp = short(i == lsize) - short(j == rsize);
      if (cmp != 0) return cmp;

      char32_t lc = _value->data[i];
      char32_t rc = rhs._value->data[j];
      cmp = (lc > rc) - (lc < rc);
      if (cmp != 0) return cmp;
      i++;
      j++;
    }
    return 0;
  }

  virtual void move(Object* obj) final { new (obj) String(std::move(_value)); }

  static Result<String> create(PodString* obj) {
    return String(TRY(MkGcRoot(obj)));
  }
  static Result<String> create(char32_t* chars, int64_t size) {
    auto pod = TRY(arena_alloc<PodString>(size * sizeof(char32_t)));
    pod->header.tag = Tag::String;

    memcpy(pod->data, chars, size * sizeof(char32_t));
    pod->size = size;

    return String(TRY(MkGcRoot(pod)));
  }

  static Result<String> create(const char* str) {
    uint64_t size = strlen(str);
    auto pod = TRY(arena_alloc<PodString>(size * sizeof(char32_t)));
    pod->header.tag = Tag::String;

    for (uint64_t i = 0; i < size; i++) pod->data[i] = str[i];
    pod->size = size;

    return String(TRY(MkGcRoot(pod)));
  }

  uint64_t size() const { return _value->size; }
  virtual Result<Value> copy_value() const final;
  Result<String> copy() const;

  Result<char32_t> operator[](uint64_t idx) const {
    if (idx >= _value->size) return ERROR(IndexOutOfRange);
    return _value->data[idx];
  }

  Result<String> concat(const char* rhs, uint64_t rhs_size) {
    uint64_t lhs_size = size();
    uint64_t res_size = lhs_size + rhs_size;

    auto pod = TRY(arena_alloc<PodString>(res_size * sizeof(char32_t)));
    pod->header.tag = Tag::String;
    pod->size = res_size;
    memcpy(pod->data, _value->data, sizeof(char32_t) * lhs_size);
    for (uint64_t i = 0; i < rhs_size; i++) pod->data[lhs_size + i] = rhs[i];

    return String(TRY(MkGcRoot(pod)));
  }

  Result<String> concat(const char* rhs) { return concat(rhs, strlen(rhs)); }

  Result<String> concat(const char32_t* rhs, uint64_t rhs_size) {
    uint64_t lhs_size = size();
    uint64_t res_size = lhs_size + rhs_size;

    auto pod = TRY(arena_alloc<PodString>(res_size * sizeof(char32_t)));
    pod->header.tag = Tag::String;
    pod->size = res_size;
    memcpy(pod->data, _value->data, sizeof(char32_t) * lhs_size);
    for (uint64_t i = 0; i < rhs_size; i++) pod->data[lhs_size + i] = rhs[i];

    return String(TRY(MkGcRoot(pod)));
  }

  Result<String> concat(String& rhs) {
    uint64_t rhs_size = rhs.size();
    uint64_t lhs_size = size();
    uint64_t res_size = lhs_size + rhs_size;

    auto pod = TRY(arena_alloc<PodString>(res_size * sizeof(char32_t)));
    pod->header.tag = Tag::String;
    pod->size = res_size;
    memcpy(pod->data, _value->data, sizeof(char32_t) * lhs_size);
    memcpy(pod->data + lhs_size, rhs._value->data, sizeof(char32_t) * rhs_size);

    return String(TRY(MkGcRoot(pod)));
  }

  Result<String> slice(uint64_t start, uint64_t end) {
    if (start > end) return ERROR(IndexOutOfRange);
    uint64_t res_size = end - start;
    auto pod = TRY(arena_alloc<PodString>(res_size * sizeof(char32_t)));
    pod->header.tag = Tag::String;
    pod->size = res_size;
    memcpy(pod->data, _value->data + start, sizeof(char32_t) * res_size);

    return String(TRY(MkGcRoot(pod)));
  }

  friend class Symbol;

 private:
  GcRoot<PodString> _value;
};

class Symbol : public Object {
 public:
  Symbol() {}
  Symbol(Symbol&& rhs) : _value(std::move(rhs._value)) {}
  Symbol(GcRoot<PodSymbol>&& val) : _value(std::move(val)) {}
  virtual Tag tag() const final { return Tag::Symbol; }
  virtual PodObject* pod() const final { return _value.get(); }
  virtual Result<short> cmp(const Object& rhs) const final {
    return -TRY(rhs.cmp(*this));
  }
  virtual Result<short> cmp(const Symbol& rhs) const final {
    auto lsize = size();
    auto rsize = rhs.size();
    uint64_t i = 0;
    uint64_t j = 0;
    while (1) {
      if (i == lsize && j == lsize) return 0;

      short cmp = short(i == lsize) - short(j == rsize);
      if (cmp != 0) return cmp;

      char32_t lc = _value->data[i];
      char32_t rc = rhs._value->data[j];
      cmp = (lc > rc) - (lc < rc);
      if (cmp != 0) return cmp;
      i++;
      j++;
    }
    return 0;
  }
  virtual Result<short> cmp(const char* rhs) const final {
    auto lsize = size();
    auto rsize = strlen(rhs);
    uint64_t i = 0;
    uint64_t j = 0;
    while (1) {
      if (i == lsize && j == lsize) return 0;

      short cmp = short(i == lsize) - short(j == rsize);
      if (cmp != 0) return cmp;

      char32_t lc = _value->data[i];
      char32_t rc = rhs[j];
      cmp = (lc > rc) - (lc < rc);
      if (cmp != 0) return cmp;
      i++;
      j++;
    }
    return 0;
  }
  virtual void move(Object* obj) final { new (obj) Symbol(std::move(_value)); }

  static Result<Symbol> create(PodSymbol* obj) {
    return Symbol(TRY(MkGcRoot(obj)));
  }

  static Result<Symbol> create(char32_t* chars, int64_t size) {
    auto pod = TRY(arena_alloc<PodSymbol>(size * sizeof(char32_t)));
    pod->header.tag = Tag::Symbol;

    memcpy(pod->data, chars, size * sizeof(char32_t));

    return Symbol(TRY(MkGcRoot(pod)));
  }

  static Result<Symbol> create(const char* str) {
    uint64_t size = strlen(str);
    auto pod = TRY(arena_alloc<PodSymbol>(size * sizeof(char32_t)));
    pod->header.tag = Tag::Symbol;

    for (uint64_t i = 0; i < size; i++) pod->data[i] = str[i];
    pod->size = size;

    return Symbol(TRY(MkGcRoot(pod)));
  }

  static Result<Symbol> create(String& rhs);
  virtual Result<Value> copy_value() const final;
  Result<Symbol> copy() const;

  uint64_t size() const { return _value->size; }

  Result<char32_t> operator[](uint64_t idx) const {
    if (idx >= _value->size) return ERROR(IndexOutOfRange);
    return _value->data[idx];
  }

 private:
  GcRoot<PodSymbol> _value;
};

class Syntax : public Object {
 public:
  Syntax() {}
  Syntax(Syntax&& rhs) : _value(std::move(rhs._value)) {}
  Syntax(GcRoot<PodSyntax>&& val) : _value(std::move(val)) {}
  Syntax(String filename, String modulename, Value expression);
  virtual Tag tag() const final { return Tag::Syntax; }
  virtual PodObject* pod() const final { return _value.get(); }
  virtual Result<short> cmp(const Object& rhs) const final {
    return -TRY(rhs.cmp(*this));
  }
  virtual Result<short> cmp(const Syntax& rhs) const final { return 0; }

  virtual void move(Object* obj) final { new (obj) Syntax(std::move(_value)); }

  static Result<Syntax> create(PodSyntax* obj) {
    return Syntax(TRY(MkGcRoot(obj)));
  }

  Result<Value> get_value();

  virtual Result<Value> copy_value() const final;
  Result<Syntax> copy() const;

 private:
  GcRoot<PodSyntax> _value;
};

class Pair : public Object {
 public:
  Pair() {}
  Pair(Pair&& rhs) : _value(std::move(rhs._value)) {}
  Pair(GcRoot<PodPair>&& val) : _value(std::move(val)) {}
  virtual Tag tag() const final { return Tag::Pair; }
  virtual PodObject* pod() const final { return _value.get(); }
  virtual Result<short> cmp(const Object& rhs) const final {
    return -TRY(rhs.cmp(*this));
  }
  virtual Result<short> cmp(const Pair& rhs) const final { return 0; }

  virtual void move(Object* obj) final { new (obj) Pair(std::move(_value)); }

  static Result<Pair> create(PodPair* obj) { return Pair(TRY(MkGcRoot(obj))); }
  static Result<Pair> create(Value& first, Value& rest);

  Result<Value> first();
  Result<Value> rest();

  virtual Result<Value> copy_value() const final;
  Result<Pair> copy() const;

 private:
  GcRoot<PodPair> _value;
};

class Int64 : public Object {
 public:
  friend class Float;

  Int64() {}
  Int64(Int64&& rhs) : _value(std::move(rhs._value)) {}
  Int64(GcRoot<PodInt64>&& val) : _value(std::move(val)) {}
  virtual Tag tag() const final { return Tag::Int64; }
  virtual PodObject* pod() const final { return _value.get(); }
  virtual Result<short> cmp(const Object& rhs) const final {
    return -TRY(rhs.cmp(*this));
  }
  virtual Result<short> cmp(const Int64& rhs) const final {
    return (_value->value > rhs._value->value) -
           (_value->value < rhs._value->value);
  }
  virtual Result<short> cmp(const Float& rhs) const final;

  virtual Result<Value> add(const Object& rhs) const final;
  virtual Result<Value> add(const Int64& rhs) const final;

  virtual Result<Value> mul(const Object& rhs) const final;
  virtual Result<Value> mul(const Int64& rhs) const final;

  virtual Result<Value> sub(const Object& rhs) const final;
  virtual Result<Value> sub_inv(const Int64& rhs) const final;

  virtual Result<Value> div(const Object& rhs) const final;
  virtual Result<Value> div_inv(const Int64& rhs) const final;

  virtual void move(Object* obj) final { new (obj) Int64(std::move(_value)); }

  static Result<Int64> create(PodInt64* obj) {
    return Int64(TRY(MkGcRoot(obj)));
  }

  static Result<Int64> create(double val) {
    auto pod = TRY(arena_alloc<PodInt64>());
    pod->header.tag = Tag::Int64;
    pod->value = val;

    return Int64(TRY(MkGcRoot(pod)));
  }

  int64_t value() const { return _value->value; }

  virtual Result<Value> copy_value() const final;
  Result<Int64> copy() const;

 private:
  GcRoot<PodInt64> _value;
};

class Float : public Object {
 public:
  friend class Int64;

  Float() {}
  Float(Float&& rhs) : _value(std::move(rhs._value)) {}
  Float(GcRoot<PodFloat>&& val) : _value(std::move(val)) {}
  virtual Tag tag() const final { return Tag::Float; }
  virtual PodObject* pod() const final { return _value.get(); }
  virtual Result<short> cmp(const Object& rhs) const final {
    return -TRY(rhs.cmp(*this));
  }
  virtual Result<short> cmp(const Float& rhs) const final {
    return (_value->value > rhs._value->value) -
           (_value->value < rhs._value->value);
  }
  virtual Result<short> cmp(const Int64& rhs) const final;

  virtual void move(Object* obj) final { new (obj) Float(std::move(_value)); }

  static Result<Float> create(PodFloat* obj) {
    return Float(TRY(MkGcRoot(obj)));
  }

  static Result<Float> create(double val) {
    auto pod = TRY(arena_alloc<PodFloat>());
    pod->header.tag = Tag::Float;
    pod->value = val;

    return Float(TRY(MkGcRoot(pod)));
  }

  double value() const { return _value->value; }

  virtual Result<Value> copy_value() const final;
  Result<Float> copy() const;

 private:
  GcRoot<PodFloat> _value;
};

class Bool : public Object {
 public:
  Bool() {}
  Bool(Bool&& rhs) : _value(std::move(rhs._value)) {}
  Bool(GcRoot<PodBool>&& val) : _value(std::move(val)) {}

  virtual Tag tag() const final { return Tag::Bool; }
  virtual PodObject* pod() const final { return _value.get(); }
  virtual Result<short> cmp(const Object& rhs) const final {
    return -TRY(rhs.cmp(*this));
  }
  virtual Result<short> cmp(const Bool& rhs) const final {
    return (_value->value > rhs._value->value) -
           (_value->value < rhs._value->value);
  }

  virtual void move(Object* obj) final { new (obj) Bool(std::move(_value)); }

  static Result<Bool> create(PodBool* obj) { return Bool(TRY(MkGcRoot(obj))); }

  static Result<Bool> create(bool val) {
    auto pod = TRY(arena_alloc<PodBool>());
    pod->header.tag = Tag::Bool;
    pod->value = val;

    return Bool(TRY(MkGcRoot(pod)));
  }

  bool value() const { return _value->value; }

  virtual Result<Value> copy_value() const final;
  Result<Bool> copy() const;

 private:
  GcRoot<PodBool> _value;
};

class Opcode : public Object {
 public:
  Opcode() {}
  Opcode(Opcode&& rhs) : _value(std::move(rhs._value)) {}
  Opcode(GcRoot<PodOpcode>&& val) : _value(std::move(val)) {}

  virtual Tag tag() const final { return Tag::Opcode; }
  virtual PodObject* pod() const final { return _value.get(); }
  virtual Result<short> cmp(const Object& rhs) const final {
    return -TRY(rhs.cmp(*this));
  }
  virtual Result<short> cmp(const Opcode& rhs) const final { return 0; }

  virtual void move(Object* obj) final { new (obj) Opcode(std::move(_value)); }

  static Result<Opcode> create(PodOpcode* obj) {
    return Opcode(TRY(MkGcRoot(obj)));
  }

  static Result<Opcode> create(Oc opcode, OpArg arg1 = {0, 0},
                               OpArg arg2 = {0, 0}, OpArg arg3 = {0, 0},
                               OpArg arg4 = {0, 0}) {
    auto pod = TRY(arena_alloc<PodOpcode>());
    pod->header.tag = Tag::Opcode;
    pod->opcode = opcode;
    pod->arg1 = arg1;
    pod->arg2 = arg2;
    pod->arg3 = arg3;
    pod->arg4 = arg4;

    return Opcode(TRY(MkGcRoot(pod)));
  }

  Oc opcode() const { return _value->opcode; }
  OpArg arg1() const { return _value->arg1; }
  OpArg arg2() const { return _value->arg2; }
  OpArg arg3() const { return _value->arg3; }
  OpArg arg4() const { return _value->arg4; }

  virtual Result<Value> copy_value() const final;
  Result<Opcode> copy() const;

 private:
  GcRoot<PodOpcode> _value;
};

class Function : public Object {
 public:
  Function() {}
  Function(Function&& rhs) : _value(std::move(rhs._value)) {}
  Function(GcRoot<PodFunction>&& val) : _value(std::move(val)) {}

  Function& operator=(Function&& rhs) {
    _value = std::move(rhs._value);
    return *this;
  }

  virtual Tag tag() const final { return Tag::Function; }
  virtual PodObject* pod() const final { return _value.get(); }
  virtual Result<short> cmp(const Object& rhs) const final {
    return -TRY(rhs.cmp(*this));
  }
  virtual Result<short> cmp(const Function& rhs) const final;

  virtual void move(Object* obj) final {
    new (obj) Function(std::move(_value));
  }

  static Result<Function> create(PodFunction* obj) {
    return Function(TRY(MkGcRoot(obj)));
  }

  static Result<Function> create(const Value& name, uint64_t arity,
                                 const Array& constants, const Array& code);

  uint64_t arity() const { return _value->arity; }

  Result<Value> name() const;
  Result<Array> code() const;
  Result<Array> constants() const;

  virtual Result<Value> copy_value() const final;
  Result<Function> copy() const;

 private:
  GcRoot<PodFunction> _value;
};

class Stack : public Object {
 public:
  Stack() {}
  Stack(Stack&& rhs) : _value(std::move(rhs._value)) {}
  Stack(GcRoot<PodStack>&& val) : _value(std::move(val)) {}

  virtual Tag tag() const final { return Tag::Stack; }
  virtual PodObject* pod() const final { return _value.get(); }
  virtual Result<short> cmp(const Object& rhs) const final {
    return -TRY(rhs.cmp(*this));
  }
  virtual Result<short> cmp(const Stack& rhs) const final { return 0; }

  virtual void move(Object* obj) final { new (obj) Stack(std::move(_value)); }

  static Result<Stack> create(PodStack* obj) {
    return Stack(TRY(MkGcRoot(obj)));
  }

  using Object::get;
  Result<Value> get(uint64_t idx) const;
  Result<void> set(uint64_t idx, const Value& val);
  Result<void> settop(uint64_t idx);
  uint64_t gettop() { return _value->top; }

  static Result<Stack> create(uint64_t size) {
    auto pod = TRY(arena_alloc<PodStack>(sizeof(OffPtr<PodObject>) * size));
    pod->header.tag = Tag::Stack;

    pod->size = size;
    pod->top = 0;

    for (uint64_t i = 0; i < size; i++) {
      pod->data[i] = 0;
    }

    return Stack(TRY(MkGcRoot(pod)));
  }

  virtual Result<Value> copy_value() const final;
  Result<Stack> copy() const;

 private:
  GcRoot<PodStack> _value;
};

// note: this class doesn't perform proper destruction of objects in some cases
class Value {
 public:
  Value() { new (buf) Nil(); }
  ~Value() { ((Object*)buf)->~Object(); }
  Value(Value&& val) {
    ((Object*)val.buf)->move((Object*)buf);
    new (val.buf) Nil();
  }
  Value(const Value&) = delete;

  template <class T>
  Value(T&& obj)
    requires std::derived_from<T, Object>
  {
    new (buf) T(std::move(obj));
  }

  Value& operator=(Value&& val) {
    ((Object*)buf)->~Object();
    ((Object*)val.buf)->move((Object*)buf);
    new (val.buf) Nil();
    return *this;
  }

  static Result<Value> create(PodObject* obj);

  static Result<Value> create(const int64_t& value) {
    return Value(TRY(Int64::create(value)));
  }

  static Result<Value> create(const char* value) {
    return Value(TRY(String::create(value)));
  }

  template <class T>
  bool is() const {
    return dynamic_cast<T*>((Object*)buf) != nullptr;
  }

  template <class T>
  T* to() const {
    return dynamic_cast<T*>((Object*)buf);
  }

  PodObject* pod() const { return ((Object*)buf)->pod(); }
  Tag tag() const { return ((Object*)buf)->tag(); }

  Object& operator*() { return *(Object*)(buf); }
  Object* operator->() { return (Object*)(buf); }

  Result<short> cmp(const Value& rhs) const {
    return ((Object*)buf)->cmp(*(Object*)rhs.buf);
  }

  Result<Value> add(const Value& rhs) const {
    return ((Object*)buf)->add(*(Object*)rhs.buf);
  }

  Result<Value> mul(const Value& rhs) const {
    return ((Object*)buf)->mul(*(Object*)rhs.buf);
  }

  Result<Value> sub(const Value& rhs) const {
    return ((Object*)buf)->sub(*(Object*)rhs.buf);
  }

  Result<Value> div(const Value& rhs) const {
    return ((Object*)buf)->div(*(Object*)rhs.buf);
  }

  Result<Value> get(Value& key) { return ((Object*)buf)->get(key); }
  Result<Value> get(int64_t key) {
    Value k = TRY(Int64::create(key));
    return ((Object*)buf)->get(k);
  }

  // TODO: cmp() probably doesn't need arena parameter
  // Result<bool> operator==(Value& rhs) { return TRY(cmp(rhs)) == 0; }
  // Result<bool> operator!=(Value& rhs) { return TRY(cmp(rhs)) != 0; }

  Result<Value> copy() const { return ((Object*)buf)->copy_value(); }

 private:
  uint8_t buf[24];
};

Result<Value> syntax_unwrap(Value& val);

Result<Value> reverse(Value& val);

Result<void> debug_print(const String& val);
Result<void> debug_print(const Value& val);

template <class K, class V>
Result<Dict> Dict::insert(const K& key, const V& value) {
  Value k = TRY(Value::create(key));
  Value v = TRY(Value::create(value));

  return insert(k, v);
}

template <class V>
Result<Array> Array::append(const V& value) const {
  Value v = TRY(Value::create(value));
  return append(v);
}