01:29 <HyperMonkey> if I define mylist is there a way to override the cons operator :: for it?

01:45 <pigeonv> yes, you can

01:45 <pigeonv> e.g. type mylist = [] | (::) of int * mylist

01:56 <Anarchos> or let (::) a l = (a:int) :: (l:mylist)

02:05 <HyperMonkey> is there a way to eliminate catch-exit in this? https://paste.ee/p/W2kwe

02:07 <HyperMonkey> I guess it's not a disaster if it has catch/exit ... can be simplified out by inlining the catch expressions into the exists ...

06:31 <def> HyperMonkey: why would you do that?

06:31 <def> catch/exit has no runtime cost

08:26 <olle_> https://affe.netlify.app/#intro.affe

08:38 <olle_> Affe = "This language aims to prevent linearity violations, notably bugs such as use-after-free. Affe is an ML-like language similar to OCaml. In particular, Affe is functional with arbitrary side effects and complete type inference (i.e., users never need to write type annotations). "

08:38 <olle_> (please don't kill me, drup)

08:38 <olle_> (still want to post that on reddit)

08:38 <olle_> (so cool...)

08:41 <Anarchos> olle_ ocaml with linear logic typing system ?

08:50 <olle_> Anarchos: yes, something like this

08:51 <olle_> Anarchos: you can find presentation and paper online if you search for "kindly bent to free us ocaml"

09:17 <olle_> How can linear types ensure that a file handler is closed?

09:17 <olle_> at the end of the program

09:50 <higherorder> Hello! I started learning Ocaml this week-end and I have a question about polymorphic variants. In the spirit of row types, I am wondering if it's possible to write a function which eliminates a certain tag from a variant. e.g a function which would have a (fantasy) type signature like [`A | `B | rest] -> [`B | rest]

09:51 <higherorder> The context in which I'd like to write such a function is when writing a partial interpreter over an AST, which would interpret some (but not all) nodes

09:54 <octachron> Only if rest is a closed row type.

09:57 <flux1> olle_: I think by removing the ability to just forget a binding, you must feed it to some function to remove it from scope

09:58 <olle_> aha

09:58 <olle_> hm

09:59 <olle_> flux1: like a close_file function?

09:59 <olle_> oh yes, the difference between "use exactly once" and "use at least once"

09:59 <flux1> yes

09:59 <olle_> or "at most"

09:59 <olle_> 11:59 < flux1> yes

09:59 <olle_> hm

09:59 <flux1> or a function that calls close_file, etc

10:00 <olle_> flux1: right

10:01 <flux1> I guess the tricky part are like: what if you return a closure that closes the file ;).

10:01 <olle_> yeah

10:01 <olle_> phew

10:03 <olle_> whatever function that uses that closure must reflect it in its type, i guess

10:35 <olle_> or that outside that closure, there's no guarantee that the file is still open

10:36 <olle_> so you give away ownership permanently

11:25 <higherorder> octachron: how so?

11:27 <octachron> For instance, "type t = [`B | `C ] let f = function `A -> `B | #t as x -> x" works as expected

11:28 <higherorder> https://www.irccloud.com/pastebin/urpm85ps/

11:28 <higherorder> oops sorry for the weird snippet

11:30 <higherorder> (in ReasonML syntax). I think it's the same as your function but it doesn't infer the same type

11:33 <higherorder> ah nevermind; got it to work; thanks!

11:34 <octachron> The ` *list of constructors* as x` part is indeed important to decouple the input and output type.

11:35 <higherorder> what is the name of that construct? (#t). It's the first time I see it

11:39 <octachron> or-pattern abbreviation: https://ocaml.org/releases/4.10/htmlman/lablexamples.html#ss:polyvariant-advanced

11:50 <higherorder> thanks!

16:25 <clement_> Hi all. I'm porting an OCaml project that includes code generated using Coq to OCaml 4.09 (we originally targeted 4.07). Coq-generated code uses Pervasives everywhere, so I'm seeing plenty of deprecation alerts on 4.09. stdlib-shims doesn't help (I don't have control on what Coq generates) so I thought I'd silence the alerts while waiting for Coq to update. But what's the right way to disable the alerts? Adding (flags

16:25 <clement_> (:standard -alert -deprecated)) to my dune file works with 4.09, but it breaks the build in 4.07, and I don't think dune has conditional flags support. How should I deal with this? Thanks!

