Transparent wrapper around Result<Ret>, as far as the user is concerned. More...

#include <asm_function.hpp>

Inheritance diagram for asmgrader::AsmFunctionResult< Ret, Args >:

Public Member Functions
constexpr	AsmFunctionResult (std::tuple< std::decay_t< Args >... > args_, std::string_view function_name_)

template<typename U >
void	set_result (U &&val)

std::string	repr (std::span< const inspection::Token > tokens, std::string_view raw_str) const

Public Member Functions inherited from asmgrader::Expected< T, E >
constexpr	Expected ()

template<typename... Args> requires (!std::is_void_v<T> && std::constructible_from<ExpectedT, Args...>)
constexpr	Expected (std::in_place_t, Args &&... args)

template<typename Tu > requires (!std::is_void_v<T> && std::convertible_to<Tu, T>)
constexpr	Expected (Tu &&value)

template<typename Eu > requires (std::convertible_to<Eu, E> && !std::is_convertible_v<T, E> && !std::is_convertible_v<T, E>)
constexpr	Expected (Eu &&error)

template<typename Eu > requires (std::convertible_to<Eu, E>)
constexpr	Expected (UnexpectedT, Eu &&error)

constexpr void	assert_val ()

constexpr bool	has_value () const

constexpr bool	has_error () const

constexpr	operator bool () const

template<typename U = T> requires (!std::is_void_v<U>)
constexpr U &	value ()

template<typename U = T> requires (!std::is_void_v<U>)
constexpr const U &	value () const

template<typename U = T> requires (std::is_void_v<U>)
constexpr void	value () const

template<typename U = T> requires (!std::is_void_v<U>)
constexpr U &	operator* ()

template<typename U = T> requires (!std::is_void_v<U>)
constexpr const U &	operator* () const

template<typename U = T> requires (!std::is_void_v<U>)
constexpr U *	operator-> ()

template<typename U = T> requires (!std::is_void_v<U>)
constexpr const U *	operator-> () const

template<typename Tu > requires (std::convertible_to<Tu, T>)
constexpr T	value_or (Tu &&default_value) const

constexpr E	error () const

template<typename Eu >
constexpr E	error_or (Eu &&default_value) const

template<typename Func >
constexpr Expected< std::invoke_result_t< Func, T >, E >	transform (const Func &func)

constexpr auto	operator<=> (const Expected &rhs) const =default

template<typename Tu > requires (!std::is_void_v<T> && !std::same_as<Tu, Expected> && !std::derived_from<Tu, Expected> && std::equality_comparable_with<Tu, T>)
constexpr bool	operator== (const Tu &rhs) const

template<typename Eu > requires (!std::same_as<Eu, Expected> && !std::derived_from<Eu, Expected> && std::equality_comparable_with<Eu, E>)
constexpr bool	operator== (const Eu &rhs) const

Public Attributes
std::tuple< std::decay_t< Args >... >	args

std::string_view	function_name

Additional Inherited Members
Public Types inherited from asmgrader::Expected< T, E >
using	ExpectedT = T

using	ErrT = E

Detailed Description

template<typename Ret, typename... Args>
class asmgrader::AsmFunctionResult< Ret, Args >

Transparent wrapper around Result<Ret>, as far as the user is concerned.

Internally provides serialized_args and function_name member variables for use in requirement serialization.