You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
Copy file name to clipboardExpand all lines: CHANGELOG.md
+87Lines changed: 87 additions & 0 deletions
Display the source diff
Display the rich diff
Original file line number
Diff line number
Diff line change
@@ -5,6 +5,91 @@ _**Note:** This is in reverse chronological order, so newer entries are added to
5
5
6
6
## Swift 5.7
7
7
8
+
*[SE-0338][]:
9
+
10
+
Non-isolated async functions now always execute on the global concurrent pool,
11
+
so calling a non-isolated async function from actor-isolated code will leave
12
+
the actor. For example:
13
+
14
+
```swift
15
+
classC { }
16
+
17
+
funcf(_: C) async { /* always executes on the global concurrent pool */ }
18
+
19
+
actorA {
20
+
funcg(c: C) async {
21
+
/* always executes on the actor */
22
+
print("on the actor")
23
+
24
+
awaitf(c)
25
+
}
26
+
}
27
+
```
28
+
29
+
Prior to this change, the call from `f` to `g` might have started execution of
30
+
`g` on the actor, which could lead to actors being busy longer than strictly
31
+
necessary. Now, the non-isolated async function will always hop to the global
32
+
cooperative pool, not run on the actor. This can result in a behavior change
33
+
for programs that assumed that a non-isolated async function called from a
34
+
`@MainActor` context will be executed on the main actor, although such
35
+
programs were already technically incorrect.
36
+
37
+
Additionally, when leaving an actor to execution on the global cooperative
38
+
pool, `Sendable` checking will be performed, so the compiler will emit a
39
+
diagnostic in the call to `f` if `c` is not of `Sendable` type.
40
+
41
+
*[SE-0353][]:
42
+
43
+
Protocols with primary associated types can now be used in existential types,
44
+
enabling same-type constraints on those associated types.
45
+
46
+
```
47
+
let strings: any Collection<String> = [ "Hello" ]
48
+
```
49
+
50
+
Note that language features requiring runtime support like dynamic casts
51
+
(`is`, `as?`, `as!`), as well as generic usages of parameterized existentials
52
+
in generic types (e.g. `Array<any Collection<Int>>`) involve additional
53
+
availability checks to use. Back-deploying usages in generic position can be
54
+
worked around with a generic type-erasing wrapper struct, which is now much
55
+
simpler to implement:
56
+
57
+
```swift
58
+
structAnyCollection<T> {
59
+
var wrapped: anyCollection<T>
60
+
}
61
+
62
+
let arrayOfCollections: [AnyCollection<T>] = [ /**/ ]
63
+
```
64
+
65
+
*[SE-0329][]:
66
+
New types representing time and clocks were introduced. This includes a protocol `Clock` defining clocks which allow for defining a concept of now and a way to wake up after a given instant. Additionally a new protocol `InstantProtocol` for defining instants in time was added. Furthermore a new protocol `DurationProtocol` was added to define an elapsed duration between two given `InstantProtocol` types. Most commonly the `Clock` types for general use are the `SuspendingClock` and `ContinuousClock` which represent the most fundamental clocks for the system. The `SuspendingClock` type does not progress while the machine is suspended whereas the `ContinuousClock` progresses no matter the state of the machine.
67
+
68
+
*[SE-0309][]:
69
+
70
+
Protocols with associated types and `Self` requirements can now be used as the
71
+
types of values with the `any` keyword.
72
+
73
+
Protocol methods that return associated types can be called on an `any` type;
74
+
the result is type-erased to the associated type's upper bound, which is another
75
+
`any` type having the same constraints as the associated type. For example:
`Clock` also has methods to measure the elapsed duration of the execution of work. In the case of the `SuspendingClock` and `ContinuousClock` this measures with high resolution and is suitable for benchmarks.
85
+
86
+
```swift
87
+
let clock =ContinuousClock()
88
+
let elapsed = clock.measure {
89
+
someLongRunningWork()
90
+
}
91
+
```
92
+
8
93
* References to `optional` methods on a protocol metatype, as well as references to dynamically looked up methods on the `AnyObject` metatype are now supported. These references always have the type of a function that accepts a single argument and returns an optional value of function type:
0 commit comments