blocks|key|834021|text|在函数式语言中，最大的共同点是使用函数来存储数据。这有点像在没有对象的对象上使用访问器函数。相反，函数是在一个能够访问所需数据的环境中创建的。现在，这个函数可以在任何地方传递和使用，并且仍然保留使用数据的能力。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|834022|下面是一个非常简单的例子。这并不是纯粹的功能，因为它确实改变了状态，但它很常见：|834023|(define+(make-counter)
++(let+((count+0))
++++(lambda+()
++++++(set!+count+(%2B+count+1))
++++++count)))

(define+x+(make-counter))

(x)+returns+1

(x)+returns+2

...etc...|code-block|syntax|javascript|834024|所以我们有一个函数，make-计数器，它返回另一个函数，其中包含计数器的状态。我们可以调用新创建的计数器并观察内部的变化。|834025|这就是功能程序的结构方式。您有以函数作为参数的函数，还有以隐藏状态返回函数的函数，这些函数都比自己管理内存干净得多。|834026|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

The largest commonality you'll find in functional languages is using functions to store data. It's a bit like using accessor functions on an object without the object. Instead, the function is created in an environment where it has access to the data it needs. Now this function can be passed and used anywhere and still retain the ability to use the data.

Here's a very simple example. This isn't purely functional as it does change state, but it's common enough:

<pre><code>(define (make-counter)
 (let ((count 0))
 (lambda ()
 (set! count (+ count 1))
 count)))

(define x (make-counter))

(x) returns 1

(x) returns 2

...etc...
</code></pre>

So we have a function, make-counter, that returns another function that has the state of the counter inside. We can call that newly created counter and observe the change inside.

This is how functional programs are structured. You have functions that take functions as arguments, you have functions that return functions with hidden state, etc. It's all a lot cleaner than managing memory yourself.

blocks|key|135471|text|我曾参与过一些相当大的功能项目。它们通常分为两个阵营(至少，我曾使用过)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|135472|极端的可伸缩性/可靠性/并发性。事务性模型可以非常紧密地构建在语言中。并发ML就是一个很好的例子，当涉及到并发正确性时，使用它的项目很难出错。|unordered-list-item|135473|分析/修改框架。这些框架所基于的许多设计模式在函数式语言中非常容易形成/构建/修改。访问者模式就是一个很好的例子。|135474|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$]]|$1|E|3|F|5|D|7|K|8|@]|9|@]|A|$]]|$1|G|3|-4|5|6|7|L|8|@]|9|@]|A|$]]]|H|$]]

I have worked with some fairly large functional projects. They usually fall into two camps (at least, the ones I have used):

<ul>
<li>Extreme scalability/reliability/concurrency. Transactional models can be built very tightly into the language. Concurrent ML is a great example of this, and projects that use it are very hard to get wrong when it comes to concurrency correctness.</li>
<li>Parsing/modifying frameworks. Many of the design patterns that these frameworks are based on are incredibly easy to formulate/build/modify in functional languages. The visitor pattern is a great example of this.</li>
</ul>

blocks|key|1134480|text|我打印并查看了Ocaml中的设计模式，它们使用模块和函子(和对象)重新创建我们习惯的正常设计模式。这很有趣，但我认为它们使用对象太多，无法真正看到函数式语言的好处。FP是非常可合成的，它是自然的一部分。我想我的简短回答是使用模和函子。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1134481|我目前的项目相当大，我们把每个模块按文件分开--隐含在ocaml中。我一直在寻找一个全面的资源，可能有一些可供选择的观点或一些想法，一个真正成功的设计，从一个项目。|1134482|entityMap|0|LINK|mutability|MUTABLE|url|http://people.csail.mit.edu/dnj/teaching/6898/projects/vicente-wagner.pdf^0|7|B|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

I printed out and looked over <a href="http://people.csail.mit.edu/dnj/teaching/6898/projects/vicente-wagner.pdf" rel="nofollow noreferrer">Design Patterns in Ocaml</a>, and they use modules and functors (and objects) to recreate the normal design patterns we are used to. It's interesting, but I think they use objects too much to really see the benefit of functional languages. FP is very composable, part of it's nature. I guess my short answer is to use modules and functors. 

My current project is pretty big, and we separate each module by files --implicit in ocaml. I've been hunting for a comprehensive resource as well that might have some alternative views or some thoughts on a really successful design that came out of a project.

blocks|key|135571|text|我认为这可能有帮助；|type|unstyled|depth|inlineStyleRanges|entityRanges|data|135572|有些模式消失了--也就是说，它们直接受到语言特性的支持，有些模式更简单，或者有不同的焦点，而有些模式基本上没有变化。|blockquote|135573|目的-2002-005+Gregory+T.+Sullivan，面向可执行设计模式的高级编程语言特性--“反射更好的模式”|offset|length|135574|二00二年三月二十二日|135575|“设计模式”(Designed)一书(Designed)(Designed)一书(Designed+GOF95+)提供了24种经过反复测试的模式，它们一致出现在设计良好的软件系统中。每个模式都提供了对设计问题的描述--模式地址，以及示例实现代码和设计注意事项。本文探讨了“四人帮”或“GOF”书中的模式是如何在使用动态、高级、面向对象的编程语言解决类似问题时出现的。有些模式消失了--也就是说，它们直接受到语言特性的支持，有些模式更简单，或者有不同的焦点，而有些模式基本上没有变化。|135576|entityMap|0|LINK|mutability|MUTABLE|url|http://dspace.mit.edu/handle/1721.1/6686^0|0|0|W|T|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$]]|$1|E|3|F|5|6|7|W|8|@]|9|@$G|X|H|Y|1|Z]]|A|$]]|$1|I|3|J|5|6|7|10|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|11|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

