<companion_cube>
(this time, right pseudo, I hope)
NhanH has joined #ocaml
ggherdov has joined #ocaml
dch has joined #ocaml
oldmanistan_ has joined #ocaml
jeroud has joined #ocaml
seangrove has quit [Ping timeout: 260 seconds]
ygrek has joined #ocaml
<chelfi>
freehck: if you have ever tried doing some ocaml evangelism, you may have heard the same complaints over and over: "why all the let ins" "why reverse type applications" "why the double semicolons" "why the weird mutation syntax" "why fun and function" "why are records so weird" "why is equality operator so weird" and so on
mattg has joined #ocaml
d0nn1e has quit [Ping timeout: 276 seconds]
seangrove has joined #ocaml
AltGr has joined #ocaml
octachron has joined #ocaml
d0nn1e has joined #ocaml
<chelfi>
so I guess it kinda makes sense to propose a reskin of the exact same language to make it palatable to newcomers
AltGr has left #ocaml [#ocaml]
<octachron>
orbifx: I would say that the revised syntax is only relevant for writing camlp4 extensions
jwatzman|work has joined #ocaml
<orbifx>
Thanks octachron
MorTal1ty has joined #ocaml
mattg has quit [Client Quit]
caw has joined #ocaml
yunxing has joined #ocaml
seangrove has quit [Ping timeout: 252 seconds]
yunxing has quit [Ping timeout: 250 seconds]
AltGr has joined #ocaml
toboggan has joined #ocaml
jwatzman|work has quit [Quit: jwatzman|work]
__y is now known as _y
<freehck>
chelfi: never thought about this. Strange people complain of strange things. I was happy about ocaml syntax. I'm afraid Reason can separate ocaml community which is not a large one already.
<gargawel>
OCaml's syntax certainly has issues / inconsistencies, but I am not too sure about FaceBook throwing its own new syntax at everyone's face either
<gargawel>
Chances are, there will be 2x more "Reason" than "OCaml" users in a year or two :-/
def`_ is now known as def`
<chelfi>
well, as long as Reason is only a set of ppx extensions, every single library, tutorial, piece of documentation, etc can be automatically ported to ocaml, so I guess if it does not deplete the set of ocaml programmers maintaining existing ocaml library, it is not that bad
<gargawel>
well, as long as Reason is only a set of ppx extensions // is it, really ?
<chelfi>
that is what I gathered from a cursory reading of the article mentionned earlier, but of course I may be wrong
<companion_cube>
it's not ppx, but it's an alternative syntax
<dmbaturin>
>and some imperative statements must be assigned to _ or ()
<chelfi>
my bad then
<companion_cube>
I'd say that as long as the two languages stay 100% compatible and translatable in both ways, it should be fine
<dmbaturin>
Someone doesn't understand the difference between assignment and pattern matching, or, worse, thinks no one else does...
amnn has joined #ocaml
<mrvn>
dmbaturin: how is one to understand assignment when there is no such thing.
<gargawel>
chelfi: it's a preprocessor, actually
<dmbaturin>
Well, my point is that whether there is or there is no such thing, what the page authors thinks is assignment definitely is not. :)
<rks`>
gasche: "it would be possible to implemented the revised syntax using ppx" really? how would you achieve that?
<dmbaturin>
This reminds me of that story of Bourne writing his shell in C with a bunch of macros to make it look like Algol-60 (IF ... FI etc.).
<dmbaturin>
Reportedly, gave a lot of headache to the next maintainer after he moved on to other projects (well, I can imagine).
Reshi has joined #ocaml
<dmbaturin>
What's also strange is that their page tries to explain things to people unfamiliar with ocaml, while explicitly stating that it's an interface for ocaml.
AltGr has left #ocaml [#ocaml]
<dmbaturin>
>We’re not aware of anything that takes Reason‘s specific approach to syntax
<dmbaturin>
Wasn't revised syntax exactly this?
kakadu has joined #ocaml
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #ocaml
jwatzman|work has joined #ocaml
amnn has quit [Read error: Connection reset by peer]
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #ocaml
Simn has joined #ocaml
amnn has joined #ocaml
dsheets has quit [Remote host closed the connection]
ygrek has quit [Ping timeout: 246 seconds]
dsheets has joined #ocaml
hay207 has quit [Ping timeout: 276 seconds]
butts_butts_ has quit [Ping timeout: 260 seconds]
hay207 has joined #ocaml
ygrek has joined #ocaml
leyyin has joined #ocaml
vpm has quit [Quit: co'o]
mattg has joined #ocaml
vpm has joined #ocaml
bba has joined #ocaml
<Drup>
rks`: I think he meant "using pp"
<Drup>
(same as reason)
<rks`>
ah
<rks`>
yes that makes sense… but wasn't it the case?
<Drup>
yes
<rks`>
right.
<Drup>
(via camlp4)
<rks`>
so basically
<rks`>
"it would be possible to do what was done"
<rks`>
right?
Simn has quit [Quit: Leaving]
<Drup>
well, you could have the new syntax extension without the camlp4 overhead
<Drup>
revised syntax*
<Drup>
anyway, it doesn't matter, the revised syntax was not even good
bba has quit [Quit: My Mac has gone to sleep. ZZZzzz…]
<Drup>
(reason has some decent points, like uniform application syntax, some more questionable points, like transforming symbols such as =/==/<>)
rand__ has quit [Quit: leaving]
bba has joined #ocaml
pierpa has joined #ocaml
rand__ has joined #ocaml
kushal has quit [Quit: Leaving]
<Drup>
huum, someone asked me a library for easy symbolic manipulations in OCaml
copy` has joined #ocaml
<Drup>
companion_cube, Leonidas ?
<companion_cube>
hmmmm
<companion_cube>
what kind of "symbolic manipulations"?
dsheets has quit [Remote host closed the connection]
rand__ has quit [Quit: leaving]
butts_butts has joined #ocaml
<Drup>
companion_cube: group theory stuff, apparently
<companion_cube>
ah, well
<companion_cube>
my experience is that it's hard to do this stuff in a generic way
<octachron>
^ I concur. Except, maybe, if you are a multi-million(billion?) company à la Mathematica
<companion_cube>
they don't do it generically, they just have everything in one language
<companion_cube>
also, I don't know what kind of manipulation you'd want to do on groups
<companion_cube>
maybe rewriting, for which there are libraries or languages
<Leonidas>
Drup: I am not aware of any, sorry.
<Drup>
yeah, so redo a custom one, ok
<companion_cube>
well :/
<reynir>
orbifx: I think it's still possible to use the revised syntax, but I don't think it supports ppx (?)
<companion_cube>
such things are very tied to the representation of expressions, which cannot be made generic
<reynir>
wow I was scrolled up
<Leonidas>
I don't quite understand why they replaced let … in with let … ; which is substituting one ugly token with another
<zozozo>
ow, commas as list separator, and no mention of tuples ?
<zozozo>
ah, so tuples have mandatory parentheses in reason, :p
<Leonidas>
zozozo: tuples are (foo, bar)
<reynir>
Parens are mandatory in tuples
<Leonidas>
zozozo: yes they do. Which is, uhh, fair enough
<zozozo>
indeed
<Leonidas>
python does without but whatever.
<zozozo>
[1,2] is fairly disturbing the first time you see it
<orbifx>
Lol
<flux>
and not very difficult to write accidentally..
<Leonidas>
zozozo: unless you programmed in any other language in the last 30 years ;)
<flux>
given all other languages out there use , as a list separator ;)
<mrvn>
what about [1,,10]?
<flux>
..syntax error?
<mrvn>
what? no sequences?
<Leonidas>
Reason feels like they cleaned up some stuff and then added a lot of really inelegant syntax. Kinda like Rust.
<flux>
if there were sequences that would certainly be a new syntax for it :)
<flux>
why not [1..10]?
<mrvn>
.oO(They must have had a Reason for it :)
<mrvn>
flno reason
<mrvn>
flux: ^
<Leonidas>
-fno-reason
<flux>
in any case I don't think sequence syntax is particularly needed, because most of the times you want you want to express half-open ranges, and it becomes awkwards with .. -syntax
<zozozo>
Leonidas: well at least the application of type arguments is fixed in Reason
<Leonidas>
flux: [1..10[?
<mrvn>
'a'..'z' is usefull
<mrvn>
Leonidas: urgs. try balancing that in a parser
<flux>
leonidas, that would be nice yes, but there could be parsing issues
<Leonidas>
let me look at type arguments
<Leonidas>
mrvn: flux: yes, that might be the reason why
<flux>
[1..]10 :-)
<Leonidas>
gosh, horrible puns
<flux>
also: 1 [..] 10 for a sequence [2..9] :)
<mrvn>
only place where I see the need for an open range would be floats. otherwise just use the predecessor
<flux>
and characters
<flux>
and, say, if there were enumerations
<Leonidas>
buuut, if they manage to nail tooling, and it looks like they do this will be VERY powerful
<Leonidas>
rtop, MeRlin
<flux>
I wonder what happens to advanced features such as modules, gadts and objects
<reynir>
If I understand correctly type foo = Foo of int list * int becomes type foo = Foo of (list int) int
<mrvn>
open [M..P];
<reynir>
which I find a bit odd
<flux>
not any weirder than function application, no?
<companion_cube>
the `of` is weird
<mrvn>
reynir: what would "type foo = Foo of list int int" parse as?
<reynir>
Well, Foo of list int int is not the same as Foo of (list int) int
<mrvn>
'a list * int * int?
<reynir>
mrvn: I believe it would be Foo of list * int * int
<Leonidas>
that is also odd that Reason uses == and === in a manner that is inverted with JavaScript
<reynir>
mrvn: I think without 'a, so a type error
<reynir>
(But I'm not very confident, I'm just going off their examples)
<reynir>
confident about this*
<zozozo>
flux: well Reason only changes the parser of the compiler, so as long as they find a syntax for gadts, there should be no problem
<reynir>
As far as I can tell they substitue the confusing Foo of int * int vs Foo of (int * int) with the confusion between Foo of list int int vs Foo of (list int) int
<reynir>
(assuming I'm not misinterpreting how it works)
<companion_cube>
oh wait, this means that right now they cannot translate all OCaml code to reason
<def`>
companion_cube: `of` might disappear
<companion_cube>
ah, right, the syntax can change
<nicoo>
companion_cube: I was kinda stuck wondering where their variant definition syntax was defined, since I didn't see where they handle the `of int * int` vs `of (int * int)` uglyness
<companion_cube>
the poly variants?
<nicoo>
No, the regular ones
dsheets has joined #ocaml
<nicoo>
Nevermind, I just found them
<nicoo>
It seens they just don't handle the issue
<nicoo>
(or do they do ((int, int)) and don't mention it in the doc?)
rgrinberg has joined #ocaml
orbifx has quit [Ping timeout: 260 seconds]
butts_butts has quit [Read error: Connection reset by peer]
butts_butts has joined #ocaml
<def`>
nicoo: that's what was discussed above
<def`>
they went the haskell way and choose Foo of int int
<def`>
`of int int` vs `of (int, int)`
<nicoo>
Ah, ok
* nicoo
should re-caffeinate
<def`>
ahah not a big deal :)
amnn has quit [Quit: My MacBook Pro has gone to sleep. ZZZzzz…]
FreeBird_ has joined #ocaml
Guest67519 has joined #ocaml
amnn has joined #ocaml
amnn has quit [Read error: Connection reset by peer]
amnn has joined #ocaml
amnn has quit [Read error: Connection reset by peer]
FreeBirdLjj has quit [Ping timeout: 252 seconds]
amnn has joined #ocaml
FreeBird_ has quit [Ping timeout: 276 seconds]
sepp2k has joined #ocaml
hcarty has joined #ocaml
FreeBirdLjj has joined #ocaml
al-maisan_ is now known as al-maisan
al-maisan has quit [Changing host]
al-maisan has joined #ocaml
AltGr has joined #ocaml
hcarty has quit [Ping timeout: 260 seconds]
Reshi has quit [Ping timeout: 250 seconds]
ygrek has quit [Ping timeout: 276 seconds]
hcarty has joined #ocaml
seliopou_ has quit [Ping timeout: 276 seconds]
noplamodo has quit [Ping timeout: 260 seconds]
zaquest has quit [Remote host closed the connection]
noplamodo has joined #ocaml
seliopou has joined #ocaml
zaquest has joined #ocaml
cantstanya has quit [Ping timeout: 260 seconds]
<def`>
Algebr``: are you around?
toomuchtvrotsurb has joined #ocaml
<def`>
thanks :)
sh0t has joined #ocaml
cantstanya has joined #ocaml
<Guest67519>
yea
Guest67519 is now known as Algebr
<Algebr>
thank you
AltGr has left #ocaml [#ocaml]
Algebr is now known as Guest98384
dsheets has quit [Remote host closed the connection]
kushal has joined #ocaml
toboggan has quit [Ping timeout: 240 seconds]
ztennix has quit [Ping timeout: 244 seconds]
chelfi has quit [Ping timeout: 260 seconds]
hcarty has quit [Ping timeout: 276 seconds]
MercurialAlchemi has quit [Ping timeout: 260 seconds]
Guest98384 has quit [Remote host closed the connection]
Guest98384 has joined #ocaml
dsheets has joined #ocaml
ygrek has joined #ocaml
chelfi has joined #ocaml
rntz has quit [Ping timeout: 252 seconds]
yomimono has joined #ocaml
AltGr has joined #ocaml
rntz has joined #ocaml
rntz has quit [Ping timeout: 260 seconds]
rntz has joined #ocaml
A19774941 has joined #ocaml
kushal has quit [Ping timeout: 246 seconds]
A1977494 has quit [Ping timeout: 240 seconds]
MercurialAlchemi has joined #ocaml
AltGr has left #ocaml [#ocaml]
scarygelatin has joined #ocaml
hcarty has joined #ocaml
t4nk867 has joined #ocaml
ztennix has joined #ocaml
t4nk867 has quit [Ping timeout: 250 seconds]
ia0 has quit [Quit: reboot]
ia0 has joined #ocaml
mistermetaphor has joined #ocaml
ygrek has quit [Ping timeout: 260 seconds]
<sh0t>
Hi guys a question about, i think, best practice. So i am implementing a small language. I have definition of abstract syntax tree in a type called expr (one of the constructor Numeric is for constant values) it parses the code as i want. Now I am starting to implement the semantics and I am thinking of defining a new type "value". Now values are expressions and I am finding my self in the situation of wanting values to be expressions.
<sh0t>
So one way to go is to define a new constructor of expression: Value of value and moving the constructor Numeric from expression to the value type. My question is: is this a smart way? Probabiliy not.
rand__ has joined #ocaml
<Drup>
it's quite usual
<sh0t>
oh ok I wasn't even sure i explained my problem correctyl...
<companion_cube>
rgrinberg: opium as an embedded server is pretty nice
<sh0t>
so is there a way to say that an element of type A is also of type B without doing what i am trying to do?
kushal has joined #ocaml
<zozozo>
sh0t: you can with polyvariant I think
<zozozo>
such as type t = [ `A ];; type t' = [ t | `B ];;
<sh0t>
polyvariant let's see...i can't find this subject on real world ocaml
<sh0t>
is it an advanced topic?
<sh0t>
(i am new of ocaml...sorry)
<flux>
polyvariant was short for polymorphic variant
<flux>
in fact I've never seen that term used.. :)
<flux>
I imagine that term should be covered
<sh0t>
oh it is
<sh0t>
thanks guys i'll give a look to that
<zozozo>
sh0t: however using polymorphic variaants is less efficient thatn regular variants if i remember correctly
<sh0t>
ok even though really efficiency is not really a concern for me at the moment :)
<flux>
I don't think there's a significant overhead with them. they are basically numbers.
<flux>
in fact I understand they are on par with regular variants with boxed data (so no tuple inlining)
Guest983` has joined #ocaml
<sh0t>
anyway guys one problem, I think, with my approach is that the number of constructors needed to "create" a value of one type increaeses like now I have to do Value(Numeric(something)) instead of just Numeric(something) (in the lexer for instance...)
<sgronblo>
so now im curious if FB will create some nice express.js style web server library
<Algebr`>
wouldn't that be amazing.
<sgronblo>
ive been looking for a good ML backend language, thought ocaml's ecosystem seemed kinda unpolished and f# seems too tied to MS
bba has quit [Quit: My Mac has gone to sleep. ZZZzzz…]
wiredsister has joined #ocaml
<Algebr`>
I think its at a big turning point now
slash^ has joined #ocaml
<sgronblo>
would be interested in what FB has been using for their reason server programs
SaidinWoT has joined #ocaml
dsheets has quit [Remote host closed the connection]
mistermetaphor has quit [Read error: Connection reset by peer]
mistermetaphor has joined #ocaml
<chelfi>
I suspect that they will be doing with Reason exactly what they have been doing with ocaml, but just with a "nicer" syntax
jwatzman|work has quit [Quit: jwatzman|work]
<pierpa>
except there's no nicer syntax
unbalancedparen has joined #ocaml
<wiredsister>
I don't quite understand the "OCaml's syntax is bad", but am happy people care.
<wiredsister>
Coming from JavaScript, the syntax was not really that big of a stumbling block. But I'm sure the Reason team has a bunch of other nicities.
aphprentice has joined #ocaml
<flux>
I think OCaml syntax has room for improvements. but actually some style guide would perhaps be almost just as good.
<flux>
for example, I never seem to find the optimal way to lay out matches inside each other ;)
<wiredsister>
There is a style guide on the website. It discusses ways to deal with nested matches.
<wiredsister>
But is very open ended...
<flux>
and often times I might even rearrange the matches (if possible) so that I don't need to use parenthesis (or begin/end)
<pecan>
I really like OCaml's syntax, but it was kind of weird at first. It's one of the more readable languages over the long-term IMO.
<flux>
in fact I think I could even enjoy a haskell-style whitespace-sensitive syntax (haskell-style as in defined by how it's transformed into non-ws-sensitive code)
<wiredsister>
The tuples were weird. * vs , was like, "wat?"
<Algebr`>
Reason is changeable, that's why we should welcome it
<flux>
reason also changed -> to => from my point of view for not very great reasons :)
<wiredsister>
I'm happy the JS people will get involved. They tend to build pragamtic tools that are nice to use.
<pecan>
lol
<wiredsister>
so that's the net positive for me.
<flux>
on non-us keyboards => is slightly more difficult to write
<wiredsister>
lol
<flux>
(though happily I use the US layout ;-))
<pierpa>
on some non-us keyboards there are no {} at all
<flux>
at all? now that's a drag for basically all programmers :)
<pecan>
Worry not, that's what we have trigraphs for in C, and those are clearly a very useful feature.
<flux>
do worry, they were deprecated in C++ :)
<pecan>
why'd they ever deprecate that, if (x) ??< foo(); ??> was the most readable syntax ever
<pierpa>
On Italian keyboards, for example, no {}. Everyone says it's not a problem! just use alt-1256 and alt-54676, wht's th eproblem.
<pecan>
flux: Actually they aren't deprecated in C++, actually C++ has new ones like %:%:
<pierpa>
that's for saying people adapt to incredible things. Someone even finds normal Ocaml syntax
<pecan>
that's a common misconception
<pecan>
they're probably going to be straight removed in C++17, but they're not even deprecated in C++14
<flux>
well, close enough
<flux>
apparently they tried it alrady on C++0x
<companion_cube>
people, I just had a glimpse at SML, and OCaml is marvellous in comparison
<flux>
and 14
dsheets has joined #ocaml
<flux>
companion_cube, but at least the SML folks have a spec :-)
<pecan>
yeah, but then you're using SML
<flux>
someone should define a formal transformation from OCaml to SML
<flux>
and get the rest of the formal benefits* for free!
bba has joined #ocaml
copy` has quit [Quit: Connection closed for inactivity]
rgrinberg has quit [Ping timeout: 276 seconds]
ztennix has quit [Ping timeout: 246 seconds]
mistermetaphor has quit [Read error: Connection reset by peer]
amnn has quit [Ping timeout: 260 seconds]
amnn has joined #ocaml
mistermetaphor has joined #ocaml
larhat has quit [Quit: Leaving.]
shinnya has joined #ocaml
amnn_ has joined #ocaml
wiredsister has quit [Ping timeout: 260 seconds]
amnn has quit [Ping timeout: 260 seconds]
<unbalancedparen>
hey what do you think about reason from facebook? any good review or post to read?
<companion_cube>
well, t he HN and reddit comments
<unbalancedparen>
companion_cube: yes, thanks. i have read it but i wanted to know if there was anything else interesting to read about it :)
butts_butts has quit [Remote host closed the connection]
<pecan>
there's not really much interesting about it, so that limits your reading opportunities slightly.
<Drup>
flux: you can't encode OCaml in SML
<Drup>
(SML doesn't even have GADTs, don't even try all the other extensions ...)
rgrinberg has joined #ocaml
mistermetaphor has quit [Read error: Connection reset by peer]
<octachron>
Drup: Even without going to extensions, SML does'nt use the relaxed version of the value restriction, isn't it?
<Drup>
oh, that's good point
<Drup>
that must be horrible to use
th5 has joined #ocaml
<Drup>
I don't know if they have it or not, in fact
mistermetaphor has joined #ocaml
amnn_ has quit [Read error: Connection reset by peer]
amnn has joined #ocaml
rgrinberg has quit [Read error: Connection reset by peer]
amnn has quit [Read error: Connection reset by peer]
amnn has joined #ocaml
<octachron>
Drup, I don't know either, but having covariant type parameters just for the sake of the relaxed value restriction sounds quite strange
<companion_cube>
SML's pattern matching is so weak
mistermetaphor has quit [Read error: Connection reset by peer]
mistermetaphor has joined #ocaml
rgrinberg has joined #ocaml
amnn has quit [Quit: My MacBook Pro has gone to sleep. ZZZzzz…]
<pecan>
that's kind of relative isn't it? OCaml's pattern matching is weak compared to Mercury.
<companion_cube>
sure, but it hurts
<companion_cube>
no disjunction in patterns, no when
<pecan>
lack of `when` was certainly annoying the one time I wrote something in sml
<companion_cube>
lack of disjunction is terrible
<Drup>
pecan: what are mercury's nice pattern matching feature ? ( I don't really know it )
<pecan>
Drup: Mercury is a logic language so it does full unification instead of just pattern matching.
<Drup>
ah right
<Drup>
like Curry
<pecan>
yeah
<octachron>
even in OCaml, I find the lack of disjunction one the worst part of working with GADTs
<companion_cube>
indeed
<pecan>
Now, frankly I don't really miss unification much when programming in OCaml, but there are a lot of levels of power of pattern matching.
<Drup>
pecan: I agree
<Drup>
the combination of logic+functional programming is very expressive
<pecan>
One of these days I'm going to write something more than a toy in Mercury...
<Drup>
companion_cube: I feel like you went out of your way to make it even uglier
<companion_cube>
it's a compiled language, isn't it?
<Drup>
it's not even a real table
<pecan>
Yeah, it compiles to a lot of targets actually.
<companion_cube>
it's nested tables actually
<pecan>
C, Java, .NET, Erlang, ASM
<pecan>
the C backend is pretty fast from what I hear
<Drup>
companion_cube: but nothing is alligned
<pecan>
If I had to guess from what I know, it's probably comparable with OCaml pre-4.03
<companion_cube>
yeah, well, I suppose it doesn't align data from distinct tables
yunxing has joined #ocaml
hcarty1 has joined #ocaml
hongbo has joined #ocaml
<hongbo>
ping Drup
<Drup>
yes ?
<hongbo>
may I ask you why jsoo distinguished method and property?
FreeBirdLjj has quit [Remote host closed the connection]
hcarty has quit [Ping timeout: 260 seconds]
<hongbo>
like `x##.property` and `x##method
Algebr` has quit [Ping timeout: 260 seconds]
<Drup>
it was always there, but before it was very not ocaml-y
<Drup>
are, you are asking why it's in the type system to begin with ?
<hongbo>
I found it not necessary, but I might be wrong, we can always use `x##method, x##prperty`
<Drup>
yeah, but the typing is a bit different
<Drup>
you can't freely translate between ocaml functions and javascript functions, for example
kolko has joined #ocaml
<Drup>
basically, it's typing subtlety for functions, mutation and permissions.
<Drup>
you can use both only for the most simple example
<hongbo>
Drop, can you give me a simple example?
<hongbo>
sorry , Drup
<hongbo>
Drup, I did some research, found it unnecessary to distinguish property and method, but I think I might miss something, so I am asking here : )
anoisz has joined #ocaml
toolslive has joined #ocaml
octachron has quit [Quit: Page closed]
<Drup>
try to export a function as a prop and call it with "x##.f arg1 arg2"
<ollehar1>
"x = y in OCaml is written x == y in Reason, and x == y is written x === y in Reason"
<ollehar1>
\o/
<ollehar1>
</rant>
toomuchtvrotsurb has quit [Remote host closed the connection]
dsheets has joined #ocaml
rand__ has quit [Quit: leaving]
<rom1504>
create ReasonReason so you can create x ==== y and x ====== y
<rom1504>
idk why nobody else thought of that yet
sh0t has quit [Ping timeout: 250 seconds]
toomuchtvrotsurb has joined #ocaml
toomuchtvrotsurb has quit [Remote host closed the connection]
jasiek has quit [Ping timeout: 252 seconds]
<reynir>
I judge language on how long their equality operator is ;)
<ollehar1>
rom1504: ;)
<Drup>
rant and circlejerk put asside
<Drup>
I consider this is a big issue
<ollehar1>
HackReason
<Drup>
the syntax should *not* change the symbols that are exported by libraries
<Drup>
if you write "let (==) x y = ..." in reason, it's exported as (=)
jasiek has joined #ocaml
<Drup>
that's ... not a good idea
<ollehar1>
that's deeper than I've thought. I'm mostly thinking in "political" terms.
<Algebr``>
if you are thinking in political terms then I'd say that anything that increases OCaml adoption is a good thing
<ollehar1>
instead of having great engineers at fb improving the ocaml environment, they will improve their own reason environment.
<Algebr``>
uh, I disagree, it improves the OCaml ecosystem
<Algebr``>
Reason is part of it, thereby improving Reason improves OCaml
<Algebr``>
and I'm sure there will be tons of side improvements as well, to jenga, to opam, etc etc.
<Drup>
Algebr``: I would have prefered an actual ocamlfmt that works on the actual ocaml syntax.
dsheets has quit [Remote host closed the connection]
<ollehar1>
they already have Flow, which seemed excellent.
<ollehar1>
*seems
sepp2k has quit [Quit: Leaving.]
<ollehar1>
I mean, Hack is not really improving PHP.
<ollehar1>
maybe not comparable.
mengu has joined #ocaml
mengu has quit [Ping timeout: 260 seconds]
toomuchtvrotsurb has joined #ocaml
nicholasf has joined #ocaml
<pierpa>
so, is <> in reason written as <<>> ?
<Drup>
pierpa: !=
<Drup>
and != is !==
<pierpa>
hmmm
<Drup>
(this is not a joke, this is going to trip people up, garanteed)
rgrinberg has quit [Ping timeout: 276 seconds]
<pierpa>
that's crazy
hcarty1 has quit [Ping timeout: 250 seconds]
sh0t has joined #ocaml
<ollehar1>
imagine what people would say about Reason if it was made by an unknown guy from anywhere.
<ollehar1>
oh well
<thomasga>
Drup: I guess you can use refmt and then translate back to OCaml
<thomasga>
anyway, all the Reason tools should work fine with OCaml as well (including the Atom editor) so I count that as a win for the community
mistermetaphor has quit [Read error: Connection reset by peer]
mistermetaphor has joined #ocaml
<Drup>
doesn't Atom+merlin already works ?
<Drup>
(I don't disagree, though)
<thomasga>
I'm not sure it did. The new plugin seems nice.
nicholasf has quit [Remote host closed the connection]
nicholasf has joined #ocaml
ollehar1 has quit [Quit: ollehar1]
madroach has quit [Read error: Connection reset by peer]
<rseymour>
you can refmt roundtrip
<rseymour>
they just need to make >>= not look so weird
<rseymour>
my coworker (who is in here under some handle I do not know) thinks they can use some %bind syntax to replace >>=
<Algebr``>
core already does that
<rseymour>
ja
<rseymour>
I'm viewing reason as a prism to view ocaml concepts in a different way. It helped me understand things about ocaml syntax as soon as I tried refmting some code. even if I didn't love the reason version
madroach has joined #ocaml
madroach has quit [Read error: Connection reset by peer]
madroach has joined #ocaml
unbalancedparen has quit [Ping timeout: 260 seconds]
madroach has quit [Read error: Connection reset by peer]
mistermetaphor has quit [Read error: Connection reset by peer]
madroach has joined #ocaml
madroach has quit [Read error: Connection reset by peer]