Modify README.md

Author: CorbyO

README.md

@@ -7,103 +7,58 @@ Option to replace Nullable as in functional programming for Unity.
 - [Serialization](#serialization)
 
 # Getting started
+
+### Initialize
 ```csharp
-using Corby.Option;
+Option<int> num = new(); // None<int>
+Option<int> num = 3.ToSome(); // Some<>(3)
+Option<Transform> parent = transform.parent.ToOption(); // Some<> or None 
+```
 
-void Func()
-{ 
-    // Default usage 
-    {
-        string helloString = "Hello";
-        string worldString = null;
-        
-        var a = helloString.Some(); // Some<String>("Hello")
-        var b = worldString.Some(); // None<String>() because worldString is null
-        var c = "Option".Some(); // Some<String>("Option") by literal
-        
-        var printString = a switch
-        {
-            Some<string> some => some.Value,
-            None<string> none => "None"
-        };
-        
-        UnityEngine.Debug.log(printString); // print "Hello"
-        UnityEngine.Debug.log(a); // print "Some<string>(Hello)"
-        UnityEngine.Debug.log(b); // print "None<string>"
-    }
-    
-    
-    // safety usage without null exception for function
-    {
-        int[] array1 = new int[] { 1, 2, 3 };
-        int[] array2 = null;
-        
-        Func<int[], Option<int>> GetLength = (array) => 
-        {
-            if (array == null) return None<int>.New;
-            return array.Length.Some();
-        }
-        
-        UnityEngine.Debug.log($"length: {GetLength(array1)}"); // print "length: Some<int>(3)"
-        UnityEngine.Debug.log($"length: {GetLength(array2)}"); // print "length: None<int>"
-    }
-    
-    
-    // Four basic operations
-    {
-        int a = 3;
-        Option<int> b = 7.Some();
-        Option<int> c = None<int>.New;
-        
-        // Option<int> is change to int whan calculated
-        UnityEngine.Debug.log($"{a.Add(b)}"); // print "a: 10"
-        UnityEngine.Debug.log($"{a.Sub(c)}"); // print "a: 3" because None isn't calculated
-        UnityEngine.Debug.log($"{b.Mul(a)}"); // print "a: 21"
-        UnityEngine.Debug.log($"{b.Div(c)}"); // print "a: 7" because None isn't calculated
-    }
+### Return without null
+```csharp
+public static Option<int> GetParent<T>(this Transform transform)
+{
+    return transform.parent.ToOption();
 }
 ```
 
+### Unwarpping
+```csharp
+var parentName = transform.GetParent().Unwrap() switch
+{
+    Some<Transform> parent => parent.name,
+    None<Transform> => "None"
+};
+```
+
+
+
 # Serialization
-![image](https://github.com/CorbyO/Option/assets/17669733/c6e738f0-28be-4257-948e-a7c8cdf2ba2d)  
-This is a simple example of how to serialize a class or struct that contains Option.  
-i don't found serialize for interface so you want to serialize the option, you use the SerializableOption class.
+![image](https://github.com/CorbyO/Option/assets/17669733/6be717ce-b181-4b86-9238-a5d00fa900b4)
+
+This is a simple example of how to serialize a class or struct that contains Option.
 
 ```csharp
-// good
 [Serializable]
 public struct TestStruct
 {
-    public SerializableOption<Vector3> OptionVector3;
-    public SerializableOption<Quaternion> OptionQuaternion;
-    public SerializableOption<Transform> OptionTransform;
-}
-
-// bad: Serialize is fail because [Serializable] is not applied.
-public struct TestStruct2
-{
-    public SerializableOption<int> i;
+    public Option<int> Number;
+    public Option<string> Name;
+    public Option<Vector3> Position;
 }
 
-// good
 [Serializable]
 public class TestClass
 {
-    public SerializableOption<int> OptionInt;
-    public SerializableOption<float> OptionFloat;
-    public SerializableOption<string> OptionString;
-    public SerializableOption<TestStruct> OptionTestStruct;
-    public SerializableOption<TestStruct2> OptionTestStruct2;
+    public Option<Sprite> Sprite;
+    public Option<List<int>> Numbers;
 }
 
 
 public class TestComponent : MonoBehaviour
 {
-    public SerializableOption<TestClass> OptionTestClass;
-    
-    void Awake()
-    {
-        var option = OptionTestClass.Get(); // Some<TestClass> or None<TestClass>
-    }
+    public Option<TestStruct> Struct;
+    public Option<TestClass> Class;
 }
 ```