typochon @typochon@functional.cafe

@otini
\iffalse.......\fi

😉

@epicmorphism I'm not quite sure. After thinking about it I think it might have something to do with the desugaring of rec-constructs (for ArrowLoop). There is none there, but it could be the « do nothing » desugaring for this construct, I don't know

I've tried to see if the optimized core looks any better, but since GHC lifts all the definitions it can to the top level, it's impossible to guess what it really looks like. I mean it's possible, you just have to track down in your head around 100 intermediate defintions (not a hyperbole)

I'm working on FRP right now, and for the paper we're righting, I wanted to know precisely how proc-notation was desugared. I knew it was not ideal, but it's even worse than I thought^^

On the photo is what the following expression gets desugared into:
proc x -> do
y <- sf -< x
z <- sg -< y
z <- sh -< (y,z)
returnA -< (z,y)

(Deduced from unoptimized core)

And here's the Hackage link (after much fear because the documentation wouldn't appear^^)

https://hackage.haskell.org/package/pattern-matcher-0.1.0.0

Aaaaand with some delay (due to pesky PhD work and marking), here it is!

https://gitlab.com/chupin/pattern-matcher

I'd be delighted if people want to review the code or contribute 😊 I'll see to publish it on Hackage in the coming days.

Thanks a lot to @otini for reviewing the documentation!

I'm wrapping up a library that exposes a compiler for patter matching to decision trees, following the excellent « Compiling pattern-matching to decision trees » paper (http://moscova.inria.fr/~maranget/papers/ml05e-maranget.pdf) Hopefully the doc should be finished this afternoon and I'll just have to update my tests for it to be usable 😊

I think GHC disagrees with my copy-pasted machine generated code.

https://peertube.mastodon.host/videos/watch/d58ea43e-b809-4c9b-92be-f61ef2d5f15e

@philipwhite Algorithm J is where type variables are mutable and can be overwritten with an instantiating type, right?

I think all the people I know use this one instead of using explicit substitutions, even in #haskell I just use the ST monad. I think I've never been able to type recursive constructs correctly with explicit substitutions anyway, I get the composition all mixed up^^

@tfb Mmh interesting, why is it particularly useful for dependent types?

Wikipedia page on Scott encoding : https://en.wikipedia.org/wiki/Mogensen%E2%80%93Scott_encoding

and on Church encoding : https://en.wikipedia.org/wiki/Church_encoding

Is there a reason why Scott encoding is very rarely mentionned compared to Church encoding? I may have a false impression, but I only found out about Scott encoding while reading something about the Reduceron (https://www.cs.york.ac.uk/fp/reduceron/) and I've never seen it in the courses about lambda calculus I followed.

Considering how everything is so much simpler using this encoding, I find that a bit weird :/ Well unless teachers like to torture students with the pred function but…

Really happy with today's solution! If carefully parametrized, the same topological function is enough for both parts :)

https://gitlab.com/chupin/advent-of-code-2018/blob/master/Day07.hs