Skip to content

Commit 7aa02d7

Browse files
liam-tealeliam-teale
committed
rename Result member variables and functions
1 parent e5676ac commit 7aa02d7

1 file changed

Lines changed: 46 additions & 42 deletions

File tree

‎include/common/result.hpp‎

Lines changed: 46 additions & 42 deletions
Original file line numberDiff line numberDiff line change
@@ -16,13 +16,14 @@ namespace zest {
1616
template<typename T, typename E>
1717
requires(!std::convertible_to<T, E>) && (!std::convertible_to<E, T>)
1818
class Result {
19+
private:
20+
std::optional<E> m_error;
21+
T m_value;
22+
1923
public:
2024
using ErrorT = E;
2125
using ValueT = T;
2226

23-
std::optional<E> error;
24-
T value;
25-
2627
/**
2728
* @brief default constructor
2829
*
@@ -46,7 +47,7 @@ class Result {
4647
template<typename U>
4748
requires std::constructible_from<T, U&&>
4849
constexpr Result(U&& value)
49-
: value(std::forward<U>(value)) {}
50+
: m_value(std::forward<U>(value)) {}
5051

5152
/**
5253
* @brief Construct with an "error" value, and the default "normal" value
@@ -60,7 +61,7 @@ class Result {
6061
requires std::constructible_from<E, F&&>
6162
constexpr Result(F&& error)
6263
requires std::default_initializable<T>
63-
: error(std::forward<F>(error)) {}
64+
: m_error(std::forward<F>(error)) {}
6465

6566
/**
6667
* @brief Construct with an "error" value and "normal" value
@@ -77,16 +78,16 @@ class Result {
7778
template<typename F, typename U>
7879
requires std::constructible_from<T, U&&> && std::constructible_from<E, F&&>
7980
constexpr Result(F&& error, U&& value)
80-
: error(std::forward<F>(error)),
81-
value(std::forward<U>(value)) {}
81+
: m_error(std::forward<F>(error)),
82+
m_value(std::forward<U>(value)) {}
8283

8384
/**
8485
* @brief conversion operator for an l-value reference to the "normal" value type
8586
*
8687
* @return T&
8788
*/
8889
constexpr operator T&() & {
89-
return value;
90+
return m_value;
9091
}
9192

9293
/**
@@ -95,7 +96,7 @@ class Result {
9596
* @return const T&
9697
*/
9798
constexpr operator const T&() const& {
98-
return value;
99+
return m_value;
99100
}
100101

101102
/**
@@ -104,7 +105,7 @@ class Result {
104105
* @return T&&
105106
*/
106107
constexpr operator T&&() && {
107-
return std::move(value);
108+
return std::move(m_value);
108109
}
109110

110111
/**
@@ -117,8 +118,8 @@ class Result {
117118
* @return "normal" value
118119
*/
119120
template<typename Self>
120-
constexpr auto get_value(this Self&& self) {
121-
return std::forward<Self>(self).value;
121+
constexpr auto value(this Self&& self) {
122+
return std::forward<Self>(self).m_value;
122123
}
123124

124125
/**
@@ -128,7 +129,7 @@ class Result {
128129
* @return false an error is not contained
129130
*/
130131
constexpr bool has_error() const {
131-
return error.has_value();
132+
return m_error.has_value();
132133
}
133134

134135
/**
@@ -141,8 +142,8 @@ class Result {
141142
* @return std::optional<E>
142143
*/
143144
template<typename Self>
144-
constexpr auto get_error(this Self&& self) {
145-
return std::forward<Self>(self).error;
145+
constexpr auto error(this Self&& self) {
146+
return std::forward<Self>(self).m_error;
146147
}
147148

148149
/**
@@ -166,16 +167,16 @@ class Result {
166167
*/
167168
template<typename F, typename Self>
168169
constexpr auto and_then(this Self&& self, F&& f) {
169-
using R = std::invoke_result_t<F, decltype((std::forward<Self>(self).get_value()))>;
170+
using R = std::invoke_result_t<F, decltype((std::forward<Self>(self).value()))>;
170171
static_assert(
171172
std::default_initializable<R>,
172173
"callable return type must be default-constructible"
173174
);
174175

175176
if (self.has_error()) {
176-
return R(std::forward<Self>(self).error.get_value());
177+
return R(std::forward<Self>(self).error().value());
177178
}
178-
return std::invoke(std::forward<F>(f), std::forward<Self>(self).value);
179+
return std::invoke(std::forward<F>(f), std::forward<Self>(self).value());
179180
}
180181

181182
/**
@@ -197,7 +198,7 @@ class Result {
197198
template<typename F, typename Self>
198199
constexpr auto or_else(this Self&& self, F&& f) {
199200
if (self.has_error()) {
200-
return std::invoke(std::forward<F>(f), std::forward<Self>(self).error.get_value());
201+
return std::invoke(std::forward<F>(f), std::forward<Self>(self).error().value());
201202
}
202203
return std::forward<Self>(self);
203204
}
@@ -223,12 +224,12 @@ class Result {
223224
*/
224225
template<typename F, typename Self>
225226
constexpr auto transform(this Self&& self, F&& f) {
226-
using R = std::invoke_result_t<F, decltype((std::forward<Self>(self).get_value()))>;
227+
using R = std::invoke_result_t<F, decltype((std::forward<Self>(self).value()))>;
227228

228229
if (self.has_error()) {
229-
return Result<R, E>(std::forward<Self>(self).error.get_value());
230+
return Result<R, E>(std::forward<Self>(self).error.value());
230231
}
231-
return Result<R, E>(std::invoke(std::forward<F>(f), std::forward<Self>(self).value));
232+
return Result<R, E>(std::invoke(std::forward<F>(f), std::forward<Self>(self).value()));
232233
}
233234

234235
/**
@@ -249,14 +250,14 @@ class Result {
249250
*/
250251
template<typename F, typename Self>
251252
constexpr auto transform_error(this Self&& self, F&& f) {
252-
using R = std::invoke_result_t<F, decltype((std::forward<Self>(self).get_error()))>;
253+
using R = std::invoke_result_t<F, decltype((std::forward<Self>(self).error().value()))>;
253254

254-
if (self.has_error()) {
255+
if (self.error()) {
255256
return Result<T, R>(
256-
std::invoke(std::forward<F>(f), std::forward<Self>(self).get_error().get_value())
257+
std::invoke(std::forward<F>(f), std::forward<Self>(self).error().value())
257258
);
258259
}
259-
return Result<T, R>(std::forward<Self>(self).get_value());
260+
return Result<T, R>(std::forward<Self>(self).value());
260261
}
261262

262263
/**
@@ -276,7 +277,7 @@ class Result {
276277
if (self.has_error()) {
277278
return std::forward<U>(other_value);
278279
}
279-
return std::forward<Self>(self).get_value();
280+
return std::forward<Self>(self).value();
280281
}
281282

282283
/**
@@ -294,7 +295,7 @@ class Result {
294295
requires std::convertible_to<F&&, E>
295296
constexpr E error_or(this Self&& self, F&& other_error) {
296297
if (self.has_error()) {
297-
return std::forward<Self>(self).error.get_value();
298+
return std::forward<Self>(self).error().value();
298299
}
299300
return std::forward<F>(other_error);
300301
}
@@ -307,8 +308,12 @@ class Result {
307308
*/
308309
template<typename E>
309310
class Result<void, E> {
311+
private:
312+
std::optional<E> m_error;
313+
310314
public:
311-
std::optional<E> error;
315+
using ErrorT = E;
316+
using ValueT = void;
312317

313318
/**
314319
* @brief default constructor
@@ -326,7 +331,7 @@ class Result<void, E> {
326331
template<typename F>
327332
requires std::constructible_from<E, F&&>
328333
constexpr Result(F&& error)
329-
: error(error) {}
334+
: m_error(error) {}
330335

331336
/**
332337
* @brief Whether an error is contained
@@ -335,7 +340,7 @@ class Result<void, E> {
335340
* @return false an error is not contained
336341
*/
337342
constexpr bool has_error() const {
338-
return error.has_value();
343+
return m_error.has_value();
339344
}
340345

341346
/**
@@ -348,8 +353,8 @@ class Result<void, E> {
348353
* @return std::optional<E>
349354
*/
350355
template<typename Self>
351-
constexpr auto get_error(this Self&& self) {
352-
return std::forward<Self>(self).error;
356+
constexpr auto error(this Self&& self) {
357+
return std::forward<Self>(self).m_error;
353358
}
354359

355360
/**
@@ -370,13 +375,12 @@ class Result<void, E> {
370375
* - callable must return a Result instance with the same error value type
371376
*
372377
* TODO: add support for non-default-constructible types
373-
* TODO: check void specialization has valid documentation
374378
*/
375379
template<std::invocable F, typename Self>
376380
constexpr auto and_then(this Self&& self, F&& f) {
377381
using R = std::invoke_result_t<F>;
378382
if (self.has_error()) {
379-
return R(std::forward<Self>(self).error.value());
383+
return R(std::forward<Self>(self).error().value());
380384
}
381385
return std::invoke(std::forward<F>(f));
382386
}
@@ -402,9 +406,9 @@ class Result<void, E> {
402406
template<typename F, typename Self>
403407
constexpr auto or_else(this Self&& self, F&& f) {
404408
if (self.has_error()) {
405-
return std::invoke(std::forward<F>(f), std::forward<Self>(self).error.value());
409+
return std::invoke(std::forward<F>(f), std::forward<Self>(self).error().value());
406410
}
407-
return std::forward<Self>(self).get_value();
411+
return std::forward<Self>(self).value();
408412
}
409413

410414
/**
@@ -430,7 +434,7 @@ class Result<void, E> {
430434
constexpr auto transform(this Self&& self, F&& f) {
431435
using R = std::invoke_result_t<F>;
432436
if (self.has_error()) {
433-
return R(std::forward<Self>(self).error.value());
437+
return R(std::forward<Self>(self).error().value());
434438
}
435439
return R{std::invoke(std::forward<F>(f))};
436440
}
@@ -453,14 +457,14 @@ class Result<void, E> {
453457
*/
454458
template<typename F, typename Self>
455459
constexpr auto transform_error(this Self&& self, F&& f) {
456-
using R = std::invoke_result_t<F&&, decltype((std::forward<Self>(self).get_error()))>;
460+
using R = std::invoke_result_t<F&&, decltype((std::forward<Self>(self).error()))>;
457461

458462
if (self.has_error()) {
459463
return Result<void, R>(
460-
std::invoke(std::forward<F>(f), std::forward<Self>(self).get_error().get_value())
464+
std::invoke(std::forward<F>(f), std::forward<Self>(self).error().value())
461465
);
462466
}
463-
return Result<void, R>(std::forward<Self>(self).get_value());
467+
return Result<void, R>(std::forward<Self>(self).value());
464468
}
465469

466470
/**
@@ -478,7 +482,7 @@ class Result<void, E> {
478482
requires std::convertible_to<F&&, E>
479483
constexpr E error_or(this Self&& self, F&& other_error) {
480484
if (self.has_error()) {
481-
return std::forward<Self>(self).error.get_value();
485+
return std::forward<Self>(self).error().value();
482486
}
483487
return std::forward<F>(other_error);
484488
}

0 commit comments

Comments
 (0)