Merge pull request #3 from TartanLlama/reference

Support optional references

Author: TartanLlama

README.md

@@ -1,5 +1,5 @@
 # optional
-Single header implementation of `std::optional` with functional-style extensions.
+Single header implementation of `std::optional` with functional-style extensions and support for references.
 
 Clang + GCC: [![Linux Build Status](https://travis-ci.org/TartanLlama/optional.png?branch=master)](https://travis-ci.org/TartanLlama/optional)
 MSVC: [![Windows Build Status](https://ci.appveyor.com/api/projects/status/k5x00xa11y3s5wsg?svg=true)](https://ci.appveyor.com/project/TartanLlama/optional)
@@ -66,6 +66,26 @@ The interface is the same as `std::optional`, but the following member functions
 - `take`: returns the current value, leaving the optional empty.
   * `opt_string.take().map(&std::string::size); //opt_string now empty;`
 
+In addition to those member functions, optional references are also supported:
+
+```
+int i = 42;
+tl::optional<int&> o = i;
+*o == 42; //true
+i = 12;
+*o = 12; //true
+&*o == &i; //true
+```
+
+Assignment has rebind semantics rather than assign-through semantics:
+
+```
+int j = 8;
+o = j;
+
+&*o == &j; //true
+```
+
 ### Compiler support
 
 Tested on:

docs/index.md

@@ -0,0 +1,3 @@
+[output]
+format=commonmark
+link_extension=html

standardese.config

@@ -1,7 +1,7 @@
 #include "catch.hpp"
 #include "optional.hpp"
 
-TEST_CASE("Assignment", "[assignment]") {
+TEST_CASE("Assignment value", "[assignment.value]") {
     tl::optional<int> o1 = 42;
     tl::optional<int> o2 = 12;
     tl::optional<int> o3;
@@ -32,3 +32,40 @@ TEST_CASE("Assignment", "[assignment]") {
     o1 = std::move(o4);
     REQUIRE(*o1 == 42);
 }
+
+
+TEST_CASE("Assignment reference", "[assignment.ref]") {
+    auto i = 42;
+    auto j = 12;
+    
+    tl::optional<int&> o1 = i;
+    tl::optional<int&> o2 = j;
+    tl::optional<int&> o3;
+
+    o1 = o1;
+    REQUIRE(*o1 == 42);
+    REQUIRE(&*o1 == &i);    
+
+    o1 = o2;
+    REQUIRE(*o1 == 12);
+
+    o1 = o3;
+    REQUIRE(!o1);
+
+    auto k = 42;
+    o1 = k;
+    REQUIRE(*o1 == 42);
+    REQUIRE(*o1 == i);
+    REQUIRE(*o1 == k);        
+    REQUIRE(&*o1 != &i);
+    REQUIRE(&*o1 == &k);
+
+    k = 12;
+    REQUIRE(*o1 == 12);
+
+    o1 = tl::nullopt;
+    REQUIRE(!o1);
+
+    o1 = std::move(o2);
+    REQUIRE(*o1 == 12);
+}

tests/assignment.cpp

@@ -2,30 +2,49 @@
 #include "optional.hpp"
 
 TEST_CASE("Constructors", "[constructors]") {
-    tl::optional<int> o1;
-    REQUIRE(!o1);
+  tl::optional<int> o1;
+  REQUIRE(!o1);
 
-    tl::optional<int> o2 = tl::nullopt;
-    REQUIRE(!o2);
+  tl::optional<int> o2 = tl::nullopt;
+  REQUIRE(!o2);
 
-    tl::optional<int> o3 = 42;
-    REQUIRE(*o3 == 42);
+  tl::optional<int> o3 = 42;
+  REQUIRE(*o3 == 42);
 
-    tl::optional<int> o4 = o3;
-    REQUIRE(*o4 == 42);
+  tl::optional<int> o4 = o3;
+  REQUIRE(*o4 == 42);
 
-    tl::optional<int> o5 = o1;
-    REQUIRE(!o5);
+  tl::optional<int> o5 = o1;
+  REQUIRE(!o5);
 
-    tl::optional<int> o6 = std::move(o3);
-    REQUIRE(*o6 == 42);
+  tl::optional<int> o6 = std::move(o3);
+  REQUIRE(*o6 == 42);
 
-    tl::optional<short> o7 = 42;
-    REQUIRE(*o7 == 42);
+  tl::optional<short> o7 = 42;
+  REQUIRE(*o7 == 42);
 
-    tl::optional<int> o8 = o7;
-    REQUIRE(*o8 == 42);
+  tl::optional<int> o8 = o7;
+  REQUIRE(*o8 == 42);
 
-    tl::optional<int> o9 = std::move(o7);
-    REQUIRE(*o9 == 42);
+  tl::optional<int> o9 = std::move(o7);
+  REQUIRE(*o9 == 42);
+
+  {
+    tl::optional<int &> o;
+    REQUIRE(!o);
+
+    tl::optional<int &> oo = o;
+    REQUIRE(!oo);
+  }
+
+  {
+    auto i = 42;
+    tl::optional<int &> o = i;
+    REQUIRE(o);
+    REQUIRE(*o == 42);
+
+    tl::optional<int &> oo = o;
+    REQUIRE(oo);
+    REQUIRE(*oo == 42);
+  }
 }

tests/constructors.cpp

@@ -122,7 +122,7 @@ TEST_CASE("Monadic operations", "[monadic]") {
 
     // callable which returns a reference
     tl::optional<int> o38 = 42;
-    auto o38r = o38.map([](int& i) -> const int& { return i; });
+    auto o38r = o38.map([](int &i) -> const int & { return i; });
     REQUIRE(o38r);
     REQUIRE(*o38r == 42);
   }

tests/extensions.cpp

@@ -37,4 +37,10 @@ TEST_CASE("Make optional", "[make_optional]") {
   REQUIRE(o5->v[1] == 1);
   REQUIRE(std::get<0>(o5->t) == 2);
   REQUIRE(std::get<1>(o5->t) == 3);
+
+  auto i = 42;
+  auto o6 = tl::make_optional<int&>(i);
+  REQUIRE((std::is_same<decltype(o6), tl::optional<int&>>::value));
+  REQUIRE(o6);
+  REQUIRE(*o6 == 42);    
 }