swift-evolution VS kotlin-wrappers

According to their changelog[0], Clock was added to the standard library with Swift 5.7, which shipped in 2022, at the same time as iOS 16. It looks like static linking by default was approved[1] but development stalled[2].

I expect that it's as simple as that: It's supported on iOS 16+ because it's dynamically linked by default, against a system-wide version of the standard library. You can probably try to statically link newer versions on old OS versions, or maybe ship a newer version of the standard library and dynamically link against that, but I have no idea how well those paths are supported.

0. https://github.com/apple/swift/blob/main/CHANGELOG.md

1. https://github.com/apple/swift-evolution/blob/main/proposals...

2. https://github.com/apple/swift-package-manager/pull/3905

[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 you want something more standard, I'd look at Kotlin Wrappers and look at examples of using react - https://github.com/JetBrains/kotlin-wrappers

Kotlin wrappers for JS.

The only reference I can find to an error boundary in Kotlin React is at QueryErrorResetBoundary.kt in the kotlin-wrappers repository. Would any of you know anything about this?

Yes! Interesting that it isn't defined in the Length.kt file (that's where I was looking for it) and is instead in its lonesome, but I guess it makes sense as it's not actually a length value. Thanks for the help!

plugins { kotlin("js") id("com.github.node-gradle.node") version "3.4.0" } kotlin { js(IR) { // let's rename it to more reusable as under that name we will access it in our boilerplate code moduleName = "stories" // browser also works fine here, we just need it for compiling purposes as of now nodejs {} // add a startup script to our package json compilations["main"].packageJson { customField( "scripts", mapOf("storybook" to "start-storybook -p 6006 -c $projectDir/.storybook --ci") ) } binaries.executable() } } tasks.named("build") { dependsOn("assemble") dependsOn("copyJsStories") } tasks.register("copyJsStories") { dependsOn("developmentExecutableCompileSync") from("$projectDir/src/main/js") into("$buildDir/compileSync/main/developmentExecutable/kotlin") // flatten all files to appear on one level eachFile { if (isDirectory) { exclude() } path = path.replace("/", ".") } } tasks.register("copyPackageJson") { dependsOn("build") from("$buildDir/tmp/publicPackageJson/package.json") into("$projectDir") } tasks.register("start") { dependsOn("build") dependsOn("npmInstall") args.addAll("run", "storybook") } tasks.named("npmInstall") { dependsOn("copyPackageJson") workingDir.set(file("$projectDir")) inputs.file("package.json") } dependencies { // dependency to the project with components implementation(project(":app")) // react dependencies to put on package.json explicitly // can resolve the actual versions on https://github.com/JetBrains/kotlin-wrappers implementation(npm("react", "^17.0.2")) implementation(npm("react-dom", "^17.0.2")) implementation(npm("react-router-dom", "^6.2.2")) // storybook specific dependencies implementation(npm("@storybook/builder-webpack5", "^6.5.9")) implementation(npm("@storybook/manager-webpack5", "^6.5.9")) implementation(npm("@storybook/node-logger", "^6.5.9")) implementation(npm("@storybook/preset-create-react-app", "^4.1.2")) implementation(npm("@storybook/react", "^6.5.9")) }

kotlin js https://github.com/JetBrains/kotlin-wrappers/tree/master/kotlin-react Multiplatform etc.

From my experience if you're truly trying to interop with JavaScript code that is already out there on npm, you better hope there is a library that already wraps it like kotlin wrappers. Otherwise you would have to write a wrapper library yourself or use dukat to convert typescript definitions to kotlin (which I have never had the best luck converting but maybe it got better?).

Everything moved to central a long back - https://github.com/JetBrains/kotlin-wrappers

It's still pretty finnicky to configure and it hasn't emerged from alpha yet, so its future isn't exactly secure, but I'm hopeful as they appear to be investing a lot of resources into it and adjacent projects, e.g. the kotlin-react library.

We already have a battle-tested integration with react (it's used inside jetbrains.space) -- https://github.com/JetBrains/kotlin-wrappers And, take a look at docs and hands-on.