eklerks

There are a lot of concurrency related libraries implementing all kind of abstractions. Distributed computation is upcoming. There is an overview here: http://www.haskell.org/haskellwiki/Applications_and_librarie...

I used haskell in different startups and is was most of the times a good choice. I have written a dozen of (embedded) domain specific languages to support rapid development. This is quite easy in haskell. Parsec helps with writing parsers for your DSL.

What I saw, was that the amount of tests could be reduced, when using haskell. The type of testing is also somewhat different. You don't have to test for type errors. QuickCheck let you test mathematical properties (in an empiric way).

The FFI compensates for the missing libraries, but is a bit difficult to use.

But the biggest reason of using haskell for me, was the way it handles concurrency and the high abstraction level. This enables you to write distributed applications in a more convenient way than usual. If you working in a web start up, you hit somewhere a point, where you need to think about this stuff.

Besides Yesod, Snap is also a interesting choice, because of it's simplicity.

I enjoy using this language. I would choose it anytime. It made me a better programmer.

You don't have to handle it everywhere explicitly. This is where Functor, Applicative, Alternative, Monoid and Monad are for. They will do the plumbing for you. Eventually you will unpack the values, but this is only necessary if you change environment.

Say we have a failing computation: failComp = Nothing

and a couple of succeeding computations: sucComp = Just 1 sucComp2 = Just 2

We can use the typeclasses to avoid explicit unpacking:

-- Monad result: Just 3

add = do x <- sucComp2 y <- sucComp return $ x + y

Applicative result: Just 3

-- the <#> should be the applicative operator. addapp = (+) <$> sucComp <#> sucComp2

Alternative: result (Just 1)

val = failComp <|> sucComp

Monoid: result (Just 2)

mon = failComp <> sucComp2

Functor result (Just 6)

-- # should be multiply operator

func = fmap (#3) sucComp2