小编bob*_*bob的帖子

这是主要的意见是内置的Javascript原型不应该被延长(或以任何方式改变):

Array.prototype.empty = function () { return this.length === 0; } // don't try that

此规则是否也适用于ES2015符号？

const empty = Symbol("empty");
Array.prototype[empty] = function empty() { return this.length === 0; }

由于symbol是string(原始的,不可变的)和object(标识)的混合,因此根据定义可以没有对象属性命名冲突.

正常对象反射不受符号影响:

Object.getOwnPropertyNames(Array.prototype).indexOf("empty"); // -1

但是ES2015的反思Reflect.ownKeys(Array.prototype)是.

所以这个问题主要是关于我们将来如何使用Reflect.ownKeys和Object.getOwnPropertySymbols未来的问题.

我正在使用lodash _.some函数检查数组中的值.但它的情况敏感.在lodash中是否有任何不区分大小写的搜索功能.下面是我的示例数组结构

    [
      {
        "Name": "Division 1",
        "ParentName": null
      },
      {
        "Name": "Division 2",
        "ParentName": null
      }
    ]

使用lodash我正在检查这样

    _.some(divisionList, ['Name', divisionname]);

请注意，即使此问题中的示例是用Javascript编码的，其基本概念在Haskell中也是常见的，而我虽然更喜欢用Javascript表达自己，但我也很欣赏Haskell中的答案。

在Javascript中，我根据单子原理使用CPS处理异步计算。但是，为了简单起见，我将对这个问题使用正常的延续单子。

一旦我的连续作文增长，我就会发现自己处于需要获得这些作文中间结果的情况。由于必须使用Javascript，因此很容易将此类结果存储在变量中，并在以后访问它们。但是由于我们在谈论连续性，因此访问中间结果意味着调用函数并多次访问它们意味着大量的重新评估。

这似乎非常适合记忆。但是，如果那个函数不返回任何东西而只调用其延续（以及顺便说一句），我该如何记住一个函数的返回值（正如我之前提到的那样，我使用异步函数也不会在Javascript事件循环的当前周期中返回任何东西） ）。

似乎我必须提取正确的延续。也许可以通过shift/ 分隔定界符来实现reset，但是我不知道如何应用这些组合器。这个问题可能并没有那么难解决，我只是对持续传递风格的魔幻之地感到困惑……所以请纵容我。

这是ContJava语言中没有备忘的简化示例：

const taggedLog = tag => s =>
  (console.log(tag, s), s);

const id = x => x;

const Cont = k => ({
  runCont: k,
  [Symbol.toStringTag]: "Cont"
});

const contAp = tf => tx =>
  Cont(k => tf.runCont(f => tx.runCont(x => k(f(x)))));

const contLiftA2 = f => tx => ty =>
  contAp(contMap(f) (tx)) (ty);

const contOf = x => Cont(k => k(x));

const contMap = f => …

这是我的Task实现方式（即一种Promise但符合monad法律且可取消的方式）。它工作坚如磐石：

const Task = k =>
  ({runTask: (res, rej) => k(res, rej)});

const tAp = tf => tk =>
  Task((res, rej) => tf.runTask(f => tk.runTask(x => res(f(x)), rej), rej));

const tOf = x => Task((res, rej) => res(x));

const tMap = f => tk =>
  Task((res, rej) => tk.runTask(x => res(f(x)), rej));

const tChain = fm => mx =>
  Task((res, rej) => mx.runTask(x => fm(x).runTask(res, rej), rej));

const log = x => console.log(x);
const elog = …

这是一个核心递归算法，因为在每次迭代中，它调用自己的数据大于之前的数据：

iterate f x =  x : iterate f (f x)

它类似于尾递归累加器风格，但它的累加器是隐式的，而不是作为参数传递。如果不是因为懒惰，那将是无限的。那么 codata 只是 WHNF 中值构造函数的结果，有点像(a, thunk)？或者 codata 是范畴论中的一个数学术语，它在编程领域没有有用的表示？

后续问题：值递归只是核心递归的同义词吗？

Scott 编码列表可以定义如下：

newtype List a =
    List {
      uncons :: forall r. r -> (a -> List a -> r) -> r
    }

与 ADT 版本相反的List是类型和数据构造函数。Scott 编码通过模式匹配来确定 ADT，这实质上意味着删除一层构造函数。这是uncons没有隐式参数的完整操作：

uncons :: r -> (a -> List a -> r) -> List a -> r
--    Nil ^    ^^^^^^^^^^^^^^^^^^ Cons
uncons nil cons (List f) = f nil cons

这是完全有道理的。uncons接受一个常数、一个延续和 aList并产生任何值。

然而，数据构造函数的类型对我来说没有多大意义：

List :: (forall r. r -> (a -> List a -> r) …