[Haskell-cafe] Tutorial: Haskell for the Evil Genius

[Bartosz Milewski]

I'm afraid this kind of 5-minute talk makes sense only if you already know 
a lot about monads or are a computer scientist; not if you're a programmer 
who wants to learn a new language. For instance, this statement starts 
making sense only if you've seen a lot of examples of monads (maybe even 
read Moggi and Wadler) and want to understand the big picture.

"... when Haskell programmers want to perform a side effect, they 
explicitly construct a description of the side effecting computation as a 
value."

And even then, what does it mean to "construct a description of the side 
effecting computation as a value" for the Maybe monad? An IO action or a 
State Monad action indeed are values that describe computations, but what 
computation does (Just 1) describe? It's the simple monads that are tricky 
to explain (I've seen a discussion to that effect in this forum and I 
wholeheartedly agree). 

--Bartosz

On Sunday, September 16, 2012 7:49:51 AM UTC-7, Tillmann Rendel wrote:
>
> Hi, 
>
> Kristopher Micinski wrote: 
> > Everyone in the Haskell cafe probably has a secret dream to give the 
> > best "five minute monad talk." 
>
> (1) Most programming languages support side effects. There are different 
> kinds of side effects such as accessing mutable variables, reading 
> files, running in parallel, raising exceptions, nondeterministically 
> returning more than one answer, and many more. Most languages have some 
> of these effects built into their semantics, and do not support the 
> others at all. 
>
> (2) Haskell is pure, so it doesn't support any side effects. Instead, 
> when Haskell programmers want to perform a side effect, they explicitly 
> construct a description of the side effecting computation as a value. 
> For every group of related side effects, there is a Haskell type that 
> describes computations that can have that group of side effects. 
>
> (3) Some of these types are built in, such as IO for accessing the world 
> outside the processor and ST for accessing local mutable variables. 
> Other such types are defined in Haskell libraries, such as for 
> computations that can fail and for computations that can return multiple 
> answers. Application programmers often define their own types for the 
> side effects they need to describe, tailoring the language to their needs. 
>
> (4) All computation types have a common interface for operations that 
> are independent of the exact side effects performed. Some functions work 
> with arbitrary computations, just using this interface. For example, we 
> can compose a computation with itself in order to run it twice. Such 
> generic operations are highly reusable. 
>
> (5) The common interface for constructing computations is called 
> "Monad". It is inspired by the mathematical theory that some computer 
> scientists use when they describe what exactly the semantics of a 
> programming language with side effects is. So most other languages 
> support some monad natively without the programmer ever noticing, 
> whereas Haskell programmers can choose (and even implement) exactly the 
> monads they want. This makes Haskell a very good language for side 
> effecting computation. 
>
>    Tillmann 
>
> _______________________________________________ 
> Haskell-Cafe mailing list 
> Haskel... at haskell.org <javascript:> 
> http://www.haskell.org/mailman/listinfo/haskell-cafe 
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20121014/746c4408/attachment-0001.htm>