11:17 <hackinghorn> I would like to find all dir/test* files but Sys.readdir does not expand the *. Is there something that expand the "*" for me in this case?

11:32 <Fardale> I would find all files in dir/ and then filter to keep only the test*.

13:17 <d_bot> <zakkor> What is more commonly used: Base or Batteries?

13:17 <d_bot> <dinosaure> @companion_cube

13:31 <companion_cube> I imagine it's base > containers > batteries, but i don't have numbers

13:32 <companion_cube> Afaik no one but Unix junkie uses batteries anymore

14:05 <d_bot> <VPhantom> Really? I had never heard of Containers until today. 🤔

14:06 <companion_cube> 😔

14:06 <d_bot> <VPhantom> I know, I'm sorry…

14:07 <d_bot> <VPhantom> I learned initially with Real World OCaml (so, Base/Core) and then heard about a duality with Batteries in places like StackOverflow, where I haven't seen Containers come up very often.

14:14 <d_bot> <VPhantom> It'd be interesting to hear from long-time users (I'm just a rookie) what use cases might distinguish the three libraries.

14:19 <d_bot> <darrenldl> used core/core kernel for a while, my overall experience is it doesnt work very well with |> cause many arguments are labelled

14:20 <d_bot> <darrenldl> containers generally have the usual convenience functions you'd want

14:52 <companion_cube> SO for OCaml is pretty sparse, I think

14:53 <smondet[m]> used all of them and/or made my own at some point over the past couple of decades. I think JaneSt's “t comes first, label everything else” is the best approach, by far. The lower mental overhead and the gain in readability/maintainability out-weights any perceived inconvenience.

14:55 <companion_cube> it's not the only dimension though

14:56 <d_bot> <VPhantom> I like argument ordering predictability. I also naturally use a "t first" approach in my own work ever since my C days decades ago. I think it fits very naturally with OCaml's currying.

14:56 <companion_cube> backward compatibility is also a practical concern, as can be (depending on your taste) compatibility with the stdlib

14:56 <companion_cube> @VPhantom sometimes "t last" works best with currying and |> though.

14:57 <d_bot> <VPhantom> I do get a kick lately, of seeing how far I can go with just the Stdlib. And yes, first and last have special uses depending on what I'm doing. I tend to naturally place types first (for currying) and I/O references last (for piping).

15:02 <d_bot> <Patate> What do you mean by "t first" and "t last" aproach?

15:05 <d_bot> <Patate> is it something like

15:05 <d_bot> <Patate> apply : t -> f:(t-> unit) -> unit

15:05 <d_bot> <Patate> vs

15:05 <d_bot> <Patate> apply : f:(t-> unit) -> t -> unit

15:05 <d_bot> <Patate> ?

15:05 <companion_cube> yeah

15:05 <d_bot> <Patate> Oh ok

15:06 <companion_cube> e.g `Map.set: key -> 'a -> 'a t -> 'a t`

15:06 <companion_cube> so you can do `Map.empty |> Map.set 1 true |> Map.set 2 false |> Map.set 3 true`

15:06 <companion_cube> (if you have a int map)

15:06 <d_bot> <Patate> I see

15:07 <d_bot> <Ulugbek> Not particularly OCaml question, but I have a UDP socket that I send from and receive to a lot of packets in a short amount of time. I have a hypothesis that there is congestion in the socket because with logging turned on my application throughput goes much higher while with logging turned off the throughput is x100 less. I think that logging to stdout is taking time away from the sender and thus decreases the congestion.

15:07 <d_bot> <Ulugbek> Any idea on how to debug or solve such a problem?

15:08 <d_bot> <reynir> I have a `(char, Bigarray.int8_unsigned_elt, Bigarray.c_layout) Bigarray.Array1.t` but I really want a `(int, Bigarray.int8_unsigned_elt, Bigarray.c_layout) Bigarray.Array1.t`. Isn't there a way to reinterpret the bigarray? been staring at the docs for a while now

15:10 <d_bot> <darrenldl> @Ulugbek oh logging on sender? was really confused as i thought you meant logging on receiver

15:11 <companion_cube> @reynir I don't think you can have that, it'll always be a char array with a underlying int8

15:11 <d_bot> <Ulugbek> my application is a node in a decentralized system, where applications broadcast packets to each other

15:11 <companion_cube> (as far as I can tell)

15:11 <d_bot> <darrenldl> is your code async?

15:11 <d_bot> <Ulugbek> yes

15:11 <d_bot> <darrenldl> is it public?

15:11 <reynir> Hm okay

15:12 <reynir> now I'm frustrated :D

15:16 <d_bot> <Patate> I did not thought there would be a discord server dedicated to ocaml! This is pretty cool!

15:17 <d_bot> <VPhantom> I thought bigarrays could have different layouts applied to them? 🤔 With `genarray_of_array1` and co.

15:18 <d_bot> <VPhantom> Sorry I mean with `Bigarray.reshape`

