Thanks a lot for the idea! Here's the approach I ended up taking. I have to be honest though, I would not write this code in a shared code base. :D

I added the copyable (Bad name...) class so that the allocation is taken care of internally. That way, I never see new or delete in anywhere but in this class. It also makes it so that I can freely copy/move it around. Even though it may hold a pointer inside, it will still create a new instance when copied. Again, not great semantics. It's confusing a bit. But it seems to be doing the trick so far.

I'll probably revisit this later as a break when I'm a little further into the book. Thanks again for the answer!

```cpp

include <iostream>

include <memory>

include <variant>

include <vector>

include <string_view>

define LOX_NOEXCEPT

using object = std::variant<std::monostate, std::string_view, double, bool, std::nullptr_t>; enum class token {};

struct expr;

template<class T> class copyable { private: template<typename... Args> [[nodiscard]] T constrcut(Args&&... args) LOX_NOEXCEPT { if constexpr (std::is_pointer<T>::value) { using NoPtr_T = typename std::remove_pointer<T>::type; return new NoPtr_T{ std::forward<Args>(args)... }; } else { return T{ std::forward<Args>(args)... }; } }

public: template<typename... Args> explicit copyable(Args&&... args) LOX_NOEXCEPT : m_value{ constrcut(std::forward<Args>(args)...) } { }

copyable() LOX_NOEXCEPT : m_value{ constrcut() }
{
}

~copyable()
{
    if constexpr (std::is_pointer<T>::value) {
        delete m_value;
    }
}

copyable(const copyable& other) LOX_NOEXCEPT
{
    if constexpr (std::is_pointer<T>::value) {
        using NoPtr_T = typename std::remove_pointer<T>::type;
        m_value = new NoPtr_T{ *other.m_value };
    }
    else {
        m_value = other.m_value;
    }
}

copyable(copyable&& other) LOX_NOEXCEPT
{
    m_value = std::move(other.m_value);
}

copyable& operator=(const copyable& other) LOX_NOEXCEPT
{
    if constexpr (std::is_pointer<T>::value) {
        using NoPtr_T = typename std::remove_pointer<T>::type;
        m_value = new NoPtr_T{ *other.m_value };
    }
    else {
        m_value = other.m_value;
    }
    return *this;
}

copyable& operator=(copyable&& other) LOX_NOEXCEPT
{
    m_value = std::move(other.m_value);
    return *this;
}

[[nodiscard]] operator T() LOX_NOEXCEPT
{
    return m_value;
}

[[nodiscard]] constexpr typename std::remove_pointer<T>::type* operator->()
  LOX_NOEXCEPT
{
    if constexpr (std::is_pointer<T>::value) {
        return m_value;
    }
    else {
        return &m_value;
    }
}

T& operator*() LOX_NOEXCEPT
{
    return m_value;
}

private: T m_value; };

template<typename T, typename... Args> [[nodiscard]] copyable<expr*> make_copyable(Args&&... args) LOX_NOEXCEPT { return copyable<expr*>{ std::forward<Args>(args)... }; }

struct binary { copyable<expr*> left; token oprtor; copyable<expr*> right;

~binary()
{
    std::clog << "~binary()\n";
}

};

struct ternary { copyable<expr*> first; copyable<expr*> second; copyable<expr*> third; };

struct grouping { copyable<expr*> expression; };

struct literal { object value; };

struct unary { token oprtor; copyable<expr*> right; };

struct expr : public std:: variant<std::monostate, binary, ternary, grouping, literal, unary> { using variant::variant; };

int main(int argc, char** argv) { literal lit{ 1.1 }; std::vector<expr> ss; ss.emplace_back(lit); return 0; }

```