01:09 <discocaml> <hockletock> Is this use of <- to write to a bytes value from olden times? https://v2.ocaml.org/api/Bytes.html#bytes_mixed_access

01:31 <discocaml> <leviroth> It still exists, but is deprecated, in OCaml 4.14.0

01:31 <discocaml> <leviroth> It was removed in 5.0

01:32 <discocaml> <leviroth> https://discuss.ocaml.org/t/syntaxic-sugar-string-set-bytes-set/10275/6?u=levi_roth

08:29 <discocaml> <octachron> The `_.[_] <-_` operator on `string`s was deprecated in 4.02 at the time where (immutable) strings and (mutable) bytes were split in two distinct types. The operator never worked on `Bytes.t`.

09:48 <discocaml> <xavierm02_> I am representing function `'a -> 'b` with `'a` and `'b` known at runtime as `type ('a, 'b) func = {source: 'a Type_equal.Id.t; target: 'b Type_equal.Id.t; func : 'a -> 'b}` (where `Type_equal.Id` allows testing equality between types at runtime, see https://ocaml.janestreet.com/ocaml-core/v0.12/doc/base/Base/Type_equal/index.html ). Composing two functions `g : ('b, 'c) func` and `f : ('a, 'b) func` is fairly awkward because nothing in the

09:48 <discocaml> <xavierm02_> My current attempt at enforcing this invariant is to replace `Type_equal.Id.t` by an abstract type `'a typ` and to only allow building values of type `a typ` via a functor `F : functor (T : sig type t end) -> sig type t val t : t typ val of_concrete : T.t -> t val to_concrete : t -> T.t end` that takes a type `T.t` and returns a type `t`, a type representation `t : t typ`, and a bijection between `T.t` and `t`. Using this is a bit t

09:48 <discocaml> <xavierm02_> Does that sound reasonable? Is there a simpler way to do this?

09:56 <discocaml> <octachron> `Type_equal` doesn't really allow to test equality between types at runtime since types don't exist at runtime. It allow to recover some type equalities after erasure, but it is still answer a type-checking and thus a compilation-time concern.

09:57 <discocaml> <octachron> Overall, I am not sure what you are trying to do, thus it is hard to judge if there is a simpler way to do ... something?

10:17 <discocaml> <xavierm02_> I am trying to interleave calculi. Say `module type Calculus = sig type t val eval : t -> t`. Then I define two calculi functors, e.g. `module MakeArith (Other : Calculus) = struct type t = Int of int | IfZThenElse of t * t * t | CoerceToArith of Other.t | ... end` and `module MakeStr (Other : Calculus) = struct type t = Str of string | Print of t | CoerceToStr of Other.t | ... end`, and combine them `module rec Arith = MakeArith (Str) and

10:17 <discocaml> <xavierm02_> I'll write this in a pastebin, it'll be easier to read

10:25 <discocaml> <xavierm02_> There: https://pastebin.com/tXTSthgJ

11:36 <olle> In terms of functional core/imperative shell, what if you have _two_ shells? E.g. one "normal" web access and another REST API access? The imperative shell would then be duplicated?

11:36 <olle> To some extent

11:38 <olle> Or you have outer shell, inner shell :) Onions.

12:38 <discocaml> <octachron> @xavierm02_ , I would recommend to move the extensibility to the skeleton of definitions with an extensible sum type tracking the identity of each module: https://gist.github.com/Octachron/389ac0d2982479904bfd2cd47a9bde14 . But if you want to keep the recursive module definition, you probably only need to add a `unwrap` pass in the every evaluator that recognize its own `Coerced`. In particular, the `coerced` constructor should probably not

13:26 <discocaml> <xavierm02_> Thanks!

13:41 <discocaml> <xavierm02_> Having the type `'a c` might indeed make some things easier. I have to think a bit more about this because I want to allow for more fine-grained descriptions of the calculi, e.g. `CbvRecord = MakeCbvRecord(CbvTerm) and CbvTerm = Sum4(Arith(CbvTerm), Str(CbvTerm), CbvRecord, Box(CbnTerm)) and CbnTerm = Sum(Freeze(CbvTerm), Fun(CbvTerm, CbnTerm)) and ...`, and I'm not yet sure how I want to handle the sums

13:46 <discocaml> <xavierm02_> I had `val match_coerced : ('a, 'b) match_coerced_branches -> 'a -> 'b` in the `Calculus` interface, with `type ('a, 'b) match_coerced_branches = { case_coerced : 'c. 'c -> ('c, 'a) Coercion.t -> 'b; case_not_coerced : 'a -> 'b}` which kind of worked for sums, but maybe I can indeed move the core-or-not distinction outside of the module, making these redundant

17:33 <Guest14> I'm having a problem with opam

17:34 <Guest14> I have a package that I couldn't get set to a particular version. I have this package locally pinned and it kept installing a non-master version. I looked in $(opam var lib)/my-pkg and found that the META and source and compiled files there were old

17:34 <Guest14> So I deleted that folder. Now ocamlfind doesn't find my package anymroe

17:36 <companion_cube> you sure you ran eval `opam env`?

17:37 <Guest14> How can I completely purge the package and install the version I want?

17:37 <Guest14> Yes, I have done that

17:37 <Guest14> I'm not unfamiliar with opam, I just have never encountered this type of behavior

17:38 <companion_cube> if it's pinned, does `opam reinstall foo` do anything?

17:38 <Guest14> It repeatedly installed the old version

17:39 <Guest14> I can remove the package the pin and then re-pin and install. But then ocamlfind still cannot find the thing

17:40 <Guest14> I swear I'm going to have to blow away an entire docker container that has all this progress because of some opam bs

17:42 <companion_cube> does `which ocamlfind` return the one in the opam sw ?

17:46 <Guest14> Yes

17:49 <Guest14> Alright, I started a new container. Copied in my package. Pin add it. Install it. Now ocamlfind query my-pkg does not find it

17:49 <Guest14> Even in the new container

17:56 <companion_cube> I haev no idea :s

17:59 <octachron> Did you check that: 1. the opam env is correctly set up 2. the `opam pin` command installed the right META file?

17:59 <Guest14> I figured out what it was.

18:28 <companion_cube> please tell!

18:41 <Guest14> So, the install steps in my opam file didn't include anything. It is a dune build and install, so I did a make in which case dune installed originally at that version. Then the opam file never rebuilt it.

18:41 <Guest14> So, of course ocamlfind couldn't find it