4 files changed, 52 insertions, 86 deletions
diff --git a/CHANGELOG.txt b/CHANGELOG.txt
index 3382159..32bdabe 100644
--- a/CHANGELOG.txt
+++ b/CHANGELOG.txt
@@ -16,6 +16,10 @@
 
 * Update logo;
 
+* Rework opt;
+* Add equivalent to C++ move: fwd;
+* Inline some opt and res methods;
+
 # 1.0.0
 
 * Update API-BREAK file;
diff --git a/test.cc b/test.cc
index d31c83f..79410ec 100644
--- a/test.cc
+++ b/test.cc
@@ -264,12 +264,12 @@ int main() {
 [&] {
 tst("results");
 
- ::zp::res<::zp::i8s,::zp::i8s> res = ::zp::err<::zp::i8s>(0x45);
+ auto res = ::zp::res<::zp::i8s,::zp::i8s>::err(0x45);
 
 chkeq(res.chk(),false);
- chkeq(res.err(),0x45);
+ chkeq(res.geterr(),0x45);
 
- res = -0x45;
+ res = ::zp::res<::zp::i8s,::zp::i8s>::oky(-0x45);
 
 auto const fun = [](char const* msg) -> void {
 ::std::cout << msg << ::std::endl;
diff --git a/zp/include/zp/det/zp.ii b/zp/include/zp/det/zp.ii
index c4a23bf..2a40cc3 100644
--- a/zp/include/zp/det/zp.ii
+++ b/zp/include/zp/det/zp.ii
@@ -17,67 +17,34 @@ constexpr auto ::zp::iscstevl() noexcept -> bool {
 }
 #endif
 
-template<typename typ> zp_nothw zp::opt<typ>::opt(::zp::det::nulopt) : _hasval(false) {}
-template<typename typ> zp::opt<typ>::opt(typ const& val) : _hasval(true),_val(val) {}
-
-template<typename typ> zp_nothw bool zp::opt<typ>::chk() const {return this->_hasval;}
-
-template<typename typ> zp_nothw typ const& zp::opt<typ>::val() const {return this->_val;}
-
 template<typename typ> template<typename funtyp,typename msgtyp> zp_nothw typ const& zp::opt<typ>::exp(funtyp const& fun,msgtyp const& msg) const {
 zp_unlik (!this->_hasval) {
 fun(msg);
 ::zp::unrch();
 }
- return this->_val;
-}
 
-template<typename typ> ::zp::opt<typ> zp::opt<typ>::operator =(typ const& val) {
- this->_hasval = true;
- this->_val = val;
-
- return *this;
+ return this->_val;
 }
 
-template<typename typ> zp_nothw typ zp::errtyp<typ>::val() const {return this->errval;}
-
-template<typename typ> template<typename valtyp> zp_nothw ::zp::errtyp<typ> zp::errtyp<typ>::operator =(valtyp const& val) {
- this->errval = val;
- return *this;
+template<typename okytyp,typename errtyp> ::zp::res<okytyp,errtyp> zp::res<okytyp,errtyp>::err(errtyp const& err) {
+ ::zp::res<okytyp,errtyp> res;
+ res._hasoky = false;
+ res._val.err = err;
+ return res;
 }
 
-template<typename typ,typename valtyp> zp_nothw ::zp::errtyp<typ> zp::err(valtyp const& val) {
- ::zp::errtyp<typ> err;
- return err = val;
+template<typename okytyp,typename errtyp> ::zp::res<okytyp,errtyp> zp::res<okytyp,errtyp>::oky(okytyp const& oky) {
+ ::zp::res<okytyp,errtyp> res;
+ res._hasoky = true;
+ res._val.oky = oky;
+ return res;
 }
 
-template<typename okytyp,typename errtyp> zp_nothw zp::res<okytyp,errtyp>::res(okytyp const& oky) : hasoky(true), okyval(oky) {}
-template<typename okytyp,typename errtyp> zp_nothw zp::res<okytyp,errtyp>::res(::zp::errtyp<errtyp> const& err) : hasoky(false),errval(err.val()) {}
-
-template<typename okytyp,typename errtyp> zp_nothw bool zp::res<okytyp,errtyp>::chk() const {return this->hasoky;}
-
-template<typename okytyp,typename errtyp> zp_nothw okytyp const& zp::res<okytyp,errtyp>::oky() const {return this->okyval;}
-template<typename okytyp,typename errtyp> zp_nothw errtyp const& zp::res<okytyp,errtyp>::err() const {return this->errval;}
-
-template<typename okytyp,typename errtyp> template<typename funtyp,typename msgtyp> zp_nothw okytyp const& zp::res<okytyp,errtyp>::exp(funtyp const& fun,msgtyp const& msg) const {
- zp_unlik (!this->hasoky) {
+template<typename okytyp,typename errtyp> template<typename funtyp,typename msgtyp> okytyp const& zp::res<okytyp,errtyp>::exp(funtyp const& fun,msgtyp const& msg) const {
+ zp_unlik (!this->_hasoky) {
 fun(msg);
 ::zp::unrch();
 }
 
- return this->okyval;
-}
-
-template<typename okytyp,typename errtyp> zp_nothw ::zp::res<okytyp,errtyp> zp::res<okytyp,errtyp>::operator =(okytyp const& oky) {
- this->hasoky = true;
- this->okyval = oky;
-
- return *this;
-}
-
-template<typename okytyp,typename errtyp> zp_nothw ::zp::res<okytyp,errtyp> zp::res<okytyp,errtyp>::operator =(::zp::errtyp<errtyp> const& err) {
- this->hasoky = false;
- this->errval = err.val();
-
- return *this;
+ return this->_val.oky;
 }
diff --git a/zp/include/zp/zp b/zp/include/zp/zp
index 1e9890f..468ea82 100644
--- a/zp/include/zp/zp
+++ b/zp/include/zp/zp
@@ -24,9 +24,9 @@
 translation units has undefined behaviour.
 */
 #if zp_std_cxx11
-#define zp_prv_trtval(typ) constexpr typ
+#define zp_prv_cstval(typ) constexpr typ
 #else
-#define zp_prv_trtval(typ) static typ const
+#define zp_prv_cstval(typ) static typ const
 #endif
 
 namespace zp {
@@ -310,78 +310,73 @@ namespace zp {
 #endif
 
 namespace det {
- struct nulopt {};
+ struct nulopttyp {};
 }
 
- zp_prv_trtval (::zp::det::nulopt) nulopt;
+ zp_prv_cstval (::zp::det::nulopttyp) nulopt;
 
 template<typename typ> class opt {
 public:
- zp_nothw opt(::zp::det::nulopt);
- opt(typ const& val);
+ zp_iln zp_nothw inline opt(::zp::det::nulopttyp) {this->_hasval = false;}
+ zp_iln inline opt(typ const& val) {this->_hasval = true; this->_val = val;}
 
- zp_nothw bool chk() const;
+ zp_iln zp_nothw inline bool chk() const {return this->_hasval;}
 
- zp_nothw typ const& val() const;
+ zp_iln zp_nothw inline typ const& val() const {return this->_val;}
 
 template<typename funtyp,typename msgtyp> zp_nothw typ const& exp(funtyp const & fun,msgtyp const & msg) const;
 
- ::zp::opt<typ> operator =(typ const& val);
+ zp_iln inline ::zp::opt<typ> operator =(typ const& val) {this->_hasval = true;this->_val = val;return *this;}
 
 private:
 bool _hasval;
 typ _val;
 };
 
- template<typename typ> struct errtyp {
+ template<typename okytyp,typename errtyp> class res {
 public:
- zp_nothw typ val() const;
- template<typename valtyp> zp_nothw ::zp::errtyp<typ> operator =(valtyp const& val);
+ zp_iln zp_nothw inline res() {}
+ zp_iln zp_nothw inline res(::zp::res<okytyp,errtyp> const& oth) {this->_hasoky = oth._hasoky;this->_val = oth._val;}
 
- private:
- typ errval;
- };
+ zp_iln zp_nothw inline static ::zp::res<okytyp,errtyp> oky(okytyp const& oky);
+ zp_iln zp_nothw inline static ::zp::res<okytyp,errtyp> err(errtyp const& err);
 
- template<typename typ,typename valtyp> zp_nothw ::zp::errtyp<typ> err(valtyp const& val);
+ zp_iln zp_nothw inline bool chk() const {return this->_hasoky;}
 
- template<typename okytyp,typename errtyp> class res {
- public:
- zp_nothw res(okytyp const& oky);
- zp_nothw res(::zp::errtyp<errtyp> const& err);
+ zp_iln zp_nothw inline okytyp & getoky() {return this->_val.oky;}
+ zp_iln zp_nothw inline okytyp const& getoky() const {return this->_val.oky;}
+ zp_iln zp_nothw inline errtyp & geterr() {return this->_val.err;}
+ zp_iln zp_nothw inline errtyp const& geterr() const {return this->_val.err;}
 
- zp_nothw bool chk() const; // true if okay.
- 
- zp_nothw okytyp const& oky() const;
- zp_nothw errtyp const& err() const;
-
- template<typename funtyp,typename msgtyp> zp_nothw okytyp const& exp(funtyp const& fun,msgtyp const& msg) const;
+ template<typename funtyp,typename msgtyp> zp_nothw okytyp const& exp(funtyp const& fun,msgtyp const& msg) const; // UB if fun doesn't return.
 
- ::zp::res<okytyp,errtyp> zp_nothw operator =(okytyp const& oky);
- ::zp::res<okytyp,errtyp> zp_nothw operator =(::zp::errtyp<errtyp> const& err);
+ zp_nothw ::zp::res<okytyp,errtyp> operator =(::zp::res<okytyp,errtyp> const& oth) {this->_hasoky = oth._hasoky;this->_val = oth._val;return *this;}
 
 private:
- bool hasoky;
+ bool _hasoky : 0x1;
 union {
- okytyp okyval;
- errtyp errval;
- };
+ okytyp oky;
+ errtyp err;
+ } _val;
 };
 
 namespace det {
- template<typename typ> struct ver {
+ template<typename typ> struct vertyp {
 typ api;
 typ ext;
 };
 }
 
- zp_prv_trtval (::zp::det::ver< ::zp::i04>) ver = {zp_apiver,zp_extver};
+ zp_prv_cstval (::zp::det::vertyp< ::zp::i04>) ver = {zp_apiver,zp_extver};
 
- zp_prv_trtval (::zp::siz) bytelen = zp_bytelen;
+ zp_prv_cstval (::zp::siz) bytelen = zp_bytelen;
 
- zp_prv_trtval (::zp::c02) unimax = zp_unimax;
+ zp_prv_cstval (::zp::c02) unimax = zp_unimax;
 
 #if zp_std_cxx11
 zp_iln constexpr auto iscstevl() noexcept -> bool; // is constant-evaluated
+
+ template<typename typ> zp_iln constexpr auto fwd(typ & ref) noexcept -> typ && {return static_cast<typ &&>(ref);}
 #endif
 
 zp_iln zp_noret zp_nothw inline void trp() {::zp_trp();}