Update README

Author: auramagi

README.md

@@ -4,55 +4,55 @@ Resolve SwiftUI views trough a resolver injected in parent that is inspired by N
 
 ## Usage
 
-### Destinations with the `ResolvableDestination` protocol
+### Destinations with `@ViewBuilder` closures
 
-1. Implement a custom type that adopts the `ResolvableDestination` protocol
-2. Provide a value of this type in the parent view with the `destination` view modifier
-3. Resolve the view using `DestinationView` with the initializer that takes the destination type as the first argument
+This is the most basic way to use Destinations.
+
+1. Register a `@ViewBuilder` closure for a value type with the `destination(for:)` view modifier
+2. In a child view, resolve the destination by using `DestinationView` with a matching value type 
 
 ```swift
 import Destinations
 
-struct MyDestination: ResolvableDestination {
-    let base: Int
-    
-    func body(value: Int) -> some View {
-        Text(base + value, format: .number)
-    }
-}
-
 struct ParentView: View {
     var body: some View {
         ChildView()
-            .destination(MyDestination(base: 100))
+            .destination(for: Int.self) { value in
+                Text(100 + value, format: .number)
+            }
     }
 }
 
 struct ChildView: View {
     var body: some View {
-        DestinationView(MyDestination.self, value: 1)
+        DestinationView(value: 1)
     }
 }
 ```
 
-### Destinations with `@ViewBuilder` closures
-
-Destinations comes with one special destination that you can use to resolve any Hashable value without implementing a custom `ResolvableDestination` type.
+### Destinations with the `ResolvableDestination` protocol
 
-1. Provide a `@ViewBuilder` closure for a value type in the parent view with the `destination(for:)` view modifier
-2. Resolve the view using `DestinationView` with the initializer with the value as the only argument
+Alternatively, you can register a custom `ResolvableDestination` implementation. This way you can inject properties from the parent and hold some state with SwiftUI property wrappers.
 
-Note, however, that while this approach more closely resembles NavigationStack and is easier to use, it has one significant one significant trade-off. Like NavigationStack, it uses `AnyView` inside to erase the type information of the view that you provide in the `destination` closure, which is an unavoidable syntax limitation. In practical terms, this is may be less efficient when SwiftUI needs to detect changes between view updates.
+1. Implement a custom type that adopts the `ResolvableDestination` protocol
+2. Register a value of this type with the `destination` view modifier
+3. In a child view, resolve the view by using `DestinationView` with a value type that matches the value type used in step 1 
 
 ```swift
 import Destinations
 
+struct MyDestination: ResolvableDestination {
+    let base: Int
+    
+    func body(value: Int) -> some View {
+        Text(base + value, format: .number)
+    }
+}
+
 struct ParentView: View {
     var body: some View {
         ChildView()
-            .destination(for: Int.self) { value in
-                Text(100 + value, format: .number)
-            }
+            .destination(MyDestination(base: 100))
     }
 }
 
@@ -84,7 +84,6 @@ struct ContentView: View {
             List {
                 DestinationNavigationLink(
                     "Present MyDestination with push transition",
-                    destination: MyDestination.self,
                     value: "Hello, world!"
                 )
 
@@ -95,7 +94,6 @@ struct ContentView: View {
         }
         .sheet(
             isPresented: $isSheetPresented,
-            destination: MyDestination.self,
             value: "Hello, modal world!"
         )
         .destination(MyDestination())
@@ -134,6 +132,4 @@ struct FileSizeLabelDestination: ResolvableDestination {
         }
     }
 }
-
 ```
-