08:38 <discocaml> <.sarna.> I'm writing an interpreter. I have a module `Object` that is used by `Environment` (which holds name -> `Object.t` pairs). `Environment.t` is used by the interpreter. but then, one of the `Object.t` variants is `Callable`, and it needs a pointer to `Interpreter.t` - aand I have a dependency cycle

08:39 <discocaml> <.sarna.> (object -> environment -> interpreter -> object)

08:39 <discocaml> <.sarna.> any idea how to break it up? I tried many times and only failed so far..

08:46 <discocaml> <Kakadu> Could you add a type parameter to environment and put Object.t there?

09:02 <discocaml> <.sarna.> I got a new cycle.. I added another type parameter though, and it *almost* works - the only thing I have left is: `exception My_exception of Foo.t * string`

09:02 <discocaml> <.sarna.> how can I make something like this compile? `exception My_exception of 'a Foo.t * string`

09:05 <discocaml> <.sarna.> is it possible? docs say that `exception` needs a "type expression", and further that "Type constructors with no parameter, as in typeconstr, are type expressions."..

09:35 <discocaml> <NULL> The information of type `'a` would be lost in the exception, so you cannot do that

09:47 <discocaml> <.sarna.> then I'm hopelessly stuck 🫠

10:32 <discocaml> <.sarna.> ok I solved it by making a `Types` module and putting all the type definitions there. I have functions in other modules

10:32 <discocaml> <.sarna.> not satisfying, but works..

10:33 <discocaml> <.sarna.> (also, had to add a ton of type hints)

11:26 <discocaml> <octachron> To avoid the hint issue, you can re-export the types in their respective module

11:27 <discocaml> <octachron> `module Object = struct type t = Types.Object = .... . end`

11:27 <discocaml> <octachron> `module Object = struct type t = Types.object = .... . end`

11:44 <discocaml> <.sarna.> ah neat, I'll try that

17:34 <discocaml> <.sarna.> hey, I noticed that when I have `Printexc.record_backtrace` it kills performance when using exceptions for exiting loops (my program gets overall 15x slower). I'm using `raise_notrace` for this - any clue why the backtrace still seems to be generated? can I disable it somehow/use a different mechanism?

17:38 <discocaml> <.sarna.> for now I found out that `Base.Exn.raise_without_backtrace` works (ie truly doesn't generate a backtrace and doesn't result in a slowdown)

18:55 <companion_cube> Hmm, do you raise the exception in a different function than the place it's caught in?

18:56 <companion_cube> How do you know a trace is still generated?

19:03 <xavierm0251> Hi. I would like to know if it is possible to track which constructors of an inductive type are used in a term. I tried using a GADT indexed by polymorphic variants, which manages to track which constructors are used when building a term, but fails to see that replacing a constructor A by another constructor C in a term with no constructor B always

19:03 <xavierm0251> yields a term without any constructor B: https://pastebin.com/Z8f0G154

19:04 <discocaml> <.sarna.> companion_cube: I know because my program gets 15x slower and in profiling I can see `caml_get_exception_raw_backtrace` takes 80% of execution time

19:04 <discocaml> <.sarna.> and yes, it's crossing function boundaries - is it important? if it says "notrace" I'd expect no trace..

19:28 <companion_cube> I'm not sure, but at least I know that the compiler can't know that this will never escape

19:29 <companion_cube> I try to keep that inside a function so it knows that the exception is local

19:36 <companion_cube> I feel stupid, but what's the email address to write on dicuss? I'm on my phone and I don't have it in my contacts as usual 😅

20:47 <octachron> xavierm0251, you can add a type tag to every variants. However, polymorphic variants are not really a good fit. Typically, your type or `replace_A_by_C` is not valid. With a closed set of variants/tags, the dual object types work somehow better.. And like always with GADT you need to annotate every functions.

22:18 <xavierm02_> octachron: I tried making it work with objects by having one field name per constructor, and the type of that field indicating whether the constructor was used or not, but the type I get for replace_A_by_C is too strict. https://pastebin.com/38ZSnUxy

22:21 <xavierm02_> I also tried representing the use a constructor by the presence of a field, but that did not work either.

22:31 <xavierm02_> (I'll disconnect now, but will read the logs tomorrow)