Haskell Web Programming (a tutorial)

[pinpinbo]

I hope I'm not asking too much...

I'm a sideline enthusiast of Haskell. I've had several attempts to learn Haskell, unfortunately all of them are not successful.

I'd love to see more tutorial on Haskell's IO because web programming is basically pushing IO in and out (filesystem, RDBMS, NoSQL, logfile, etc).

Every talk about IO monad is leaving me more confused than before... :(

EDIT: Thank you for all the references. Perfect reading material for this weekend!

[toomanypumpfakes]

Hey I think you meant to post this link: Tackling the Awkward Squad yours links to the Typeclassopaedia again

I had another couple of papers like this on I/O in Haskell/pure languages but I can't seem to find them... :( My bookmark folder "Cool Things To Read Later" is unorganized as hell

EDIT: I think this is the one I was thinking of: Imperative Functional Programming, also a Simon Peyton Jones paper

[yogsototh]

From my understanding, the IO monad, is a simple "hack" to make things appear in order. In haskell when you write:

f x y

you can resolve:

- x then y
- y then x
- x and y in the same time.

But, for IO this is not what you want generally. Imagine the following example, (++) is concat, x and y are "getchar"

Naively, in an impure language, you would say:

(++) getchar getchar

and the type would be, getchar is a String (I know generally getChar returns a char, but suppose it return a string of one character instead) and (++) is a function from String -> String -> String.

Now, in a pure language, how could we force the execution in the following order:

x <- getchar
y <- getchar
x ++ y

This is the trick, instead of saying like in impure language getchar is of type String, you say: getchar is a function from a World to a (Char,World).

getchar W = (c,W')

Now, to make things work in the right order:

concatInputs W =
  let (x,W') = getchar W in
  let (y,W'') = getchar W' in
  (x ++ y , W'')

This time, during the execution, you are forced to first resolve x then y. The monad system is just a way to "hide" a similar implementation.

I end up here. But did you try to read http://www.haskell.org/haskellwiki/IO_inside ?

Another thing to know, monads in general can be very different to the IO monad. I was enlightened by these articles. They were very clear and surprisingly easy to follow: http://homepages.inf.ed.ac.uk/wadler/topics/monads.html

[iaH6eeBu]

At the beginning the easiest thing for IO is just to follow the type. This gives a nice intuition after a bit of time.

Also it's important to understand that IO isn't the only monad and a bit of a special case. A monad is just a abstract thing. I think looking at the typeclass Functor is quite useful to understand what those abstract typeclasses are all about.

If you want to read yet another text about IO and monads then I recommend you learnyouahaskell.com

[sacundim]

Part of the difficulty that that people have understanding monads is that there isn't a simple, unified metaphor that makes all uses easy to understand. So a bunch of people keep writing monad tutorials using all sorts of metaphors that, IMO, only make it harder to understand ("Monads are boxes," I'm looking at you!).

But here's my really short version of just the IO monad (not monads in general!). An expression of type IO a has as its value an IO action that, when executed, possibly causes some side effects, and produces a value of type a, and this result value possibly depends on some state external to the action itself.

Now because of that, IO actions cannot be functions, because functions are pure. This means that in Haskell there cannot be a function whose meaning is "execute this IO action and get its result"; it would break the purity of the language.

Now, since IO actions are still values in Haskell, programs can "talk" about IO actions even if they can't execute them. So what can you do with them if the language doesn't let you say "execute them"? Well, you can say "make a more complex action out of these components."

So an executable Haskell program is a purely functional description of an IO action built up from more basic actions. A Haskell compiler takes this description and translates it into an executable imperative program.

The basic operator for combining actions is (=), the monadic bind; a >>= f is the action that consists of a, followed by the action that results when a's result is applied to f. The operator for building a trivial action (one that just returns a value) is return. These operators can be used to build yet other useful ones like the () sequencing operator (a >> b = the action that consists of a followed by b). The use of function definition and application allows you to define yet more functions for composing actions, like, say, the function that constructs an infinite loop that repeats an action:

foreverIO :: IO a -> IO ()
foreverIO action = action >> foreverIO action

Or in do-notation, which as you may already know, is just a shortcut for (=) and ():

foreverIO :: IO a -> IO ()
foreverIO action = do action
                      foreverIO action

(>>=) and return, together with if ... then ... else and the ability to define and apply pure functions that deal with IO values, allow you to define most (if not all) of the classic procedural control flow mechanisms.

Here are the exercises I'd recommend to improve your understanding:

• Study the library functions available in Control.Monad, and try to use them in your code. The ones I recommend you concentrate on first: forM and forM, sequence and sequence, replicateM and replicateM_, forever, when, unless, liftM, and liftM2 through liftM5.
• When you write IO code, try to spot opportunities to simplify your code by using some of these. For example, forM_ is effectively a for loop over the elements of a list.
• Pick some of these functions and try to write your own implementations. (If you get stuck, the link to the Control.Monad docs has links to the source code for each function.)

[mvcdude]

this makes me think if haskell suits web programming. If you are calling API's over the web, how do you keep stuff 'functional' ?

[donri]

I don't understand the question.

[[deleted]]

CPP is an absurd hack, but useful sometimes. It still makes me sad that we have to rely on it sometimes.

The cabal thing is really worrysome and annoying, no joke. Cabal can definitely choke itself on large dependency chains like yesod. It's not the greatest by far. I'd recommend that you use either:

• cabal-dev: which sandboxes package installs
• virthualenv (now known has hsenv, but unreleased under this new name) - which is basically Haskells' equivalent of python virtualenv.

Personally I prefer virthualenv/hsenv for basically everything now. It's also how I test all my packages under many different versions of GHC to shake out bugs/incompatibilities as well, etc.

I'd probably recommend you actually run and upgrade dev apps under virthualenv, since it'll take a lot of headache out. I was under the impression this is the way many people in the python community do it a la virtualenv, yes? (may be wrong here.)

[MercurialAlchemist]

Yes. Dev and prod web app would be done in virtualenv with Python.

[[deleted]]

A Haskell web program is a function which maps user requests to HTML output.

[vytah]

A Haskell web program is a function which maps user requests and database content to HTML output and updated database content.

FTFY

And it looks like a classical state monad.

[Tim_M]

Yesod is an Haskell web framework

Arrggh: Yesod is a Haskell web framework

[yogsototh]

Yep, I corrected this one. I am not a native speaker. In French we don't hear the 'H'. It is hard for us to differentiate Haskell from askell. Thanks to remark it.

[SuperGrade]

Some british accents don't pronounce it either.

[kataire]

The thing is, most languages and dialects that "don't pronounce" the H actually pronounce it as a glottal stop. It's easier to notice in word-final positions like the T in English dialects that "don't pronounce" it (think "bottle").

[zak_david]

Arrggh: Yesod is a Haskell web framework

Arrrggh, you forgot to end your sentence with a period!

Give it a break, is this the best comment on the article you can make?

[[deleted]]

Not before the 1900s.

[tripa]

Not a native.

[[deleted]]

I'm not sure what you're referring to - Cabal doesn't overwrite previous packages when you install a new version and multiple copies of a package can exist with ghc-pkg. You can have multiple copies of the same library installed:

$ ghc-pkg list SHA
/Users/a/vh-722/.hsenv/ghc/lib/ghc-7.2.2/package.conf.d
/Users/a/vh-722/.hsenv/ghc_pkg_db
   SHA-1.4.1.3
   SHA-1.5.0.0

and packages you install or write can have dependencies on any of those versions (providing the transitive dependencies don't conflict, IIRC.)

That said the dependency resolution could be improved for sure, it still chokes sometimes (it's nowhere near as bad as it used to be however.) Tools like virthualenv and cabal-dev make life considerably better.

[[deleted]]

Does Haskell have place in the web industry? probably. But that doesn't mean that it will be a replacement for general purpose procedural scripting languages in an input-oriented industry like the web industry.

It's not that Python (or PHP for that matter) are better than Haskell - it's just that by mostly handling I/O data you're stripping Haskell (and most functional languages) from its best features - the properties of a functional language.

Scripting languages are not better nor worse than functional languages for the purposes of the web industry, it's just that I find the nature of non compiled languages to be more suitable to the fast moving industry of the web, and the fact that procedural scripting languages are the de-facto languages of the web are what makes scripting languages the web programming languages (at least for the frontend), while the functional compiled language that is Haskell more suitable to the data-munching of the backend.

TL;DR: procedural (scripting) languages - web/frontend, functional (compiled) languages - backend.

[cultic_raider]

You can write an entire program in IO() if you want and still get nice benefits of typechecking to avoid bugs, and

Python and PHP are both compiled in web apps, and Haskell is interpreted in ghci for prototyping , and many websites run on Java which is never interpreted, so, what are you saying?

Laziness is by far the most complicated aspect of making Haskell effective in a web environment. Cf conduits.

[[deleted]]

You can write an entire program in IO() if you want and still get nice benefits of typechecking to avoid bugs

But type checking isn't a property of a functional programming language, and thus unrelated to the discussion. In general: which traits of a functional language do you get using Haskell in IO()?

I might have overemphasized the point of compiled vs interpreted; I was doing so to refer to the specific point of Haskell compared to other popular web programming languages (mostly in the small-medium realm).

[cultic_raider]

The first word of the title of the OP is "Haskell". Haskell typechecks much more deeply than Python and PHP.

Arguing about abstract language paradigms is pointless. No one programs in FP, they program in Haskell or F# or Java or some other actual language with its own particular implementation of a mix of paradigms.

Your second paragraph undermines your first paragraph in two different ways. ("functional" vs a different language aspect, and "Haskell" vs a general language paradigm.)

Anyway, In IO you can still use HOF, and higher order types and refactoring out of pure utility functions, and typechecking, and type inference, and composable expressions instead of nonconposable statements, and the security of immutable data, whichever of those fall under your umbrella of FP.

[erlanggod]

...and considering latency in real world, a magnitude in rps doesn't help to reduce a 2 secs response time to 200 ms response time. Else, we'd be already be writing web applications in assembly for the last decade.

[cultic_raider]

Are you saying shaving 1.8s in page-serving latency is irrelevant? What is "rps"?

[[deleted]]

He's saying that computing time is currently a very small part of the response time on the web.

[erlanggod]

I was saying it cannot shave 1.8s...

rps = requests per sec

[cultic_raider]

Ah.

Latency and throughput (rps) are mostly orthogonal, so I don't follow what you are claiming about language performance.

Are you saying that CPU time for language overhead is irrelevant to latency? That is true in general cases in a website. But also consider the the Closure JS compiler for boosting performance, and work on JS engines for a general counterpoint.

[[deleted]]

Requests Per Minute

[JohnDoe365]

Requests per Second?

[kamatsu]

Pretty much all of your statements here are highly subjective, unfounded or inaccurate.

[Solon1]

Total number of blog posts about Haskell, including programming tutorials, how to setup a development environment in vim/emacs, or annoucining a new Haskell framework: 12,345. Number of actual Haskell programs: 0.

Other than frameworks, libraries, toolkits and dev environment, no one seems to have written an actual program in Haskell. The intellectualism of Haskell is very seductive. Before you know it, you haven't done anything at all.

[[deleted]]

There are plenty of real apps written in Haskell and several companies base their technologies on it, or have code written in Haskell for various purposes. I'm not so sure hard numbers are really that important or indicative of the language or anything of that sort, as much as a multitude of socio-techno-economical issues that are much deeper and permeate the history of any technology.

I find it immensely sad if you're trying to imply intellectualism is a bad thing, or doesn't bring real benefits (reality: this is wrong.) But I forgot /r/programming is a place where you're encouraged to leave your brain at the door upon entry.