What's the next step to learning Haskell after monads?

 

I've been gradually learning Haskell, and even feel like I've got a hang of monads. However, there's still a lot of more exotic stuff that I barely understand, like Arrows, Applicative, etc. Although I'm picking up bits and pieces from Haskell code I've seen, it would be good to find a tutorial that really explains them wholly. (There seem to be dozens of tutorials on monads.. but everything seems to finish straight after that!)

Here are a few of the resources that I've found useful after "getting the hang of" monads:

  • As SuperBloup noted, Brent Yorgey's Typeclassopedia is indispensable (and it does in fact cover arrows).
  • There's a ton of great stuff in Real World Haskell that could be considered "after monads": applicative parsing, monad transformers, and STM, for example.
  • John Hughes's "Generalizing Monads to Arrows" is a great resource that taught me as much about monads as it did about arrows (even though I thought that I already understood monads when I read it).
  • The "Yampa Arcade" paper is a good introduction to Functional Reactive Programming.
  • On type families: I've found working with them easier than reading about them. The vector-space package is one place to start, or you could look at the code from Oleg Kiselyov and Ken Shan's course on Haskell and natural language semantics.
  • Pick a couple of chapters of Chris Okasaki's Purely Functional Data Structures and work through them in detail.
  • Raymond Smullyan's To Mock a Mockingbird is a fantastically accessible introduction to combinatory logic that will change the way you write Haskell.
  • Read Gérard Huet's Functional Pearl on zippers. The code is OCaml, but it's useful (and not too difficult) to be able to translate OCaml to Haskell in your head when working through papers like this.

    • Most importantly, dig into the code of any Hackage libraries you find yourself using. If they're doing something with syntax or idioms or extensions that you don't understand, look it up.

    Regarding type classes:

  • Applicative is actually simpler than Monad . I've recently said a few things about it elsewhere, but the gist is that it's about enhanced Functor s that you can lift functions into. To get a feel for Applicative , you could try writing something using Parsec without using do notation--my experience has been that applicative style works better than monadic for straightforward parsers.

  • Arrow s are a very abstract way of working with things that are sort of like functions ("arrows" between types). They can be difficult to get your mind around until you stumble on something that's naturally Arrow -like. At one point I reinvented half of Control.Arrow (poorly) while writing interactive state machines with feedback loops.

  • You didn't mention it, but an oft-underrated, powerful type class is the humble Monoid . There are lots of places where monoid-like structure can be found. Take a look at the monoids package, for instance.

    • Aside from type classes, I'd offer a very simple answer to your question: Write programs! The best way to learn is by doing, so pick something fun or useful and just make it happen.

    In fact, many of the more abstract concepts--like Arrow --will probably make more sense if you come back to them later and find that, like me, they offer a tidy solution to a problem you've encountered but hadn't even realized could be abstracted out.

    However, if you want something specific to shoot for, why not take a look at Functional Reactive Programming--this is a family of techniques that have a lot of promise, but there are a lot of open questions of what the best way to do it is.

    Typeclasses like Monad , Applicative , Arrow , Functor are great and all, and even more great for changing how you think about code than necessarily the convenience of having functions generic over them. But there's a common misconception that the "next step" in Haskell is learning about more typeclasses and ways of structuring control flow. The next step is in deciding what you want to write, and trying to write it, exploring what you need along the way.

    And even if you understand Monads, that doesn't mean you've scratched the surface of what you can do with monadically structured code. Play with parser combinator libraries, or write your own. Explore why applicative notation is sometimes easier for them. Explore why limiting yourself to applicative parsers might be more efficient.

    Look at logic or math problems and explore ways of implementing backtracking -- depth-first, breadth-first, etc. Explore the difference between ListT and LogicT and ChoiceT. Take a look at continuations.

    Or do something completely different!

    链接地址: http://www.djcxy.com/p/80784.html

    上一篇: Scala中的真实世界函数式编程

    下一篇: 单子之后学习Haskell的下一步是什么？