07:55 <discocaml> <aerbil313> Ok, guys. Why OCaml instead of Rust? I’m gonna learn Rust regardless, but I want to know whether learning OCaml will allow me to be more productive than Rust for small-scale personal projects/prototyping. (For anything that will make it into production, Rust is still my choice.) Many say using Rust also for this purpose (quick prototyping) is still productive, by cloning and uniquely referencing memory instead of fighting with the borrow

07:55 <discocaml> <aerbil313> Ok, guys. Why OCaml instead of Rust? I’m gonna learn Rust regardless, but I want to know whether learning OCaml will allow me to be more productive than Rust for small-scale personal projects/prototyping. (For anything that will make it into production, Rust is still my choice.) Many claim using Rust also for this purpose (quick prototyping) is still very productive, by cloning and uniquely referencing memory instead of fighting with the

07:57 <discocaml> <aerbil313> Ok, guys. Why OCaml instead of Rust? I’m gonna learn Rust regardless, but I want to know whether learning OCaml will allow me to be more productive than Rust for small-scale personal projects/prototyping. (For anything that will make it into production, Rust is still my choice.) Many claim using Rust also for this purpose (quick prototyping) is still very productive, by cloning and uniquely referencing memory instead of fighting with the

07:57 <discocaml> <aerbil313> (Please “reply” to this message so that I see the notification.)

08:26 <discocaml> <octachron> * the module system

08:26 <discocaml> <octachron> * a different type system

08:26 <discocaml> <octachron> * GC: rust memory design bleeds into a lot of part of the language, you cannot really avoid its influence

08:26 <discocaml> <octachron> * compilation speed with real incremental compilation

09:53 <tom1212> hi! I find it a bit heavy to pass the Array module as a first class module: https://bpa.st/3LIQ

09:53 <tom1212> problem is, I don't want to use ocaml's polymorphic array type because my array is a C value and I'd like to not convert it to an ocaml array

10:05 <zozozo> tom1212: if you have C arrays, you should be able to use ocaml bigarrays since they are basicaly wrappers around C arrays

10:07 <tom1212> thanks, actually these are not C arrays

10:08 <zozozo> I also see that your Array_sig seems to also include a monad part ? (i.e. the `'a m` type)

10:08 <tom1212> yes

10:09 <zozozo> it seems a bit more complicated than expected to merge these two signatures, compared to having the regular expected array sigs, and combining its functions with the traditional monad bind

11:29 <Bitwiser> Hi, where can I find the GC log file (all the messages logged using [caml_gc_message] and [caml_gc_log] functions)?

14:35 <discocaml> <regularspatula> There’s a few threads on discuss about this. Here’s one: https://discuss.ocaml.org/t/advantages-of-ocaml-over-rust/2112

14:38 <discocaml> <regularspatula> Though if you’re going to learn rust anyway, why not also use it for small personal projects too…how else will you learn it otherwise?

14:55 <discocaml> <masterbuilder> Rust is a great language, it's worth learning in any case, doesn't need to be an either or - however, in my experience it is not really a good language for quick prototyping, since it requires you to think about many details that are honestly quite irrelevant to implementing ideas in code. proficiency in the language can mitigate this friction but the point remains that solving problems in Rust occasionally requires an extremely unnatura

14:57 <discocaml> <regularspatula> Not as safe as rust in what way…preventing data races?

14:58 <discocaml> <masterbuilder> it's easy to wrap any arbitrary code in OCaml via the FFI but Rust requires `unsafe` for this, so you have to opt in to the unsafeness or devise a safe abstraction around it

14:59 <discocaml> <regularspatula> Ah the ffi

15:04 <discocaml> <masterbuilder> this is true as well though, since Rust has it encoded in the type system

15:04 <discocaml> <regularspatula> Sure, I just don’t think I’ve heard someone say that ocaml is less safe than rust is all

15:06 <discocaml> <masterbuilder> well, there is also that some more obscure OCaml functions can invoke undefined behavior iirc, that cannot happen in safe Rust

15:06 <discocaml> <masterbuilder> but UB in Ocaml is almost nonexistent so it's kinda moot

15:06 <discocaml> <regularspatula> I’m guessing your talking about Obj

15:07 <discocaml> <masterbuilder> that's an obvious one but I think it exists outside of Obj, just something I feel like I've seen but I can't recall examples

