Thursday, March 29, 2012

Announcing Happstack 7

We are pleased to announce the  release of Happstack 7!

Happstack is a fast, modern, web application framework written in Haskell. Please check out the brand new website to read about what is new in Happstack 7, and what we are planning for Happstack 8, and what makes Happstack great!

Wednesday, February 1, 2012

new tutorial on acid-state, ixset, and lenses


I just uploaded a new tutorial which covers three distinct, but related topics:

  • acid-state - a native Haskell, noSQL, RAM-cloud database
  • IxSet  - a multi-indexed collection type (similar to Data.Map but with support for  multiple keys)
  • data-lens - a library which provides syntax that makes it easier to update nested records and other data types

The tutorial is available here:

The section on lenses is a great applied introduction to the concept which requires no understanding of Happstack, acid-state, or IxSet. So, even if you don't care about acid-state, you may find it useful if you have ever wondered what the heck lenses are.

Sunday, January 22, 2012

ANN: happstack-server 6.5.1

I am pleased to announce the release of happstack-server 6.5.1. Changes include:

Discussion here: 

Saturday, January 14, 2012 now less evil

If you experienced some outage today trying to reach, it is because we very ungracefully transfered our domain from the evil pro-SOPA godaddy to the less-evil anti-SOPA namecheap. Yay!

You are probably already familiar with SOPA/PIPA, but if not, here is some more information:

The DNS changes have probably propagated to you by now, but if not, they should in the next 24 hours.

Monday, November 14, 2011

ANN: happstack-lite - a friendly introduction to Happstack

Happstack is a powerful Haskell web framework with a rich API that has
evolved over the last 7 years to meet the needs of real world web

Unfortunately a rich and flexible API can also be daunting when all
you need is something simple. What many people don't realize is that
inside Happstack lives a very simple and easy to use web framework.

I am pleased to announce a new member of the Happstack family:


happstack-lite is minimal version of Happstack that is designed give
you everything you need to get started with web develop in a much
cleaner, easier package. It is an ideal starting point for novice Haskell programmers or developers who are new to the Happstack family.

We have done that by:

 1. collecting the most essential types and functions into a single, well-documented module

 2. giving all the functions simple type signatures. No crazy monad
 transformers, far fewer type classes, etc.

 3. creating a new, small tutorial (less than 2000 words) that shows
 you how to use all the features of happstack-lite.

But, the best part is that happstack-lite is 100% compatible with regular Happstack. If you find you do need some of the extra features that Happstack offers, you can simply import the extra functions and use them. Migrating from happstack-lite to happstack is trivial -- mostly just changing `import Happstack.Lite` to `import Happstack.Server`. So, you are not locked into staying with happstack-lite if you decide you need more. And you can still use the many addon packages such as happstack-hsp or happstack-jmacro if you want.

happstack-lite is not crippled or underpowered. In fact, it offers features and performance on par with other Haskell frameworks while being as simple as possible. If you have ever looked at Happstack in the past and felt it was too complicated -- I would highly encourage to look again. Especially if the last time you looked was prior to Happstack 6.

Check out the tutorial here: happstack-lite.

We would love to hear your feedback and criticisms. Please see the related discussion at:

Thursday, July 21, 2011

type-safe urls via web-routes, part 2: Boomerang

web-routes is a system for implementing type-safe web-routes in Haskell web applications. In part 1, we saw the basics of how to use web-routes.

In part 1, we used template haskell to automatically derive the mapping between the url string and the url type. This makes development very easy, but the automatically derived urls are not all that visually appealing.

In this part, we introduce a way to manually specify the mapping between the url type and the url string. This gives the developer 100% control over the mapping. Up to now, the problem with creating a manual mapping has been that you had to implement the specification twice. You had to write a show function to turn a url type into a url string, and a read function to turn a url string into a url type. These functions are basically inverses of each other, both following the same spec.

What we really want to do is write the spec once and automatically extract the printer and parser from the spec. That way we can be sure they are inverses of each other, and we do not have to repeat ourselves. And we do not have to repeat ourselves. Because that is annoying.

Fortunately, Sjoerd Visscher and Martijn van Steenbergen figured out exactly how to do that and published a proof of concept library know as Zwaluw. With permission, I have refactored their original library into two separate libraries: boomerang and web-routes-boomerang.

boomerang is a general purpose, standalone invertible parser library. web-routes-boomerang adds glue code around boomerang so that it can be used to with web-routes.

Using boomerang we can take a route like this one:

> data Sitemap
>     = Home
>     | Article ArticleId
>     | UserOverview
>     | UserDetail Int String
>       deriving (Eq, Ord, Read, Show, Data, Typeable)

a specify a route map like this:

> sitemap :: Router Sitemap
> sitemap =
>     (  rHome
>     <> rArticle . (lit "article" </> articleId)
>     <> lit "users" . users
>     )
>     where
>       users =  rUserOverview
>             <> rUserDetail </> int . lit "-" . anyString

which defines a mapping like this:

/article/int<=>Article int
/users/int-string<=>UserDetail int string

The sitemap function looks like a ordinary parser. But, what makes it is exciting is that it also defines the pretty-printer at the same time.

For more in-depth details, see the relevant section of the Happstack Crash Course. If you just want to play with boomerang then start here.

Monday, July 11, 2011

type-safe urls via web-routes, part 1

web-routes is a suite of libraries which provide "type-safe" web routing. Instead of working directly with url strings in your web application, you create types to represent the routes.

The web-routes library has been around for several years. The idea itself is fairly obvious to many Haskell programmers, and so the idea has been rediscovered many times.

web-routes is designed to be exceedingly flexible. It is not explicitly tied to any haskell web framework, templating system, etc. It forms the basis of type-safe urls in yesod. There is also support for Happstack and HSP.

web-routes does not impose any particular method of mapping the url types to strings. We provide a variety of ways to defining mappings via addons including quasi-quotation, template haskell, generics, parsec, and more. If none of these systems suit your fancy, you can easily provide your own system. You basically need to provide two functions:

urlToString :: url -> [(String, String)] -> [String]
stringToUrl :: [String] -> Either String url

If you have an idea for how to map urls to types, I would encourage you to consider basing it on web-routes. A significant amount of effort has gone into handling issues like unicode and url escaping (among other things). If you use web-routes you do not need to know *any* of those rules. web-routes takes care of all that nastiness for you. If you find that web-routes is not suitable for your needs, I would love to hear why and see if we can not fix it.

The biggest issue with web-routes has been the lack of good documentation. So, I am pleased to announce that the first in a series of tutorials on web-routes is now online at:

Comments, questions, and corrections appreciated!