05:22 <Corbin> I am in awe of Printf.printf's magical type-sensing powers. I want to imagine something similar: I have functions with signatures that might vary a little; say, they take one or more ints and return an int. Is there a good idiom for managing this sort of function with unknown signature?

05:31 <d_bot> <EduardoRFS> Corbin: GADTs?

05:52 <Corbin> Not exactly. I guess that I should pick up where I stopped talking with ccube yesterday. I have expressions that might operate on ints or floats; they might have type `int -> int` or `int -> int -> int`. I know that I could enumerate specific types which are okay, and create a sort of calling-convention interface; but I'm interested in whether there's any other techniques, including magic.

05:53 <Corbin> GADTs could work, but I'd have to be more rigorous about knowing the types of my expressions, which is (to use some local slang) a total bummer.

07:18 <d_bot> <octachron> Taking a list or arrays of integers sounds like the simpler solution.

07:18 <d_bot> <octachron> (There is no magic beyond the syntax in Format or Printf)

09:05 <nd__> Aloha… I updated opam to `v2.1.0` and the init script slows down my zsh tremendously. Anyone else experiencing this?

10:04 <d_bot> <Kakadu> @Corbin: you may try to google Oleg's "unusual polymorphism"

10:38 <olle> How come OCaml didn't adapt the keyword forall?

10:42 <d_bot> <Alistair> Because OCaml only supports Rank-1 polymorphism, hence the `forall` is implicit

10:55 <olle> Ali, no, sometime's you have to manually add the 'a . 'a thing

10:55 <olle> the dot

10:56 <d_bot> <Alistair> Yes, but you asked why we don't have the `forall` keyword?

10:56 <d_bot> <Drup> Because people don't like keywords

10:56 <d_bot> <Drup> so `.` was the chosen piece of syntax

10:56 <d_bot> <Alistair> Especially when they don't clarify anything ^

10:57 <d_bot> <Drup> Well, in this case, anything is clearer than `.`

10:59 <olle> Yeah, dot is weird

11:00 <olle> "People" don't like keywords?

11:00 <olle> Xavier?

11:00 <d_bot> <Alistair> I think it's rather natural, standard quantifier notation is usually `Quantifier vars. term`

11:01 <olle> In which context? Ali

11:01 <d_bot> <Alistair> Since a `forall` keyword wouldn't add any additional information (since core types don't support existential quantifiers), then a natural reduced syntax would be `vars. term`

11:02 <olle> "natural"...

11:02 <d_bot> <Alistair> Type theory, first-order (and higher-order) logic

11:02 <olle> So, how many other usages do '.' have in that context?

11:04 <olle> Because in OCaml it's already record field access.

11:04 <olle> And module access.

11:06 <d_bot> <Alistair> In types? none. In other things e.g. expressions, etc, `.` is used rather often. Field resolution (as in records and modules). Used as an operator for composition in Haskell

11:09 <olle> I rest my case xD

11:40 <Anarchos> hello, how to submit a patch for /opam/src_ext/dune-local/src/dune_filesystem_stubs/readdir.c ?

13:15 <d_bot> <Kakadu> let' s imagine someone want to put pure functional program into FPGA. After CPSing non tailrec functions and defunctionalization the final program blows up in size. What could be the ideas to do something differently to get a smaller programs?

13:33 <d_bot> <ggole> Optimise the defunctionalisation so you don't get huge cases?

13:34 <d_bot> <Kakadu> Maybe... Are there any smart words in particular that I should google?

13:36 <d_bot> <ggole> There are a few defunctionalising compilers that use dataflow analysis for this purpose. MLton and GRIN are the ones I would look at.

13:41 <vsiles> is there a way to track down all the `match x with | A -> .. | _ -> ..` statements for a specific type ?

13:42 <vsiles> I'd like to add a new constructor to the type, and want to be sure I update all the right places, so I'm looking for the _ -> catch all

13:43 <d_bot> <antron> @vsiles there is grep, and another way is to rename the `A` constructor to force errors at all patterns

13:46 <vsiles> that would force errors to all patterns whenre A is, not all patterns of the type

13:46 <vsiles> maybe there's a compiler warning, I'll check the list

13:47 <vsiles> 4 Fragile pattern matching: matching that will remain complete even if additional constructors are added to one of the variant types matched.

13:47 <vsiles> maybe that one

13:48 <d_bot> <ggole> You can comment out the definition of the entire type containing A, changing it to something like `type t = BreakPlease`

13:49 <vsiles> not bad :D

13:49 <d_bot> <ggole> It might be possible to get merlin to do this for you... `merlin-occurrences` doesn't quite fit the bill though

13:49 <d_bot> <ggole> It shows occurrences of an individual constructor or type constructor

13:51 <d_bot> <ggole> On a more speculative note, I've considered the idea of a 'new constructor' annotation that gets the compiler to spit out a list of the places which silently range over the annotated constructor (or field)

13:52 <d_bot> <ggole> Might be handy for this kind of thing

13:53 <vsiles> looks like we don't have a lot of fragile pattern matching anyway. I might just remove them and enable the warning altogether

13:53 <d_bot> <ggole> Oh hey, another idea; put `[@deprecated]` on each constructor

13:54 <d_bot> <ggole> But this will mark construction too

13:56 <vsiles> (I'm confused, warning 4 is not what I'm looking for :p)

13:56 <vsiles> I think I'll try you BreakPlease idea :)

14:06 <vsiles> hmm no, I'm getting only a few errors at a time (like only the one in the same file)

15:52 <Anarchos> vsiles or look for ' _ -> ' ?

17:48 <Corbin> Kakadu: Thanks, that was good reading.

17:50 <Corbin> I decided to modify my desires somewhat. To have a concrete goal: I have a small applicative DSL describing functions R * R * R -> R, and a wrapper around that which describes functions R * R -> R * R * R * R. I will simply specialize everything for these cases, and worry about generalities at the next design step.

17:51 <Corbin> I'm trying to make a raytracer faster in the long term by specializing it to low-level code. For reasons, I thought that OCaml would be a good target; I wanted to use the compiler and runtime. The first signature is signed distance functions in 3D, and the second is pixel colors in 2D.

20:12 <companion_cube> if you do numerics, be sure to use bigarrays and not arrays

20:15 <Anarchos> companion_cube i am just reinstalling all my ocaml ecosystem, i will resume my work on my math verifier soon

20:21 <companion_cube> good luck

20:25 <Anarchos> companion_cube for the reinstallation ? or for my verifier ?

20:26 <companion_cube> the verifier :p

20:31 <Anarchos> companion_cube the verifier is almost finisshed

20:38 <Anarchos> octachron I used your trick to use a local compiler, but when i do 'opam switch MYSWITCH' i get the error : Can not set external switch '/Data1/INFORMATIQUE/OCAML/ocaml' globally.

22:57 <d_bot> <Et7f3> Is their a function that does like `Unix.open_process_args_in` (it avoid invoking shell) but does the lookup in `PATH` or if need to do that ourself ?