blocks|key|1480784|text|编写haskell编译器:-)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1480785|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

blocks|key|3840033|text|像Monad，Applicative，Arrow，Functor这样的类型类都很棒，甚至比函数泛型带来的便利更能改变你对代码的看法。但有一种普遍的误解，认为Haskell的“下一步”是学习更多的类型类和结构化控制流的方法。下一步是决定你想要写什么，并试着写出来，探索你需要的东西。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3840034|即使您了解Monads，这也不意味着您已经触及了monadically结构化代码所能做的事情的皮毛。尝试使用解析器组合器库，或者编写自己的解析器组合器库。探索为什么应用符号有时对他们来说更容易。探索为什么限制自己使用应用型解析器可能更有效。|3840035|查看逻辑或数学问题，探索实现回溯的方法--深度优先、广度优先等。探索ListT与LogicT和ChoiceT之间的区别。看一下continuations。|3840036|或者做一些完全不同的事情！|3840037|entityMap^0|1|5|7|B|J|5|P|7|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|W|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|X|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|Y|8|@]|D|@]|E|$]]|$1|L|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|M|$]]

Typeclasses like <code>Monad</code>, <code>Applicative</code>, <code>Arrow</code>, <code>Functor</code> 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!

blocks|key|3840080|text|毫无疑问，你能做的最重要的事情就是探索更多的黑客行为。尝试使用Haskell的各种奇异特性可能会让您找到某些问题的改进解决方案，而Hackage上的库将极大地扩展您的工具集。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3840081|关于Haskell生态系统最好的部分是，你可以在学习外科手术般的精确的新抽象技术和学习如何在Hackage上使用巨大的电锯之间取得平衡。|3840082|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Far and away the most important thing you can do is explore more of Hackage. Grappling with the various exotic features of Haskell will perhaps let you find improved solutions to certain problems, while the libraries on Hackage will vastly expand your set of tools.

The best part about the Haskell ecosystem is that you get to balance learning surgically precise new abstraction techniques with learning how to use the giant buzz saws available to you on Hackage.

