lambda_calc/expression.h at main · kelbudiul/lambda_calc · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
#pragma once

#include <string>
#include <memory>

// Forward declarations
class Variable;
class Abstraction;
class Application;
class NamedReference;
class IVisitor;

// Base Expression class
class Expression {
public:
    virtual ~Expression() = default;

    // Accept method for the visitor pattern
    virtual void accept(IVisitor& visitor) = 0;

    // Helper method to create a deep copy of the expression
    virtual std::shared_ptr<Expression> clone() const = 0;

    // Helper method to convert expression to string for display
    virtual std::string toString() const = 0;
};

// Variable expression (represents a variable in lambda calculus)
class Variable : public Expression {
private:
    std::string name;

public:
    explicit Variable(std::string name) : name(std::move(name)) {}

    void accept(IVisitor& visitor) override;

    std::shared_ptr<Expression> clone() const override {
        return std::make_shared<Variable>(name);
    }

    std::string toString() const override {
        return name;
    }

    const std::string& getName() const {
        return name;
    }
};

// Abstraction expression (represents a lambda abstraction: λx.M)
class Abstraction : public Expression {
private:
    std::string parameter;
    std::shared_ptr<Expression> body;

public:
    Abstraction(std::string parameter, std::shared_ptr<Expression> body)
        : parameter(std::move(parameter)), body(std::move(body)) {}

    void accept(IVisitor& visitor) override;

    std::shared_ptr<Expression> clone() const override {
        return std::make_shared<Abstraction>(parameter, body->clone());
    }

    std::string toString() const override {
        return "λ" + parameter + "." + body->toString();
    }

    const std::string& getParameter() const {
        return parameter;
    }

    const std::shared_ptr<Expression>& getBody() const {
        return body;
    }
};

// Application expression (represents function application: M N)
class Application : public Expression {
private:
    std::shared_ptr<Expression> function;
    std::shared_ptr<Expression> argument;

public:
    Application(std::shared_ptr<Expression> function, std::shared_ptr<Expression> argument)
        : function(std::move(function)), argument(std::move(argument)) {}

    void accept(IVisitor& visitor) override;

    std::shared_ptr<Expression> clone() const override {
        return std::make_shared<Application>(function->clone(), argument->clone());
    }

    std::string toString() const override {
        return "(" + function->toString() + " " + argument->toString() + ")";
    }

    const std::shared_ptr<Expression>& getFunction() const {
        return function;
    }

    const std::shared_ptr<Expression>& getArgument() const {
        return argument;
    }
};

// Named reference expression (refers to a defined expression)
class NamedReference : public Expression {
private:
    std::string name;

public:
    explicit NamedReference(std::string name) : name(std::move(name)) {}

    void accept(IVisitor& visitor) override;

    std::shared_ptr<Expression> clone() const override {
        return std::make_shared<NamedReference>(name);
    }

    std::string toString() const override {
        return name;  // Just show the name
    }

    const std::string& getName() const {
        return name;
    }
};