reasonml.github.io | Reason 's documentation site | Proxy library

There's some interesting proposals for erased type unions, allowing for Typescript-style anonymous union constraints.

You have to specify that the string is unicode at the point of creation, not at the point of use:

Have you checked float_of_string_opt ? This function has type string => option(float) if a error occured it will be None

Or you can do

There are several different problems here:

1. You use an identifier called document in the last line, but have not defined any such identifier. Instead you have assigned the name dom to reference document on the JavaScript side. The last line should therefore be let tag = dom |> get_by_id("main");.

2. This will unfortunately still not work in "Try Reason", however, because it runs the code in a Web Worker which does not have access to document.

3. Sketch.sh does not use BuckleScript and therefore does not understand BuckleScript FFI annotations. You can however use https://nit.sketch.sh/, which does.

Looks like they screwed up the precedence of -> so that it's actually interpreted as

BuckleScript removes a prefixed underscore character from reserved words when compiling to JavaScript, so you can name the prop _as and it will work:

The functionality exposed by the Str module is actually implemented in C, and is therefore not easily portable to JavaScript. Any JavaScript implementation of Regular Expressions would likely be significantly slower than the built-in JavaScript implementation as well.

Furthermore, providing a common interface to multiple implementations isn't trivial since Regular Expression implementations differ in more or less subtle ways and aren't fully compatible with each other. Most aren't even regular, despite the name.

There's been some discussion around how a common interface for JS and native regexes can be accomplished, but there's no obvious solution and I'm not aware that anything has been concluded. But I would think that at the very least you'd have to implement a parser that would only accept the common subset of regex syntax, before passing it on to the underlying regex engine to be parsed again, which would obviously have a notable performance impact and is non-trivial to implement.

For now, you should be able to use Js.Re for JavaScript regexes and conditional compilation in order to use Str or some other implementation natively.

Another alternative might be to compile ocaml-re to JavaScript using js-of-ocaml and then interface with that using externals. Or port the project to bsb if possible, to use it directly. That will likely increase the size of your code bundle significantly, however, and it's not particularly straightforward to accomplish.

It's very similar to React and well described in Thinking in React as

React is all about one-way data flow down the component hierarchy. It may not be immediately clear which component should own what state. This is often the most challenging part for newcomers to understand...

You should pass both handler and the state down to children from parent components. Good example can be found here.

Use [bs.as] to alias the name of the key. This will apparently not change the name of the getter which will remain _NameGet in this case but the value no longer returns undefined.