feat: add from from? from! methods to Option

So we can conv the std lib to Option type
to get a no nil world

Author: initdc

spec/option_spec.cr

@@ -216,4 +216,26 @@ describe Option do
     expect_raises(Option::WrapingNil) { Some(Bool?)[false] }
     expect_raises(Option::WrapingNil) { None(Bool?)[] }
   end
+
+  it "from" do
+    Option.from(0).should eq(Some[0])
+    Option.from("").should eq(Some[""])
+    Option.from(false).should eq(Some[false])
+    Option.from([] of Int32).should eq(Some[[] of Int32])
+    Option.from({} of String => Int32).should eq(Some[{} of String => Int32])
+
+    Option(Bool).from?(nil).should eq(None(Bool)[])
+    expect_raises(Option::WrapingNil) { Option.from?(nil) }
+
+    Option(String).from?(ENV["USER"]?).should eq(Some[%x(whoami).chomp])
+    Option(String).from?(ENV["NOT_EXISTING"]?).should eq(None(String)[])
+
+    Option.from! { ENV["USER"] }.should eq(Some[%x(whoami).chomp])
+    Option.from! { ENV["NOT_EXISTING"] }.should eq(None(String)[])
+
+    env_user = -> { ENV["USER"] }
+    env_not_existing = -> { ENV["NOT_EXISTING"] }
+    Option.from!(env_user).should eq(Some[%x(whoami).chomp])
+    Option.from!(env_not_existing).should eq(None(String)[])
+  end
 end

src/option.cr

@@ -98,15 +98,15 @@ abstract struct Option(T)
 
     def map(&block : T -> U) : Option(U) forall U
     {% if type == "Some" %}
-      Some.new(block.call(@value))
+      Some(U).new(block.call(@value))
     {% elsif type == "None" %}
       None(U).new
     {% end %}
     end
 
     def map(block : T -> U) : Option(U) forall U
     {% if type == "Some" %}
-      Some.new(block.call(@value))
+      Some(U).new(block.call(@value))
     {% elsif type == "None" %}
       None(U).new
     {% end %}
@@ -267,6 +267,26 @@ abstract struct Option(T)
       end
     end
   end
+
+  def self.from(value : T) : Option(T)
+    Some(T).new(value)
+  end
+
+  def self.from?(value : T | Nil) : Option(T)
+    value.nil? ? None(T).new : Some(T).new(value)
+  end
+
+  def self.from!(&block : -> T) : Option(T)
+    Some(T).new(block.call)
+  rescue
+    None(T).new
+  end
+
+  def self.from!(block : -> T) : Option(T)
+    Some(T).new(block.call)
+  rescue
+    None(T).new
+  end
 end
 
 struct Some(T) < Option(T)