7 ms·

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

• dmnd 17y ago
  Exactly, multiplying two numbers and reversing a string aren't what got me interested in Ruby. TryRuby was an absolutely frictionless way to learn the basics because it had a few lessons built in. I'll be back to this site in a few weeks to check for progress...
• derefr 17y ago
  I think the reason I've avoided getting into Haskell is that it seems like, no matter what tutorials or references I read on it, I never make it any further into http://www.willamette.edu/~fruehr/haskell/evolution.html http://www.willamette.edu/~fruehr/haskell/evolution.html before I completely lose track of what's going on. Haskell seems like it has all the same stuff as most other languages, but then there's this whole other layer of knowledge (mostly mathematical problem-domain knowledge) you have to add on before you can actually claim to "know" Haskell. I'm always hoping there'll be a tutorial that covers that sort of stuff, instead of just saying "here's how to do in Haskell the stuff you already know how to do in Ruby."
  • noamsml 17y ago
    I think YAHT is sorta decent in that regard. In the fourth chapter it teaches you enough to do something, and then it ramps you up a bit. It's still really confusing, but it's better than usual.
  • jerf 17y ago
    I am not sure, but it's worth checking: You do know that link is a joke, right? "Senior Haskell programmer" is where reality stops (give or take an entry or two, not counting the last "tenured professor" one), and if you can't get "foldr" you're ill-equipped to deal with more advanced Javascript techniques either.
    • derefr 17y ago
      Yeah, I'm aware that the whole point of it is the needless complexity of the latter solutions—still, you have to know Haskell to understand exactly why the latter solutions are so ridiculous (beyond merely gawking at them unappreciatively) and you have to understand Haskell even better to actually come up with the penultimately-contrived solutions. I'd like to be able to tell those jokes without it being like making sounds in a foreign language—that's what I mean by "knowing" Haskell. You can't speak a language until you can make a witty retort in it ;)
  • dons 17y ago
    > all the same stuff as most other languages, but then there's this whole other layer of knowledge (mostly mathematical problem-domain knowledge) you have to add on before you can actually claim to "know" Haskell. That's just computer science -- a bunch of CS stuff is easier to express in Haskell, so we do, but it might need some background. > here's how to do in Haskell the stuff you already know how to do in Ruby Try a different tutorial. Maybe: Real World Haskell?
• jmillikin 17y ago
  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
  • deleted 17y ago
    [deleted]
• jackowayed 17y ago
  Totally agree. Try ruby isn't great because it's a ruby shell in your browser. It's great because it's a ruby shell in your browser that shows off many features of the language. By the end, though people are definitely still beginners, they have a decent handle on the syntax and many of the basic objects. More than just multiplying numbers and reversing a string.