Clojure有什么原则吗 a。像Java这样的面向对象语言 b。或者其他更具启发性的方法，比如“告诉别人不要问”、“喜欢组合而不是继承”、“与接口对话” 是否有任何设计模式（用于灵活的代码） 像面向对象的封装这样的函数式编程基础的反作用是什么 知道这些方面的资源吗？1a）我不知道这样的事情，但每本关于FP的书都会做类似的事情 1b） “偏好组合vs继承”-->已经得到处理，因为您是从FP开始的 “与抽象对话”->更一般 “尽可能地懒惰” “避免状态” “使用纯函数！！！” 列表项 2.）

我正在学习ML，有人能解释一下什么是穷举模式吗？如果模式匹配不能失败，那么它就是穷举模式。即，所有可能发生的情况都包含在模式中 例如，以下模式匹配并不详尽，因为它不包括列表为空的情况： fun sum (x::xs) = x + sum xs 以下内容是详尽的，因为这两种情况都包括在内： fun sum (x::xs) = x + sum xs | sum [] = 0 通常，代数数据类型上的模式匹配是穷举的，当且仅当存在默认情况或所有构造函数都存在情况且每个子模式的匹配是穷举的。我从这

假设函数g定义如下 utop # let g ~y ~x = x + y ;; val g : y:int -> x:int -> int = <fun> utop # g ~x:1 ;; - : y:int -> int = <fun> utop # g ~y:2 ;; - : x:int -> int = <fun> utop # g ~x:1 ~y:2 ;; - : int = 3 utop # g ~y:2 ~x:1 ;; -

如何编写一个函数，该函数将评分函数（我已经编写）和字符串对列表作为输入（我对如何编写感到困惑），并返回一个修改后的字符串对列表，其中返回的列表应包含输入中的所有最佳字符串对，并根据输入函数进行评分 输入示例： '( ("hello" "b_low") ("hello_" "b_l_ow") ("hello" "_blow") ("hello" "blow") ("h_e_llo" "bl_o__w") ) 示例输出： ( ("hello" "b_low") ("hello_" "b_l_ow"

