02:05 <d_bot> <gorilacoding> Anyone have general tips on ocaml code optimization?

02:17 <d_bot> <RegularSpatula> https://ocamlverse.github.io/content/optimizing_performance.html

02:20 <d_bot> <gorilacoding> Thank you!

13:04 <d_bot> <Ulugbek> This one can also be useful: https://tarides.com/blog/2019-09-13-decompress-experiences-with-ocaml-optimization

13:33 <mclovin> gorilacoding: if you can speak french: https://www.irill.org/videos/OUPS/2021-12/oups-dec21-chambart.html

14:11 <neiluj> Hi!

14:13 <neiluj> Is there a way to define a polymorphic function but restrained to types having access to a specific function ? For instance "let print_array ~label a = Printf.eprintf "%s = %s" label ((Array.map (fun e -> (to_string e) ^ "\n") a) |> Array.to_list |> String.concat "")

14:14 <neiluj> where a is an array of elements that can be converted to a string

14:14 <neiluj> sorry it's pretty vague

14:16 <neiluj> maybe adding a module as an argument having to_string in its signature and binding the module's abstract type t to the type of the elements of a?

14:16 <neiluj> if that makes sense

14:28 <mclovin> You could just add a `to_string` parameter to `print_array` ?

14:32 <neiluj> indeed, that's way simpler!

14:32 <neiluj> thanks

17:32 <quartz> Hello. I'm having trouble compiling my code. The error I'm getting is: reference to unbound regexp name 'digit' on line 90 character 3. https://bpa.st/3JYQ

17:33 <d_bot> <NULL> You defined digit as OCaml value and not ocamllex "regexp" (apparently that's how they're called)

17:35 <quartz> What is OCaml value?

17:36 <d_bot> <NULL> A regular OCaml definition

17:37 <quartz> So I need to change line 90 to regexp digit+ as lem...

17:39 <quartz> Ahhh that does not work either

17:41 <d_bot> <NULL> I think your definitions in the preamble won't work, they need to be put in the ocamllex part

17:41 <d_bot> <NULL> I'm talking about digit letter whitespace and newline

17:43 <quartz> Lines 25 - 29?

17:45 <d_bot> <NULL> Yes

17:46 <quartz> What do you mean by the 'ocamllex part'?

17:46 <d_bot> <NULL> After the closing }

17:48 <quartz> Hmmmm, OK

17:52 <quartz> Now it's telling me: "Error: unbound constructor DEDENT line 30

17:52 <quartz> https://bpa.st/UACA

17:53 <quartz> I only defined it once... how can it be a problem?

17:53 <d_bot> <NULL> Is it defined in Parser ?

17:54 <quartz> Good question

17:54 <d_bot> <NULL> Where is it defined ?

17:57 <quartz> I'm not sure, I'll check the parser

20:03 <d_bot> <AZAH> Is there a Cheatsheet with all the List operations?

20:04 <d_bot> <NULL> https://ocaml.org/api/List.html

20:04 <d_bot> <AZAH> Like a pdf, with examples maybe

20:04 <d_bot> <NULL> Not a cheatsheet, but at least it's an exhaustive list

20:48 <Corbin> In any CAM, including OCaml, is it expected that the bytecode for folding over a list (starting at the nil-end of the list) will push a stack entry for every element in the list?

21:31 <zozozo> Corbin: assuming that fold_left is tail recursive (which it should), it should operate in constant stack space

21:33 <zozozo> So if it pushes a stack entry for recursive calls, I'd expect that entry to replace the current one (which might be implemented as a pop then push, but I have no idea if it's a good idea, pour of it's implemented that way in the CAM)

22:29 <Corbin> zozozo: Curious. Using the labels in https://ocaml.org/api/List.html#1_Iterators, where the list's elements are [b1; b2; ...; bn], how is the list (not) unpacked onto the stack? Wouldn't each of the elements generate a pending stack frame?

22:30 <d_bot> <NULL> (Most of) those functions start from the top, so they follow the pointers and don't have to lay the list down in memory

23:06 <Corbin> NULL: That's interesting. Is there documentation on exactly how this works? I've been reading the CAM and ZINC papers, but haven't quite made it all come together.

23:07 <d_bot> <NULL> That's mostly my intuition about how tail-recursion-optimisation works out

23:25 <Corbin> Hm. Still puzzled. A list [b1; b2; ...; bn] would be constructed as (cons bn (cons ... (cons b2 (cons b1 (nil))) ... )). So, in a CAM, if we wanted to deconstruct the list, then the only cell we can access first is bn. Accessing the other cells would require pushing the intermediate cells to the stack, I think?

23:26 <d_bot> <NULL> OCaml lists are prepended, not appended

23:26 <d_bot> <NULL> `[b1; b2; ...; bn]` is `b1 :: b2 :: ... :: bn :: []`

23:28 <Corbin> Oh! Okay. For some reason I got convinced that ZINC derivatives like OCaml were the other way around in memory. Well, that's one fewer mystery, thanks.