core: Implement From<T> for Option<T>

This allows improved ergonomics for functions that have optional
parameters: instead of taking `Option<T>`, they can have a type
parameter bounded by `Into<Option<T>>`. That way, a value of type `T`
can be passed directly without being wrapped by `Some`.

As an example, a function

    fn foo<T>(required: i32, optional: T) -> i32
        where T: Into<Option<i32>>
    {
        required + optional.into().unwrap_or(0)
    }

can be called as `foo(2, None)` or as `foo(2, 3)`.

Refs rust-lang/rfcs#1402

Author: kamalmarhubi

src/libcore/option.rs

@@ -142,6 +142,7 @@
 use self::Option::*;
 
 use clone::Clone;
+use convert::From;
 use default::Default;
 use iter::ExactSizeIterator;
 use iter::{Iterator, DoubleEndedIterator, FromIterator, IntoIterator};
@@ -710,6 +711,14 @@ impl<T> Default for Option<T> {
     fn default() -> Option<T> { None }
 }
 
+#[unstable(feature = "option_from", reason = "recently added", issue = "0")]
+impl<T> From<T> for Option<T> {
+    #[inline]
+    fn from(t: T) -> Option<T> {
+        Some(t)
+    }
+}
+
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> IntoIterator for Option<T> {
     type Item = T;

src/libcoretest/option.rs

@@ -270,3 +270,28 @@ fn test_cloned() {
     assert_eq!(opt_ref_ref.clone().cloned(), Some(&val));
     assert_eq!(opt_ref_ref.cloned().cloned(), Some(1));
 }
+
+#[test]
+fn test_from() {
+    assert_eq!(Some(3), Option::from(3));
+}
+
+#[test]
+fn test_into_optional_parameters() {
+    use core::convert::Into;
+    fn myfunc<T, U, V>(t: T, u: U, v: V) -> Option<u8>
+        where T: Into<Option<u8>>,
+              U: Into<Option<u8>>,
+              V: Into<Option<u8>> {
+        match (t.into() ,u.into(), v.into()) {
+            (Some(t), Some(u), Some(v)) => Some(t + u + v),
+            _ => None,
+        }
+    }
+
+    assert_eq!(None, myfunc(None, 2, 3));
+    assert_eq!(None, myfunc(1, None, 3));
+    assert_eq!(None, myfunc(1, 2, None));
+    assert_eq!(Some(6), myfunc(1, 2, 3));
+    assert_eq!(Some(6), myfunc(Some(1), Some(2), Some(3)));
+}