12:17 <neiluj> hi!

12:17 <neiluj> are optional default values evaluated if a value is supplied?

12:19 <neiluj> for instance `let foo ?(x=bar()) () = x`

12:27 <theblatte> I'd say yes but that's easy to test :)

12:29 <theblatte> also I'd be wrong

12:29 <discocaml> <dumbpotato> ```# let counter = ref 0

12:29 <discocaml> <dumbpotato> let increment refcell =

12:29 <discocaml> <dumbpotato>     let current = !refcell in

12:29 <discocaml> <dumbpotato>     refcell := current + 1;

12:29 <discocaml> <dumbpotato>     current

12:29 <discocaml> <dumbpotato> let add ?(x=(increment counter)) y = x + y;;

12:29 <discocaml> <dumbpotato> # add 0;;

12:29 <discocaml> <dumbpotato> - : int = 0

12:29 <discocaml> <dumbpotato> # add 1;;

12:29 <discocaml> <dumbpotato> - : int = 1

12:29 <discocaml> <dumbpotato> ```

12:29 <discocaml> <dumbpotato> looks like it’s evaluated every time like in javascript not once like in python

12:30 <neiluj> thanks, indeed ocaml is strict

12:58 <companion_cube> (it's the good choice, too; python's choice is broken and a classic footgun)

13:32 <neiluj> actually, no: if a value is provided the default value is not executed

13:34 <neiluj> let f ?(x = assert false) () = x;;

13:34 <neiluj> neither f ~x:3;; nor f ~x:3 ();; crash

15:51 <discocaml> <leviroth> Weirdly the behavior of default arguments doesn’t appear to be described at all in the language reference chapter of the manual

15:59 <companion_cube> surprising indeed, I don't find anything either

16:06 <discocaml> <octachron> The behavior is partially unspecified currently (because it matters for optimizing heavy user of optional arguments like lablgtk), see https://github.com/ocaml/ocaml/pull/10653 .

16:07 <discocaml> <leviroth> I am also kind of ambivalent about the behavior. I mean it’s called a default value, but the semantics are that it’s a default *expression* that gets evaluated later on!

16:23 <companion_cube> that's fair, but it being an expression is the correct behavior when you think of it

18:25 <adrien> how much more memory-expensive is Foo (1,2,3) compared to (1,2,3)?

18:25 <companion_cube> if declared as `… | Foo of int * int * int`, same amount of memory

18:27 <adrien> thanks; and, how could they be declared otherwise?

18:27 <adrien> s/they/it/

18:31 <companion_cube> `| Foo of (int * int * int)`

18:31 <octachron> "Foo of (int * int * int)" is a block of size 1 containing a pointer to the triple.

18:31 <companion_cube> which is 2 words more

18:32 <adrien> ah, ok; makes sense, thanks

18:51 <companion_cube> have you tried statmemprof?

18:54 <adrien> no, not at the moment

18:54 <adrien> I've been mostly reading the code because it's short and I think I actually found the right place to insert Gc.do_something ()

18:56 <adrien> basically, after "BatIMap.(imap |> from low |> until high)" where low and high are close relative to the bounds of imap

18:56 <adrien> and actually I've also wrapped that in a function because I don't know if this form makes the intermediate value (between from and until) collectable

19:05 <adrien> I can't really tell if it works or if it makes the program so slow that the memory seems to not increase

20:50 <adrien> I let the machine do the work; basically that part of the code really seems to need 14GB or so; another later part generates more garbage and more frequent collections help stay under 16GB instead of reaching 21GB at the cost of CPU time; next step will be to analyse the large value but it's an interval map for [0..200M] with more than 10M values and it's possible memory usage cannot be improved