00:03 <primosoma> hello

00:05 <primosoma> is there anyone that know the ssl library?

00:12 <d_bot> <Fermion> I'm having some trouble with clangml in utop.

00:12 <d_bot> <Fermion>

00:12 <d_bot> <Fermion> ```

00:12 <d_bot> <Fermion> utop # #require "clangml";;

00:12 <d_bot> <Fermion> Error: Reference to undefined global `Parse'

00:12 <d_bot> <Fermion> ```

00:12 <d_bot> <Fermion> this should work, right?

00:13 <d_bot> <Fermion> actually, utop-full works! Why would that be?

00:33 <d_bot> <Et7f3> utop-full also preload some other libraries like compiler-libs that contain Parse module.

00:34 <d_bot> <Et7f3> Yes. Some of us use ssl library. What do you want to know ?

00:50 <primosoma> I'm trying to connect to an irc server. It seems that the client is connected but I don't receive any answer from the server. If it is possible I paste the code in the chat

00:58 <primosoma> (or I can create a GitHub gist)

01:14 <companion_cube> (use a pastebin or gist yes)

01:14 <companion_cube> are you using a library?

01:17 <primosoma> yes. I use Ssl module. I installed it with opam

01:18 <primosoma> https://gist.github.com/primosoma/4474abe82bbdaa10fb8157d9ecec6c70

03:23 <d_bot> <gar> I need to get a foo.cmi file for a foo.ml file. I can extract the .mli file by passing `-i` and then compiling it, but I can also pass `-intf foo.ml -o foo.cmi`, or rename `foo.ml` to `foo.mli` and compile it with `-intf`. Will these produce identical .cmi files?

03:25 <companion_cube> typically, just use dune and it'll do the dirty work for you

09:48 <d_bot> <fakusb> I want to let people experiment with OCaml by using the toplevel, but don't want them to have access to my filesystem, or load modules.

09:48 <d_bot> <fakusb>

09:48 <d_bot> <fakusb> Is there a build-in way to tell toplevel "please don't touch anything except stdin/ stderr and stdout?

09:49 <primosoma> fakusb, maybe a container?

09:50 <d_bot> <fakusb> Yes, a container would be an option, but I want to find out if i can get away with less.

09:51 <d_bot> <fakusb> How bad of an idea is it to disallow all directives (for example, by filtering out `#`, and filtering out the few Stdlib functions that touch the file system before passing on the phrases a user writes to ocamltop?)

09:51 <d_bot> <fakusb> The setting is semi-private, in that only students on the discourse server of our course would have access to it

09:51 <d_bot> <fakusb> (i plan a discord bot 🙂 )

09:52 <d_bot> <fakusb> You mean the general concept of containers, not something build-in to ocaml, do you?

09:52 <primosoma> yes, i mean docker

09:52 <d_bot> <fakusb> (Or a library)]

11:06 <d_bot> <octachron> @gar : you cannot compile an implementation file as an interface `ocamlc -intf foo.ml` will emit a syntax error as soon as `foo.ml` contains non-type-level items. Similarly, `ocamlc -i foo.ml` emits a mli file aimed at human reader, and it can fail to produce a valid mli file. The canonical path is to compile the file with `ocamlc -c foo.ml` which produces a correct `foo.cmi` file for all valid `foo.ml`.

11:36 <zozozo> @fakusb : there's try-ocaml that does that (one of the solutions being that the toplevel is actually executed on the client, so no trouble for the server)

11:40 <d_bot> <fakusb> A good idea; we actually use https://try.ocamlpro.com/ as the suggested way for our students to learn OCaml.

11:40 <d_bot> <fakusb>

11:40 <d_bot> <fakusb> I was thinking about what would be needed to provide a discord bot that provides the toplevel, more as a per project for myself than as something solving a huge problem.

13:12 <d_bot> <gar> @octachron Thanks, did not know that about `-i`. @companion_cube I'm using Bazel, not Dune.

14:07 <d_bot> <Et7f3> You will always forget one way.

14:07 <d_bot> <fakusb> Yeah, i think so. I think the way to go is docker.

14:09 <d_bot> <fakusb> Just out of couriosity: are there known cases of ocaml code that types, uses only the stdlib minus the file/stream part, but doing nasty stuff, like reading memory in a bad way?

14:11 <d_bot> <Et7f3> Obj

14:12 <d_bot> <Et7f3> maybe dynlink

14:12 <d_bot> <Et7f3> other API that can be added when upgrading compiler

14:12 <Armael> Marshal as well

14:13 <d_bot> <Et7f3> Yes this one is really evil

14:16 <d_bot> <Et7f3> Sys.command

14:17 <d_bot> <Et7f3> even if you disallow it. The compiler use it internally so you might be able to inject command with specially crafter flag.

14:19 <d_bot> <gar> I'm running into a problem with codept. Not sure if this is the right forum, but here goes: I generate a file, `codept.args`, listing all the modules in the project, and I pass it to codept using `-args`. I do this because I need global deps analysis. The problem is that some of the files do not appear in the output. The cause seems to be that the codebase includes duplicate sourcefile names; for example, `main.ml` occurs in multip

14:27 <d_bot> <octachron> I would suggest to open an issue and I will look at it.

14:27 <d_bot> <octachron> If the stars are aligned using the `-nested` argument which puts all modules `foo/dir/m.ml` into the `Foo . Dir` namespace might solve the issue without creating problems.

14:27 <d_bot> <octachron> Otherwise, if the duplicate modules are only leaf modules, you could put them in their own namespace with `Namespace[main.ml]`.

14:29 <d_bot> <octachron> For instance, `codept test/main.ml Exe[main.ml]` places the second `main` module in the `Exe` namespace solving the issue.

14:29 <d_bot> <octachron> Otherwise, you will need to communicate more about the namespace structure to `codept` in order to explain how the project is differentiating between the duplicate modules.

14:32 <d_bot> <gar> Ok thanks, I'll fiddle around with your suggestions and open an issue with either a problems or some documentation.

14:43 <companion_cube> @gar oof, good luck

23:21 <d_bot> <Fermion> Hey folks -- Merlin in emacs will complete standard namespaces like "List" and "Format" but won't do packages I #required,

23:21 <d_bot> <Fermion> I feel like I'm missing a step here.

23:30 <d_bot> <Fermion> or well -- I'm pretty confused. There's a nice document here https://discuss.ocaml.org/t/ocaml-repl-driven-development/4068/4 about sending stuff to the toplevel. I have a dune project with (executable (name foo) (libraries bar)), and I want to edit foo.ml in an interactive way

23:31 <d_bot> <Fermion> as in, edit some stuff, send it to the repl, and so on and so forth. The repl doesn't know anything about bar though, so i guess I have to #require it in

23:31 <d_bot> <Fermion> but I'm not supposed to #require in foo.ml!

23:31 <d_bot> <Fermion> so it's all very confusing how I'm supposed to set stuff up to do this kind of development