Update documentation

Author: ra1028

README.md

@@ -377,7 +377,7 @@ To look into the APIs in more detail, visit the [API referrence](https://ra1028.
 
 ### [AtomRoot](https://ra1028.github.io/swiftui-atom-properties/documentation/atoms/atomroot)
 
-Provides the internal store which provides atoms to view-tree through environment values.  
+Provides a store object which manages the state of atoms to view-tree through environment values.  
 It must be the root of any views to manage atoms used throughout the application.
 
 ```swift
@@ -398,7 +398,7 @@ struct ExampleApp: App {
 ### Atoms
 
 An atom represents a piece of state and is the source of truth for your app. It can also represent a derived data by combining and transforming one or more other atoms.  
-Each atom does not actually have a global data inside, and retrieve values from the internal store provided by the `AtomRoot`. That's why *they can be accessed from anywhere, but never lose testability.*  
+Each atom does not actually have a global data inside, and retrieve values from the store provided by the `AtomRoot`. That's why *they can be accessed from anywhere, but never lose testability.*  
 
 An atom and its value are associated using a unique `key` which is automatically defined if the atom conforms to `Hashable`, but you can also define it explicitly without Hashable.  
 
@@ -1458,7 +1458,7 @@ struct RootView: View {
 </details>
 
 Unfortunately, SwiftUI has a bug in iOS14 or lower where the `EnvironmentValue` is removed from a screen presented with `.sheet` just before dismissing it. Since this library is designed based on `EnvironmentValue`, this bug end up triggering the friendly `assertionFailure` that is added so that developers can easily aware of forgotten `AtomRoot` implementation.  
-As a workaround, `AtomScope` has the ability to explicitly inherit the internal store through `AtomViewContext` from the parent view.
+As a workaround, `AtomScope` has the ability to explicitly inherit the store through `AtomViewContext` from the parent view.
 
 #### Some SwiftUI modifiers cause memory leak (Fixed in iOS16)
 

Sources/Atoms/AtomRoot.swift

@@ -1,7 +1,6 @@
 import SwiftUI
 
-/// A view that stores the state container of atoms and provides an internal store to view-tree
-/// through environment values.
+/// A view that stores the state of atoms.
 ///
 /// It must be the root of any views to manage the state of atoms used throughout the application.
 ///

Sources/Atoms/AtomScope.swift

@@ -2,9 +2,23 @@ import SwiftUI
 
 /// A view to override or monitor atoms in scope.
 ///
-/// For some reasons, sometimes SwiftUI can fail to pass environment values in the view-tree.
-/// The typical example is that, if you use SwiftUI view inside UIKit view, it could fail as
-/// SwiftUI can't pass environment values across UIKit.
+/// This view allows you to monitor changes of atoms used in descendant views by``AtomScope/observe(_:)``.
+///
+/// ```swift
+/// AtomScope {
+///     MyView()
+/// }
+/// .observe { snapshot in
+///     if let count = snapshot.lookup(CounterAtom()) {
+///         print(count)
+///     }
+/// }
+/// ```
+///
+/// It inherits from the atom store provided by ``AtomRoot`` through environment values by default,
+/// but sometimes SwiftUI can fail to pass environment values in the view-tree for some reason.
+/// The typical example is that, in case you use SwiftUI view inside UIKit view, it could fail as
+/// SwiftUI can't pass environment values to UIKit across boundaries.
 /// In that case, you can wrap the view with ``AtomScope`` and pass a view context to it so that
 /// the descendant views can explicitly inherit the store.
 ///
@@ -21,19 +35,19 @@ import SwiftUI
 /// }
 /// ```
 ///
-/// ``AtomScope`` can be created without passing a view context, and in this case, it inherits
-/// from an internal store through environment values from ``AtomRoot.
-/// It allows you to monitor changes of atoms used in descendant views by``AtomScope/observe(_:)``.
+/// Additionally, if for some reason your app cannot use ``AtomRoot`` to manage the store
+/// that manages the state of atoms, you can manage the store on your own and pass the instance
+/// to ``AtomScope`` so that you can use the atoms in descendant views.
 ///
 /// ```swift
-/// AtomScope {
-///     MyView()
-/// }
-/// .observe { snapshot in
-///     if let count = snapshot.lookup(CounterAtom()) {
-///         print(count)
-///     }
+/// let store = AtomStore()
+/// let rootView = AtomScope(store) {
+///     RootView()
 /// }
+/// let window = UIWindow(frame: UIScreen.main.bounds)
+///
+/// window.rootViewController = UIHostingController(rootView: rootView)
+/// window.makeKeyAndVisible()
 /// ```
 ///
 public struct AtomScope<Content: View>: View {

Sources/Atoms/Context/AtomTestContext.swift

@@ -3,7 +3,7 @@ import Foundation
 
 /// A context structure that to read, watch, and otherwise interacting with atoms in testing.
 ///
-/// This context has an internal Store that manages atoms, so it can be used to test individual
+/// This context has a store that manages the state of atoms, so it can be used to test individual
 /// atoms or their interactions with other atoms without depending on the SwiftUI view tree.
 /// Furthermore, unlike other contexts, it is possible to override or observe changes in atoms
 /// by this itself.