サクサク読めて、アプリ限定の機能も多数!
トップへ戻る
TGS2024
reasonablypolymorphic.com
Does it ever feel like the internet is getting worse? That’s been my impression for the last decade. The internet feels now like it consists of ten big sites, plus fifty auxiliary sites that come up whenever you search for something outside of the everyday ten. It feels like it’s harder to find amateur opinions on matters, except if you look on social media, where amateur opinions are shared, unso
Haskell2020 is the long-awaited sequel to Haskell2010 — a formal, prescriptive standard of the Haskell language, that all implementations should adhere to. Today we have two previous standards, Haskell2010 and Haskell98, but neither is particularly in-line with the language as it’s written in this day and age. The aim of Haskell2020 is to bring these older standards in line with the way the langua
aka “what the hell is that Tactics stuff?” This is the second post in a series of implementation details in polysemy — a fast, powerful and low-boilerplate effect-system library. In the last post we discussed the Yo type, which accumulates weaving functions of the form Functor f => f () -> (∀ x. f (m x) -> n (f x)) -> e m a -> e n (f a). As a quick reminder, the f functor corresponds to some piece
When asked about the virtues of Haskell’s strong type system, most people will say the best part is that it lets you refactor with a zen-like tranquility, or that it stops your program from crashing at runtime. I mean, those are both great. But my favorite part is that having a strong type system means I don’t need to use my brain to do programming. It sounds snide, but it’s true. Here’s a functio
aka “what the hell is that Yo type?” This is the first post in a series of implementation details in polysemy — a fast, powerful and low-boilerplate effect-system library. Even if you’re not particularly interested in polysemy, there are some functional pearls here — and a crash course on the history on the implementations of free monads in Haskell. Critics of free monads often make the claim that
The approach here, and my original implementation are both lifted almost entirely from Luka Horvat’s plugin for simple-effects. All praise should be directed to him. Last time we chatted about using a GHC plugin to run custom Core-to-Core transformations on the programs that GHC is compiling. Doing so allows us to add custom optimization passes, and even other, more exotic things like rewriting la
The venerable Lyxia had this to say about my last post on freer monads: I agree the performance argument is way less important than the frequency at which it’s thrown around makes it seem. The reason freer performance sucks is that you’re repeatedly constructing and deconstructing trees at runtime. However, that is only a consequence of the implementation of freer as a GADT (initial encoding). I b
I’ve spent a good deal of my professional life arguing against using protobuffers. They’re clearly written by amateurs, unbelievably ad-hoc, mired in gotchas, tricky to compile, and solve a problem that nobody but Google really has. If these problems of protobuffers remained quarantined in serialization abstractions, my complaints would end there. But unfortunately, the bad design of protobuffers
I’ve been working on a simple Haskell98 compiler over the last few days, partly as an excuse to learn how it works, and partly to have a test-bed for trying out some potential language extensions. More on that in a future blog post. As of yesterday, I have typeclass resolution working. The algorithm to desugar constraints into dictionaries hasn’t been discussed much. Since it’s rather involved, an
Today I want to demonstrate a “well-known” Haskell technique among library authors, that I haven’t ever seen written down. It allows you to do all sorts of amazing things, such as: generate lenses for arbitrary data-types without resorting to TemplateHaskell; sequence over data-types; and automatically track dependencies for usages of record fields. As for this post, we’ll look at how to build typ
Update 2019-05-30: Formation finally got around to opensourcing the work done here. https://github.com/formationai/proto-lens-grpc aka “Type-Level Icing Sugar” Context🔗 At work recently I’ve been working on a library to get idiomatic gRPC support in our Haskell project. I’m quite proud of how it’s come out, and thought it’d make a good topic for a blog post. The approach demonstrates several type
How These Things Work: The Preface Table of Contents Part 1 – Diagrams Preface Machine Diagrams Universal Machines Interlude Numbers Arithmetic Abstraction Multiplexing Latches Constructions on Annotations Memory Cells Part 2 – Symbolic Computations A New Foundation Symbolic Computation Symbolic Evaluation and Equational Reasoning More Types Polymorphism Back in Business and Better than Ever The I
A few weeks ago, on a whim my friend and I decided to hackathon our way through an app to help us learn how to play guitar. In a stroke of inspiration, we decided to learn something new, and do the project in the Elm programming language, about which I had heard many good things. Consider this post to be what I wished I knew about Elm before deciding to write code in it. Since I can’t send this in
このページを最初にブックマークしてみませんか?
『Home :: Reasonably Polymorphic』の新着エントリーを見る
j次のブックマーク
k前のブックマーク
lあとで読む
eコメント一覧を開く
oページを開く