- I changed the API because I like to use the word value in other parts of my code and I ended up using value.value and it made me sad.

  - value -> raw
  - valueObservable -> observable
  - valueStream -> stream

Author: meech-ward

CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to AsyncObservable will be documented in this file.
 
+## [0.3.0] - 2025-03-08
+
+### Changed
+- I changed the API because I like to use the word "value" in other parts of my code and I ended up using "value.value" and it made me sad.
+  - value -> raw
+  - valueObservable -> observable
+  - valueStream -> stream
+
 ## [0.2.1] - 2025-03-07
 
 ### Added

README.md

@@ -10,9 +10,9 @@ The API is probably stable. Let me know if the API should change, otherwise this
 
 ```swift
 // values
-asyncObservable.value
-asyncObservable.valueStream
-asyncObservable.valueObservable
+asyncObservable.raw
+asyncObservable.stream
+asyncObservable.observable
 
 // updates
 asyncObservable.update(2)
@@ -37,17 +37,17 @@ actor Something {
 }
 
 let something = Something()
-something.someProperty.value // "Hello, world!"
+something.someProperty.raw // "Hello, world!"
 
-for await value in something.someProperty.valueStream {
+for await value in something.someProperty.stream {
   print(value) // hello world (then whatever the property is updated to)
 }
 
 
 struct SomethingView: View {
   let something: Something // Note: someProperty should be marked with @MainActor for this to work as is
   var body: some View {
-    Text(something.someProperty.valueObservable) // hello world (then whatever the property is updated to)
+    Text(something.someProperty.observable) // hello world (then whatever the property is updated to)
   }
 }
 ```
@@ -59,7 +59,7 @@ The streams buffering policy defaults to `.unbounded`, so it will "gather" value
 ```swift
 let someProperty = AsyncObservable(1)
 
-let stream = someProperty.valueStream // already has 1
+let stream = someProperty.stream // already has 1
 someProperty.update { $0 + 1 } // 2
 someProperty.update { $0 + 1 } // 3
 someProperty.update { $0 + 1 } // 4
@@ -74,7 +74,7 @@ Canceling the task that the stream is running in will cancel the stream. So you
 ```swift
 let someProperty = AsyncObservable(1)
 
