

Try Haskell - boryas
http://tryhaskell.org/
Edit: I'm not the creator of this, I just saw it on programming reddit and thought it would interest people here. With that said, if you want to give feedback to the creator, there would be a better place: http://www.reddit.com/r/haskell/comments/b58rk/try_haskell/
======
munctional
Does anyone have any suggestions for beginner Haskell projects?

I've read through some Haskell material before and tried following tutorials,
but I always end up dropping it because I can't think of anything for which I
would use it.

I have no problem with functional and functional-esque programming (Erlang,
Common Lisp, etc.), but I just can't come up with anything to do in Haskell.
:(

EDIT:

Thanks for the great suggestions, everyone! I think I'll do some crpyo-based
maths work in Haskell since that is what holds my interest at the moment. :-)

~~~
lg
I usually start picking up new languages by taking something I've written and
translating it into the new language.

~~~
brianobush
exactly my approach, also you can try college homework assignments found via
google.

------
gphil
Cool! I really like what the Haskell community is doing lately to reach out to
new users. As someone who didn't know anything about functional programming a
year ago, I can say that I've learned a lot just by messing around with it a
little bit.

~~~
giu
Same here. I can only recommend to learn you a functional programming language
for greater good. I love every minute I spend writing Haskell code, be it a
simple console application or something more complex. It's really fun,
interesting and educational, and I'm only at the beginning :)

------
Ezra
I applaud the effort, but this is far from complete. As far as I can tell, you
can only do standalone expressions, to the exclusion of anything interesting.

    
    
        Type Haskell expressions in here.
        > let x = 10
        not an expression: `let x = 10'
    

I understand that mueval has this limitation too? It's more defensible in the
irc context that "state" would be disallowed. Here, it's just crippling.

I don't need the mtl stuff, but being able to define a basic function would be
nice!

<http://codepad.org/> will run full programs for you ... I guess that'll
continue to be my tool of choice for online Haskell prototyping.

Still, this project does seem promising.

~~~
jerf
The developer posted on Reddit that this was a premature release.
(Clarification: That is to say, he did something like email the link to a
buddy and it unexpectedly ended up on Reddit, not that it was formally
released and then regretted.)

To be honest, if you're at the point where you want that sort of thing, I'd
generally suggest simply downloading ghci. ISTM that all these "try it online"
things are good for are making the decision of whether you want to bother with
that step. (Perhaps I'm spoiled on Linux where downloading GHC or Ruby is
hardly any harder than visiting a web page anyhow.)

------
nym
Nice, but needs more steps... get me to the point where I understand what a
Monad is, because I really want to know!

~~~
jmillikin
I don't understand how people keep failing to understand monads. Maybe it's
the line noise operator `>>=' ?

Lets define a simple type, `Maybe', which can store either a value or an
absence of value:

    
    
      data Maybe a = Just a | Nothing
        deriving (Show)
    

And define a function which compares a number against a limit, and returns
`Nothing' if the value is out of range:

    
    
      clamp :: Ord a => a -> a -> Maybe a
      clamp limit x = if x > limit then Nothing else Just x
    

Easy enough. Now, how should the number be compared against multiple limits?

One way is to just brute-force it:

    
    
      multiclamp :: Ord a => a -> a -> a -> Maybe a
      multiclamp lim1 lim2 x = case clamp lim1 x of
        Nothing -> Nothing
        Just x' -> clamp lim2 x'
    

But this is ugly. Lets use monads to simplify it.

First, take a look at the core Monad operations. I'm going to use `build' and
`bind' instead of `return' and `>>=', because they're probably more familiar
to most readers.

    
    
      class Monad m where
        build :: a -> m a
        bind :: m a -> (a -> m b) -> m b
    

Next, we'll define an instance of the `Monad' typeclass for `Maybe'. It will
use the same semantics as the `multiclamp' example -- that is, if the first
test returns `Nothing', the entire computation will return `Nothing':

    
    
      instance Monad Maybe where
        build x = Just x
    
        bind Nothing  _ = Nothing
        bind (Just x) f = f x
    

