Clean-up pass for DocC (#599)

Author: mluisbrown

Sources/ComposableArchitecture/Effect.swift

@@ -29,7 +29,7 @@ extension Effect {
     .deferred { () -> SignalProducer<Value, Error> in
       work()
       return .empty
-    }
+  }
   }
 
   /// Concatenates a variadic list of effects together into a single effect, which runs the effects
@@ -87,14 +87,14 @@ extension Effect {
   /// Note that you can only deliver a single value to the `callback`. If you send more they will be
   /// discarded:
   ///
-  /// ```swift
+  ///    ```swift
   /// Effect<Int, Never>.future { callback in
   ///   DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
   ///     callback(.success(42))
   ///     callback(.success(1729)) // Will not be emitted by the effect
   ///   }
-  /// }
-  /// ```
+  ///     }
+  ///    ```
   ///
   /// - Parameter attemptToFulfill: A closure that takes a `callback` as an argument which can be
   ///   used to feed it `Result<Output, Failure>` values.
@@ -110,8 +110,8 @@ extension Effect {
         case let .failure(error):
           observer.send(error: error)
         }
-      }
-    }
+  }
+}
   }
 
   /// Turns any publisher into an ``Effect`` that cannot fail by wrapping its output and failure in
@@ -120,12 +120,12 @@ extension Effect {
   /// This can be useful when you are working with a failing API but want to deliver its data to an
   /// action that handles both success and failure.
   ///
-  /// ```swift
-  /// case .buttonTapped:
-  ///   return fetchUser(id: 1)
-  ///     .catchToEffect()
-  ///     .map(ProfileAction.userResponse)
-  /// ```
+  ///    ```swift
+  ///     case .buttonTapped:
+  ///       return fetchUser(id: 1)
+  ///         .catchToEffect()
+  ///         .map(ProfileAction.userResponse)
+  ///    ```
   ///
   /// - Returns: An effect that wraps `self`.
   public func catchToEffect() -> Effect<Result<Value, Error>, Never> {
@@ -139,11 +139,11 @@ extension Effect {
   /// This is useful for times you want to fire off an effect but don't want to feed any data back
   /// into the system. It can automatically promote an effect to your reducer's domain.
   ///
-  /// ```swift
-  /// case .buttonTapped:
-  ///   return analyticsClient.track("Button Tapped")
-  ///     .fireAndForget()
-  /// ```
+  ///    ```swift
+  ///     case .buttonTapped:
+  ///       return analyticsClient.track("Button Tapped")
+  ///         .fireAndForget()
+  ///    ```
   ///
   /// - Parameters:
   ///   - outputType: An output type.

Sources/ComposableArchitecture/Effects/Cancellation.swift

@@ -19,19 +19,19 @@ extension Effect {
   /// value can be used for the identifier, such as a string, but you can add a bit of protection
   /// against typos by defining a new type that conforms to `Hashable`, such as an empty struct:
   ///
-  ///    ```swift
-  ///     struct LoadUserId: Hashable {}
+  /// ```swift
+  /// struct LoadUserId: Hashable {}
   ///
-  ///     case .reloadButtonTapped:
-  ///       // Start a new effect to load the user
-  ///       return environment.loadUser
-  ///         .map(Action.userResponse)
-  ///         .cancellable(id: LoadUserId(), cancelInFlight: true)
+  /// case .reloadButtonTapped:
+  ///   // Start a new effect to load the user
+  ///   return environment.loadUser
+  ///     .map(Action.userResponse)
+  ///     .cancellable(id: LoadUserId(), cancelInFlight: true)
   ///
-  ///     case .cancelButtonTapped:
-  ///       // Cancel any in-flight requests to load the user
-  ///       return .cancel(id: LoadUserId())
-  ///    ```
+  /// case .cancelButtonTapped:
+  ///   // Cancel any in-flight requests to load the user
+  ///   return .cancel(id: LoadUserId())
+  /// ```
   ///
   /// - Parameters:
   ///   - id: The effect's identifier.

Sources/ComposableArchitecture/Effects/Debouncing.swift

@@ -18,7 +18,7 @@ extension Effect {
   ///         .map(Action.searchResponse)
   ///         .debounce(id: SearchId(), for: 0.5, scheduler: environment.mainQueue)
   ///    ```
-  ///    
+  ///
   /// - Parameters:
   ///   - id: The effect's identifier.
   ///   - dueTime: The duration you want to debounce for.

Sources/ComposableArchitecture/Effects/Timer.swift

@@ -50,7 +50,7 @@ extension Effect where Value == Date, Error == Never {
   ///       let store = TestStore(
   ///         initialState: .init(),
   ///         reducer: appReducer,
-  ///         envirnoment: .init(
+  ///     environment: .init(
   ///           mainQueue: scheduler
   ///         )
   ///       )
@@ -87,6 +87,6 @@ extension Effect where Value == Date, Error == Never {
     return SignalProducer.timer(
       interval: interval, on: scheduler, leeway: tolerance ?? .seconds(.max)
     )
-    .cancellable(id: id, cancelInFlight: true)
+      .cancellable(id: id, cancelInFlight: true)
   }
 }

Sources/ComposableArchitecture/Reducer.swift

@@ -90,7 +90,9 @@ import ReactiveSwift
 /// sometimes you are required to do work synchronously, such as in animation blocks.
 ///
 /// * It is possible to create a scheduler that performs its work immediately when on the main
-/// thread and otherwise uses `DispatchQueue.main.async` (e.g. see CombineScheduler's [UIScheduler](https://github.com/pointfreeco/combine-schedulers/blob/main/Sources/CombineSchedulers/UIScheduler.swift)). This introduces a lot more complexity, and should probably not be adopted without having a very
+/// thread and otherwise uses `DispatchQueue.main.async` (e.g. see CombineScheduler's
+/// [UIScheduler](https://github.com/pointfreeco/combine-schedulers/blob/main/Sources/CombineSchedulers/UIScheduler.swift)).
+/// This introduces a lot more complexity, and should probably not be adopted without having a very
 /// good reason.
 ///
 /// This is why we require all actions be sent from the same thread. This requirement is in the same

Sources/ComposableArchitecture/Store.swift

@@ -14,99 +14,99 @@ import SwiftUI
 ///
 /// To use this API, you model all the action sheet actions in your domain's action enum:
 ///
-///    ```swift
-///     enum AppAction: Equatable {
-///       case cancelTapped
-///       case deleteTapped
-///       case favoriteTapped
-///       case infoTapped
+/// ```swift
+/// enum AppAction: Equatable {
+///   case cancelTapped
+///   case deleteTapped
+///   case favoriteTapped
+///   case infoTapped
 ///
-///       // Your other actions
-///     }
-///    ```
+///   // Your other actions
+/// }
+/// ```
 ///
 /// And you model the state for showing the action sheet in your domain's state, and it can start
 /// off in a `nil` state:
 ///
-///    ```swift
-///     struct AppState: Equatable {
-///       var actionSheet: ActionSheetState<AppAction>?
+/// ```swift
+/// struct AppState: Equatable {
+///   var actionSheet: ActionSheetState<AppAction>?
 ///
-///       // Your other state
-///     }
-///    ```
+///   // Your other state
+/// }
+/// ```
 ///
 /// Then, in the reducer you can construct an `ActionSheetState` value to represent the action
 /// sheet you want to show to the user:
 ///
-///    ```swift
-///     let appReducer = Reducer<AppState, AppAction, AppEnvironment> { state, action, env in
-///       switch action
-///         case .cancelTapped:
-///           state.actionSheet = nil
-///           return .none
-///
-///         case .deleteTapped:
-///           state.actionSheet = nil
-///           // Do deletion logic...
-///
-///         case .favoriteTapped:
-///           state.actionSheet = nil
-///           // Do favoriting logic
-///
-///         case .infoTapped:
-///           state.actionSheet = .init(
-///             title: "What would you like to do?",
-///             buttons: [
-///               .default(TextState("Favorite"), send: .favoriteTapped),
-///               .destructive(TextState("Delete"), send: .deleteTapped),
-///               .cancel(),
-///             ]
-///           )
-///         return .none
-///       }
-///     }
-///    ```
+/// ```swift
+/// let appReducer = Reducer<AppState, AppAction, AppEnvironment> { state, action, env in
+///   switch action
+///     case .cancelTapped:
+///       state.actionSheet = nil
+///       return .none
+///
+///     case .deleteTapped:
+///       state.actionSheet = nil
+///       // Do deletion logic...
+///
+///     case .favoriteTapped:
+///       state.actionSheet = nil
+///       // Do favoriting logic
+///
+///     case .infoTapped:
+///       state.actionSheet = .init(
+///         title: "What would you like to do?",
+///         buttons: [
+///           .default(TextState("Favorite"), send: .favoriteTapped),
+///           .destructive(TextState("Delete"), send: .deleteTapped),
+///           .cancel(),
+///         ]
+///       )
+///     return .none
+///   }
+/// }
+/// ```
 ///
 /// And then, in your view you can use the `.actionSheet(_:send:dismiss:)` method on `View` in order
 /// to present the action sheet in a way that works best with the Composable Architecture:
 ///
-///    ```swift
-///     Button("Info") { viewStore.send(.infoTapped) }
-///       .actionSheet(
-///         self.store.scope(state: \.actionSheet),
-///         dismiss: .cancelTapped
-///       )
-///    ```
+/// ```swift
+/// Button("Info") { viewStore.send(.infoTapped) }
+///   .actionSheet(
+///     self.store.scope(state: \.actionSheet),
+///     dismiss: .cancelTapped
+///   )
+/// ```
 ///
 /// This makes your reducer in complete control of when the action sheet is shown or dismissed, and
 /// makes it so that any choice made in the action sheet is automatically fed back into the reducer
 /// so that you can handle its logic.
 ///
 /// Even better, you can instantly write tests that your action sheet behavior works as expected:
 ///
-///    ```swift
-///     let store = TestStore(
-///       initialState: AppState(),
-///       reducer: appReducer,
-///       environment: .mock
-///     )
-///
-///     store.send(.infoTapped) {
-///       $0.actionSheet = .init(
-///         title: "What would you like to do?",
-///         buttons: [
-///           .default(TextState("Favorite"), send: .favoriteTapped),
-///           .destructive(TextState("Delete"), send: .deleteTapped),
-///           .cancel(),
-///         ]
-///       )
-///     }
-///     store.send(.favoriteTapped) {
-///       $0.actionSheet = nil
-///       // Also verify that favoriting logic executed correctly
-///     }
-///    ```
+/// ```swift
+/// let store = TestStore(
+///   initialState: AppState(),
+///   reducer: appReducer,
+///   environment: .mock
+/// )
+///
+/// store.send(.infoTapped) {
+///   $0.actionSheet = .init(
+///     title: "What would you like to do?",
+///     buttons: [
+///       .default(TextState("Favorite"), send: .favoriteTapped),
+///       .destructive(TextState("Delete"), send: .deleteTapped),
+///       .cancel(),
+///     ]
+///   )
+/// }
+/// store.send(.favoriteTapped) {
+///   $0.actionSheet = nil
+///   // Also verify that favoriting logic executed correctly
+/// }
+/// ```
 ///
   @available(iOS 13, macOS 10.15, macCatalyst 13, tvOS 13, watchOS 6, *)
 public struct ActionSheetState<Action> {