Swiftpack.co - Swift Packages by codeface-io

The markdown parsing is broken/disabled for release notes. Sorry about that, I'm chasing the source of a crash that's been bringing this website down for the last couple of days. Avoids compiling code of the CombineObserver library on Linux since Combine is unavailable there Fixes compile issues on iOS, tvOS and watchOS Fixes the unstable version of the dependence on SwiftyToolz This update lets go of some hard-earned features in favour of simplicity and shifts focus to native Swift features that have recently filled some gaps. 7.0.0 also expresses a renewed commitment to semantic versioning, in particular since SwiftObserver has moved to the [Codeface GitHub organization](https://github.com/codeface-io). ## Removed - `Promise` has been removed as any Promise/Future implementation is obsolete with Swift's latest native concurrency features. - "One-shot" observations have been removed, as their primary purpose was to enable `Promise`. - `FreeObserver` and "global" observations have been removed, since they undermined the memory management concept without much benefit - Any value type-specific extensions of `Var<Value>` have been removed, as the property wrapper now fulfills their purpose. - Cocoapods support has been dropped. ## Changed - Protocol `Observable` has been renamed to `ObservableObject` so the new property wrapper could be conveniently named `Observable` and because the protocol is actually a class protocol. - Author filters `from` and `notFrom` require **non**-optional `AnyAuthor`. ## Improved - Variable values don't need to be `Codable` anymore. `Var<Value>` remains `Codable` where `Value` is. - Many small refinements, more or less under the hood. ## Added - Property wrapper `Observable` allows to make any `var: Value` observable by storing it in a wrapped `Var<Value>`. - CombineObserver is a new library product of the SwiftObserver package, offering conversion of SwiftObserver's `ObservableObject`s into Combine `Publisher`s. New functions on `Promise<Value>` that return a mapped new `Promise<MappedValue>`: * `map(...)` * `unwrap(default)` * `new()` All that's new is also compatible with message authors and ad-hoc transform chains: * Promises: * `Promise<Value>` is a `Messenger<Value>` with some conveniences for async returns * Promise composition functions `promise`, `then` and `and` * Free Observers: * Class for adhoc observers `FreeObserver` * Global function `observe(...)`, and `observed(...)` on observables, both use `FreeObserver.shared` * Global function `observeOnce(...)`, and `observedOnce(...)` on observables, both use `FreeObserver` * `BufferedObservable`: * `BufferedObservable` has been renamed to `ObservableCache`. * `ObservableCache` can be created via observable transform `cache()`, which makes `Message` optional only when necessary. * `whenCached` retrieves non-optional message from caches that have optional `Message`. * Observables can stop their observations via `stopBeingObserved()` and `stopBeingObserved(by: observer)`. * `Weak` is available as observable transform `weak()` and is generally a regular transform object. * All transforms have mutable property `origin` which is the underlying observable whose messages get transformed. * It's possible for an observer to do multiple simultaneous observations of the same observable. * Memory management is new: * Before 6.0, memory leaks were *technically* impossible, because SwiftObserver still had a handle on dead observers, and you could flush them out when you wanted "to be sure". Now, dead observations are actually impossible and you don't need to worry about them. * Observers now automatically clean up when they die, so a call of `stopObserving()` in deinit can now be omitted. Observers can still call `stopObserving(observable)` and `stopObserving()` if they want to manually end observations. * `Observer` now has one protocol requirement, which is typically implemented as `let connections = Connections()`. The `connections` object keeps the `Observer`s observations alive. * A few memory management functions were removed since they were overkill and are definitely unnecessary now. * The new design scales better and should be more performant with ginormous amounts of observers and observables. * The `Observable` protocol has become simpler. * The requirement `var latestMessage: Message {get}` is gone. * No more message duplication in messengers since the `latestMessage` requirement is limited to `BufferedObservable`s. And so, switching buffering on or off on messengers is also no more concern. * Message buffering now happens exactly whenever it is really possible, that is whenever the observable is backed by an actual value (like variables are) and there is no filter involved in the observable. Filters annihilate random access pulling. The weirdness of a mapping having to ignore its filter in its implementation of `latestMessage` is gone. * `Observable` just requires one `Messenger`. * All observables are now implemented the same way and are thereby on equal footing. You could now easily reimplement `Var` and benefit from the order maintaining message queue of `Messenger`. * Custom observables are simpler to implement: * The protocol is the familiar `Observable`. No more separate `CustomObservable`. * The `typealias Message = MyMessageType` can now be omitted. * The need to use optional message types to be able to implement `latestMessage` is gone. * Observers can optionally receive the author of a message via an alternative closure wherever they normally pass in a message handler, even in combined observations. And observables can optionally attach an author other than themselves to a message, if they want to. * This major addition breaks no existing code and the author argument is only present when declared in the observer's message handler or the observable's `send` function. * This is hugely beneficial when observing shared mutable states like the repository / store pattern, really any storage abstraction, classic messengers (notifiers) and more. * Most importantly, an observer can now ignore messages that he himself triggered, even when the trigger was indirect. This avoids redundant and unintended reactions. * The internals are better implemented and more readable. * No forced unwraps for the unwrap transforms * No weird function and filter compositions * No more unnecessary indirection and redundance in adhoc observation transforms * Former "Mappings" are now separated into the three simple composable transforms: map, filter and unwrap. * The number of lines has only slightly increased because lots of complexity could be removed. * The `ObservableObject` base class is gone. * Other consistency improvements and features: * An observer can now check whether it is observing an observable via `observer.isObserving(observable)`. * Stand-alone and ad hoc transforms now also include an `unwrap()` transform that requires no default message. * Message order is maintained for all observables, not just for variables. All observables use a message queue now. * The source of transforms cannot be reset as it was the case for mappings. As a nice side effect, the question whether a mapping fires when its source is reset is no concern anymore. * `Change<Value>` is more appropriately named `Update<Value>` since its properties `old` and `new` can be equal. * `Update` is `Equatable` when its `Value` is `Equatable`, so messages of variables can be selected via `select(Update(specificOldValue, specificNewValue))` or any specific value update you define. * The issue that certain Apple classes (like NSTextView) cannot directly be `Observable` because they can't be referenced weakly is gone. SwiftObserver now only references an `Observable`'s `messenger` weakly. * Removed - Variable string assignment operator - Variable number assignment operators * Changed - Reworked Documentation * Added - SPM Support - Gitter chat * **Renamings:** * Some memory management functions have been renamed to be more consistent with the overall terminology. * The type `Observable.Update` has been renamed to `Observable.Message`. * **Non-optional generic types:** Variables and messengers do no longer add implicit optionals to their generic value and message types. This makes it possible to create variables with non-optional values and the code is more explicit and consistent. * You can still initialize variables and messengers without argument, when you choose to make their value or message type optional. * **Dedicated observer pools:** All *observables* now maintain their own dedicated pool of *observers*. This improves many aspects: * All *observables* get highest performance * The whole API is more consistent * Custom *observable* implementations are more expressive and customizable * Memory management is easier as all *observables*, when they die, stop their observations * **Meaningful custom observables:** Custom *observables* now adopt the `CustomObservable` protocol. And they provide a `Messenger<Message>` instead of the `latestUpdate`. * As long as Swift can't infer the type, you'll also have to specify the associated `Message` type. * **Consistent variables:** * The operators on string- and number variables now work on all combinations of optional and non-optional generic and main types. For instance, string concatenation via `+` works on all pairs of `String`, `String?`, `Var<String>`, `Var<String?>`, `Var<String>?` and `Var<String?>?`. * All variables with values of type `String`, `Int`, `Float` and `Double` also have a non-optional property that is named after the value type (`string`, `int` ...). * Added class `Messenger` * Added class `ObservabeObject` as a mostly internally used abstract base class for *observables*. `Var`, `Mapping` and `Messenger` now derive from `ObservableObject`.

The markdown parsing is broken/disabled for release notes. Sorry about that, I'm chasing the source of a crash that's been bringing this website down for the last couple of days. This update turns the former edge count into a proper generically typed edge weight, whereby `Graph` and `GraphEdge` each gain another type parameter. This, of course, is a breaking change, and all tests had to be adjusted. **New or Changed:** * More consistent and powerful API (includes renames, removals and additions) * Subscript access to graph values * func to remove node * No more node id determination closure, neither in API nor internally * value map function that creates a new graph with a mapped value type * edge-, value- and node filters – each as a mutating and a copying variant * graph is conditionally `Codable` * graphs can be expressed as `Dictionary` literals and certain ones as `Array` literals **New or Changed:** * Many API changes, including added, removed and renamed functions * Algorithms to find and filter essential edges * `Sendable` conformance is conditional * Algorithm APIs refers to nodes and edges by ID instead of full value * Some API types are opaque * Loads of new tests * New initializers to create complete graphs with edges * Graphs are conditionally `Equatable` * Nodes in graphs no longer have an order and can not be sorted anymore * Correct counts returned by ancestor counts algorithm * Algorithm to find transitive edges (the edges that are not in the transitive reduction) * Four functions to filter by edges * Since 0.4.0, Graph is `Sendable`. Now that is documented. Fixes compile issues on iOS, tvOS and watchOS Since SwiftNodes is intended as true open-source software, its dependency versions must be stable so it can itself be a stable dependency. Cleans up the API by renaming some stuff. Also adds 2 convenience functions. This is the beginning of a commitment to semantic versioning. See <https://github.com/codeface-io/SwiftNodes#development-status> for details.

The markdown parsing is broken/disabled for release notes. Sorry about that, I'm chasing the source of a crash that's been bringing this website down for the last couple of days. Fixes compile issues on iOS, tvOS and watchOS ### Changed * Packet handler closure must be passed to initializer of `LSP.ServerExecutable` * Dependency versions in Package.swift file have been stabilized ### Added * `LSP.PacketDetector` convenience func for reading single Bytes * Shorthand type aliases `LSP.Request`, `LSP.Response`, `LSP.ErrorResult` and `LSP.Notification` * Loads of documentation This is the beginning of a commitment to semantic versioning. See <https://github.com/codeface-io/SwiftLSP#development-status> for details.

The markdown parsing is broken/disabled for release notes. Sorry about that, I'm chasing the source of a crash that's been bringing this website down for the last couple of days. Since LSPServiceKit is intended as true open-source software, its dependency versions must be stable so it can itself be a stable dependency. This is the beginning of a commitment to semantic versioning. See <https://github.com/codeface-io/LSPServiceKit#development-status> for details.