Merge pull request #11 from sideeffect-io/feature/rename-asyncStateMachine

project: rename AsyncStateMachineSequence to AsyncStateMachine

Author: twittemb

README.md

@@ -150,10 +150,10 @@ let runtime = Runtime<State, Event, Output>()
   .register(middleware: { (event: Event) in print("Event: \(event)") })
 ```
 
-The `AsyncStateMachineSequence` can then be instantiated:
+The `AsyncStateMachine` can then be instantiated:
 
 ```swift
-let sequence = AsyncStateMachineSequence(
+let sequence = AsyncStateMachine(
   stateMachine: stateMachine,
   runtime: runtime
 )
@@ -176,12 +176,12 @@ await sequence.send(Event.personsHaveEntered(persons: 3))
 
 - Side effects are `async` functions executed in the context of `Tasks`.
 - Task priority can be set in the Runtime: `.map(output: Output.close(speed:), to: close(speed:), priority: .high)`.
-- Collaborative task cancellation applies: when an AsyncStateMachineSequence is deinit, all the pending side effect tasks will be marked as cancelled.
+- Collaborative task cancellation applies: when an `AsyncStateMachine` is deinit, all the pending side effect tasks will be marked as cancelled.
 
 ### Async sequence
 
-- `AsyncStateMachineSequence` benefits from all the operators associated to `AsyncSequence` (`map`, `filter`, …). (See also [swift async algorithms](https://github.com/apple/swift-async-algorithms))
-- `AsyncStateMachineSequence` is compliant with a multiple producer / multiple consumer mode in a concurrent mode. Although to output is not shared (meaning each consumer will receive the successive versions of the state), the transitions are guaranteed concurrent-safe.
+- `AsyncStateMachine` benefits from all the operators associated to `AsyncSequence` (`map`, `filter`, …). (See also [swift async algorithms](https://github.com/apple/swift-async-algorithms))
+- `AsyncStateMachine` is compliant with a multiple producer / multiple consumer mode in a concurrent mode. Although to output is not shared (meaning each consumer will receive the successive versions of the state), the transitions are guaranteed concurrent-safe.
 
 ## How to inject dependencies?
 
@@ -265,53 +265,53 @@ XCTStateMachine(stateMachine)
 
 ## Using Async State Machine with SwiftUI and UIKit
 
-No matter the UI framework you use, rendering a user interface is about interpreting a state. You can use an `AsyncStateMachineSequence` as a reliable state factory, exposing the state with the provided `ViewState`.
+No matter the UI framework you use, rendering a user interface is about interpreting a state. You can use an `AsyncStateMachine` as a reliable state factory. `ViewStateMachine` is a handy wrapper around `AsyncStateMachine` that eases the consumption of the state from a UI perspective.
 
 A simple and naive SwiftUI usage could be:
 
 ```swift
 struct ContentView: View {
-  @ObservedObject viewState: ViewState<State, Event, Output>
+  @ObservedObject viewStateMachine: ViewStateMachine<State, Event, Output>
 
   var body: some View {
     VStack {
-      Text(self.viewState.state.description)
+      Text(self.viewStateMachine.state.description)
       Button {
-        self.viewState.send(Event.personsHaveEntered(persons: 1))
+        self.viewStateMachine.send(Event.personsHaveEntered(persons: 1))
       } label: { 
         Text("New person")
       }
       Button {
-        self.viewState.send(Event.closeButtonWasPressed)
+        self.viewStateMachine.send(Event.closeButtonWasPressed)
       } label: { 
         Text("Close the door")
       }
     }.task {
-      await viewState.start()
+      await self.viewStateMachine.start()
     }
   }
 }
 
 …
 
-let viewState = ViewState(myAsyncStateMachine)
-ContentView(viewState: viewState)
+let viewStateMachine = ViewStateMachine(asyncStateMachine: myAsyncStateMachine)
+ContentView(viewStateMachine: viewStateMachine)
 ```
 
 With UIKit, a simple and naive approach would be:
 
 ```swift
 let task: Task<Void, Never>!
-let viewState: ViewState<State, Event, Output>!
+let viewStateMachine: ViewStateMachine<State, Event, Output>!
 let cancellable = AnyCancellable()
 
 override func viewDidLoad() {
   super.viewDidLoad()
   self.task = Task { [weak self] in
-    await self?.viewState.start()
+    await self?.viewStateMachine.start()
   }
 
-  self.cancellable = self.viewState.$state.sink { [weak self] state in
+  self.cancellable = self.viewStateMachine.$state.sink { [weak self] state in
   	self?.render(state: state)
   }
 }
@@ -332,7 +332,7 @@ func deinit() {
 Allows to send an event while awaiting for a specific state or set of states to resume.
 
 ```swift
-await viewState.send(
+await viewStateMachine.send(
   .closeButtonWasPressed,
   resumeWhen: .closed
 )`
@@ -372,13 +372,13 @@ When(states: OneOf {
 Allows to create a SwiftUI binding on the current state, sending an Event when the binding changes.
 
 ```swift
-self.viewState.binding(send: .closeButtonWasPressed)
+self.viewStateMachine.binding(send: .closeButtonWasPressed)
 ```
 
 Allows to create a SwiftUI binding on a property of the current state, sending an Event when the binding changes.
 
 ```swift
-self.viewState.binding(keypath: \.persons, send: .closeButtonWasPressed)
+self.viewStateMachine.binding(keypath: \.persons, send: .closeButtonWasPressed)
 ```
 
 ### Connecting two state machines

Sample/Sample/ContentView.swift

@@ -26,7 +26,7 @@ struct ContentView: View {
 
 struct ContentView_Previews: PreviewProvider {
   static let viewStateMachine = ViewStateMachine(
-    asyncStateMachineSequence: asyncSequence
+    asyncStateMachine: asyncStateMachine
   )
 
   static var previews: some View {

Sample/Sample/SampleApp.swift

@@ -10,7 +10,7 @@ import SwiftUI
 
 @main
 struct SampleApp: App {
-  let viewStateMachine = ViewStateMachine(asyncStateMachineSequence: asyncSequence)
+  let viewStateMachine = ViewStateMachine(asyncStateMachine: asyncStateMachine)
 
   var body: some Scene {
     WindowGroup {

Sample/Sample/StateMachine.swift

@@ -96,7 +96,7 @@ actor Counter {
 }
 
 
-let asyncSequence = AsyncStateMachineSequence(stateMachine: stateMachine, runtime: runtime)
+let asyncStateMachine = AsyncStateMachine(stateMachine: stateMachine, runtime: runtime)
 
 extension Date {
    func getFormattedDate(format: String) -> String {

Sources/AsyncStateMachineSequence.swift …syncStateMachine/AsyncStateMachine.swiftSources/AsyncStateMachineSequence.swift renamed to Sources/AsyncStateMachine/AsyncStateMachine.swift Sources/AsyncStateMachineSequence.swift renamed to Sources/AsyncStateMachine/AsyncStateMachine.swift

@@ -1,4 +1,11 @@
-public final class AsyncStateMachineSequence<S, E, O>: AsyncSequence, Sendable
+//
+//  AsyncStateMachine.swift
+//
+//
+//  Created by Thibault WITTEMBERG on 02/07/2022.
+//
+
+public final class AsyncStateMachine<S, E, O>: AsyncSequence, Sendable
 where S: DSLCompatible & Sendable, E: DSLCompatible & Sendable, O: DSLCompatible {
   public typealias Element = S
   public typealias AsyncIterator =
@@ -44,7 +51,7 @@ where S: DSLCompatible & Sendable, E: DSLCompatible & Sendable, O: DSLCompatible
       stateMiddlewares: runtime.stateMiddlewares
     )
 
-    // As channals are retained as long as there is a sender using it,
+    // As channels are retained as long as there is a sender using it,
     // the receiver will also be retained.
     // That is why it is necesssary to have a weak reference on the self here.
     // Doing so, self will be deallocated event if a channel was using it as a receiver.

Sources/Engine.swift Sources/AsyncStateMachine/Engine.swiftSources/Engine.swift renamed to Sources/AsyncStateMachine/Engine.swift

@@ -9,24 +9,24 @@ public class ViewStateMachine<S, E, O>: ObservableObject
 where S: DSLCompatible & Equatable, E: DSLCompatible, O: DSLCompatible {
   @Published public var state: S
 
-  let asyncStateMachineSequence: AsyncStateMachineSequence<S, E, O>
+  let asyncStateMachine: AsyncStateMachine<S, E, O>
 
-  public init(asyncStateMachineSequence: AsyncStateMachineSequence<S, E, O>) {
-    self.asyncStateMachineSequence = asyncStateMachineSequence
-    self.state = self.asyncStateMachineSequence.initialState
+  public init(asyncStateMachine: AsyncStateMachine<S, E, O>) {
+    self.asyncStateMachine = asyncStateMachine
+    self.state = self.asyncStateMachine.initialState
   }
 
   public func send(_ event: E) {
-    self.asyncStateMachineSequence.send(event)
+    self.asyncStateMachine.send(event)
   }
 
   public func send(
     _ event: E,
     resumeWhen predicate: @escaping (S) -> Bool
   ) async {
-    await withUnsafeContinuation { [asyncStateMachineSequence] (continuation: UnsafeContinuation<Void, Never>) in
+    await withUnsafeContinuation { [asyncStateMachine] (continuation: UnsafeContinuation<Void, Never>) in
       Task {
-        await asyncStateMachineSequence.engine.register(onTheFly: { state in
+        await asyncStateMachine.engine.register(onTheFly: { state in
           if predicate(state) {
             continuation.resume()
             // middleware will be unregistered after the predicate has been matched
@@ -35,7 +35,7 @@ where S: DSLCompatible & Equatable, E: DSLCompatible, O: DSLCompatible {
           return false
         })
 
-        asyncStateMachineSequence.send(event)
+        asyncStateMachine.send(event)
       }
     }
   }
@@ -77,7 +77,7 @@ where S: DSLCompatible & Equatable, E: DSLCompatible, O: DSLCompatible {
   }
 
   nonisolated public func start() async {
-    for await state in self.asyncStateMachineSequence {
+    for await state in self.asyncStateMachine {
       await self.publish(state: state)
     }
   }
@@ -90,8 +90,8 @@ public extension ViewStateMachine {
   func binding(send event: @escaping (S) -> E) -> Binding<S> {
     Binding {
       self.state
-    } set: { [asyncStateMachineSequence] value in
-      asyncStateMachineSequence.send(event(value))
+    } set: { [asyncStateMachine] value in
+      asyncStateMachine.send(event(value))
     }
   }
 
@@ -102,8 +102,8 @@ public extension ViewStateMachine {
   func binding<T>(keypath: KeyPath<S, T>, send event: @escaping (T) -> E) -> Binding<T> {
     Binding {
       self.state[keyPath: keypath]
-    } set: { [asyncStateMachineSequence] value in
-      asyncStateMachineSequence.send(event(value))
+    } set: { [asyncStateMachine] value in
+      asyncStateMachine.send(event(value))
     }
   }
 

Sources/ViewStateMachine.swift …AsyncStateMachine/ViewStateMachine.swiftSources/ViewStateMachine.swift renamed to Sources/AsyncStateMachine/ViewStateMachine.swift Sources/ViewStateMachine.swift renamed to Sources/AsyncStateMachine/ViewStateMachine.swift

@@ -1,3 +1,10 @@
+//
+//  AsyncStateMachineTests.swift
+//
+//
+//  Created by Thibault WITTEMBERG on 20/06/2022.
+//
+
 @testable import AsyncStateMachine
 import XCTest
 
@@ -71,7 +78,7 @@ enum Output: DSLCompatible, Equatable {
   case o3(value: String)
 }
 
-final class AsyncStateMachineSequenceTests: XCTestCase {
+final class AsyncStateMachineTests: XCTestCase {
 //  func testPerformance() async {
 //  let stateMachine = StateMachine<State, Event, Output>(initial: State.s1(value: "s1")) {
 //    When(states: OneOf {
@@ -187,7 +194,7 @@ final class AsyncStateMachineSequenceTests: XCTestCase {
         }
       })
 
-    let sequence = AsyncStateMachineSequence(stateMachine: stateMachine, runtime: runtime)
+    let sequence = AsyncStateMachine(stateMachine: stateMachine, runtime: runtime)
 
     // When
     Task {
@@ -255,8 +262,8 @@ final class AsyncStateMachineSequenceTests: XCTestCase {
     let runtime2 = Runtime<State, Event, Output>()
       .connectAsReceiver(to: channel)
 
-    let asyncStateMachineSequence1 = AsyncStateMachineSequence(stateMachine: stateMachine1, runtime: runtime1)
-    let asyncStateMachineSequence2 = AsyncStateMachineSequence(stateMachine: stateMachine2, runtime: runtime2)
+    let asyncStateMachineSequence1 = AsyncStateMachine(stateMachine: stateMachine1, runtime: runtime1)
+    let asyncStateMachineSequence2 = AsyncStateMachine(stateMachine: stateMachine2, runtime: runtime2)
 
     let firstStatesHaveBeenEmitted = expectation(description: "The first states have been emitted")
     firstStatesHaveBeenEmitted.expectedFulfillmentCount = 2
@@ -307,7 +314,7 @@ final class AsyncStateMachineSequenceTests: XCTestCase {
     let runtime = Runtime<State, Event, Output>()
 
     // Given
-    var sut: AsyncStateMachineSequence<State, Event, Output>? = AsyncStateMachineSequence(
+    var sut: AsyncStateMachine<State, Event, Output>? = AsyncStateMachine(
       stateMachine: stateMachine,
       runtime: runtime,
       onDeinit: { asyncStateMachineSequenceIsDeinit.fulfill() }
@@ -341,7 +348,7 @@ final class AsyncStateMachineSequenceTests: XCTestCase {
       .connectAsReceiver(to: channel1)
       .connectAsReceiver(to: channel2)
 
-    var sut: AsyncStateMachineSequence<State, Event, Output>? = AsyncStateMachineSequence(
+    var sut: AsyncStateMachine<State, Event, Output>? = AsyncStateMachine(
       stateMachine: stateMachine,
       runtime: runtime,
       onDeinit: { asyncStateMachineSequenceIsDeinit.fulfill() }

…sts/AsyncStateMachineSequenceTests.swift …tateMachine/AsyncStateMachineTests.swiftTests/AsyncStateMachineSequenceTests.swift renamed to Tests/AsyncStateMachine/AsyncStateMachineTests.swift Tests/AsyncStateMachineSequenceTests.swift renamed to Tests/AsyncStateMachine/AsyncStateMachineTests.swift

@@ -46,8 +46,8 @@ final class ViewStateMachineTests: XCTestCase {
         eventWasReceived.fulfill()
       })
 
-    let sequence = AsyncStateMachineSequence(stateMachine: stateMachine, runtime: runtime)
-    let sut = ViewStateMachine(asyncStateMachineSequence: sequence)
+    let sequence = AsyncStateMachine(stateMachine: stateMachine, runtime: runtime)
+    let sut = ViewStateMachine(asyncStateMachine: sequence)
 
     Task {
       await sut.start()
@@ -85,8 +85,8 @@ final class ViewStateMachineTests: XCTestCase {
     let runtime = Runtime<State, Event, Output>()
       .map(output: .o1, to: { Event.e2 })
 
-    let sequence = AsyncStateMachineSequence(stateMachine: stateMachine, runtime: runtime)
-    let sut = ViewStateMachine(asyncStateMachineSequence: sequence)
+    let sequence = AsyncStateMachine(stateMachine: stateMachine, runtime: runtime)
+    let sut = ViewStateMachine(asyncStateMachine: sequence)
 
     Task {
       await sut.start()
@@ -122,8 +122,8 @@ final class ViewStateMachineTests: XCTestCase {
     let runtime = Runtime<State, Event, Output>()
       .map(output: .o1, to: { Event.e2 })
 
-    let sequence = AsyncStateMachineSequence(stateMachine: stateMachine, runtime: runtime)
-    let sut = ViewStateMachine(asyncStateMachineSequence: sequence)
+    let sequence = AsyncStateMachine(stateMachine: stateMachine, runtime: runtime)
+    let sut = ViewStateMachine(asyncStateMachine: sequence)
 
     Task {
       await sut.start()
@@ -159,8 +159,8 @@ final class ViewStateMachineTests: XCTestCase {
     let runtime = Runtime<State, Event, Output>()
       .map(output: .o1, to: { Event.e2 })
 
-    let sequence = AsyncStateMachineSequence(stateMachine: stateMachine, runtime: runtime)
-    let sut = ViewStateMachine(asyncStateMachineSequence: sequence)
+    let sequence = AsyncStateMachine(stateMachine: stateMachine, runtime: runtime)
+    let sut = ViewStateMachine(asyncStateMachine: sequence)
 
     Task {
       await sut.start()
@@ -196,8 +196,8 @@ final class ViewStateMachineTests: XCTestCase {
     let runtime = Runtime<State, Event, Output>()
       .map(output: .o1, to: { Event.e2 })
 
-    let sequence = AsyncStateMachineSequence(stateMachine: stateMachine, runtime: runtime)
-    let sut = ViewStateMachine(asyncStateMachineSequence: sequence)
+    let sequence = AsyncStateMachine(stateMachine: stateMachine, runtime: runtime)
+    let sut = ViewStateMachine(asyncStateMachine: sequence)
 
     Task {
       await sut.start()
@@ -224,8 +224,8 @@ final class ViewStateMachineTests: XCTestCase {
         eventWasReceived.fulfill()
       })
 
-    let sequence = AsyncStateMachineSequence(stateMachine: stateMachine, runtime: runtime)
-    let sut = ViewStateMachine(asyncStateMachineSequence: sequence)
+    let sequence = AsyncStateMachine(stateMachine: stateMachine, runtime: runtime)
+    let sut = ViewStateMachine(asyncStateMachine: sequence)
 
     Task {
       await sut.start()
@@ -259,8 +259,8 @@ final class ViewStateMachineTests: XCTestCase {
         eventWasReceived.fulfill()
       })
 
-    let sequence = AsyncStateMachineSequence(stateMachine: stateMachine, runtime: runtime)
-    let sut = ViewStateMachine(asyncStateMachineSequence: sequence)
+    let sequence = AsyncStateMachine(stateMachine: stateMachine, runtime: runtime)
+    let sut = ViewStateMachine(asyncStateMachine: sequence)
 
     Task {
       await sut.start()
@@ -299,8 +299,8 @@ final class ViewStateMachineTests: XCTestCase {
         eventWasReceived.fulfill()
       })
 
-    let sequence = AsyncStateMachineSequence(stateMachine: stateMachine, runtime: runtime)
-    let sut = ViewStateMachine(asyncStateMachineSequence: sequence)
+    let sequence = AsyncStateMachine(stateMachine: stateMachine, runtime: runtime)
+    let sut = ViewStateMachine(asyncStateMachine: sequence)
 
     Task {
       await sut.start()
@@ -343,8 +343,8 @@ final class ViewStateMachineTests: XCTestCase {
         eventWasReceived.fulfill()
       })
 
-    let sequence = AsyncStateMachineSequence(stateMachine: stateMachine, runtime: runtime)
-    let sut = ViewStateMachine(asyncStateMachineSequence: sequence)
+    let sequence = AsyncStateMachine(stateMachine: stateMachine, runtime: runtime)
+    let sut = ViewStateMachine(asyncStateMachine: sequence)
 
     Task {
       await sut.start()