-let stream = someProperty.valueStream // already has 1
+let stream = someProperty.stream // already has 1
 let task = Task {
   for await value in stream {
     print(value) // 1, 2, 3
@@ -93,7 +93,7 @@ Streams are finalized as soon as you break out of the loop, so you can't reuse t
 ```swift
 let someProperty = AsyncObservable(1)
 
-let stream = someProperty.valueStream // already has 1
+let stream = someProperty.stream // already has 1
 // only print first value
 for await value in stream {
   print(value) // 1
@@ -106,7 +106,7 @@ for await value in stream {
 }
 
 // do this ✅
-for await value in someProperty.valueStream {
+for await value in someProperty.stream {
 
 }
 ```

Sources/AsyncObservable/AsyncObservable.swift

@@ -71,22 +71,22 @@ open class AsyncObservable<T: Sendable>: AsyncObservableReadOnly, @unchecked Sen
   /// The observable state object for SwiftUI/UIKit integration.
   /// This property is accessed on the MainActor to ensure thread-safe UI updates.
   @MainActor
-  public lazy var observable: State = {
-    let observable = State(value: value, didSetValue: didUpdateFromObservable)
-    return observable
+  public lazy var observableState: State = {
+    let observableState = State(value: raw, didSetValue: didUpdateFromObservable)
+    return observableState
   }()
 
   /// The current value accessible from the MainActor.
   /// This is a convenience property that provides direct access to the observable value.
   @MainActor
-  public var valueObservable: T {
-    observable.value
+  public var observable: T {
+    observableState.value
   }
 
   /// An async stream of values that can be used with Swift concurrency.
   /// This property provides a convenient way to access the value stream without calling `stream()`.
-  public var valueStream: StreamOf<T> {
-    stream()
+  public var stream: StreamOf<T> {
+    streamOf()
   }
 
   /// Storage for active stream continuations, keyed by UUID to allow multiple observers
@@ -95,13 +95,13 @@ open class AsyncObservable<T: Sendable>: AsyncObservableReadOnly, @unchecked Sen
 
   /// The current value managed by this instance.
   /// Updates to this value are automatically propagated to all observers.
-  private var _value: T
-  public private(set) var value: T {
+  private var _raw: T
+  public private(set) var raw: T {
     get {
-      serialQueue.sync { _value }
+      serialQueue.sync { _raw }
     }
     set {
-      serialQueue.sync { _value = newValue }
+      serialQueue.sync { _raw = newValue }
     }
   }
   private var _shouldUpdateFromObservable = true
@@ -137,7 +137,7 @@ open class AsyncObservable<T: Sendable>: AsyncObservableReadOnly, @unchecked Sen
     }
     DispatchQueue.main.async {
       self.shouldUpdateFromObservable = false
-      self.observable.value = value
+      self.observableState.value = value
       self.shouldUpdateFromObservable = true
     }
   }
@@ -164,7 +164,7 @@ open class AsyncObservable<T: Sendable>: AsyncObservableReadOnly, @unchecked Sen
     serialQueue: DispatchQueue = DispatchQueue(label: "AsyncObservable")
   )
   {
-    _value = initialValue
+    _raw = initialValue
     self.bufferingPolicy = bufferingPolicy
     self.serialQueue = serialQueue
   }
@@ -189,7 +189,7 @@ open class AsyncObservable<T: Sendable>: AsyncObservableReadOnly, @unchecked Sen
   ///   - notifyObservers: Whether to notify stream observers (default: true)
   ///   - updateObservable: Whether to update the observable state (default: true)
   public func update(_ value: T, notifyObservers: Bool = true, updateObservable: Bool = true) {
-    self.value = value
+    self.raw = value
     updated(value, notifyObservers: notifyObservers, updateObservable: updateObservable)
   }
 
@@ -202,7 +202,7 @@ open class AsyncObservable<T: Sendable>: AsyncObservableReadOnly, @unchecked Sen
   public func update(
     _ cb: @escaping (_ value: T) -> (T), notifyObservers: Bool = true, updateObservable: Bool = true
   ) {
-    let newValue = cb(value)
+    let newValue = cb(raw)
     update(newValue, notifyObservers: notifyObservers, updateObservable: updateObservable)
   }
 
@@ -217,9 +217,9 @@ open class AsyncObservable<T: Sendable>: AsyncObservableReadOnly, @unchecked Sen
     updateObservable: Bool = true
   ) {
     serialQueue.sync {
-      cb(&_value)
+      cb(&_raw)
     }
-    updated(value, notifyObservers: notifyObservers, updateObservable: updateObservable)
+    updated(raw, notifyObservers: notifyObservers, updateObservable: updateObservable)
   }
 
   /// Internal helper to manage stream continuations
@@ -237,7 +237,7 @@ open class AsyncObservable<T: Sendable>: AsyncObservableReadOnly, @unchecked Sen
   /// The stream immediately yields the current value and then yields all subsequent updates.
   ///
   /// - Returns: A StreamOf<T> instance that can be used with async/await code
-  private func stream() -> StreamOf<T> {
+  private func streamOf() -> StreamOf<T> {
     let id = UUID()
     return StreamOf<T>(
       bufferingPolicy: bufferingPolicy,
@@ -248,7 +248,7 @@ open class AsyncObservable<T: Sendable>: AsyncObservableReadOnly, @unchecked Sen
       builder: { [weak self] continuation in
         guard let self else { return }
         self.setContinuation(id: id, continuation: continuation)
-        continuation.yield(self.value)
+        continuation.yield(self.raw)
       })
   }
 }

Sources/AsyncObservable/AsyncObservableReadOnly.swift

@@ -9,20 +9,15 @@ public protocol AsyncObservableReadOnly<T>: Sendable {
     /// The type of value being observed.
     associatedtype T: Sendable
 
-    /// The observable state object for SwiftUI/UIKit integration.
-    /// This property is accessed on the MainActor to ensure thread-safe UI updates.
-    @MainActor
-    var observable: AsyncObservable<T>.State { get }
-
     /// The current value accessible from the MainActor.
     /// This is a convenience property that provides direct access to the observable value.
     @MainActor
-    var valueObservable: T { get }
+    var observable: T { get }
 
     /// An async stream of values that can be used with Swift concurrency.
     /// This property provides a convenient way to access the value stream.
-    var valueStream: StreamOf<T> { get }
+    var stream: StreamOf<T> { get }
 
     /// The current value managed by this instance.
-    var value: T { get }
+    var raw: T { get }
 } 

Tests/AsyncObservableTests/AdvancedBehaviorTests.swift

@@ -12,9 +12,9 @@ struct AsyncObservableAdvancedTests {
 
     var receivedValues = [Int]()
 
-    let valueStream = observable.valueStream
+    let stream = observable.stream
     let task = Task {
-      for await value in valueStream {
+      for await value in stream {
         receivedValues.append(value)
         if receivedValues.count >= 4 {
           break
@@ -33,7 +33,7 @@ struct AsyncObservableAdvancedTests {
 
     // We should have received values in the correct sequence
     #expect(receivedValues == [0, 1, 2, 3])
-    #expect(observable.value == 3)
+    #expect(observable.raw == 3)
   }
 
   @Test("Should handle custom buffering policies")
@@ -51,7 +51,7 @@ struct AsyncObservableAdvancedTests {
 
     var unboundedValues = [Int]()
     let unboundedTask = Task {
-      for await value in unboundedObservable.valueStream {
+      for await value in unboundedObservable.stream {
         unboundedValues.append(value)
         if unboundedValues.count >= 10 {
           break // Important to break the loop
@@ -78,7 +78,7 @@ struct AsyncObservableAdvancedTests {
 
     var noBufferValues = [Int]()
     let noBufferTask = Task {
-      for await value in noBufferObservable.valueStream {
+      for await value in noBufferObservable.stream {
         noBufferValues.append(value)
         break // Break immediately after first value
       }
@@ -98,11 +98,11 @@ struct AsyncObservableAdvancedTests {
     let observable = AsyncObservable(0)
 
     var receivedValues = [Int]()
-    let valueStream = observable.valueStream
+    let stream = observable.stream
 
     // Set up a task that will perform updates when specific values are observed
     let updateTask = Task {
-      for await value in valueStream {
+      for await value in stream {
         receivedValues.append(value)
 
         // When we see value 2, trigger an update to 10
@@ -138,7 +138,7 @@ struct AsyncObservableAdvancedTests {
     #expect(receivedValues.contains(20))
 
     // Final value should be 20
-    #expect(observable.value == 20)
+    #expect(observable.raw == 20)
   }
 
   @Test("Should handle value cycling and detection of duplicate updates")
@@ -147,10 +147,10 @@ struct AsyncObservableAdvancedTests {
     let observable = AsyncObservable(0)
 
     var receivedValues = [Int]()
-    let valueStream = observable.valueStream
+    let stream = observable.stream
 
     // Consume initial value
-    for await value in valueStream {
+    for await value in stream {
       receivedValues.append(value)
       break
     }
@@ -161,7 +161,7 @@ struct AsyncObservableAdvancedTests {
     // Create a task to collect values
     let task = Task {
       var count = 0
-      for await value in valueStream {
+      for await value in stream {
         receivedValues.append(value)
         count += 1
         if count >= updatedValues.count {
@@ -198,21 +198,21 @@ struct AsyncObservableAdvancedTests {
     let observable = AsyncObservable(10)
 
     // Get initial value
-    let initialValue = observable.value
+    let initialValue = observable.raw
     #expect(initialValue == 10)
 
     // Verify we can update normally
     observable.update(30)
-    #expect(observable.value == 30)
+    #expect(observable.raw == 30)
 
     // Test that value updates correctly through different methods
     observable.update(40)
-    #expect(observable.value == 40)
+    #expect(observable.raw == 40)
 
     observable.update { current in current + 5 }
-    #expect(observable.value == 45)
+    #expect(observable.raw == 45)
 
     observable.mutate { value in value += 5 }
-    #expect(observable.value == 50)
+    #expect(observable.raw == 50)
   }
 } 

Tests/AsyncObservableTests/BasicTests.swift

@@ -7,9 +7,9 @@ struct AsyncObservableBasicTests {
 
   @available(iOS 17.0, macOS 14.0, tvOS 17.0, watchOS 10.0, *)
   private func ensureValue<T: Equatable>(_ value: T, asyncObservable: AsyncObservable<T>) async {
-    #expect(asyncObservable.value == value)
-    await #expect(asyncObservable.valueObservable == value)
-    for await value in asyncObservable.valueStream {
+    #expect(asyncObservable.raw == value)
+    await #expect(asyncObservable.observable == value)
+    for await value in asyncObservable.stream {
       #expect(value == value)
       break
     }
@@ -30,10 +30,10 @@ struct AsyncObservableBasicTests {
     let observable = AsyncObservable(0)
     let newValue = 100
 
-    let valueStream = observable.valueStream
+    let stream = observable.stream
     observable.update(newValue)
-    await #expect(valueStream.first { _ in true } == 0)
-    await #expect(valueStream.first { _ in true } == newValue)
+    await #expect(stream.first { _ in true } == 0)
+    await #expect(stream.first { _ in true } == newValue)
 
     await ensureValue(newValue, asyncObservable: observable)
   }
@@ -43,12 +43,12 @@ struct AsyncObservableBasicTests {
   func testTransformUpdate() async {
     let observable = AsyncObservable(10)
 
-    let valueStream = observable.valueStream
+    let stream = observable.stream
     observable.update { currentValue in
       return currentValue * 2
     }
-    await #expect(valueStream.first { _ in true } == 10)
-    await #expect(valueStream.first { _ in true } == 20)
+    await #expect(stream.first { _ in true } == 10)
+    await #expect(stream.first { _ in true } == 20)
     await ensureValue(20, asyncObservable: observable)
   }
 
@@ -57,14 +57,14 @@ struct AsyncObservableBasicTests {
   func testMutateValue() async {
     let observable = AsyncObservable([1, 2, 3])
 
-    let valueStream = observable.valueStream
+    let stream = observable.stream
     observable.mutate { value in
       value.append(4)
     }
-    await #expect(valueStream.first { _ in true } == [1, 2, 3])
-    await #expect(valueStream.first { _ in true } == [1, 2, 3, 4])
+    await #expect(stream.first { _ in true } == [1, 2, 3])
+    await #expect(stream.first { _ in true } == [1, 2, 3, 4])
 
-    #expect(observable.value == [1, 2, 3, 4])
-    await #expect(observable.valueObservable == [1, 2, 3, 4])
+    #expect(observable.raw == [1, 2, 3, 4])
+    await #expect(observable.observable == [1, 2, 3, 4])
   }
 }