mro_name has quit [Remote host closed the connection]
yichiehc has joined #ocaml
mro_name has joined #ocaml
tizoc has quit [Quit: Coyote finally caught me]
tizoc has joined #ocaml
bartholin has quit [Ping timeout: 265 seconds]
bartholin has joined #ocaml
bjorkintosh has joined #ocaml
waleee-cl has joined #ocaml
dh` has joined #ocaml
zebrag has quit [Quit: Konversation terminated!]
zebrag has joined #ocaml
mro_name has quit [Remote host closed the connection]
<qwr>
difficulty in F# to OCaml compilation might come from libraries
<qwr>
as the only reason to even want such transpiler would be compiling existing F# code, which uses existing .NET libraries
<qwr>
and if you're going through the trouble of modifing the code to use other libraries, then quite probably changing few syntactic differences is smaller part of the work
<qwr>
and it might be possible to also implement C#-to-OCaml compiler and port for example Mono runtime to it, but i'm pretty sure, that it would be a major effort
ArthurStrong has quit [Ping timeout: 252 seconds]
mro_name has joined #ocaml
mro_name has quit [Ping timeout: 268 seconds]
_whitelogger has joined #ocaml
zebrag has quit [Quit: Konversation terminated!]
bartholin has quit [Ping timeout: 240 seconds]
zebrag has joined #ocaml
mro_name has joined #ocaml
mro_name has quit [Remote host closed the connection]
bartholin has joined #ocaml
vicfred has joined #ocaml
mal`` has quit [Quit: Leaving]
mro_name has joined #ocaml
<d_bot>
<Firgeis> I'd say it's way more difficult than that, F# has a whole range of syntax dealing with OO which does not exist in OCaml
<Drup>
it's like saying racket is compatible in ocaml because both are functional. The only common point between the OOP aspects in ocaml and .Net is the fact there is "object" in the name
<d_bot>
<EduardoRFS> Drup: not sure about `.Net` but Java OOP models nicely to OCaml OOP when doing FFI, almost 1 : 1. Even thought they're used in a different way.
ArthurStrong has joined #ocaml
<companion_cube>
except for the utf16 strings, right? :p
curtosis[away] has quit [Quit: My Mac Mini has gone to sleep. ZZZzzz…]
<d_bot>
<EduardoRFS> well I just have a black box called `String.t`, but yeah to interact with Strings and long I need some helpers
<d_bot>
<EduardoRFS> but like the core structure of a class an interface and etc ... actually works
<d_bot>
<EduardoRFS> I have this generator, which does low level bindings, then I build high level bindings on top of it
<d_bot>
<EduardoRFS> pattern matching on let fails, but match works
<d_bot>
<EduardoRFS> also this is one of the changes I think Melange inherited from ReScript, all let are transformed into let + match, which concerns me, is this always a safe transformation?
<d_bot>
<EduardoRFS> probably there is an issue on github that I cannot find
rosterok has joined #ocaml
<d_bot>
<octachron> The fields of the module `X` are not in the scope in the second case.
<d_bot>
<octachron> Whereas in the first case, the projection comes first, the fields are added to the environment, and when typechecking the pattern they are found "accidentally" and the typechecker just triggers a `name-out-of-scope` warning.
<d_bot>
<octachron> Transforming `let` into `let` + `match` should be safe and entirely unnecessary?
<d_bot>
<ec> Hm. Is there a way to ignore a missing module when invoking `ocamldoc`?
zebrag has quit [Quit: Konversation terminated!]
zebrag has joined #ocaml
<d_bot>
<EduardoRFS> it solves the problem, essentially the second case types into Melange
<d_bot>
<EduardoRFS> which I would argue should be the behavior in OCaml
sanyud has joined #ocaml
shawnw has joined #ocaml
layet has joined #ocaml
<sanyud>
Hi everyone , I'm Sanyu Daver and an outreachy applicant and would like to contribute for the project "Add templating to the OCaml documentation generator"
curtosis[away] has joined #ocaml
sanyud has quit [Ping timeout: 240 seconds]
ArthurStrong has quit [Quit: leaving]
mro_name has quit [Remote host closed the connection]
mro_name has joined #ocaml
mro_name has quit [Ping timeout: 240 seconds]
<d_bot>
<octachron> @EduardoRFS , most type system people would argue that it is the first behavior and its use of accidentally propagated information that is an issue.
<d_bot>
<EduardoRFS> Why would it be? The information is available on the ident, seems expected that if X.value is typed and known, you can access it's records.
<d_bot>
<octachron> No, you should be able to type the patterns and the expressions in any order and end up with the same result.
<d_bot>
<octachron> The optimal behavior would be to integrate type-directed disambiguation in the notion of principality in a way that makes this kind of propagation principled.
curtosis[away] has quit [Quit: My Mac Mini has gone to sleep. ZZZzzz…]
<d_bot>
<EduardoRFS> Yeah but that's clearly not true, so my question is why do we run let from left to right instead of right to left?
<d_bot>
<EduardoRFS> And even better, would changing it break any code?
<d_bot>
<octachron> The order definitively matters for for GADTs.
<d_bot>
<octachron> And yes, changing the order will breaks all that does not compiler with `-principal` + the related warnings as errors.
<d_bot>
<EduardoRFS> Sad
<d_bot>
<octachron> Note that there is some work towards making type-directed disambiguation more robust/principled. However, with the pandemy, I don't know how well it is going.
zebrag has quit [Read error: Connection reset by peer]
zebrag has joined #ocaml
wilfredh has quit [Quit: Connection closed for inactivity]