value.cpp

#include "value.hpp"
#include "object.hpp"
#include <iostream>

bool isBool(const Value &value) { return std::holds_alternative<bool>(value); }

bool isNil(const Value &value) {
  return std::holds_alternative<std::monostate>(value);
}

bool isNumber(const Value &value) {
  return std::holds_alternative<double>(value);
}

bool isObj(const Value &value) {
  return std::holds_alternative<std::shared_ptr<Obj>>(value);
}

bool isString(const Value &value) {
  return std::holds_alternative<std::string>(value);
}

// Compares two Values for equality. It checks if both values hold the same type
// and then compares them using std::visit.
bool valuesEqual(const Value &a, const Value &b) {
  if (a.index() != b.index())
    return false;
  return std::visit(
      [](const auto &lhs, const auto &rhs) -> bool {
        using LhsT = std::decay_t<decltype(lhs)>;
        using RhsT = std::decay_t<decltype(rhs)>;
        if constexpr (std::is_same_v<LhsT, RhsT>) {
          return lhs == rhs; // Compare if types are the same.
        } else {
          return false;
        }
      },
      a, b);
}

// Prints a Value based on its type.
// Uses std::visit to apply different print logic for each type in the variant.
void printValue(const Value &value) {
  std::visit(
      [](const auto &v) {
        using T = std::decay_t<decltype(v)>;
        // Print boolean values as "true" or "false".
        if constexpr (std::is_same_v<T, bool>) {
          std::cout << (v ? "true" : "false");

          // Print numeric values.
        } else if constexpr (std::is_same_v<T, double>) {
          std::cout << v;

          // Print string values.
        } else if constexpr (std::is_same_v<T, std::string>) {
          std::cout << v;

          // Print a list (ObjList) by recursively printing each element.
        } else if constexpr (std::is_same_v<T, std::shared_ptr<ObjList>>) {
          std::cout << "[";
          for (size_t i = 0; i < v->elements.size(); ++i) {
            printValue(v->elements[i]);
            if (i < v->elements.size() - 1)
              std::cout << ", ";
          }
          std::cout << "]";

          // Print function objects (ObjFunction). If the function has a name,
          // print it; otherwise, print "<script>"
        } else if constexpr (std::is_same_v<T, ObjFunction *>) {
          if (v->name.empty()) {
            std::cout << "<script>";
          } else {
            std::cout << "<fn " << v->name << ">";
          }

          // Print "nil" for nil (monostate) values.
        } else if constexpr (std::is_same_v<T, std::monostate>) {
          std::cout << "nil";
        } else {
          std::cout << "Unknown value type.";
        }
      },
      value);
}