10:47 <discocaml> <xavierm02_> Is there an idiomatic way of making explicit that the onus is on the programmer to check that some invariant holds when using a function? When the invariants are simple enough to be decidable, one can simply check that they hold and throw an exception if they do not, but they often are not. For example, it would be reasonable to have `module Injection : sig type ('a, 'b) t = private 'a -> 'b val of_fun : ('a -> 'b) -> ('a, 'b) t end`, and

10:50 <discocaml> <xavierm02_> I'd like to make this explicit because otherwise, one might use `Injection.of_fun` without checking the invariants just like e.g. `MemoizedFunction.of_fun`.

10:53 <discocaml> <xavierm02_> Maybe defining a type `type promise = IPromiveThatICheckedTheInvariants` and then `val of_fun : ('a -> 'b) -> promise -> ('a, 'b) t`?

10:53 <discocaml> <leviroth> Seems reasonable, though in a lot of contexts putting something about injectivity in a labeled argument may accomplish the same goal.

10:59 <discocaml> <xavierm02_> Ah so `val of_fun : i_promise_that_i_checked_the_invariants: unit -> ('a -> 'b) -> ('a, 'b) t`?

11:23 <discocaml> <leviroth> That could work, but I was thinking of something slightly different. I was assuming that if you need the user to provide an injective function `f`, they're probably providing it as a function argument to some higher-order function `h` (maybe there are other cases though). So you could have `h`'s argument be labeled e.g. `val h : injective_function:('a -> 'b) -> ...`

11:59 <discocaml> <xavierm02_> The actual type contains more than just the function, so it's easier to have everything take arguments of type `('a, 'b) t`. But I guess this also applies to `of_fun`, I could have `of_fun : injective_function: ('a -> 'b) -> more_stuff -> ('a, 'b) t`.

11:59 <discocaml> <xavierm02_> I think I'll go with that. Thank you!

13:56 <neiluj> hi! trying to pass a module in a function: let f ((module B_mod) : (sig include module type of A.B end)) = (module struct ...)

13:57 <neiluj> why is the signature of B_mod not accepted? there is a syntax error near the sig

14:05 <octachron> The type of first class modules needs to be an explicitly named module type.

14:07 <discocaml> <xavierm02_> neiluj: I think it should be `let f ((module M) : (module S)) = ...` or `let f (module M : S) = ...` instead of `let f ((module M) : S) = ...`

14:08 <discocaml> <xavierm02_> In addition to what octachron said, so adding `module type S = sig include module type of A.B end` before the definition of `f`

14:23 <adrien> hi, is there a syntax to deconstruct labelled arguments?

14:26 <neiluj> it works, many thanks!

14:26 <octachron> let f ~x:(Some _ | None) = ()

14:28 <adrien> octachron: thanks! :)

14:33 <neiluj> can you pass a functor to a function?

14:35 <octachron> first class module can contain functors

14:46 <neiluj> indeed:)thx!

14:57 <discocaml> <xavierm02_> Is it possible to "open" constructor or field names without "opening" the corresponding type? More precisely, is it possible to replace `open M` by something else to get this code to typecheck: https://pastebin.com/h5681xsd

14:59 <discocaml> <xavierm02_> I know there are other ways to make this compile such as `let f ({field} : M.t) = field + 1` or `let f {M.field} = field + 1`, but I'm looking for an alternative to the open

15:01 <discocaml> <xavierm02_> If the type lives in another module, this can be done with ppx_import, e.g. `open (struct type%import other_name = M.t end)`, but otherwise, I don't know how to keep the definition of t while renaming it

15:02 <discocaml> <octachron> You can re-export the type definition by hand.

15:02 <discocaml> <octachron> But that sounds like a complicated solution to avoid having an alias for the toplevel `t` or using qualified field names.

15:15 <discocaml> <xavierm02_> I was hoping there was some trick with a `:=` substitution on module types 😦