I think this may help; 

<blockquote>
 Some of the patterns disappear -- that
 is, they are supported directly by
 language features, some patterns are
 simpler or have a different focus, and
 some are essentially unchanged.
</blockquote>

[AIM-2002-005] Gregory T. Sullivan, <a href="http://dspace.mit.edu/handle/1721.1/6686" rel="nofollow noreferrer">Advanced Programming Language Features for Executable Design Patterns "Better Patterns Through Reflection</a>

March 22, 2002

<blockquote>
 The Design Patterns book [GOF95]
 presents 24 time-tested patterns that
 consistently appear in well-designed
 software systems. Each pattern is
 presented with a description of the
 design problem the pattern addresses,
 as well as sample implementation code
 and design considerations. This paper
 explores how the patterns from the
 "Gang of Four'', or "GOF'' book, as it
 is often called, appear when similar
 problems are addressed using a
 dynamic, higher-order, object-oriented
 programming language. Some of the
 patterns disappear -- that is, they
 are supported directly by language
 features, some patterns are simpler or
 have a different focus, and some are
 essentially unchanged.
</blockquote>

blocks|key|834163|text|在使用功能语言的项目的“体系结构”中，常见的线索是它们往往被划分成代数层，而不是传统的系统体系结构意义上的子系统。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|834164|要获得此类项目的优秀示例，请查看XMonad、易语和HappS。如果您检查它们是如何构造的，您会发现它们由一元结构层组成，中间有一些组合器胶水。|offset|length|834165|还请看Scala实验论文，其中概述了一个体系结构，其中一个系统由对其依赖项进行抽象的组件组成。|834166|entityMap|0|LINK|mutability|MUTABLE|url|http://xmonad.org/|1|http://www.haskell.org/haskellwiki/Yi|2|http://happs.org/|3|http://www.cs.princeton.edu/~dpw/popl/06/odersky.pdf^0|0|G|6|0|N|2|1|Q|5|2|0|3|7|3|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@]|9|@$D|X|E|Y|1|Z]|$D|10|E|11|1|12]|$D|13|E|14|1|15]]|A|$]]|$1|F|3|G|5|6|7|16|8|@]|9|@$D|17|E|18|1|19]]|A|$]]|$1|H|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]|P|$5|K|L|M|A|$N|Q]]|R|$5|K|L|M|A|$N|S]]|T|$5|K|L|M|A|$N|U]]]]

The common thread in the "architecture" of projects that use functional languages is that they tend to be separated into layers of algebras rather than subsystems in the traditional systems architecture sense.

For great examples of such projects, check out <a href="http://xmonad.org/" rel="noreferrer">XMonad</a>, <a href="http://www.haskell.org/haskellwiki/Yi" rel="noreferrer">Yi</a>, and <a href="http://happs.org/" rel="noreferrer">HappS</a>. If you examine how they are structured, you will find that they comprise layers of monadic structure with some combinator glue in between.

Also look at <a href="http://www.cs.princeton.edu/~dpw/popl/06/odersky.pdf" rel="noreferrer">The Scala Experiment</a> paper which outlines an architecture where a system is composed of components that abstract over their dependencies.

blocks|key|135643|text|希望不要太切分，但对于浏览这个问题答案的人来说可能很有趣，这是Peter的这个演示文稿动态规划中的设计模式。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|135644|entityMap|0|LINK|mutability|MUTABLE|url|http://norvig.com/design-patterns/^0|17|A|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Hopefully not too tangential, but probably interesting for anyone browsing the answers to this question is this presentation <a href="http://norvig.com/design-patterns/" rel="nofollow noreferrer">Design Patterns in Dynamic Programming</a> by Peter Norvig.

I'm familiar with object-oriented architecture, including use of design patterns and class diagrams for visualization, and I know of service-oriented architecture with its contracts and protocol bindings, but is there anything characteristic about a software architecture for a system written in a functional programming language?

I know that FP has been used for medium-size to large scale projects. Paul Graham wrote the first incarnation of Yahoo! Store in Common Lisp. Some lisp development systems are complex. Artifical intelligence and financial systems written in functional languages can get pretty big. They all have at least some kind of inherent architecture, though, I'm wondering if they have anything in common?

What does an architecture based on the evaluation of expressions look like? Are FP architectures more composable?

Update: Kyle reminded me that <a href="http://mitpress.mit.edu/sicp/" rel="noreferrer">SICP</a> is a good resource for this subject.

Update 2: I found a good post on the subject: <a href="http://lorgonblog.spaces.live.com/Blog/cns!701679AD17B6D310!511.entry" rel="noreferrer">How does functional programming affect the structure of your code?</a>

Functional Programming Architecture

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我熟悉面向对象的体系结构，包括使用设计模式和类图进行可视化，我知道面向服务的体系结构及其契约和协议绑定，但是对于用函数编程语言编写的系统的软件体系结构有什么特点吗？。我知道FP已经被用于中等到大型的项目.保罗格雷厄姆写了雅虎的第一次化身！在公共商店里。有些lisp开发系统很复杂。用函数式语言编写的人工智能和金融系统可能...

问功能编程体系结构
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问功能编程体系结构EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问功能编程体系结构
EN