Added toOptional function.

source/handy_http_primitives/optional.d

@@ -88,36 +88,47 @@ struct Optional(T) {
     version (Have_asdf) {
         import asdf;
 
-        /**
+        static if (
-         * Deserializes an optional value from raw ASDF data. This function
+            __traits(compiles, deserialize!T(Asdf.init))
-         * is defined to allow for automatic deserialization of Optionals when
+        ) {
-         * parsing JSON or other data types.
+            /**
-         * Params:
+            * Deserializes an optional value from raw ASDF data. This function
-         *   data = The data representing an optional value.
+            * is defined to allow for automatic deserialization of Optionals when
-         * Returns: An exception if one is thrown.
+            * parsing JSON or other data types.
-         */
+            * Params:
-        SerdeException deserializeFromAsdf(Asdf data) {
+            *   data = The data representing an optional value.
-            if (data == null) {
+            * Returns: An exception if one is thrown.
-                this.isNull = true;
+            */
-                this.value = T.init;
+            SerdeException deserializeFromAsdf(Asdf data) {
-            } else {
+                static if (!__traits(compiles, {T t; t = T.init;})) {
-                this.isNull = false;
+                    return new SerdeException(
-                this.value = deserialize!T(data);
+                        "Cannot deserialize Optional that contains immutable or otherwise unassignable value. " ~
+                        "Ensure that the following code compiles: T t; t = T.init; for the given type T."
+                    );
+                } else {
+                    if (data == null) {
+                        this.isNull = true;
+                        this.value = T.init;
+                    } else {
+                        this.isNull = false;
+                        this.value = deserialize!T(data);
+                    }
+                    return null;
+                }
             }
-            return null;
-        }
 
-        /**
+            /**
-         * Serializes an optional value to allow for the automatic serialization
+            * Serializes an optional value to allow for the automatic serialization
-         * of Optionals when writing JSON or other data types.
+            * of Optionals when writing JSON or other data types.
-         * Params:
+            * Params:
-         *   serializer = The serializer to use (provided by ASDF).
+            *   serializer = The serializer to use (provided by ASDF).
-         */
+            */
-        void serialize(S)(ref S serializer) {
+            void serialize(S)(ref S serializer) const {
-            if (this.isNull) {
+                if (this.isNull) {
-                serializer.putValue(null);
+                    serializer.putValue(null);
-            } else {
+                } else {
-                serializer.putValue(this.value);
+                    serializeValue(serializer, this.value);
+                }
             }
         }
     }
@@ -136,6 +147,18 @@ auto mapIfPresent(alias fn, T)(Optional!T opt) {
     return Optional!U.of(fn(opt.value));
 }
 
+/**
+ * Helper function to get an Optional value for an existing value. Due to D's
+ * type inference, you can simply write `auto opt = toOptional(x);` to avoid
+ * having to write out types when constructing optionals.
+ * Params:
+ *   t = The value to construct an optional from.
+ * Returns: The optional with the given value.
+ */
+Optional!T toOptional(T)(T t) {
+    return Optional!T.of(t);
+}
+
 unittest {
     Optional!string s = Optional!string.of("hello");
     assert(!s.isNull);
@@ -179,5 +202,29 @@ unittest {
         assert(sa.b && sa.b.value == "hello world!");
         assert(sa.c && sa.c.value == 3.14f);
         assert(sa.d && sa.d.value == Sd(42, 67));
+
+        // Check that optionals containing immutable data aren't supported for serialization & deserialization:
+        struct Invalid {
+            immutable int x;
+        }
+        Optional!Invalid opt = Optional!(Invalid).of(Invalid(42));
+        static assert(__traits(compiles, serializeToJson(opt)));
+        try {
+            deserialize!(Optional!(Invalid))(`{"x": 123}`);
+            assert(
+                false,
+                "Failed to ensure that an exception is thrown when attempting to deserialize an incompatible Optional."
+            );
+        } catch (SerdeException exc) {
+            // pass.
+        }
     }
 }
+
+// Tests for toOptional.
+unittest {
+    int x = 5;
+    auto optX = x.toOptional;
+    assert(!optX.isNull);
+    assert(optX.value == 5);
+}