标签: functional-programming

我有以下问题.

证明对于某些类型的所有有限列表xs和该类型的谓词p和q:

filter p (filter q xs) = filter q ( filter p xs)

我需要一些示例xs列表来解决这个问题吗？或者如何解决这个问题呢？谢谢.

Play框架是否默认包含任何镜头支持？像Monocole或Scalaz 那样的东西.也许我不知道有推荐的替代方法(及其基本原理).

场景:我有一个案例类的不可变的,深度嵌套的对象,我想用一个在对象中某处更改的字段来复制它.

我正在寻找这样做非常简单而不需要太多样板,就像像Monocole那样的镜头库.

我很惊讶Play框架内置了任何支持.我错过了什么吗？如果没有,是否有任何已知的支持计划？

我是OCaml的新手,我现在正在尝试实现一个函数,该函数返回一个列表,其中包含输入列表中偶数位置的所有元素.对于[1; 2; 3; 5],返回[2; 5]和[1 3]返回[3]; 并且对于["i";"am";"new";"to";"ocaml"]返回["am";"to"].希望有人能给我一些解决这个问题的建议.

当我从类型的地图中获取元素时Map[Int,Int],我得到了Some(24),我不能使用+,-,*,/它的操作,因为它不是Int.你能告诉我如何Int从该地图中获取类型值而不是Some(24)？

我目前正在研究一些涉及多项式的代码(不是我的),以便更好地理解功能样式LISP编程.

(define collect-terms(a)
  (sort a #'compare))

(defun compare(a b)
  (llt (car (cdr a)) (car (cdr b))))

我不明白当函数定义为2时,compare方法在collect-terms中调用时,compare方法如何才能只使用一个参数.

在这种情况下,compare成功获取传递的列表的子列表,并将它们用作a和b的值.

如何实现一个将sum_numbers(2)(3)(4)......(n) 在python 中以下列方式调用的函数？

结果应该是 2+3+4+.....+n

我的提示是因为函数是pythons中的对象,有可能使用嵌套函数来做那些但我不确定.

def sum_number(x):
    def sum_number_2(y):
        def sum_number_3(z):
        ....................
            def sum_number_n(n)
                return n
            return sum_number_n
        return sum_number_3
    return sum_number_2
  return sum_number

但是,不是编写这么多嵌套函数,我们应该能够在几个嵌套函数中执行它,以便在以下列方式调用时计算n个值的总和 sum_numbers(2)(3)(4)......(n)

我面临的问题是，给定一个列表和一个保护条件，我必须验证列表中的每个元素是否都通过保护条件。

如果其中一个元素未通过防护检查，则该函数应返回false。如果它们全部通过了防护检查，那么该函数应该返回true。这个问题的限制是我只能使用单个 return 语句。

我的代码：

def todos_lista(lista, guarda):
  for x in lista:
    return(False if guarda(x)==False else True)

如何在等待状态下运行 Array.map？

const CLASS_PATH = 'User/matt/Github/project';
const PACKAGE_JSON = 'package.json';

const walk = async path => {
  let dirs = [];
  for (const file of await readdir(path)) {
    if ((await stat(join(path, file))).isDirectory()) {
      dirs = [
        ...dirs,
        file,
      ];
    }
  }
  return dirs;
};


async function main() {
  const packagePaths = await walk(CLASS_PATH)
        .map(pkgName => join(CLASS_PATH, pkgName, PACKAGE_JSON));

}
main();

我刚刚偶然发现了一些 OCaml 代码，它编写了如下循环：

    let r = ref (f 0) in
    for i = 1 to k - 1 do
      r := f i * !r
    done ;
    !r
  in

这很有趣，因为我通常看到这通常使用 OCaml 中的递归函数来完成。一个相对于另一个有优势吗？

基本上，我有一个列表["apple", "banana"]，我想附加"|4"到列表中的每个参数，以便我最终得到["apple|4", "banana|4"].

我可以这样做map (Text.append "|4") ["apple", "banana"]，但是附加的顺序错误，即结果是["|4apple", "|4banana"]。

有没有好的方法告诉你Text.append朝这张地图上的另一个方向走？