有人能解释一下这个解决方案是如何工作的吗

Question

我通过反复试验解决了以下问题，但仍然没有正确理解我是如何做到的。

有一个函数缺点：const cons = (x, y) => f => f(x, y);

将值存储到变量对：const pair = cons(5, 3);

创建两个函数 car 和 cdr ，它们每个都会返回一个参数。

car(pair); // 5

cdr(pair); // 3

我的解决方案：

const car = pair => pair((x, y) => x);

const cdr = pair =>pair((x,y) => y);

const cons = (x, y) => f => f(x, y);

const pair = cons(5, 3);

const car = pair => pair((x, y) => x);

const cdr = pair => pair((x,y) => y);

const carTest = car(pair);
const cdrTest = cdr(pair);

console.dir(carTest);
console.dir(cdrTest);

Answer 1

这里cons(x, y)构造了一个pair，而car(pair)和cdr(pair)返回first和last元素pair。

而pair 也是一个function，它将函数作为输入并将输入函数的输出返回为x 和y。

---

为了更好地解释您的解决方案：

const car = pair => pair((x, y) => x);

将箭头函数重写为常规函数：

function car(pair){

   var result= pair(
   function temp(x, y){
     return x;
    }
   );
   return result;
}

这里

1. Car函数将pair作为argument。

const car = pair =>........;

2. pair 是一个 function，它接受另一个函数作为输入，其中 2 arguments 有 5 ,3 作为 value。

......=> 对（......）;

3.这2个values作为argument传递并在x, y中赋值，x作为结果返回。

.................((x, y) => x);

---

const cons = (x, y) => f => f(x, y);

const pair = cons(5, 3);

//const car = pair => pair((x, y) => x);
const cdr = pair => pair((x,y) => y);

function car(pair){
   
   var result= pair(
   function temp(x, y){
     return x;
    }
   );
   return result;
}
const carCall = car(pair);
const cdrCall = cdr(pair);

console.log(carCall);
console.log(cdrCall);

Answer 2

很难回答你是如何“做到的”，因为你似乎对答案有些迷茫。

当你还不知道答案时，通过发明一个从未如此线性的思维过程来作弊，一种方法是首先仔细观察cons 做了什么：

const cons = (x, y) => (f => f(x, y))

它需要两个东西，(x, y)，然后返回一个函数。
此函数接受另一个函数f，并将该函数应用到(x, y) 的结果返回给cons。

对于car，我们要提取这样一对的第一个元素。

要选择(x, y)的第一个元素，我们可以将它传递给函数

const first = (x, y) => x 

由于 pair 是一个接受一个函数并将该函数应用于其元素的东西，因此将 first 传递给 pair 应该选择它的第一个元素：

(cons(3,5))(first)

是 3。

但是现在语法“倒退”了，所以我们使用另一个函数来扭转它：

const car = p => p(first)

代入first的定义：

const car = p => p((x,y) => x)  

同样的过程导致cdr。

---

要确切了解正在发生的事情，您有

const pair = cons(5, 3);

代入cons的定义：

const pair = f => f(5, 3);

将car 应用到f => f(5,3) 并继续替换：

(pair => pair((x, y) => x)) (f => f(5,3))

-->

(f => f(5,3)) ((x, y) => x))

--> 

((x, y) => x)) (5,3)

--> 5

Answer 3

查看类型：

// cons :: (a, b) -> ((a, b) -> r) -> r
const cons = (x, y) => f => f(x, y);

// pair :: ((Number, Number) -> r) -> r
const pair = cons(5, 3);

// fst :: (a, b) -> a
const fst = (x, y) => x;

// snd :: (a, b) -> b
const snd = (x, y) => y;

// car :: (forall r. ((a, b) -> r) -> r) -> a
const car = pair => pair(fst);

// cdr :: (forall r. ((a, b) -> r) -> r) -> b
const cdr = pair => pair(snd);

如您所见，cons 采用两个值 x :: a 和 y :: b 并创建一对。对是一个函数，它将 另一个 函数作为输入，并通过将 输入函数 应用到 x 和 y 来返回 输入函数 的输出。这使我们可以做一些事情，比如添加对的值（即cons(5, 3)((x, y) => x + y)，其计算结果为8）。

现在，如果我们将该对应用于函数fst 和snd，那么我们将分别得到该对的第一个值和第二个值。因此，car 和 cdr 只需将输入对分别应用于函数 fst 和 snd。希望对您有所帮助。

Answer 4

const cons = (x, y) => f => f(x, y);
const pair = cons(5, 3);
// pair = f => f(5, 3)
const car = pair => pair((x, y) => x);
// replace f as (x, y) => x
// then ((x, y) => x)(5, 3)