#pragma once

#include "error.hpp"

#include <memory>

namespace lambda {

enum class LambdaType : uint8_t { VARIABLE, FUNCTION, APPLICATION };

#ifdef LAMBDA_NOALIGN

#pragma pack(push, 1)

#endif

class LambdaBase {

public:

virtual ~LambdaBase() = default;

virtual inline LambdaType getType() const noexcept = 0;

};

class Variable : public LambdaBase {

public:

// Using uint16_t because it's pleanty enough

// Using uint32_t doesnt change optimized size, but does change

// "real" size

std::uint16_t count;

char name;

Variable(char name, std::uint16_t count = 0) : name(name), count(count) {}

inline LambdaType getType() const noexcept override {

return LambdaType::VARIABLE;

}

inline bool operator==(const Variable& other) const noexcept {

return name == other.name;

}

};

class Function : public LambdaBase {

public:

Variable bound;

std::unique_ptr<LambdaBase> body;

Function(Variable bound, std::unique_ptr<LambdaBase> body)

: bound(std::move(bound)), body(std::move(body)) {

if (!this->body)

throw LambdaLibException("Failed to create a function, body is nullptr.");

}

inline LambdaType getType() const noexcept override {

return LambdaType::FUNCTION;

}

};

class Application : public LambdaBase {

public:

// These unique ptr are 16 bytes each, because we have virtual destructor (and

// virtual function?)

std::unique_ptr<LambdaBase> left;

std::unique_ptr<LambdaBase> right;

Application(

std::unique_ptr<LambdaBase> left, std::unique_ptr<LambdaBase> right)

: left(std::move(left)), right(std::move(right)) {

if (!(this->left && this->right))

throw LambdaLibException(

"Failed to create an application, one or more arguments are nullptr.");

}

inline LambdaType getType() const noexcept override {

return LambdaType::APPLICATION;

}

};

#ifdef LAMBDA_NOALIGN

#pragma pack(pop)

#endif

} // namespace lambda