Using this definition, `multiclamp' can be written thus:

    
    
      multiclamp2 :: Ord a => a -> a -> a -> Maybe a
      multiclamp2 lim1 lim2 x = bind
        (clamp lim1 x)
        (\x' -> clamp lim2 x')
    

Although ugly, this notation is sufficiently generic that the compiler can
generate it from an imperative notation. Lets look at two more examples.
First, `multiclamp2' written using "real" monads. Notice that this is exactly
the same as before, except `bind' is an operator named `>>=':

    
    
      multiclamp3 :: Ord a => a -> a -> a -> Maybe a
      multiclamp3 lim1 lim2 x =
        (clamp lim1 x) >>=
        (\x' -> clamp lim2 x')
    

And finally, using the imperative-style `do' notation. Note that although this
is imperative, it is _not_ impure -- this is semantically equal to
`multiclamp3':

    
    
      multiclamp4 :: Ord a => a -> a -> a -> Maybe a
      multiclamp4 lim1 lim2 x = do
        x' <- clamp lim1 x
        clamp lim2 x'
    

This is, obviously, a superficial example -- you'd never see such verbose code
in code written by an experienced programmer. But the verbosity helps to
visualize what the compiler is doing.

For completeness, here's a "cleaner" version, which takes advantage of
currying and the combinator `.':

    
    
      multiclamp5 :: Ord a => a -> a -> a -> Maybe a
      multiclamp5 lim1 lim2 = (clamp lim2 =<<) . clamp lim1

~~~
_delirium
> I don't understand how people keep failing to understand monads. Maybe it's
> the line noise operator `>>=' ?

For me at least, the mathematics line-noise is a bigger issue, and it made
more sense once I ignored it. As a _programming construct_ , monads seem quite
understandable to me, even clever. But many of the explanations, especially
earlier ones, started out with a type-theoretic explanation with links to
category theory...

In particular, I was under the misimpression for years, because of it being
presented that way, that monads were essentially of interest only for people
who were hung up on type-checking: that they were a solution to how to make
the type-checking go through on a certain class of problems, by lifting an
underlying type into the Monadic type and getting it back out again. As
someone who mainly uses dynamically typed languages, this didn't seem of
interest, since in Lisp, I don't care if the type-checking goes through or
not. It was probably years later that I figured out they had some non-type-
related programming benefit.

~~~
anonymousDan
Which are? I've read somewhere they help improve the modularity of your code,
is this what you're referring to?

~~~
chousuke
Functional programming is very focused on composing operations. Function
composition is an obvious example, but it is not the only one. As far as I
understand monads, they allow you to write generic operations separate from
the logic needed to compose those operations.

Inspired by this article. and in a fit of temporary insanity, I implemented a
simple monad protocol and the Maybe and List monads in Clojure. It's not fit
for use, but it was fun to write.

<http://gist.github.com/312281>

It may not be immediately evident what is being composed there, but if you
look at lift, it breaks the multi-argument "+" operator into several partial
applications and composes each of those under the given monad, giving
interesting results. This was necessary to maintain support for a variable
number of arguments.

Note that the code uses features only available in the git master branch, so
you will need a snapshot build to run it.

------
simplify
The text area scrolls to the very top every time I type, not letting me see
what I type [Safari 4.0.3]

Pretty cool app. A tutorial to go along with it would do wonders.

~~~
mhansen
Also in Chrome 5.0.322.2 dev

------
jashkenas
Ah, but can it reverse an infinite list?

    
    
        > reverse [1..]
    
        Time limit exceeded

------
baguasquirrel
Pretty nifty. Needs import though, so you can do stuff like:

:m + Data.List intersperse '.' "hello"

And anything else you'd need if you want to use stuff other than just the
Prelude.

~~~
jedbrown
Many modules are already imported, including Data.List.

------
cool-RR
Please add help for something beyond "beginners".

------
binarycheese
Very impressive

------
baguasquirrel
Pretty nifty. Needs import though, so you can do stuff like:

:m + Data.List intersperse '.' "hello"

And anything else you'd need if you want to use stuff other than just the
Prelude.

------
baguasquirrel
Pretty nifty. Needs import though, so you can do stuff like:

:m + Data.List intersperse '.' "hello"

And anything else you'd need if you want to use stuff other than just the
Prelude.

------
baguasquirrel
Pretty nifty. Needs import though, so you can do stuff like:

:m + Data.List intersperse '.' "hello"

And anything else you'd need if you want to use stuff other than just the
Prelude.