15:19 <companion_cube> layouts yes, but the type vs underlying storage type are relatively fixed

15:20 <companion_cube> you can turn your thing into a 3D byte array if you want

15:20 <companion_cube> it'll still be `char`

15:20 <d_bot> <VPhantom> Ah yes I see they're matched in the signature. Bummer.

15:20 <d_bot> <Patate> Why do you need this @VPhantom ?

15:20 <companion_cube> you can go from char to int, but it means packing chars 4 by 4 or 8 by 8

15:21 <companion_cube> (so the result is 4 or 8× shorter)

15:21 <d_bot> <VPhantom> @Patate It's in reference to the question by @reynir and since I'm starting to learn how to do buffers and I/O with Bigarray I took an interest. 😉

15:21 <d_bot> <Patate> I am not sure this is what they wanted

15:22 <d_bot> <Patate> Oh yes, I mistook you for reynir ^^

15:24 <d_bot> <Patate> The goal is to see each int8_unsigned as an int instead of a char, am I right?

17:46 <reynir> yea

17:47 <reynir> well, I'm trying to use a bigarray from one API with another API, and one treats them as chars and the other as ints, but as far as I understand (and I don't understand bigarray very well) the underlying type in memory is 8bit unsigned ints

17:55 <Drup> reynir: there was a PR to add an operation to change the kind as you say

17:55 <Drup> something by gasche, iirc

18:08 <reynir> Ah

18:08 <reynir> curious what happened with that PR

18:23 <d_bot> <Patate> Oh ok, I understand better now

18:36 <d_bot> <Patate> There might be a hack to this, as after all they are both arrays of int8_unsigned internally... But I have no clue how to do it...

18:40 <d_bot> <EduardoRFS> Can pattern matching on a first class module change the type of an abstract type? Like it happens when matching on GADTs.

18:49 <d_bot> <Patate> What do you mean by pattern matching a first class module?

19:18 <d_bot> <octachron> Not currently, there are not type equation to introduce when pattern matching on a first class modules

19:21 <companion_cube> how are equations handled, internally? rewriting?

19:42 <d_bot> <Alistair> Is there any documentation on how gadts are implemented?

19:51 <d_bot> <octachron> The current implementation works by adding a temporary expansion to an abstract type through the environment (which is why GADTs can only refine abstract types).

19:57 <d_bot> <octachron> I fear that the documentation are the few articles on the subject, the few comments in the code and the code itself.

19:58 <d_bot> <Alistair> I've read the ambivalent types paper, but it was rather unclear on a couple things and I was looking to see whether the code could clarify anything

20:21 <d_bot> <hcarty> @reynir IIRC there was a post on the discuss forum showing how to use ctypes to cast bigarrays between different types but the same memory representation

20:22 <d_bot> <hcarty> https://discuss.ocaml.org/t/cast-bigarray-kind/8469/6 is the thread I was thinking of

21:02 <Corbin> https://news.ycombinator.com/item?id=29594762 is there any merit to this complaint? AFAICT they're just being tribal, but it would be nice to know about such issues.

21:08 <companion_cube> that's 100% bullshit

21:09 <Armael> this looks like standard HN shitposting? very few factual elements are being discussed there

21:13 <companion_cube> s/few/none/

21:23 <Leonidas> Corbin: well, that post doesn't factuate anything, really. "the way Haskell or Ocaml are built" means nothing

21:23 <Leonidas> Like, does the poster dislike the build system? the fact that they are both written in C? Who knows!

21:23 <companion_cube> you could replace by "python and php" and it'd be at least as accurate

21:23 <Leonidas> > They both have a single relevant implementation

21:24 <Leonidas> Which is true for nearly all languages.

21:24 <companion_cube> > OCaml is moving too fast

21:24 <companion_cube> lolllllolol

21:24 <Leonidas> Notable exceptions include Java (which has... like two relevant implementations) and maybe C/C++?

21:25 <Leonidas> Yes, the moving too fast thing is ridiculous

21:25 <Leonidas> > Ocaml lacks good docs

21:25 <Leonidas> This might be the possibly best substatiated claim but this is getting better.

21:26 <Leonidas> and honestly the ocaml manual is not much worse than the python manual.

21:26 <Leonidas> so yeah, total shitposting

21:34 <d_bot> <Kakadu> > ... the language's functional programming style and clear expressiveness made it possible for code reviews to be performed by traders [from Janestreet] who were not programmers...

21:34 <d_bot> <Kakadu> Do you know how to factcheck this sentence from wikipedia? It could be true but I never heard about it before

21:35 <d_bot> <VPhantom> I have read it in posts by Yaron Minsky. Possibly the ACM post from way back, actually. Digging…

21:37 <d_bot> <VPhantom> Huh, I thought he said it in <https://queue.acm.org/detail.cfm?id=2038036> (2011) but I can't find the quote I have in mind in there. 🤔