assemblyscript VS reference-types

Incidentally, it’s also what AssemblyScript uses: https://github.com/AssemblyScript/assemblyscript/blob/main/s...

Use it as a Front-End for other low-level languages.

> MHO typescript could just cut loose from its javascript compatibility. Why not compile it to wasm instead of transpiling it to javascript?

Check out AssemblyScript which is exactly that:

https://www.assemblyscript.org/

If you're curious, check out AssemblyScript, that might describe better what needs to be cut from TypeScript to make it possible to be compiled to WASM.

This is kinda the idea behind AssemblyScript, but IIRC it's more of a low-level typescript-ish syntax for WebAssembly.

https://www.assemblyscript.org/ maybe, but I'm not sure exactly what you need.

Exactly, WASM was designed to be very very lightweight... you can put a lot of logic into a very small amount of WASM, but you need a good compiler to do that, or write WASM by hand to really feel the benefit. If you just compile Go to WASM, with its GC, runtime and stdlib included in the binary, yeah it's going to be pretty heavy... Rust doesn't have a runtime but as you said, for some reason, produces relatively large binaries (not the case only in WASM by the way). Probably, the best ways to create small WASM binaries is to compile from C or from a WASM-native language like AssemblySCript (https://www.assemblyscript.org).

Well we have all the new ECMA standards that will be introduced in 5 years now. It's looking more like Java actually. its accessor and typing patterns match it the most. TypeScript has had quite the profound influence over future ECMA design. There is a not so well known project called AssemblyScript which I think has a promising future. Since future ecma standards closely resembles it and TypeScripts popularity has exploded I have a feeling it may become a real standard as well.

If you can guarantee that Typescript type hints will always be followed, you can turn it into more optimised code. Unfortunately, this means you've got to break Javascript semantics, so this means creating a new language, but people have done it. For example, AssemblyScript is a language that is designed as a strict subset of Typescript that compiles directly down to WebAssembly instead of Javascript, producing much more efficient code (most of the time). The tradeoff is that it has some slightly different semantics to Javascript, which means your existing codebase — and most of the libraries you use — will probably require some adaption before running correctly in AssemblyScript.

> It could be an interesting use case for WASM if the problem of passing data into the WASM VM cheaply (perhaps by reference) can be solved.

WASM Reference Types should hopefully solve this. The WASM working group seems to have some good momentum - so I'm hopeful this (or a similar replacement spec) will land sooner rather than later.

https://github.com/WebAssembly/reference-types/blob/master/p...

AFAIK GC is irrelevant for "direct DOM access", you would rather want to hop into the following rabbit hole:

- reference types: https://github.com/WebAssembly/reference-types/blob/master/p...

- interface types (inactive): https://github.com/WebAssembly/interface-types/blob/main/pro...

- component model: https://github.com/WebAssembly/component-model

If this looks like a mess, that's because it is. Compared to that, the current solution to go through a Javascript shim doesn't look too bad IMHO.

[1]: https://github.com/WebAssembly/proposals

A glance of the overview and spec seems to indicate that WASM will provide some primitive data types, and any GC language can build their implementation on top of it. As I understand it, it's heavily based on Reference Types[3], which allows acting on host-provided types, and is already considered part of the spec [4]. It doesn't remove the need for the 5 different runtimes to have their own GC, but it lowers the bulk that the runtimes need to carry around, and offloads some of that onto the WASM runtime instead.

[3]: https://github.com/WebAssembly/reference-types/blob/master/p...

They've talked about interface types, and added reference types, which is a stepping stone toward the GC extension proposal, which would be a stepping stone toward manipulating the DOM from the WebAssembly side, but their official roadmap page is more short-term.

Nope, WASM reference types, it has nothing to do with .NET type system.

> And there's been talk of exposing the JS GC to wasm for a few years. Hopefully when that stuff lands, it'll get easier to marshal objects across the gap.

You don't need a Wasm GC to do this. If you only need js objects to pass on to, say, the host's function or check is null or not, then reference types that are opaque external references: https://github.com/WebAssembly/reference-types/blob/master/p...

You can even do many more things if you export `Reflect` to WebAssembly: https://github.com/AssemblyScript/assemblyscript/blob/main/t...

Reference Types are available almost everywhere already (In Safari will be available after 15.0): https://webassembly.org/roadmap

Re: GC -- yes, indeed, the whole business with safepoints arose from the need to support Wasm reference types as a backend for Wasmtime or Firefox. No safepoints are needed for Rust (or other C-like) code.

Reference Types,