审查表上给了我以下功能： (define mystery(lambda(m n) (cond ((= m 0) n) ((= n 0) m) (#t (+ 2(mystery(- m 1)(- n 1)))) ))) 前两个条件很简单，只是递归的或者让我困惑。在我看来，递归将继续，直到它们都等于零，这当然不会返

我有一个这样的应用程序序列（f（f（fx）），是一个任意函数和任意应用程序序列。 我想证明f（xy）和（xy）），x=（ff…）和y=任何值，都是相等的。 我需要以下代码中的证明： Fixpoint r_nat {A : Type} (a : nat) : A -> (A -> A) -> A := match a with |S n => fun (x0 : A) (a0 : A -> A) => r_nat n (a0 x0) a0 |

我得到此值不是函数，无法应用。我认为这是由语法错误引起的。此代码有什么问题？函数应用程序的F#语法是： let compoundInterest initial monthly years (interest : decimal) = interest * (1.0m + interest) pown years compoundInterest 100.0m 100.0m 5.0m 0.1m 也就是说，每当编译器看到一个表达式后跟空格，然后后跟另一个表达式时，编译器就会将其视为函数

val SOME i=Int.fromString e 我的代码上有这样一行代码，smlnj向我显示了这个警告 vm.sml:84.7-84.32 Warning: binding not exhaustive SOME i = ... 这是坏习惯吗？我应该使用一个函数来处理该选项，还是我遗漏了什么？如果您只是在处理一个小脚本，您只需运行一次，这并不一定是坏做法：如果Int.fromString e失败（并返回NONE而不是SOME），然后，值绑定将失败，并向相应的处理程序

我有一个Clojure函数，它接受一个数字序列，将其切分为适当的位数，并返回一个延迟的块序列（首先是最低顺序的位）。它填充最后一个块的高阶位以填充块大小，我需要关于“最佳方式（tm）”的建议，以记录填充量，同时保持其惰性和功能性 非常感谢智慧的话语 (defn block-seq ([block-size bytes] "reads a byte-seq into a sequence of block-size bits." (block-seq 8 block-size

我有一个在图像上绘制形状的程序。我对每个形状都有一个单独的名称空间，它们位于单独的文件中 com/name/box.clj-->具有com.name.box命名空间。 com/name/triangle.clj-->具有com.name.triangle命名空间 它们都共享一个名为generate的公共函数，该函数在屏幕上绘制它们，所以如果我使用use，函数名会发生冲突 现在，我用load file加载它们。有更好的方法吗？查看Clojure API，似乎有多种包含文件的方法。对于包含大量文件的

在lambda演算中（λx.λy.λs.λz.x s（y s z））用于两个教会数字的加法我们如何解释这一点，lambda演算对于函数式编程有什么好的资源吗？非常感谢你的帮助。λf2。λs。λz。（f1 s（f2 s z））计算加法，因为它实际上是将由f2表示的数字（f2 s z）代入（f1 s z）内的“零” 示例：让我们以两个为f2，sz展开形式。f1是一个：sz。用f2替换最后一个z，得到三个的扩展形式sz 用黑板和挥手会更容易，抱歉。在lambda演算中，您可以根据数据类型产生的操作来编

有关许多有趣的示例，请参见Scala。许多任务本质上都是由函数概念解决的，例如可组合计算。在以面向对象的方式开发的项目中，您可能会遇到此类问题 工作的最佳工具独立于该工具的主导范式。如果您的项目是真正必要的，您可能不需要纯功能性语言。但您可能仍然需要一种具有功能特性的语言；函数式风格处理低级代码结构的方式与面向对象风格处理高级结构的方式相同。两者都允许您以语言支持的方式打包某些公共模式 在主要是命令式项目中，函数样式在表达式和语句级别非常有用，允许您抽象常见循环和序列： 例如，以这种常见模式为例

既然副作用破坏了引用的透明性，它们不是违背了函数式语言的观点吗？据我所知，如果你想在函数式语言中产生副作用，您必须显式地编写它们。纯函数式编程语言使用两种技术来模拟副作用： 1） 一种表示外部状态的世界类型，类型系统保证该类型的每个值只使用一次 在使用这种方法的语言中，print和read函数可能分别具有（string，world）->world和world->（string，world）类型 它们可以这样使用： let main w = let w1 = print ("What's yo

我需要一个函数，它将接收字符和数字的列表，然后返回相加的数字（忽略字符）。这就是我到目前为止所做的： (define (adder lst) (cond ((null? lst) 0) ((number? (car lst)) (+(adder (car lst)) (adder (cdr lst)))) ((char? (car lst)) ((adder(cdr lst)))) )) (display (a

我正在做一些家庭作业，但我在某件事上耽搁了好几个小时。 我相信这真的很琐碎，但在翻阅了所有可用的文档之后，我仍然无法理解它。 谁能帮我一把吗？ 基本上，OCaml编程中的练习要求使用平方求幂算法定义函数x^n 我已经研究了解决方案： let rec exp x = function 0 -> 1 | n when n mod 2 = 0 -> let y = exp x (n/2) in y*y | n when n mod 2 <> 0 -&

我完全不明白，接口在OCaml中是如何工作的 让我们看一个例子： 关于“a” 所以这里“a”的含义是什么？我的意思是我理解在描述函数时，'a表示任意类型。那这是什么意思？这是否意味着任意设置 另外，为什么要在集合前面放“a”？ 摘要 在解释这个例子时，他说： 我们需要抽象地定义集合的多态类型。那个 在接口中，我们将声明一个类型“a set”，而不给出 定义，防止程序的其他部分知道，或 取决于我们选择的集合的特定表示形式 从上面的语句中，我想这意味着在接口定义中，我们应该隐藏实现细节。但是隐

我阅读了函数中的多态性，并看到了这个示例 fun len nil = 0 | len rest = 1 + len (tl rest) 所有其他示例也处理nilarg 我想检查其他类型的多态性概念，比如 fun func (a : int) : int = 1 | func (b : string) : int = 2 ; 并得到了跟踪误差 stdIn:1.6-2.33 Error: parameter or result constraints of clauses do

以下是我对基于列表的快速排序的实现： let partition pivot l = let rec p left right = function | [] -> (left, right) | hd::tl -> let c = compare pivot hd in if c > 0 then p (hd::left) right tl else p left (hd::righ

我对把偏执论纳入计划有点困惑。下面是一个例子： =>(define foo1 (lambda (n) (+ n 1))) =>(foo1 ((lambda () 5))) =>value:6 给出结果6。但我很惊讶为什么这没有给出一个错误。下面是我如何在计算机中使用它的：首先计算（lambda（）5）表达式并返回5。现在，我们删除了它的偏执： =>(foo (5)) 现在这应该是无效的，因为我们在调用函数时不使用paranthes作为参数。但它没有错误。有人能告诉我

在像Haskell这样的函数式编程中，我可以定义函数 add a b = a+b 然后，add3将返回一个带有一个参数的函数，并返回3+something 我怎么能在围棋中做到这一点 当我定义一个包含多个（比如说n个）参数的函数时，我可以只给它一个参数，然后得到另一个包含n-1个参数的函数吗 更新： 对不起，我原来的问题用词不准确 我认为我的问题应该作为两个理由提出： GO中是否有部分应用程序 你怎么吃咖喱 感谢Anly92和Alex解决了我的第二个问题。然而，我也对第一个问题感到好奇。也

我有很多关于OCaml的问题 如何编译代码？我希望有一个.exe文件（我正在windows上工作） 如何使用？在一个文件夹中，我有两个文件： file1.ml和file2.ml 而file2.ml包含#use“file1.ml”，但编译器找不到file1.ml。我该怎么办 尝试ocamlc或ocamlopt #use是顶级指令。当依靠编译器创建可执行文件时，文件会被单独编译然后链接，就像大多数其他语言的编译器一样 如果您确实想学习OCaml，请参阅本书： 这本书是几周前出版的，目前是关于OCa

在Scala和Haskell等函数式编程语言中，有一种类型，通常用于表示成功的结果或失败/错误对象。当包含失败时，或者称为“左”，当包含成功结果时，或者称为“右” 为什么“不成功”是“左”而“成功”是“右”呢？为什么首先要使用这些说明？来自Haskell的文档： 左构造函数用于保存错误值，右构造函数用于保存正确值（助记符：“Right”也表示“correct”）。这只是一个猜测，但在Haskell中，在第二种类型上，都是一元的，即与右构造函数关联的类型。因此，通用一元代码将只更改右类型，因此保持

我试图从Elixir中的映射中过滤出一些值 这： 导致此错误的原因： **（FunctionClauseError）Enumerable.function.reduce/3中没有匹配的函数子句 但是过滤器和映射操作都是独立工作的 Enum.filter params, fn {k, v} -> k == v end Enum.map(params, fn {k, v} -> {k, v} end) 他们不工作时，管道 我确信我遗漏了一些明显的东西 编辑在Elixir的主分支上，如

是否可以在sml/nj中编写带有签名的函数： fn : 'a -> 'b fn: ( 'a -> 'b ) -> ( 'b -> 'a ) -> 'a -> 'b -> 'c fn : 'a -> 'b foo : ('a -> 'b) -> ('b -> 'a) -> 'a -> 'b -> 'c 我最初的目的是制作一个带有签名的函数： fn : 'a -> 'b fn: ( 'a ->

我一直在尝试在Agda中对Monad类型类进行编码。我已经走了这么远： module Monad where record Monad (M : Set → Set) : Set1 where field return : {A : Set} → A → M A _⟫=_ : {A B : Set} → M A → (A → M B) → M B 所以Monad“instance”实际上只是传递的函数的记录。问题：为什么Monad是排序Set1？用Set注释

我在《长生不老药》中看到了这段代码： defmodule Recursion do def print_multiple_times(msg, n) when n <= 1 do IO.puts msg end def print_multiple_times(msg, n) do IO.puts msg print_multiple_times(msg, n - 1) end end Recursion.print_multiple_times

如何在两个输入列表上使用“结束”，每次从两个列表中选择一个元素 例如，有： (+/)[1;2 3] = +[+[1;2];3] = 6 如何执行以下操作： f:{x+y+z}; (f/)[1;2 3;22 33] = f[f[1;2;22];3;33] = 61 谢谢。“结束”每次接受两个参数，因此三个参数不是选项： 要实现您提到的功能，必须扭曲功能和输入： f:{x+y[0]+y[1]} (f/)1,flip(2 3;22 33) “over”每次接受两个参数，因此三个参数不是选项：

我遇到了以下两个函数定义： function n_times(f, n) { if (n === 1) {return f;} else { return function(x) { return f((n_times(f, n - 1)) (x)); } } } function chain(f, n) { if(n === 1) { return f; } else {

tl；博士 在一个在每个帧上调用函数onEnterFrame的程序中，如何存储和改变状态？例如，如果您正在制作一个关卡编辑器或一个绘图程序，其中跟踪状态并进行小的增量更改是很诱人的。在全局状态变化最小的情况下，处理这种事情的最有效的方法是什么 长版本： 在接受用户输入的交互式程序中，如鼠标单击和按键，我们可能需要跟踪数据模型的状态。例如： 是否选择了某些元素？ 鼠标光标是否悬停在某个元素上，哪个元素？ 鼠标按钮按下多长时间？这是单击还是拖动？ 我们有时还需要对大型模型进行小的更改： 在标高编辑器

Immutable.js数据结构是函数吗 我的直觉是肯定的： Map({ a: 1, b: 2 }).map(x => 10 * x) // Map { a: 10, b: 20 } 我正在寻找关于Immutable.js结构是函子的程度的深入解释。它们是否同时遵循身份和构成法则？是所有的集合函子，还是仅仅是映射，列表，以及序列？任何支持映射方法的东西都应该真正遵守身份法则。集合只是暂时的函子：您必须假设所涉及的相等性测试足够严格。如果可以以任何方式区分“相等”的要素，那么构成法则就会失

我还在学习这个计划 如果您有这两个列表： '((1 2 (3 4) 5) (12 13 4)) '((3 4 9) (7 6 5 4)) 我想获得以下列表： '((1 2 (3 4) 5) (12 13 4) (3 4 9) (7 6 5 4)) '(((1 2 (3 4) 5) (12 13 4)) (3 4 9) (7 6 5 4)) 但是使用cons： (cons '((1 2 (3 4) 5) (12 13 4)) '((3 4 9) (7 6 5 4))) 我得到以下列表： '

我正在尝试从TMDB网站抓取电影数据。我用纯javascript完成了我的代码，但我想通过使用ramda.js将代码更改为函数式编程风格 我在下面附上了我的代码。我想去掉for循环（如果可能的话）并使用R.pipe函数 (async () => { for (let i = 0; i < 1000; i++) { (() => { setTimeout(async () => { let year = startYr + Math.

对不起，这个问题太天真了 我知道状态单子的本质是一个类型为S=>（S，a）的映射，其中S是状态的类型，a是计算结果的类型。那么状态单子的本质将被定义为（在Scala中） 就这些，没什么大不了的。为什么这么多的书也把flatMap放在状态单子的定义中？除了诸如“否则，与国家玩会变得容易出错”之类的论点之外，还有什么动机？就我所见，flatMap主要适用于列表或集合。所以，我真的很怀念这里的一些大画面。有人能澄清一下吗？多谢各位 我希望看到一个不需要了解单子的答案。事实上，在单子概念被实际引入之前，

纯函数的一个优点是，它们的输入完全决定了它们的输出，允许缓存结果以供以后使用。但是，如果没有以下两种情况，我看不出如何实现这一点： 存储缓存的可变全局状态（在真正的纯函数式语言中不可能） 在所有计算过程中线程化缓存（笨拙，即使使用monad） 具有运行时支持的某种注释（有点粗糙，但可能足够了） 一个非常聪明的运行时（可能是不可预测的，并且有其他开销） memoize在纯函数式语言中是如何实现的？目前为止我所见过的唯一一种使用的语言#1-全局状态。您可以依赖惰性求值，也就是说，您的纯函数返回一

这给了我一个错误返回：没有名为NIL的块当前可见。我试着把return语句四处移动，但我不确定它是什么意思 请以Lisp方式缩进代码，这可以在许多编辑器中自动完成，如Emacs： (defun take-n (lst i) (setf newlst '()) (dotimes (n i) (setf newlst (cons (car lst) newlst)) (print (cons (car lst) newlst)) (setf lst (cdr

我试图在SML中找到列表的中间元素，而不使用表单list.whatever的任何预实现函数。我可以使用一个函数，它获取两个相同的列表，递归地调用自己，从一个列表中删除一个项目，从另一个列表中删除两个项目，直到第二个列表为空。第一个列表的头将是原始列表的中间元素。我是SML新手，无法找到从列表中删除第一项或列表中删除前两项的方法。任何帮助都会很好。您可以使用来确定列表的形状并命名其组件： fun middle xs = let fun middle_rec (_ :: []) (x

所以这可能是一个愚蠢的问题，但在刚刚开始使用OCaml之后，我现在在utop中遇到了一个错误。我试图断言两个整数在结构上是不相等的 assert 2 <> 3;; Error: This expression has type int but an expression was expected of type bool because it is in the condition of an assertion assert 2 3；； 错误：此表达式的类型为int，但表达

在Idris中读取文件的首选惯用方式是什么？例如，我试图从一个映射到Int值的文件中读取数字，然后对所有内容求和。输入文件 5344612 import Data.String myCast: Maybe Integer -> Integer myCast Nothing = 0 myCast (Just val) = val sumNums: String -> Integer sumNums s = sum (map myCast (map parseInteger (wo

我正在阅读使用lisp方言的SICP。我的问题是，为什么需要下面定义的序列到表达式转换函数，它在条件定义中使用，但在if表达式中不使用 (define (sequence->exp seq) (cond ((null? seq) seq) ((last-exp? seq) (first-exp seq)) (else (make-begin seq)))) (define (make-begin seq) (cons 'begin seq)

标准ML是否有Java BigInt等价物？正常int类型在溢出时引发异常 是的，请参见结构。BigInt等价物称为LargeInt。有关如何在int（又称int）和LargeInt之间转换的一些函数，请参见 嗯，int对计算置换之类的东西提出了一个令人讨厌的限制。SML需要使用更自然的大型数字数据类型。官方SML'97标准引入了一系列结构，如Int、IntInf、Int32、Int64、LargeInt等 要在实践中实际使用它们以使事情按预期工作，并使它们高效工作，您需要仔细查看手头的SML实

我写了一个简单的脚本来解决一个“逻辑难题”，这是一种来自学校的难题，在那里你会得到一些规则，然后必须能够找到解决问题的方法，比如“音乐会上有五位音乐家，他们分别是A、B、C、D和E，每一位都一个接一个地演奏。。。如果A在B之前，D不是最后一个。。。谁何时上场的顺序是什么？“等等 为了评估可能的解决方案，我将每个“规则”作为一个单独的函数编写，例如，它将评估可能的解决方案（简单地表示为字符串列表）是否有效 #Fifth slot must be B or D def rule1(solution)

这似乎是一个好消息 溪流也是单子吗 有人能识别可选单子中的内函子和两个自然变换吗？编辑下面的答案是不正确的（保留在这里作为历史记录） 是的，在每种情况下，函子都由类及其map方法组成，两种自然转换是of和flatMap（identity） 正确的答案似乎是。如果你知道Haskell:Java的流不是别的，那么Haskell的列表monad[]和Java的可选项不是别的，Haskell的可能是monad。是的，Java.util.Stream.Stream满足monad定律 以下先决条件是： St

在Haskell中，您可以使用$操作符清理代码位，从而消除对参数的需要 elm是否支持此操作符或类似的操作 我可以自己定义，但我希望这是内在的 下面是它的工作原理： import Html import List exposing (map, foldr) datas = [("a", 1), ("b", 2), ("c", 3)] {--} ($) : (a -> b) -> (a -> b) ($) a b = a b infixr 0 $ --} main =

这是我的代码和警告。如果有人知道我如何摆脱这些警告，我将非常感激，因为我的代码给出了正确的输出。它们有两种方式： 实际上，您将变量用于和中的 您可以在 例如： CL-USER 30 > (defmacro foo (bar) `(list)) FOO CL-USER 31 > (compile 'foo) ;;;*** Warning in FOO: BAR is bound but not referenced FOO ((FOO #<COND

这就是我所拥有的： (define (10th-power 10 y) (if (= y 0) 1 (* 10 ((10th-power 10 (- y 1))))) 例如，如果我输入2，它应该给出1024。在这个简短的过程中有很多错误。以下是racket报告的错误： read:a'）应关闭（“，因为您缺少结尾的父项 define:不是标识符…在10中因为10不能是变量名，它不能在参数列表中 应用程序：不是一个过程。递归部分中的双括号使第十次方的结果尝试作为一个过程作为结果，而不是只使

有人能告诉我为什么这个代码#让func[g]a=ga:：[]；； 输出此警告 警告8：此模式匹配并非详尽无遗。 以下是一个不匹配值的示例： [] 参数[g]将匹配单个元素列表，并将该元素绑定到gfunc[f]a将起作用，但如果函数应用于空列表func[]a，或具有多个元素的列表func[f，g]a，该怎么办？除了引发异常，它还能做什么？这就是警告告诉您的。参数[g]将匹配单个元素列表，并将该元素绑定到gfunc[f]a将起作用，但如果函数应用于空列表func[]a，或具有多个元素的列表func

在文档中，提到了如何使用replace来完成证明，但它最终使用了rewrite，这似乎是为您编写replace的语法糖。我对理解如何明确地使用它感兴趣 如果我理解正确，它可以用来重写sk=S（加k0）为S（加k0）=S（加k0），给出k=+k0的证明，然后可以通过自反性证明。但是如果我们把它作为replace{P=\x=>sx=S（加k0）}{x=k}{y=plusk0}rec，我们现在需要一个sk=S（加k0）的证明，这就是我们想要证明的。简而言之，我不确定确切的P应该是什么。啊，回想起来，这

我正在尝试使用F类型提供程序在我的应用程序中包含天气数据。我正在使用OpenWeatherMap.org获取当前的天气数据 有时OpenWeatherMap响应不显示任何雨的JSON，例如1小时内没有雨 所以如果我做这样的事情： type WeatherForecast= JsonProvider<"http://api.openweathermap.org/data/2.5/weather?lat=39.64&lon=-74.28&appid=MyKeyICantShar

我有以下代码： fn main() { let xs = vec!["1i32".to_string(), "2".to_string(), "3".to_string()]; let ys = do_some(xs); println!("{:?}", ys); } fn do_some(tokens: Vec<String>) -> Result<Vec<String>, bool> { tokens

为什么Ocaml有可变数组？就我所理解的函数式编程而言，它是为了最小化副作用。可变（编辑：）数组是否与此想法相反 甚至字符串在Ocaml中都是可变的，这在python中甚至不存在，或者Ocaml不被认为是纯函数式语言吗？Ocaml不是纯函数式语言，对。它有一个纯功能子集，但支持变异和许多命令式构造（以及可变的OO对象）。IMHO的重点是允许程序员在为函数式编程提供优秀支持（以及一种鼓励）的同时进行必要的权衡 正如@AnuragSoni所指出的，列表和数组在OCaml中是不同的。数组是可变的，但列