swift-evolution VS swift

[A Vision for Embedded Swift](https://github.com/apple/swift-evolution/blob/main/visions/e...) has the details on this new build mode and is quite interesting.

> Effectively, there will be two bottom layers of Swift, and the lower one, “non-allocating” Embedded Swift, will necessarily be a more restricted compilation mode (e.g. classes will be disallowed as they fundamentally require heap allocations) and likely to be used only in very specialized use cases. “Allocating” Embedded Swift should allow classes and other language facilities that rely on the heap (e.g. indirect enums).

Also, this seems to maybe hint at the Swift runtime eventually being reimplemented in non-allocating Embedded Swift rather than the C++ (?) that it uses now:

> The Swift runtime APIs will be provided as an implementation that’s optimized for small codesize and will be available as a static library in the toolchain for common CPU architectures. Interestingly, it’s possible to write that implementation in “non-allocating” Baremetal Swift.

I may be out of my depth here as I've only casually used Rust, but this seems similar to Swift's proposed lifetime dependencies[1]. They're not in the type system formally so maybe they're closer to poloneius work

[1]: https://github.com/apple/swift-evolution/blob/3055becc53a3c3...

Swift recently adopted a region-based approach for safe concurrency that builds on Milano et al’s ideas: https://github.com/apple/swift-evolution/blob/main/proposals...

No, it's not. Refcounting CAN be a garbage collection algorithm, but in Swift it's deterministic and done at compile time. Not to mention recently added support for non-copyable types that enforces unique ownership: https://github.com/apple/swift-evolution/blob/main/proposals...

You can stackallocate buffers with unsafe Swift but it's not exactly fun to use. https://github.com/apple/swift-evolution/blob/main/proposals/0322-temporary-buffers.md

If the docs do not suffice, read the concurrency proposals of Swift Evolution. The authors describe the semantics in a very detailed way there.

Because of C/C++ interop, and integration with CMake, you can just add Swift to a Zephyr project and it pretty much Just Works. [The docs](https://github.com/apple/swift/blob/main/docs/EmbeddedSwift/...) should mostly apply to the Zephyr SDK as well.

Fortunately, the Observation framework is part of the Swift 5.9 standard library. We can learn more information by examining its source code.

They do! See https://github.com/apple/swift/blob/main/docs/LibraryEvoluti...

You can also see an example of what a different high level language integration with Swift ABI looks like here: https://github.com/dotnet/designs/blob/main/proposed/swift-i...

So is differentiable Swift a package for Swift or is it part of the Swift standard library? The video says go to swift.org but I can't find any info about differentiable Swift on that site.

Swift's Differentiable Programming Manifesto. Swift has a powerful differentiable programming component, integrated with the compiler.

You can do the same thing the other way around - https://github.com/apple/swift/blob/main/docs/Android.md.

Codable (along with other derived conformances like Equatable, Hashable, and RawRepresentable) is indeed built in to the compiler[0], but unlike Serde, it operates during type-checking on a fully-constructed AST (with access to type information), manipulating the AST to insert code. Because it operates at a later stage of compilation and at a much higher level (with access to type information), the work necessary is significantly less.

With ongoing work for Swift macros, it may eventually be possible to rip this code out of the compiler and rewrite it as a macro, though it would need to be a semantic macro[1] rather a syntactic one, which isn't currently possible in Swift[2].

[0] https://github.com/apple/swift/blob/main/lib/Sema/DerivedCon...

`Int` is a regular struct with a single stored property of type `Builtin.Word` . But the latter is a magical compiler built-in. Source for integer types is generated from this template - https://github.com/apple/swift/blob/9da65ca0a15fdf341649c994b0a77ec3b71f2687/stdlib/public/core/IntegerTypes.swift.gyb