
Relit: Typed Literal Macros for Reason - wcrichton
https://github.com/cyrus-/relit
======
kbd
Could anyone please compare Reason and Elm? I tried Elm for a while but felt
really constrained, and strongly disliked feeling trapped in its bubble.

~~~
riwsky
for better or for worse, there is much less of a Reason bubble to be trapped
in. The foreign function interface of the bucklescript compiler
(Reason/Ocaml->js) makes for a much more gradual boundary between javascript
and Reason code than that between js and Elm, a difference that flows
naturally out of the different language designs: OCaml is multi-paradigmatic,
sporting mutability and an object system, whereas Elm tries to help the user
(e.g. via better isolation/prevention of errors) by sticking to one paradigm.

Even within the functional paradigm, OCaml offers all the tools Elm does
(leading to re-implementations of elm structures like
[https://github.com/OvermindDL1/bucklescript-
tea](https://github.com/OvermindDL1/bucklescript-tea) ), and more — the module
system is the biggest one to come to mind, but library authors have even found
client-side uses for esoterica like phantom types (ensuring certain safe usage
patterns without runtime costs).

Bubbles can be nice, though! For example, some people are confused by the fact
that there is a "beta" standard library in addition to the one that Reason
ships with - and that at least one popular (arguably the most popular) book on
OCaml — "Real World OCaml" uses a third standard library which is neither of
those. One can debate how much of a problem or how widespread of a problem
this is in practice, but it stands that this is not a problem at all for Elm.

------
crimsonalucard
Anybody got a gauge on reason? Does it have the potential to change the
current paradigm on client side browser development?

~~~
nouveaux
Comment I wrote in a previous thread with some minor edits:

"We chose ReasonML after a previous project of working with JS, React and
Flow. We started using Reason back in May. The plan was to use typescript, but
after some great experiences with Rust on personal projects, I really wanted a
language closer to Rust.

Our team loves using Reason and for me, it's been such a breath of fresh air.
Working on front end code is a lot more fun because many of the frustrating
things with JavaScript/React has been removed. The compiler is VERY fast and
the language is well designed.

With that said, the learning curve is a bit much due to the lack of beginner
friendly documentation. If you do not have experience with an ML like language
(Rust, Swift, Scala, Ocaml, F#) AND React, I think it will be painful. Despite
that, it is totally worth learning.

The good news is that the core team realizes this and things are changing
fast. React was originally designed for an ML based language and you can it's
easy to see all the awkwardness of ReactJs removed in ReasonReact. ReasonReact
really is an eye opening experience of how good front end dev can be."

~~~
kbd
I didn't realize Reason was so geared towards React. Would it be foolish to
use an alternative like Vue with it? What about server-side with Node?

~~~
fspeech
Reason itself is an alternative syntax for OCaml. The developers have built
great support for React but in principle you can do whatever you can do with
JS.

~~~
kbd
So what's the deal with BuckleScript? The docs are really unclear on their
relation and just call it a "partner project". But it's the actual compiler?
Then what is Reason?

~~~
fspeech
Reason = syntax for OCaml. Bucklescript is a transpiler to js. You can use
other transpilers if you want but Bucklescript is great and has tightly
integrated support. The best way to experience it is to just follow the "npm
install" instructions. It may be a little confusing since you install
Bucklescript, instead of Reason, as Reason is a syntax that Bucklescript
supports. The online playground works great as well if you just want to get a
feeling about the language.

~~~
crimsonalucard
Can bucklescript compile OCaml into js?

~~~
fspeech
Yes that is what it was designed to do. Of course if your code calls out to
some library implemented in native you will need to substitute with the js
equivalent. Bucklescript has special syntax for you to describe the FFI to js,
like Typescript. Otherwise it is OCaml in classical syntax or in Reason.

