Break Gently with Pattern Synonyms
This is a really brief post to call out a nice trick for providing users a nice migration message when you delete a constructor in a sum type. The Problem You have a sum type, and you want to delete a redundant constructor to refactor things. data Foo = Bar Int | Baz Char | Quux Double That Quux is double trouble. But if we simply delete it, then users will get a Constructor not found: Quux. This
Dynamic Exception Reporting in Haskell
Exceptions kind of suck in Haskell. You don’t get a stack trace. They don’t show up in the types of functions. They incorporate a subtyping mechanism that feels more like Java casting than typical Haskell programming. A partial solution to the problem is HasCallStack - that gives us a CallStack which gets attached to error calls. However, it only gets attached to error - so you can either have Str
Plucking Constraints
There’s a Haskell trick that I’ve observed in a few settings, and I’ve never seen a name put to it. I’d like to write a post about the technique and give it a name. It’s often useful to write in a type class constrained manner, but at some point you need to discharge (or satisfy?) those constraints. You can pluck a single constraint at a time. This technique is used primarily used in mtl (or other
Write Junior Code
A plea to Haskellers everywhere. Haskell has a hiring problem. There aren’t many Haskell jobs, and there aren’t many Haskell employees. Haskell employees tend to be senior engineers, and the vast majority of job ads want senior-level Haskell candidates. The vast majority of Haskell users do not have any professional production experience, and yet almost every job wants production Haskell experienc
Keeping Compilation Fast
You’re a Haskell programmer, which means you complain about compilation times. We typically spend a lot of time waiting for GHC to compile code. To some extent, this is unavoidable - GHC does a tremendous amount of work for us, and we only ever ask it to do more. At some point, we shouldn’t be terribly surprised that “doing more work” ends up meaning “taking more time.” However, there are some thi
Return a Function to Avoid Effects
To help write robust, reliable, and easy-to-test software, I always recommend purifying your code of effects. There are a bunch of tricks and techniques to accomplish this sort of thing, and I’m going to share one of my favorites. I have implemented a pure data pipeline that imports records from one database and puts them in another database with a slightly different schema. Rather than implement
Keep your types small...
… and your bugs smaller In my post “Type Safety Back and Forth”, I discussed two different techniques for bringing type safety to programs that may fail. On the one hand, you can push the responsibility forward. This technique uses types like Either and Maybe to report a problem with the inputs to the function. Here are two example type signatures: safeDivide :: Int -> Int -> Maybe Int lookup :: O
ghcid for the win!
Supercharge your Haskell development experience with ghcid! ghcid is – at the current moment – the most important tool for Haskell development environments. It is fast, reliable, works on all kinds of projects, and is remarkably versatile. You can use it with any editor workflow, primarily by not integrating your editor! (though there are integrations available if you’re brave) For these reasons,
Transforming Transformers
There’s a kind fellow named lunaris on the FPChat slack channel that shares exceptionally good advice. Unfortunately, due to the ephemeral nature of Slack, a lot of this advice is lost to history. I’ve been pestering him to write up his advice in a blog so that it could be preserved. He hasn’t posted it yet, so I’m going to start posting his rants for him ;) lunaris works with a company called Hab
Three Layer Haskell Cake
The question of “How do I design my application in Haskell?” comes up a lot. There’s a bunch of perspectives and choices, so it makes sense that it’s difficult to choose just one. Do I use plain monad transformers, mtl, just pass the parameters manually and use IO for everything, the ReaderT design pattern, free monads, freer monads, some other kind of algebraic effect system?! The answer is: why
Haskell Performance Debugging
Someone posted a Treap implementation to reddit that was slow. Let’s analyze it and determine what’s up. The repo is available here Base Run I set the code up in a Cabal project, created a makefile, and ran an initial profiling run. The code and profiling output are in the base branch on GitHub. Before we look at any of the executing code or profilign output, let’s check out the definition of the
MonadBaseControl in Five Minutes
This post is intended to be a short guide on using MonadBaseControl effectively in Haskell code without understanding it. Tiny synopsis The big idea behind MonadIO m is that you can perform a transformation IO a -> m a. The big idea behind MonadBaseControl is that you can perform a transformation m a -> IO a. Most monads have additional context than just IO, so to go from your custom monad to IO r
Type Safety Back and Forth
Types are a powerful construct for improving program safety. Haskell has a few notable ways of handling potential failure, the most famous being the venerable Maybe type: data Maybe a = Nothing | Just a We can use Maybe as the result of a function to indicate: Hey, friend! This function might fail. You’ll need to handle the Nothing case. This allows us to write functions like a safe division funct
リリース、障害情報などのサービスのお知らせ
最新の人気エントリーの配信
j次のブックマーク
k前のブックマーク
lあとで読む
eコメント一覧を開く
oページを開く
Unpack your Existentials
Effectful Property Testing
Splitting Persistent Models
Laziness Quiz
The Trouble with Typed Errors
Stealing Where from Rust
Servant Route Smooshing