
Compile OCaml to JavaScript, use ReactJS, bindings to ReactJS, several examples - e_d_g_a_r
https://github.com/fxfactorial/ocaml-reactjs
======
btown
For those interested in this,
[https://github.com/bloomberg/bucklescript](https://github.com/bloomberg/bucklescript)
is an alternate (albeit new) OCaml to JS compiler. There's already talk about
supporting JSX syntax:
[https://github.com/bloomberg/bucklescript/issues/162](https://github.com/bloomberg/bucklescript/issues/162)

~~~
Scarbutt
Differences from js_of_ocaml (not an easy find)

 _Js_of_ocaml takes lowlevel bytecode from OCaml compiler, BuckleScript takes
the highlevel rawlambda representation from OCaml compiler

Js_of_ocaml focuses more on existing OCaml eco-system(opam) while
BuckleScript's major goal is to target npm

Js_of_ocaml and BuckleScript have slightly different runtime encoding in
several places, for example, BuckleScript encodes OCaml Array as JS Array
while js_of_ocaml requires its index 0 to be of value 0.

Both projects are improving quickly, so this can change in the future!_

~~~
rajington
I haven't really gotten into much ML yet, and I'm curious to hear what people
knowledgeable with OCaml think about
[http://facebook.github.io/reason/](http://facebook.github.io/reason/)

The name makes it impossible to research to find any blog posts or anything,
but the familiar syntax alone might make it at least a first step for me.

~~~
e_d_g_a_r
Speaking for myself, I think Reason is a very good thing and rewriting this in
Reason or adding a Reason layer is a goal/TODO.

~~~
rajington
That's awesome and great work.

I know it's dumb that the thing holding me back from OCaml is the syntax, but
after giving up on an Om project I've come to accept js will always be the
greatest common denominator.

~~~
lmm
Maybe consider Scala? It's an ML family language with more familiar syntax,
and also has a Javascript backend.

------
xamlhacker
In the same vein, there are also some F# to JS compiler projects such as
Funscript ([http://funscript.info/](http://funscript.info/)) and Fable
([https://github.com/fsprojects/Fable](https://github.com/fsprojects/Fable)).
F# is an open-source Ocaml inspired language for .net.

~~~
piaste
Also plugging Websharper ([http://websharper.com/](http://websharper.com/))
which is a full web framework that includes a F# to JS compiler to write the
client-side part of the code.

Though you can use just the compiler inside a regular ASP.NET MVC project, if
you so choose.

------
hongboz
FYI: you can try bucklescript compiler in browser, and see generated JS code
side by side instantly [https://bloomberg.github.io/bucklescript/js-
demo/](https://bloomberg.github.io/bucklescript/js-demo/)

------
e_d_g_a_r
opam version is a little bit behind curve, use `opam pin add -y reactjs
git@github.com:fxfactorial/ocaml-reactjs.git`

~~~
magnumkarter
I've been learning OCaml and hoped I could find something like this. Thank
you.

~~~
e_d_g_a_r
Thanks! Star it if you like it, use it and open issues if any arise.

------
e_d_g_a_r
Sean just made this awesome much more real world usage example of a TODO MVC :
[https://www.dropbox.com/s/um29z2793ta7s9l/todomvc_state_repl...](https://www.dropbox.com/s/um29z2793ta7s9l/todomvc_state_replay.mp4?dl=0)

------
jiyinyiyong
ClojureScript is better than that, except for the type system.

~~~
sgrove
It's probably worth elaborating your opinion here. I've used ClojureScript
_heavily_ and feel I have a good sense of the comparison, but someone else
reading your comment wouldn't be any better informed for it.

I'm genuinely curious as to your comparison though, would love to read it!

------
amelius
How is the performance?

Imho, we need an equivalent of the "great programming language shootout" for
all the AltJS languages.

~~~
hongboz
For bucklescript, the performance is excellent, better than handwritten JS:
[https://github.com/bloomberg/bucklescript#more-
examples-1](https://github.com/bloomberg/bucklescript#more-examples-1)

------
galfarragem
Isn't this a less polished version of Elm?

~~~
e_d_g_a_r
This has nothing to do with elm..

------
ilostmykeys
Why?

~~~
klibertp
A sane, powerful type system is actually enough of a rationale and a selling
point, at least for me.

Also, allowing side-effects while still providing the mentioned type system
makes it potentially much easier to integrate with existing JS code.

~~~
cies
Another reason for it being "much easier to integrate with existing JS code"
is strict evaluation.

Haskell is lazy, which means using GHCJS to compile it to JS produces code
full of explicit thunks (think of promises). Both Elm and PureScript are
compile-to-JS-languages that inherit a lot from Haskell, but not it's
laziness.