blocks|key|2432070|text|以下是我在“掌握”monads的诀窍后发现的一些有用的资源：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2432071|2432072|正如SuperBloup所指出的，Brent+Yorgey的Typeclassopedia是不可或缺的(事实上，它确实涵盖了Real+World+Haskell中大量可以被认为是“monad之后”的伟大东西:应用程序解析、monad转换器和STM，例如，|unordered-list-item|offset|length|2432073|John+Hughes的"Generalizing+Monads+to+Arrows"是一个很好的资源，它教会了我关于monads和箭头的同样多的知识(尽管当我读到它的时候，我认为我已经理解了monads+)。|2432074|2432075|+"Yampa+Arcade"论文是一篇很好的介绍Functional+Reactive+monads类型家族的文章:我发现使用它们比阅读关于它们的知识更容易。vector-space包是一个开始的地方，或者您可以查看Oleg+Kiselyov和Ken+Shan的代码Chris+Okasaki的Purely+Functional+Data+Structures的几个章节，并在Haskell.|2432076|Read+Smullyan的Functional+Pearl+on+zippers是一个奇妙的组合逻辑介绍，它将改变您编写detail.|2432077|Raymond+Gérard+To+Mock+a+Mockingbird的Functional+Pearl+on+zippers的方式。代码是OCaml的，但在阅读这样的论文时，能够在头脑中将OCaml转换为Haskell是很有用的(而且不是太难)。|2432078|2432079|最重要的是，深入研究您发现自己正在使用的任何Hackage库的代码。如果他们在做一些你不理解的语法、习惯用法或扩展，可以查一下。|2432080|entityMap|0|LINK|mutability|MUTABLE|url|http://www.haskell.org/wikiupload/8/85/TMR-Issue13.pdf|1|http://book.realworldhaskell.org/|2|http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.29.4575|3|http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.65.8016&rep=rep1&type=pdf|4|http://hackage.haskell.org/package/vector-space|5|http://okasaki.blogspot.com/2008/02/ten-years-of-purely-functional-data.html|6|http://www.st.cs.uni-saarland.de/edu/seminare/2005/advanced-fp/docs/huet-zipper.pdf|7|http://en.wikipedia.org/wiki/To_Mock_a_Mockingbird|8^0|0|0|U|F|0|1Q|I|1|0|C|V|2|0|0|1|E|3|28|C|4|44|X|5|0|E|R|6|0|F|L|7|11|R|8|0|0|0^^$0|@$1|2|3|4|5|6|7|1G|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|1I|8|@]|9|@$F|1J|G|1K|1|1L]|$F|1M|G|1N|1|1O]]|A|$]]|$1|H|3|I|5|E|7|1P|8|@]|9|@$F|1Q|G|1R|1|1S]]|A|$]]|$1|J|3|-4|5|E|7|1T|8|@]|9|@]|A|$]]|$1|K|3|L|5|E|7|1U|8|@]|9|@$F|1V|G|1W|1|1X]|$F|1Y|G|1Z|1|20]|$F|21|G|22|1|23]]|A|$]]|$1|M|3|N|5|E|7|24|8|@]|9|@$F|25|G|26|1|27]]|A|$]]|$1|O|3|P|5|E|7|28|8|@]|9|@$F|29|G|2A|1|2B]|$F|2C|G|2D|1|2E]]|A|$]]|$1|Q|3|-4|5|6|7|2F|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|2G|8|@]|9|@]|A|$]]|$1|T|3|-4|5|6|7|2H|8|@]|9|@]|A|$]]]|U|$V|$5|W|X|Y|A|$Z|10]]|11|$5|W|X|Y|A|$Z|12]]|13|$5|W|X|Y|A|$Z|14]]|15|$5|W|X|Y|A|$Z|16]]|17|$5|W|X|Y|A|$Z|18]]|19|$5|W|X|Y|A|$Z|1A]]|1B|$5|W|X|Y|A|$Z|1C]]|1D|$5|W|X|Y|A|$Z|1E]]|1F|$5|W|X|Y|A|$Z|1C]]]]

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

<ul>
<li>As SuperBloup noted, Brent Yorgey's <a href="http://www.haskell.org/wikiupload/8/85/TMR-Issue13.pdf" rel="noreferrer">Typeclassopedia</a> is indispensable (and it does in fact cover arrows).</li>
<li>There's a ton of great stuff in <a href="http://book.realworldhaskell.org/" rel="noreferrer">Real World Haskell</a> that could be considered "after monads": applicative parsing, monad transformers, and STM, for example.</li>
<li>John Hughes's <a href="http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.29.4575" rel="noreferrer">"Generalizing Monads to Arrows"</a> 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).</li>
<li>The <a href="http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.65.8016&amp;rep=rep1&amp;type=pdf" rel="noreferrer">"Yampa Arcade"</a> paper is a good introduction to Functional Reactive Programming.</li>
<li>On type families: I've found working with them easier than reading about them. The <a href="http://hackage.haskell.org/package/vector-space" rel="noreferrer">vector-space</a> package is one place to start, or you could look at the code from Oleg Kiselyov and Ken Shan's <a href="http://okmij.org/ftp/gengo/NASSLLI10/" rel="noreferrer">course on Haskell and natural language semantics</a>.</li>
<li>Pick a couple of chapters of Chris Okasaki's <a href="http://okasaki.blogspot.com/2008/02/ten-years-of-purely-functional-data.html" rel="noreferrer">Purely Functional Data Structures</a> and work through them in detail.</li>
<li>Raymond Smullyan's <a href="http://en.wikipedia.org/wiki/To_Mock_a_Mockingbird" rel="noreferrer">To Mock a Mockingbird</a> is a fantastically accessible introduction to combinatory logic that will change the way you write Haskell.</li>
<li>Read Gérard Huet's <a href="http://www.st.cs.uni-saarland.de/edu/seminare/2005/advanced-fp/docs/huet-zipper.pdf" rel="noreferrer">Functional Pearl on zippers</a>. 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.</li>
</ul>

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.

blocks|key|3840221|text|关于类型类：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3840222|3840223|Applicative实际上比Monad更简单。我最近在其他地方提到了a+few+things+about+it，但要点是它是关于增强的Functor，您可以在其中提升函数。要了解Applicative，您可以尝试使用编写代码，而不使用do表示法--我的经验是，应用程序风格比一元式更有效，因为简单的sort是一种非常抽象的方式，可以处理类似于函数的东西(类型之间的“箭头”)。它们可能很难让你明白，直到你偶然发现了一些本质上是Arrow-like的东西。在编写带有反馈循环的交互式状态机时，我一度重塑了Control.Arrow的一半(差劲)。|unordered-list-item|offset|length|style|CODE|3840224|你没有提到它，但一个经常被低估、功能强大的类型类是不起眼的Monoid。有很多地方可以找到类么半群结构。例如，看看monoids+package。|3840225|3840226|3840227|除了类型类之外，我会提供一个非常简单的答案来回答你的问题：编写程序！最好的学习方法是通过实践，所以选择一些有趣或有用的东西，然后让它发生。|BOLD|3840228|事实上，许多更抽象的概念--比如Arrow--可能会更有意义，如果您稍后再来看它们，并发现它们为您遇到但甚至没有意识到可以抽象出来的问题提供了一个整洁的解决方案。|3840229|但是，如果您想要实现特定的目标，为什么不看一下Functional+Reactive+Programming--这是一系列很有前途的技术，但是对于最好的方法是什么，还有很多悬而未决的问题。|3840230|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/3242361/haskell-how-is-pronounced/3242853#3242853|1|http://hackage.haskell.org/package/monoids|2|http://www.haskell.org/haskellwiki/Functional_Reactive_Programming^0|0|0|0|B|F|5|1W|7|2I|B|3A|2|5Y|5|70|D|Z|L|0|0|T|6|1L|F|1|0|0|0|T|5|0|G|5|0|N|V|2|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|17|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|18|8|@$F|19|G|1A|H|I]|$F|1B|G|1C|H|I]|$F|1D|G|1E|H|I]|$F|1F|G|1G|H|I]|$F|1H|G|1I|H|I]|$F|1J|G|1K|H|I]|$F|1L|G|1M|H|I]]|9|@$F|1N|G|1O|1|1P]]|A|$]]|$1|J|3|K|5|E|7|1Q|8|@$F|1R|G|1S|H|I]]|9|@$F|1T|G|1U|1|1V]]|A|$]]|$1|L|3|-4|5|6|7|1W|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|1X|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|1Y|8|@$F|1Z|G|20|H|P]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|21|8|@$F|22|G|23|H|I]]|9|@]|A|$]]|$1|S|3|T|5|6|7|24|8|@]|9|@$F|25|G|26|1|27]]|A|$]]|$1|U|3|-4|5|6|7|28|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|11]]|12|$5|X|Y|Z|A|$10|13]]|14|$5|X|Y|Z|A|$10|15]]]]

Regarding type classes:

<ul>
<li><code>Applicative</code> is actually simpler than <code>Monad</code>. I've recently said <a href="https://stackoverflow.com/questions/3242361/haskell-how-is-pronounced/3242853#3242853">a few things about it</a> elsewhere, but the gist is that it's about enhanced <code>Functor</code>s that you can lift functions into. To get a feel for <code>Applicative</code>, you could try writing something using <a href="http://hackage.haskell.org/package/parsec" rel="nofollow noreferrer">Parsec</a> without using <code>do</code> notation--my experience has been that applicative style works better than monadic for straightforward parsers.</li>
<li><code>Arrow</code>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 <code>Arrow</code>-like. At one point I reinvented half of <code>Control.Arrow</code> (poorly) while writing interactive state machines with feedback loops.</li>
<li>You didn't mention it, but an oft-underrated, powerful type class is the humble <code>Monoid</code>. There are lots of places where monoid-like structure can be found. Take a look at the <a href="http://hackage.haskell.org/package/monoids" rel="nofollow noreferrer">monoids package</a>, for instance.</li>
</ul>

<hr>

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 <code>Arrow</code>--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 <a href="http://www.haskell.org/haskellwiki/Functional_Reactive_Programming" rel="nofollow noreferrer">Functional Reactive Programming</a>--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.

blocks|key|2432170|text|作为下一步(而不是六个“下一步”)，我建议您学习编写自己的类型类。这里有几个简单的问题可以让你入门：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2432171|2432172|为QuickCheck编写了一些有趣的实例声明。例如，假设您想要生成随机树，这些树在某种程度上与以下小问题有关:定义函数/\、\/和complement+(“"interesting".|unordered-list-item|offset|length|style|CODE|2432173|Move”，"or"，&“complement”)，这些函数不仅可以应用于布尔值，还可以应用于任意数量的谓词。(如果你仔细观察，你可以在SO上找到这个问题的答案。)|2432174|2432175|entityMap^0|0|0|1O|2|1R|2|1U|A|0|D|A|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|P|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|Q|8|@$F|R|G|S|H|I]|$F|T|G|U|H|I]|$F|V|G|W|H|I]]|9|@]|A|$]]|$1|J|3|K|5|E|7|X|8|@$F|Y|G|Z|H|I]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$]]