15:08 <discocaml> <regularspatula> unsafe_get for array and stuff like that I suppose

15:09 <discocaml> <regularspatula> This discussion got me reading this: https://doc.rust-lang.org/reference/behavior-considered-undefined.html#:~:text=Rust%20code%20is%20incorrect%20if,must%20never%20cause%20undefined%20behavior. …pretty interesting

15:11 <discocaml> <masterbuilder> something that is pretty unintuitive is that Rust enforces mutability NAND aliasing without exception, even in `unsafe` code, so some things are just not possible to do with the language period

15:11 <discocaml> <regularspatula> Kind of interesting to compare to ocaml

15:12 <discocaml> <masterbuilder> if you can mutate something through a pointer that pointer **must not** be aliased

15:12 <discocaml> <regularspatula> That’s mainly about preventing data race?

15:13 <discocaml> <regularspatula> I know we’re veering off from ocaml talk …maybe better in off topic idk

15:13 <discocaml> <masterbuilder> no it applies in single threaded code too, it's just how the memory model works

15:19 <discocaml> <aerbil313> Thanks guys for feedback! I decided to learn Ocaml as well.

15:19 <discocaml> <aerbil313> Thanks for feedback! I decided to learn Ocaml as well.

15:37 <discocaml> <aerbil313> Thanks for feedback! I decided to learn Ocaml as well.

15:37 <discocaml> <aerbil313> Edit: I just happened to come upon my past research into Perl 6. I reviewed my mental notes and ended up with two options: Learn Rust & Raku or Ocaml & Raku. It would take more effort than I want to invest to be proficient in all langs at once. I can’t leave Rust, so I chose Raku over Ocaml, for that it seems Ocaml seems a GC’ed functional Rust, while Raku offers far more than that.

15:37 <discocaml> <aerbil313> Thanks for feedback! I decided to learn Ocaml as well.

15:37 <discocaml> <aerbil313> I just happened to come upon my past research into Perl 6. I reviewed my mental notes and ended up with two options: Learn Rust & Raku or Ocaml & Raku. It would take more effort than I want to invest to be proficient in all langs at once. I can’t leave Rust, so I chose Raku over Ocaml, for that it seems Ocaml seems a GC’ed functional Rust, while Raku offers far more than that.

15:38 <discocaml> <aerbil313> I just happened to come upon my past research into Perl 6. I reviewed my mental notes and ended up with two options: Learn Rust & Raku or Ocaml & Raku. It would take more effort than I want to invest to be proficient in all langs at once. I can’t leave Rust, so I chose Raku over Ocaml, for that it seems Ocaml is a GC’ed functional Rust, while Raku offers far more than that.

15:38 <discocaml> <aerbil313> I just happened to come upon my past research into Perl 6. I reviewed my mental notes and ended up with two options: Learn Rust & Raku or Ocaml & Raku. It would take more effort than I want to invest to be proficient in all langs at once. I can’t leave Rust, so I chose Raku over Ocaml, for that it seems Ocaml is a GC’ed functional Rust, while Raku seem to offer more than that.

15:52 <discocaml> <Kali> How so?

16:36 <discocaml> <froyo> > Rust enforces mutability NAND aliasing without exception, even in unsafe code,

16:36 <discocaml> <froyo> masterbuilder: I thought it was possible in unsafe code...?

16:36 <discocaml> <froyo> by converting refs to raw ptrs

16:49 <discocaml> <masterbuilder> it's possible but it becomes undefined behavior instead of a compiler error

16:49 <discocaml> <masterbuilder> so it really isn't possible

16:50 <discocaml> <masterbuilder> you can create the pointers just not use them in any meaningful way

16:50 <discocaml> <masterbuilder> I think ptr arithmetic is fine

16:50 <discocaml> <masterbuilder> but as soon as you dereference them all bets are off

16:51 <discocaml> <masterbuilder> the semantics for unsafe Rust aren't even fully defined atm and volatile so not only can it break it most likely will

17:11 <discocaml> <froyo> I see now why people who find themselves needing to use lots of unsafe rust prefer zig etc.

17:11 <discocaml> <froyo> seen a couple of those kinds of blogs popping up

22:49 <discocaml> <Ada> I don't write a lot of rust but I don't see at what point writing that amount of unsafe code doesn't just lend itself to be done in C directly and wrapped at a higher level