01:23 <mizlan> Hello! How may I encode a value of type (string * int) list to a value of type Yojson.t as an object? Or anything like int -> Yojson.t (`Int)

13:39 <discocaml> <JM> I wouldn't hold my breadth for OCaml 5 support. The activity on esy has been pretty low, and the OCaml community is more focused on opam+dune so you'll have better support by sticking to these tools.

13:49 <discocaml> <Ada> yeah, i pretty much came to the conclusion myself that i should just learn my way around dune and opam

13:49 <discocaml> <Ada> it’s a shame cause ocamls existing tools can definitely be daunting but idk

13:50 <discocaml> <Ada> everything to do with reason now seems to be more focused on rescript which as far as i can tell is ocaml rewritten to look like typescript, then compiled to javascript

14:00 <discocaml> <JM> It's true that the folks behind rescript have diverge from the OCaml ecosystem, but the original "philosophy" of Reasonml is still much alive, and we have tools like https://melange.re/ that will allow you to use OCaml and/or Reason for backend as well. (so one more reason to learn dune 😉 )

14:11 <discocaml> <deepspacejohn> Unless there's a very concrete reason to use Esy, my unofficial suggestion is to just use OPAM. The time it takes to learn how to use it is a small price to pay for having a more reliable package manager. Source: I personally tried using Esy when I was new and I kept running into random incompatibilities or edge-case bugs that I wasn't prepared to deal with. Most things have "just worked" with OPAM and there's much more community support

14:12 <discocaml> <deepspacejohn> Just my personal/anecdotal opinion, and I'm sure others may disagree. But I believe OPAM is more beginner friendly, either way.

15:55 <discocaml> <tym972> Hi, I have a problem with an interactive program. The "flush stdout" don't work as excepted. Could someone help me?

15:56 <discocaml> <octachron> With more information, probably. With the available data, the most likely culprit is `Format` internal buffer.

15:58 <remexre> I'm trying to make a Hashtbl with mutable keys, compared by pointer; is there an Obj function to get the (address >> 1)

15:59 <remexre> Or does with_tag do what I want

15:59 <discocaml> <tym972> I'll find out, thank you

16:00 <discocaml> <octachron> Pointer addresses are not stable you cannot store them or use them for comparison.

16:00 <remexre> Hm, is the recommended approach to use the generic hash function on a tuple of all the immutable fields then?

16:03 <discocaml> <contificate> Can use polymorphic hash, `Hashtbl.hash`, if things you define to be "equal" would hash to the same values. Things can be considered equal, like sets implemented atop balanced trees, even if structurally unequal, so you'd roll your own in that case.

16:03 <discocaml> <contificate> To get around the pointer stuff, you can just ascribe tags yourself. That's not too uncommon when you can't rely on an actual pointer value, since the object it points to may be moved (during collection/movement from minor to major heap).

16:07 <remexre> Yeah, Hashtbl.hash doesn't work because of the mutability; by a tag, you mean add a field with unique contents to each value? I think that'd work, actually...

16:10 <discocaml> <contificate> I've done it before, although I haven't done it for mutable keys.

16:10 <discocaml> <contificate> In the past, I've thought I'd need mutable keys but managed to work around it.

16:11 <discocaml> <contificate> For example, you can do a LALR parser generator (which is like sets of item sets, modulo lookahead - you merge them, blah blah), and I just had a kind of "canonical representation" map, immutable keys (the immutable component) mapping to the mutable representation (which I modified during processing, then basically "resolved" every item set by gets its representative from the map at the end).

16:11 <discocaml> <contificate> For example, you can do a LALR parser generator (which is like sets of item sets, modulo lookahead - you merge them, blah blah), and I just had a kind of "canonical representation" map, immutable keys (the immutable component) mapping to the mutable representation (which I modified during processing, then basically "resolved" every item set by getting its representative from the map at the end).

16:12 <discocaml> <contificate> For example, you can do a LALR parser generator (which is like sets of item sets, modulo lookahead - you merge them, blah blah), and I just had a kind of "canonical representation" map, immutable keys (the immutable component - LR(0)/core item set) mapping to the mutable representation (the LR(0) core w/ lookaheds - which I modified during processing, then basically "resolved" every item set by getting its representative from the map at th

16:12 <discocaml> <contificate> For example, you can do a LALR parser generator (which is like sets of item sets, modulo lookahead - you merge them, blah blah), and I just had a kind of "canonical representation" map, immutable keys (the immutable component - LR(0)/core item set) mapping to the mutable representation (the LR(0) core w/ lookaheads - which I modified during processing, then basically "resolved" every item set by getting its representative from the map at t

17:59 <discocaml> <Et7f3 (@me on reply)> It depend of the os. On windows it seems to be a viable option