16:26 <companion_cube> maybe you could alias `module Pervasives = Stdlib` somewhere?

16:27 <Armael> that’ll break pre-stdlib

16:28 <companion_cube> not with stdlib-shims

16:39 <octachron> clement_, you can disable the alert through the (deprecated) deprecation warning "-w -3" rather than the alert mechanism

16:40 <companion_cube> (also, yessss)

16:42 <clement_> companion_cube: I don't know a good way to prepend text to Coq's generated ML code, but maybe with a careful grep? Or maybe with a copiler option to open a module that contains a fake Pervasives…

16:42 <clement_> octachron: Yes, perfect! That works nicely

16:43 <sleepydog> is there a Coq issue open to move to Stdlib ?

16:45 <clement_> sleepydog: https://github.com/coq/coq/issues/11359 maybe?

16:45 <companion_cube> yeah, `-open MyPrelude` or something

16:55 <clement_> In a similar vein, how do I tell OPAM that I need coq-ltac2 only if coq is < 8.11? I currently have "coq" {>= "8.9"} and "coq-ltac2" {>= "0.3"}, but coq-ltac2 is incompatible with 8.11 because it comes bundled with it.

16:57 <companion_cube> I guess one of these packages should declare the incompatibility

17:00 <clement_> It does: coq-ltac2 says it's not compatible with coq >= 8.11

17:00 <clement_> But as a result if I make it a dependency I can't target 8.11

17:01 <Armael> maybe coq-ltac2 should default to a dummy package if it detects coq >= 8.11

17:02 <Armael> or you have a different implementation of the opam package, one for <8.11 and one for >=8.11

17:03 <companion_cube> ^

17:04 <Armael> I think it’s how it works for the shim packages

17:04 <Armael> e.g. maybe look at the opam package for uchar

18:32 <clement_> Armael: Thanks, I will look :)

19:26 <olle> ocsigen mentiones comet but not websockets_

19:26 <olle> _?

19:26 <olle> comet should probably be considered deprecated

19:26 <olle> who's maintinaing this?????

20:10 <olle> Reason it is... grrr

20:13 <waleee-cl> olle: are you looking for strictly frontend-stuff?

20:16 <waleee-cl> if so, have you seen incr_dom?

20:17 <waleee-cl> or, https://github.com/OvermindDL1/bucklescript-tea/

20:19 <olle> waleee-cl: nah, i want to do both be and fe in ocaml with websockets

20:19 <olle> seems like there's no such thing right now

20:20 <olle> checking out reasonml + react right now

20:20 <waleee-cl> incr_dom is ocaml

20:21 <waleee-cl> https://github.com/janestreet/incr_dom/

20:22 <olle> waleee-cl: server or client?

20:23 <waleee-cl> client, js_of_ocaml

20:23 <olle> ah

20:23 <olle> not enough, need server too

20:25 <waleee-cl> yeah, that side has gone a bit stale unfortunately

20:26 <olle> pity

20:27 <olle> well, found a good blog post from last year, gonna give it a try :)

20:29 <waleee-cl> olle: found https://github.com/vbmithr/ocaml-websocket in this thread https://discuss.ocaml.org/t/how-to-use-websocket-websocket-class-in-ocsigen/1385/2

20:33 <olle> yes, I've done websocket with lwt before, years ago, but I want a ready-to-go framework for both server and client in one package

20:33 <olle> waleee-cl: thanks for tring xD

20:33 <olle> wait

20:34 <olle> yeah, i read that thread - no standard way in ocsigen, what i can find

20:36 <olle> waleee-cl: check this out: https://dev.to/deciduously/real-time-communication-in-reasonml-with-bs-socket-1p5l

20:41 <olle> seems like it transpiles ocaml to js on server side and client side

20:41 <olle> s/ocaml/reasonml