09:28 <d_bot> <Cyclomatic Complexity> I forgot who sent the link to https://xavierleroy.org/publi/strong-reduction.pdf (A Compiled Implementation of Strong Reduction)

09:28 <d_bot> <Cyclomatic Complexity> By chance, does anyone know an implementation of it in OCaml/Coq?

09:38 <d_bot> <thangngoc89> How would you return a struct with Ctypes? I can only find examples with returning scalar values

13:17 <Armael> would anyone know of an ocaml/reason library to parse/interpret SVG paths?

13:23 <olle> affine types are not part of the road map yet?

13:41 <d_bot> <Ulugbek> https://github.com/LexiFi/landmarks had the last release in 2018 but the master branch is active. Anybody knows the current status of the project? (usable or not, when the next release maybe and should we wait for it to be compat with 4.12, etc)

14:56 <d_bot> <Alistair> Is `'a1 ... 'an. t` only first order polymorphism?

15:05 <d_bot> <ggole> What do you mean?

15:05 <companion_cube> @Alistair it's only allowed in records fields (and object methods?)

15:05 <d_bot> <ggole> OCaml is limited to first-class polymorphism with the sort-of-exception of object/record fields being able to be polymorphic

15:06 <companion_cube> so it's in a place where it's actually a type scheme

15:06 <companion_cube> and it'll be instantiated at each use site

15:09 <d_bot> <Alistair> An this resulted in 2 types of unification variables in `type_expr`? The `univar` and `var`?

15:10 <companion_cube> I have no idea

15:10 <companion_cube> the post from Oleg which is all I know about type inference in OCaml, would mean that var and univar are the same, except univar has level +∞

15:12 <d_bot> <ggole> In `'a . t` `'a`isn't just a type variable, but locally abstract too

15:12 <d_bot> <ggole> Which is what this notation was really introduced for

15:13 <d_bot> <Alistair> So it adds the abstract type `(type a)` locally?

15:15 <d_bot> <ggole> Locally abstract means that the `a` in `type a` can be refined by matching against a GADT which has `a` as a parameter

15:18 <d_bot> <ggole> Wait, no. I'm thinking of `type a. a`. Ugh.

15:19 <d_bot> <ggole> Sorry, `type a. a` means a polymorphic variable that is also locally abstract. `'a . t` just means polymorphic.

15:19 <d_bot> <Alistair> Okay 👍

16:17 <d_bot> <Armael> @antron I'm trying to use lambdasoup to parse-modify-print SVG files; I'm not sure if this is officially supported but it seems to be mostly working, as in lambdasoup was able to parse/print the SVG files I fed it. However, it looks like it's turning the name of the `viewBox` attribute of `<svg>` into `viewbox` (note the small case `b`), which appears to break the svg! Any idea why that is happening?

17:00 <d_bot> <antron> can you link me to an example input where this is happening? the html5 spec requires the opposite of that, i.e. even if it was `viewbox` in the input, it must be turned into `viewBox` by the parser. however, it's possible that either the input isn't triggering the parser's svg mode, or there is a bug in the parser

17:01 <d_bot> <Armael> https://paste.isomorphis.me/pi5 sure, here's my input file

17:02 <d_bot> <Armael> https://paste.isomorphis.me/obA and this is what I obtain after parsing+printing

17:07 <d_bot> <antron> ah this is just svg, not svg in html

17:07 <d_bot> <antron> have you tried using this to parse it as XML? <https://aantron.github.io/lambdasoup/#VALfrom_signals>

17:07 <d_bot> <Armael> yes it comes from a .svg file

17:08 <d_bot> <antron> yep i failed to note that from your original comment it seems..

17:08 <d_bot> <Armael> thanks, I'll try to use from_signals

17:09 <d_bot> <antron> you may then also want to use the XML serializer, <https://aantron.github.io/lambdasoup/#VALsignals>

17:09 <d_bot> <Armael> thanks again, looks like it works now!

17:10 <d_bot> <Armael> now, I guess I could've used an XML parsing library, rather than lambdasoup

17:10 <d_bot> <antron> great, glad to hear. im always worried about the XML support, because i think relatively few people are using it

17:10 <d_bot> <antron> well Markup.ml is an XML parsing library as well as HTML5

17:10 <d_bot> <antron> lambdasoup itself does not parse either one, its just a layer that allows traversing the document tree with CSS

17:10 <d_bot> <Armael> yeah but I guess I only need an XML parser in that case

17:11 <d_bot> <Armael> and also none of the error recovery stuff

17:12 <d_bot> <antron> the error recovery stuff is in the HTML5 parser, it's just some harmless dead code if you are not using it

17:12 <d_bot> <antron> (the HTML5 parser is required by the spec to recover from errors in specific ways)

17:13 <d_bot> <Armael> ah, I see 🙂

17:14 <d_bot> <antron> actually i think the XML parser might also be error-recovering, because thats the way errors are reported in the markup api. but the docs recommend using an error handler that just throws an exception or otherwise signals an error to your code <https://aantron.github.io/markup.ml/#VALparse_xml>

17:16 <d_bot> <antron> the errors in the XML parser are real but the recovery is made-up, because there is no error recovery in the XML spec