10:49 <Guest8> Hi. I am using OCaml as a concrete example to illustrate some theoretical stuff, and for one of the examples, I'd really like to be able to evaluate open terms, i.e. terms with free variables. Ideally, the program x should crash, the program let _ = (fun _ -> x) in () should not crash, and the program let _ = x in () should not either. I can

10:49 <Guest8> get the desired behavior for the first two by replacing all free variable occurrences by exit 1 and for the last two by replacing them by Obj.magic 0. Is there some way to get all three? I'd expect no solution to exist since I basically want a non-value term such as exit 1 to be treated like a value by let-expressions, but I'm asking just in

10:49 <Guest8> case.

10:55 <Fardale> you don't need anything for let _ = x in () to work

10:55 <Fardale> Sorry, I guess x is not define in this case

10:57 <Fardale> Here, you seems to need some lazy evaluation, in OCaml you need to use explicite lazy value for this.

11:09 <Guest8> I can't see a simple way of using lazy. There might be some whole-program transformation that adds Lazy.from_val and Lazy.force everywhere that does not affect the behavior of the program and such that we can then evaluate open terms by replacing free variables by Lazy.from_fun (fun () -> exit 1), but it looks fairly complicated to define

11:34 <zozozo> Guest8: you can replace all occurrences of your free variables by "(assert false)"

11:56 <octachron> that doesn't work for "let _ = free in ()", but that's mostly because such expression doesn't seem valid with an eager semantics.

12:00 <neiluj> hey! how do you deal when in a module, you have several modules included for which one of them has a main type which is equal to a type defined in a module, leading to the type checker believing than some arguments should have an other type than the correct one?

12:00 <neiluj> does that need more context?

12:10 <theblatte> neiluj: is `module X with type t = Y.t` what you want?

12:24 <neiluj> theblatte: thanks! It looks like so

12:36 <octachron> a with constraint can only modify a module type not a module.

12:37 <octachron> Generally, you want to avoid including modules with colliding type names because this create unnamable types.

12:44 <neiluj> thanks! indeed used module type of to get the signature out of the module

12:44 <neiluj> actually the error was an absence of conversion

12:44 <neiluj> *was due to

13:19 <Guest8> "assert false" seems to work in the same cases as "exit 1"

13:22 <Guest8> The only ways I can envision what I want being possible is:

13:22 <Guest8> - either there is some ocaml intepreter that only fetches values when needed;

13:22 <Guest8> - or there is some way to build a value that says "I am a pointer" and points so something out of the program's memory, so that "let x = y in t" might propagate the value without dereferencing the pointer, but any real use of x would dereference the pointer and crash

13:33 <Guest8> Substituting free variables by "Obj.magic (fun _ -> exit 1)" might work (for code that does not use the Obj module, otherwise Obj.is_block distinguishes this from a free variable), but there might be other ways to distinguish this from a free variable

15:37 <jedb> does OCaml have anything equivalent to do notation in Haskell?

15:38 <jedb> currently assuming I need to bodge together the relevant operators and do it manually, but if there's an idiomatic way that would be nice

16:13 <octachron> jedb, Ocaml does have let binding operators that work like the `do` notation for a specific monad.

16:15 <octachron> But they are currently not defined by default in the standard library: `let (let*?) = Option.bind`

16:15 <octachron> let*? x = Some 4 in Some (4 + x)

16:18 <jedb> ...I am confused as how that syntax works, but if it does the job then neato

16:23 <octachron> `let* x = expr in y` is the same as `do { x <- expr; y }`

16:24 <octachron> (OCaml has also an applicative `and` syntax if needed)