The <code><- pure</code> pattern
Summary: Sometimes <- pure makes a lot of sense, avoiding some common bugs. In Haskell, in a monadic do block, you can use either <- to bind monadic values, or let to bind pure values. You can also use pure or return to wrap a value with the monad, meaning the following are mostly equivalent: let x = myExpression x <- pure myExpression The one place they aren't fully equivalent is when myExpressio
Monads as Graphs
Summary: You can describe type classes like monads by the graphs they allow. In the Build Systems a la Carte paper we described build systems in terms of the type class their dependencies could take. This post takes the other view point - trying to describe type classes (e.g. Functor, Applicative, Monad) by the graphs they permit. Functor The Functor class has one operation: given Functor m, we ha
Thoughts for a Haskell IDE
Summary: We have been working on pieces for a Haskell IDE at Digital Asset. At Digital Asset, we wrote the DAML programming language. The compiler builds on GHC, and one of the important tools for using DAML is an IDE. You can try the DAML IDE online or download it. Since we wrote the DAML IDE in Haskell, and DAML uses GHC under the hood, it's possible to take the work we did for the DAML IDE and
foldr under the hood
Summary: The foldr function seems simple, but is actually very complex, with lots of layers. This post dives through the layers. The foldr function takes a list and replaces all : (cons) and [] (nil) values with functions and a final value. It's available in the Haskell Prelude and described on Wikipedia. As some examples: sum = foldr (+) 0 map f = foldr (\x xs -> f x : xs) [] But the simple foldr
Inside the paper: Build Systems a la Carte
Summary: How we went about writing a build systems comparison paper, how we learnt what we learnt, and why the end result surprised us. A glimpse inside writing a paper. The final version of the Build Systems a la Carte paper has just been sent to ICFP 2018 - see an overview from one of my co-authors. The paper is a collaboration between Andrey Mokhov at Newcastle University, Simon Peyton Jones at
Benchmarking strchr vs memchr
Summary: memchr is faster, but the obvious implement seems to beat the builtin versions. There are two related C functions for finding the next character in a string - strchr which assumes the string has a NUL character at the end, and memchr which takes the string length as an argument. For strings where you have the size and a NUL terminator, which is fastest? Using gcc 6.2.0 64bit MSYS2 on Wind
The Four Flaws of Haskell
Summary: Last year I made a list of four flaws with Haskell. Most have improved significantly over the last year. No language/compiler ecosystem is without its flaws. A while ago I made a list of the flaws I thought might harm people using Haskell in an industrial setting. These are not flaws that impact beginners, or flaws that stop people from switching to Haskell, but those that might harm a bi
A simple Haskell function
Summary: An example of a small function I recently wrote - from type signature to tests. When writing a build system there are lots of nasty corner cases to consider. One is that command line limits combined with lots of arguments sometimes requires splitting a single command up into multiple commands, each of which is under some maximum length. In this post I'll describe a function that was requi
Making sequence/mapM for IO take O(1) stack
Summary: We have a version of mapM for IO that takes O(1) stack and is faster than the standard Haskell/GHC one for long lists. The standard Haskell/GHC base library sequence function in IO takes O(n) stack space. However, working with Tom Ellis, we came up with a version that takes O(1) stack space. Our version is slower at reasonable sizes, but faster at huge sizes (100,000+ elements). The stand
Parallel/Pipelined Conduit
Summary: I wrote a Conduit combinator which makes the upstream and downstream run in parallel. It makes Hoogle database generation faster. The Hoogle database generation parses lines one-by-one using haskell-src-exts, and then encodes each line and writes it to a file. Using Conduit, that ends up being roughly: parse =$= write Conduit ensures that parsing and writing are interleaved, so each line
Thoughts on Conduits
Summary: I'm growing increasingly fond of the Conduit library. Here I give my intuitions and some hints I'd have found useful. Recently I've been working on converting the Hoogle database generation to use the Conduit abstraction, in an effort to reduce the memory and improve the speed. It worked - database generation has gone from 2Gb of RAM to 320Mb, and time has dropped from several minutes (or
Handling Control-C in Haskell
Summary: The development version of ghcid seemed to have some problems with terminating when Control-C was hit, so I investigated and learnt some things. Given a long-running/interactive console program (e.g. ghcid), when the user hits Control-C/Ctrl-C the program should abort. In this post I'll describe how that works in Haskell, how it can fail, and what asynchronous exceptions have to do with i
Implementing a Functor instance
Summary: Implementing a Functor instance is much easier than implementing a Monad instance, and can turn out to be quite useful. Haskell forces all programmers to understand some details of the Monad typeclass to do basic IO, but currently nothing forces people to learn the Functor typeclass. However, Functor is much simpler than Monad, and all Monads must be Functors, so thinking more about Funct
nub considered harmful
Summary: Don't use nub. A much faster alternative is nubOrd from the extra package. The Haskell Data.List module contains the function nub, which removes duplicate elements. As an example: nub [1,2,1,3] == [1,2,3] The function nub has the type Eq a => [a] -> [a]. The complexity of take i $ nub xs is O(length xs * i). Assuming all elements are distinct and you want them all, that is O(length xs ^ 2
Towards Shake 1.0
Summary: I've just released a new version of Shake, with a --demo feature and an underlying continuation monad. I want to release v1.0 in the near future. I've just released a new version of the Shake build system, version 0.13.3. While the version number is only 0.0.1 higher, the changelog lists a large number of improvements. In particular, two changes are: The Action monad is now based on conti
リリース、障害情報などのサービスのお知らせ
最新の人気エントリーの配信
j次のブックマーク
k前のブックマーク
lあとで読む
eコメント一覧を開く
oページを開く
Proving fib equivalence
Idris reverse proofs
Proving stuff with Idris
Code Review Reviewed
Compiling GHC on Windows