

Is this weird Haskell technique something I made up?

A friend asked me the other day about techniques in Haskell to pretend to make up keywords. For example, suppose we want something like a (monadic) while loop, say like this: while cond act = cond >>= \b -> if b then act >> while cond act else return () This uses a condition cond (which might be stateful or exception-throwing or whatever, but which must yield a boolean value) and an action act (likewise, but its value is ignored) and it repeates the action over and over until the condition is false. Now suppose for whatever reason we don't like writing it as while condition action and we want instead to write while condition do action or something of that sort. (This is a maximally simple example, but the point should be clear even though it is silly.) My first suggestion was somewhat gross: while c _ a = ... Now we can write while condition "do" action and the "do" will be ignored. Unfortunately we can also write while condition "wombat" action and you know how programmers are when you give them enough rope. But then I had a surprising idea. We can define it this way: data Do = Do while c Do a = ... Now we write while condition Do action and if we omit or misspell the Do we get a compile-time type error that is not even too obscure. For a less trivial (but perhaps sillier) example, consider: data Exception a = OK a | Exception String instance Monad Exception where ... data Catch = Catch data OnSuccess = OnSuccess data AndThen = AndThen try computation Catch handler OnSuccess success AndThen continuation = case computation of OK a -> success >> (OK a) >>= continuation Exception e -> (handler e) >>= continuation The idea here is that we want to try a computation, and do one thing if it succeeds and another if it throws an exception. The point is not the usefulness of this particular and somewhat contrived exception handling construct, it's the syntactic sugar of the Catch , OnSuccess , and AndThen : try (evaluate some_expression) Catch (\error -> case error of "Divison by zero" -> ... ... ) OnSuccess ... AndThen ... I was fairly confident I had seen something like this somewhere before, and that it was not original to me. But I've asked several Haskell experts and nobody has said it was familar. I thought perhaps I had seen it somewhere in Brent Yorgey's code, but he vehemently denied it. So my question is, did I make up this technique of using a one-element type as a pretend keyword? [ Addendum: At least one example of this trick appears in LiquidHaskell. I would be interested to hear about other places it has been used. ] [ Addendum: Jeremy Yallop points out that a similar trick was hinted at in McBride and Paterson “Idioms: applicative programming with effects” (2008), with which I am familiar, although their trick is both more useful and more complex. So this might have been what I was thinking of. ]

[Other articles in category /prog/haskell] permanent link

