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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
// SPDX-License-Identifier: MIT
// Copyright (c) 2026 Paul Buetow
package rpn
// ArithmeticOperator defines the interface for basic arithmetic operators.
type ArithmeticOperator interface {
Add(stack *Stack) error
Subtract(stack *Stack) error
Multiply(stack *Stack) error
Divide(stack *Stack) error
Power(stack *Stack) error
Modulo(stack *Stack) error
}
// LogarithmicOperator defines the interface for logarithmic operators.
type LogarithmicOperator interface {
Log2(stack *Stack) error
Log10(stack *Stack) error
Ln(stack *Stack) error
}
// MetricOperator defines the interface for metric unit conversion.
type MetricOperator interface {
Convert(stack *Stack) error
}
// BooleanOperator defines the interface for boolean comparison operators.
type BooleanOperator interface {
GT(stack *Stack) error
LT(stack *Stack) error
GTE(stack *Stack) error
LTE(stack *Stack) error
EQ(stack *Stack) error
NEQ(stack *Stack) error
}
// HyperOperator defines the interface for hyper operators.
type HyperOperator interface {
HyperAdd(stack *Stack) error
HyperSubtract(stack *Stack) error
HyperMultiply(stack *Stack) error
HyperDivide(stack *Stack) error
HyperPower(stack *Stack) error
HyperModulo(stack *Stack) error
HyperLog2(stack *Stack) error
HyperLog10(stack *Stack) error
HyperLn(stack *Stack) error
}
// StackOperator defines the interface for stack manipulation operators.
type StackOperator interface {
Dup(stack *Stack) error
Swap(stack *Stack) error
Pop(stack *Stack) error
Delete(stack *Stack) error
Show(stack *Stack) (string, error)
}
// VariableOperator defines the interface for variable operations.
type VariableOperator interface {
ListVariables() (string, error)
ClearVariables()
AssignLeft(stack *Stack) error
AssignRight(stack *Stack) error
DeleteVariable(name string) error
}
// ConstantOperator defines the interface for constant operations.
type ConstantOperator interface {
ListConstants() (string, error)
ClearConstants()
}
// PowerIntOperator defines the interface for integer power operations (**) using binary exponentiation.
type PowerIntOperator interface {
FastPower(stack *Stack) error
}
// ModeController defines the interface for calculation mode and prefix mode control.
type ModeController interface {
SetMode(CalculationMode)
GetMode() CalculationMode
SetPrefixMode(PrefixMode)
GetPrefixMode() PrefixMode
}
// MetricCommander defines the interface for metric query commands.
type MetricCommander interface {
MetricRegistry() MetricReader
MetricShow(stack *Stack) (string, error)
MetricList(stack *Stack) (string, error)
MetricCategory(stack *Stack, categoryName string) (string, error)
MetricCompatible(stack *Stack) (string, error)
}
// CustomMetricManager defines the interface for custom metric operations.
type CustomMetricManager interface {
CustomShow(stack *Stack, name string) (string, error)
CustomList(stack *Stack) (string, error)
CustomDefine(name string, factor float64, category string) error
CustomUndefine(name string) error
}
// OperatorProvider combines all operator interfaces needed by the OperatorRegistry.
// This satisfies DIP by decoupling the registry from the concrete *Operations type.
type OperatorProvider interface {
ArithmeticOperator
PowerIntOperator
LogarithmicOperator
BooleanOperator
StackOperator
VariableOperator
ConstantOperator
MetricOperator
HyperOperator
}
// Registration interfaces — focused composites for each operator group.
// Adding a new operator category only requires creating a new registration
// interface and helper, without editing OperatorProvider or existing helpers.
type (
// ArithmeticOpProvider covers standard arithmetic, fast power, and log operators.
ArithmeticOpProvider interface {
ArithmeticOperator
PowerIntOperator
LogarithmicOperator
}
// ComparisonOpProvider covers boolean comparison operators.
ComparisonOpProvider interface {
BooleanOperator
}
// VariableOpProvider covers variable assignment and metric conversion.
VariableOpProvider interface {
VariableOperator
MetricOperator
}
// CommandOpProvider covers command operators that return immediate results.
CommandOpProvider interface {
StackOperator
VariableOperator
ConstantOperator
}
)
// OperationsProvider combines all interfaces that RPN needs from Operations.
// RPN depends on this interface (DIP) rather than the concrete *Operations type.
type OperationsProvider interface {
ModeController
StackOperator
MetricCommander
CustomMetricManager
}
// OperatorRegistryProvider defines the methods RPN needs from the operator registry.
// RPN depends on this interface (DIP) rather than the concrete *OperatorRegistry type.
type OperatorRegistryProvider interface {
IsStandardOperator(token string) bool
IsHyperOperator(token string) bool
HandleStandardOperator(stack *Stack, token string) (string, bool, error)
HandleHyperOperator(stack *Stack, token string) (string, bool, error)
}
// Operator implementations are split across focused sub-interfaces
// (ArithmeticOperator, LogarithmicOperator, MetricOperator, BooleanOperator,
// HyperOperator, StackOperator, VariableOperator, ConstantOperator,
// PowerIntOperator) for clarity.
//
// The OperationsProvider interface is the combined interface that RPN depends
// on, satisfying DIP by decoupling RPN from the concrete *Operations type.
//
// Each sub-interface and OperationsProvider is satisfied by *Operations,
// verified by compile-time checks in operations.go.
|
