01:53 <d_bot> <msk> Hello fellow travelers 🙂 I'm trying move from Erlang to Ocaml, and I cant seem to find a good "timestamp" to work with... lets say I have a timeseries, and I would like a list of (timestamp, int) pairs... what would be the best timestamp to use ? if I want ns resolution?

01:58 <companion_cube> using which clock?

01:58 <companion_cube> if you're using the standard posix clock, there's `ptime`

01:58 <companion_cube> if using a monotonic clock (probably not, it's more for profiling within one process run) there's `mtime`

10:45 <d_bot> <Alistair> Is there an idiomatic way to do private exceptions? e.g. a constructor for `exn` that can only be constructed in the defined module. I know you can do `type exn += private ...`, but seems a bit reliant on knowing internally that `exn` is an open type.

11:01 <d_bot> <darrenldl> @msk depends on what you want to use the timestamp for next, but ptime is a good bet

11:01 <d_bot> <darrenldl> @msk ^

11:30 <d_bot> <octachron> `exn` is an extensible sum type, the special exception syntax is here only because exceptions predate extensible sum.

11:45 <d_bot> <inkbottle> I want to convert `let eval_value (type a) (v : a value) : a =` to `let eval_value = fun` syntax, but so far I can't get it accepted by the type checker. (from https://dev.realworldocaml.org/gadts.html)

11:49 <d_bot> <bnguyenv> `let eval_value : type a. a value -> a = fun v -> ...` ?

11:58 <d_bot> <glennsl> Or `let eval = fun (type a) (v: a value): a -> ...`

11:58 <d_bot> <glennsl> I think `type a.` is slightly more restrictive

12:05 <d_bot> <inkbottle> hum

12:05 <d_bot> <idnes> how is the notation `type a. a t -> a` called and what does it mean? define some generic `type a` and then the signature is `a t -> a`? how is `a t` itself called? i understand that it is a type `t` with subtype `a` somehow... but where do i look for that in the manual?

12:06 <d_bot> <octachron> `let eval_value = fun (type a) -> fun (v: a value) : a -> ....`

12:08 <d_bot> <octachron> The `type a . a value -> a ` syntax combines the creation of fresh locally abstract type `a` with an explicit universal quantification over this type `a`. It is required if your `eval` function is recursive.

12:09 <d_bot> <octachron> @idnes , there are GADTs: https://ocaml.org/manual/gadts-tutorial.html

12:10 <d_bot> <inkbottle> I'm not familiar with the `: a` part of `fun (v: a value) : a ->`

12:10 <d_bot> <inkbottle> the latter one

12:13 <d_bot> <octachron> `fun p : ty -> expr` is a syntactic sugar for `fun p -> (expr:ty)`

12:14 <d_bot> <tjltjl> ...so it took me a few weeks of active use of OCaml to finally switch to the janestreet core library. But now I think I'm pretty much settled

12:16 <d_bot> <inkbottle> @octachron `fun (type a) (v : a value) -> (match v with Int x -> x | Bool x -> x) : a`, this is not accepted, I'm missing something.

12:17 <d_bot> <inkbottle> about the syntactic sugar from above

12:18 <d_bot> <NULL> The brackets after the last `->`

12:18 <d_bot> <octachron> ((match v with Int x -> x | Bool x -> x) : a)

12:18 <d_bot> <NULL> (which include the type annotation)

12:19 <d_bot> <inkbottle> tx, really cool.

12:20 <d_bot> <inkbottle> `ocamlformat` doesn't want to leave it like that, but it's another story. Maybe there is a way to convince it otherwise.

12:25 <d_bot> <Alistair> Would it not be beneficial to provide syntax e.g. `private exception of ...` though?

12:26 <d_bot> <idnes> thanks

12:28 <d_bot> <inkbottle> Another question: can we understand `fun (type a) v -> t`, as a function taking a type parameter like with the "polymorphic lambda calculus" (though we don't need, and can't really provide it)? (That would be `\Lambda a . \lambda v . t`)

12:31 <d_bot> <Bluddy> any use-cases in the wild of extensible types?

12:31 <d_bot> <Alistair> Effects

12:32 <d_bot> <octachron> @TheBloodlessMan that would increase the duplication of syntax for the same underlying concept.

12:32 <d_bot> <octachron> hmaps, format tags, ...

12:34 <d_bot> <octachron> @inkbottle it does introduce a fresh type variable, but like you said the parallel is limited when there is no explicit application of functions to types.

12:35 <d_bot> <Alistair> Yes, however, it would provide more *consistent* syntax for exceptions. Also it is not immediately obvious to beginners (or intermediate) users of the language that exceptions and extensible variants are necessarily the same thing

12:44 <d_bot> <inkbottle> @octachron tx

12:50 <d_bot> <Bluddy> @octachron mind if I copy your explanation from stack overflow to ocamlverse? https://stackoverflow.com/questions/54730373/when-should-extensible-variant-types-be-used-in-ocaml I'll credit you

12:51 <d_bot> <idnes> re ocaml/ocaml repo: do i have to make an issue before i submit a pr? i got ocaml to compile using mingw+microsoft compiler, i.e. no cygwin

13:01 <d_bot> <octachron> @Bluddy sure, but note that my explanation answers the question asked in the body (how are extensible sums represented at runtimes) rather than the one in the title.

13:04 <d_bot> <Bluddy> still a very good explanation

16:33 <d_bot> <mbacarella> Is there a proper name for sub-libraries inside of opam? e.g. if you `opam install core` you only install the core opam package, but if you then do `ocamlfind list | grep core` you'll see a bunch of sub-libraries like `core.nano_mutex` and `core.daemon`. You simply list those in the dune `libraries` stanza if you want them.

23:05 <d_bot> <cod1r> hi

23:40 <imode> seems like the streams documentation is broken. https://ocaml.org/learn/tutorials/streams.html

23:40 <imode> lots of errors.