As a single next step (rather than half a dozen "next steps"), I suggest that you learn to write your own type classes. Here are a couple of simple problems to get you started:

<ul>
<li>Writing some interesting instance declarations for QuickCheck. Say for example that you want to generate random trees that are in some way "interesting".</li>
<li>Move on to the following little problem: define functions <code>/\</code>, <code>\/</code>, and <code>complement</code> ("and", "or", &amp; "not") that can be applied not just to Booleans but to predicates of arbitrary arity. (If you look carefully, you can find the answer to this one on SO.)</li>
</ul>

blocks|key|2432203|text|Contribute+to+GHC!|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2432204|​|2432205|📷|atomic|2432206|2432207|entityMap|0|LINK|mutability|MUTABLE|url|http://hackage.haskell.org/trac/ghc/wiki/GettingStarted|1|IMAGE|IMMUTABLE|imageUrl|https://i.imgur.com/MxSqK.gif|imageAlt^0|0|I|0|0|0|0|1|1|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@$A|Y|B|Z|1|10]]|C|$]]|$1|D|3|E|5|6|7|11|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|12|8|@]|9|@$A|13|B|14|1|15]]|C|$]]|$1|I|3|E|5|6|7|16|8|@]|9|@]|C|$]]|$1|J|3|-4|5|6|7|17|8|@]|9|@]|C|$]]]|K|$L|$5|M|N|O|C|$P|Q]]|R|$5|S|N|T|C|$U|V|W|-4]]]]

<a href="http://hackage.haskell.org/trac/ghc/wiki/GettingStarted" rel="nofollow noreferrer">Contribute to GHC!</a>

<a href="http://hackage.haskell.org/trac/ghc/wiki/GettingStarted" rel="nofollow noreferrer"><img src="https://i.imgur.com/MxSqK.gif" alt="Get started with hacking on GHC!"></a>

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!)

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

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我一直在逐步学习Haskell，甚至觉得我已经掌握了monads的诀窍。然而，仍然有许多更奇特的东西我几乎不懂，像箭头，应用程序等。虽然我正在从我见过的Haskell代码中挑选一些零碎的东西，但如果能找到一个真正完整地解释它们的教程，那将是一件好事。(似乎有许多关于monad的教程..但一切似乎都会在那之后直接结束！)

问学习Haskell的下一步是什么？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问学习Haskell的下一步是什么？EN