00:51 <discocaml> <qrpnxz> > a bind and return function in the monadic interface part of the interface is not harder to discover than an instance of the monad type class.

00:51 <discocaml> <qrpnxz> Sometimes there is no instance, but you need it, except it isn't "your" type. Then what? You can fork the library, 😔 or you can make an orphan instance, 🤢 or you have to make a wrapper type and duplicate pre-existing API 😩 (only partly alleviated by deriving).

00:51 <discocaml> <qrpnxz> Sometimes a 20 line example is worth a hundred words 🙏

01:02 <discocaml> <qrpnxz> eio is pretty straight forward and explicit. It's not aimed at concurrency alone, but what I would call IO resource management in general. It has a wide variety of capabilities and a structure to pass them aroudn and track them: domains, processes, time, buffers, file system, byte streams, networking, etc.

01:03 <discocaml> <qrpnxz> And it's a mature library.

01:03 <discocaml> <qrpnxz> Some other mentioned I think still need work, and need documentation.

01:15 <companion_cube> it'd be nice if it adopted picos

09:44 <discocaml> <reynir1396> Is `type unit` defined anywhere in a file or so? Or is it built-in?

09:45 <discocaml> <._null._> It's built-in but it could be defined manually. I think it's built-in because it's used by other built-in stuff

09:46 <discocaml> <._null._> Same goes for lists I think

09:47 <discocaml> <lecondorduplateau> <https://ocaml.org/manual/5.2/api/Stdlib.Unit.html> 🗿

09:48 <discocaml> <gooby_clown> You wish to tell me that `unit` is defined as `Unit.t` which is defined as `unit`

09:48 <discocaml> <gooby_clown> :triggered_ocaml:

09:48 <discocaml> <gooby_clown> Thought actually how should this `t = r = s` syntax be interpreted

09:49 <discocaml> <._null._> t is defined as r, but the constructors should now point to t instead of r

09:49 <discocaml> <._null._> (so unit is not defined as Unit.t)

09:49 <discocaml> <gooby_clown> Ahh

09:50 <discocaml> <gooby_clown> Then you were right, it's the same with list https://github.com/ocaml/ocaml/blob/trunk/stdlib/list.ml#L17

09:52 <discocaml> <reynir1396> Ah thanks

09:52 <discocaml> <reynir1396> I like the documentation for `Unit.to_string` btw

09:52 <discocaml> <reynir1396> well, all of the functions in `Unit`

09:53 <discocaml> <reynir1396> must have been fun to write :D

09:53 <discocaml> <gooby_clown> They should make it a functor instance

09:54 <discocaml> <gooby_clown> "`fmap f ()` is ()"

09:54 <discocaml> <reynir1396> Nice

09:54 <discocaml> <reynir1396> ```OCaml

09:54 <discocaml> <reynir1396> type t = unit = ()

09:54 <discocaml> <reynir1396>

09:54 <discocaml> <reynir1396> let equal () () = true

09:54 <discocaml> <reynir1396> let compare () () = 0

09:54 <discocaml> <reynir1396> let to_string () = "()"

09:54 <discocaml> <reynir1396> ```

10:01 <discocaml> <lecondorduplateau> why have named parameter `b` in `Unit.to_string` lmao

10:08 <discocaml> <lecondorduplateau> why have named parameter `b` in `Unit.to_string` documentation lmao

14:10 <discocaml> <luck33> What is the common functionality of a "Make" function? I saw a blog post alluding to there being some consensus on what Make should do.

14:11 <discocaml> <._null._> Do you mean `make` vs `create` ?

14:13 <discocaml> <deepspacejohn> for a module with type `t`, `make` or `create` is conventionally the function to construct a new value of type `t`. In the stdlib, `create` is usually used for mutable types.

14:14 <discocaml> <hockletock> capital-M Make is a functor e.g. Set.Make

14:14 <discocaml> <hockletock> it makes a useful version of a module with a supplied type

14:17 <discocaml> <._null._> Is it ? I thought the consensus was that `create` is for uninitialised stuff

14:21 <discocaml> <deepspacejohn> I suppose so, but uninitialized things need to be mutable.

14:22 <discocaml> <._null._> The nuance would be between `Array.make` and `Array.create_float`

14:22 <discocaml> <deepspacejohn> Ah, yeah I see.

14:24 <discocaml> <deepspacejohn> I guess most types, creating an initialized one would mean using a function like `of_seq`

15:00 <companion_cube> finally adding cookie support to ezcurl!

15:00 <companion_cube> 🎉

15:10 <discocaml> <gooby_clown> 🎉

20:36 <Anarchos> Is this syntax legal ? (c_library_flags (:include (flags.sexp))) Error: Unexpected list

22:22 <discocaml> <Kali> type unit is built-in, but in the sense that it is predefined rather than being anything special: `()` can be used as a constructor name in any variant type you want, it just happens to be used for unit by default

22:22 <discocaml> <Kali> for example:

22:22 <discocaml> <Kali> ```ocaml

22:22 <discocaml> <Kali> type demo = () of int

22:22 <discocaml> <Kali>

22:22 <discocaml> <Kali> let demonstration = () 5

22:22 <discocaml> <Kali> ```

22:22 <discocaml> <Kali> for example:

22:22 <discocaml> <Kali> ```ocaml

22:22 <discocaml> <Kali> type demo = () of int

22:22 <discocaml> <Kali>

22:22 <discocaml> <Kali> let demonstration : demo = () 5

22:22 <discocaml> <Kali> ```

22:23 <discocaml> <Kali> type unit is built-in, but in the sense that it is predefined rather than being anything special: `()` can be used as a constructor name in any variant type you want, it just happens to be used for unit by default (list is similar in this manner)

22:23 <discocaml> <Kali> type unit is built-in, but in the sense that it is predefined rather than being anything special: `()` can be used as a constructor name in any variant type you want, it just happens to be used for unit by default (list is similar in this manner with (::) and [])

22:47 <discocaml> <qrpnxz> lol

22:48 <discocaml> <qrpnxz> your story doesn't hold up

22:48 <discocaml> <qrpnxz> wait it does

22:48 <discocaml> <qrpnxz> i was just getting a warning

22:48 <discocaml> <qrpnxz> understandably 😆

22:59 <discocaml> <Kali> yes, you get a warning whenever you redefine the () constructor

23:00 <discocaml> <Kali> since in most cases you probably mean the type unit, not the constructor ()

23:00 <discocaml> <Kali> but it is just a warning; the above code is perfectly valid

23:06 <discocaml> <._null._> `type cursed = () of unit list | [] of unit | (::) of cursed * cursed let cursed = [] () :: () [()]`

23:16 <discocaml> <yawaramin> oh lort.

23:29 <discocaml> <Kali> ```ocaml

23:29 <discocaml> <Kali> type unit = []

23:29 <discocaml> <Kali>

23:30 <discocaml> <Kali> type 'a list = (::) | () of 'a * 'a list

23:30 <discocaml> <Kali>

23:30 <discocaml> <Kali> let ignore _ = []

23:30 <discocaml> <Kali> let a_list = () (1, () (2, () (3, (::))))

23:30 <discocaml> <Kali> ```

23:44 <companion_cube> Good god

23:55 <discocaml> <deepspacejohn> Let’s make the most cursed alternate stdlib possible