06:02 <insep> hi, i have a question related to dune, is it possible to build just dune-configurator and install only it?

06:28 <d_bot> <rgrinberg> I don't see how that's possible. You need dune to build dune-configurator

06:39 <insep> i already have dune, i just want to build dune-configurator separately from anything else, currently i have `dune build @install -p dune-configurator; dune install --destdir="/"`, but that second command complains about missing <package>.install for everything

06:47 <d_bot> <rgrinberg> You can do `dune install dune-configurator --destdir="/"`

06:51 <insep> that worked, thx!!!!

14:13 <d_bot> <Cyclomatic Complexity> because it is impossible to google for symbols, i have to ask here instead

14:13 <d_bot> <Cyclomatic Complexity> how do you redefine custom array operators? like, I'd like to define `[|| woo ||]`, or even just overload `[| |]`

14:13 <d_bot> <Cyclomatic Complexity> i have found custom indexing operators, but i'm interested in custom array constructors

14:17 <d_bot> <ggole> `[||]` is implemented directly afaik

14:18 <d_bot> <Cyclomatic Complexity> i think i saw custom constructors

14:19 <d_bot> <Cyclomatic Complexity> must have been ~~the wind~~ a ppx / just misremembering custom indexing ops

14:20 <d_bot> <ggole> The closest thing is redefining the constructors that list literals are desugared into

14:20 <d_bot> <ggole> But those are datatype constructors, which are quite different from the array literal

14:21 <d_bot> <ggole> There was a custom literal thing as well, but that isn't standard

14:26 <d_bot> <octachron> Another issue is that `[| |]` is not an ordinary function, contrarily to `Array.get` (`.()`) and `Array.set` (`.()<-`).

18:26 <d_bot> <Alistair> Is it possible to have changes in the `.ml` file be automatically reflected in the `.mli` file. e.g. type definitions / module type definitions

18:30 <dmbaturin> Alistair: ocamlc -i prints module interface, though it can't merge and update.

18:32 <d_bot> <Alistair> Also is there a library function to map on `Result.t` errors? e.g. `emap : ('a, 'e) t -> f:('e -> 'f) -> ('a, 'f) t`?

18:32 <companion_cube> in which library? :p

18:33 <d_bot> <Alistair> Base

18:33 <companion_cube> oh, surely. idk base.

18:33 <dmbaturin> Result.map is in stdlib.

18:33 <companion_cube> but this is map_err

18:33 <d_bot> <Alistair> Found it, `Result.map_error`

18:33 <dmbaturin> Yes, sorry. map_error

18:34 <d_bot> <roddy> @TheBloodlessMan Unfortunately no, the standard way of dealing with painful amounts of duplication is the intf trick https://www.craigfe.io/posts/the-intf-trick

18:34 <dmbaturin> I arguably should be sleeping now, but I'm not.

18:34 <companion_cube> the intf trick ♥

18:36 <dmbaturin> GOod reminder, I need to do that in the TOML lib.

18:53 <d_bot> <Alistair> Can you inherit type constructors in ocaml? I guess polymorphic variants sort of do this, but I was wondering if there are any other ways. Context: I have a `Solver.error` type, which my `Infer` module is currently wrapping around w/ `SolverError of Solver.error` constructor, but kinda adds another level of pattern matching, so I was wondering whether `Infer.error` could extend `Solver.error`?

18:54 <dmbaturin> There are extensible (open) sum types, but there's no inheritance there. If you want inheritance, you may need to resort to... objects. :)

18:55 <d_bot> <Alistair> oh no, not objects 😟

18:56 <dmbaturin> Nothing wrong with objects.

18:56 <jyc> objects are kind of nifty in OCaml, row polymorphism is pretty useful

18:56 <dmbaturin> I'm sometimes seriously thinking of writing an parallel universe standard library with objects. ;)

18:57 <companion_cube> the biggest issue for me, with objects, is that merlin is not too good on them

18:57 <dmbaturin> Hhm, but it _can_ be made to be good with it?

18:57 <Fardale> merlin is not good with object because nobody use object, or nobody use object because merlin is not good with it?

18:58 <jyc> is merlin recommended over ocaml-lsp? I last used OCaml "seriously" before ocaml-lsp came out

18:58 <companion_cube> oh I mean, same thing

18:58 <companion_cube> ocamllsp is merlin + lsp more or less :D

18:58 <companion_cube> afaik

18:59 <jyc> oh haha

18:59 <jyc> thanks

18:59 <companion_cube> Fardale: no idea :p

19:04 <d_bot> <monk> are row types in ocaml predicated on using its class system or can you get away with just using ocaml objects for it

19:04 <d_bot> <monk> row polymorphism*

19:04 <companion_cube> it only works with objects I think

19:04 <companion_cube> (and poly variants)

19:05 <d_bot> <monk> coolio

19:07 <d_bot> <monk> i have nothing against Objects generally, it's subtyping by way of class inheritance where i get angry

19:07 <d_bot> <Alistair> Is there a reason to the following? I understood that `private` just ensures that a value of the type couldn't be constructed outside the module? ```

19:07 <d_bot> <Alistair> utop # type basic = private [ `Black | `Red ];;

19:07 <d_bot> <Alistair> type basic = private [ `Black | `Red ]

19:07 <d_bot> <Alistair>

19:07 <d_bot> <Alistair> utop # type foo = private [ basic | `Green ];;

19:07 <d_bot> <Alistair> Line 1, characters 21-26:

19:07 <d_bot> <Alistair> Error: The type basic does not expand to a polymorphic variant type```

19:08 <companion_cube> @monk: subtyping is not correlated to inheritance in OCaml :)

19:08 <companion_cube> and you cn use `object … end` expressions without any class, if you so wish

19:08 <d_bot> <monk> terminology bites me once again

19:09 <companion_cube> @Alistair: not sure what `private` on poly variants is useful for

19:10 <d_bot> <Alistair> Excellent point 🤦‍♂️

19:11 <companion_cube> without `private` it works pretty well :p

19:46 <d_bot> <octachron> @TheBloodlessMan : a private abbreviation creates a new type that is a subtype of the abbreviated type. Thus the issue with inlining the type definition in a polymorphic type expression.