标签: cons

有什么区别

(cons 2  3)

和

'(2 . 3)

在Lisp？

我想要

class MyClass(object):
    _my_unique = ????      # if this were lisp, I would have written (cons nil nil) here

    def myFunc (self, arg):
        assert arg != _my_unique    # this must never fail
        ...

用什么代替???来确保assert永不失败？

（和Lisp，我可以创建_my_unique与(cons nil nil)和使用eq的assert）。

附注。用例：我将放入_my_uniquea dict，所以我希望它等于自身，但我不希望它等于（在dict碰撞意义上）从外部传入的任何东西。

Ruby对名为的枚举有一个方便的功能each_cons。其中“为每个连续元素数组迭代给定的块”。真的很好 除了这绝对是一个each方法，该方法在完成时返回nil，而不是像您那样循环遍历的值的数组map。

但是，如果遇到需要遍历可枚举类型的情况，请获取一个元素及其缺点，然后对它们执行一些操作，然后将它们返回到数组中，该怎么办？通常，我会将map用于这种行为。但是map_cons不存在。

一个例子：

给定一个整数列表，我需要查看那些整数中的哪些重复并返回仅包含这些整数的列表

[1, 1, 4, 5, 6, 2, 2] ## I need some function that will get me [1, 2]

我可以说：

[1, 1, 4, 5, 6, 2, 2].each_cons(2) {|e| e[0] if e[0] == e[1]}

但是，由于它each在数组上，因此它将成功完成并nil在最后返回。我需要它表现得像map和不像each。

这是ruby支持的行为吗？我是完全从错误的方向出发吗？

我们可以在 F# 中编写3 + 4或(+) 3 4并获得相同的结果，这适用于大多数运算符。

为什么 cons 运算符的::行为不同？例如，如果我跑

(::) 1 [2;3]

我得到

error FS0010: Unexpected symbol '::' in expression

而我想得到 [1;2;3]。

在相关说明中，为什么List.Cons不咖喱？没有类型的内置 cons 函数'T -> 'T list -> 'T list吗？

简单代码：

> (cons null (cons 1 2))
'(() 1 . 2)
> (cons (cons 1 2)  null)
'((1 . 2))

最初，我希望结果是一样的。我能想到一些含糊的解释，但也想听听知识渊博的人的强项。

为什么结果不一样？

有什么区别:

(cons 'a (cons 'b 'c)) ;; (A B . C)

和

(cons 'a '(b.c)) ;; (A B.C)

我需要使用cons创建以下列表((ab).c),所以我试图理解那个"." 代表.

LE:我有以下(cons (cons 'a 'b) 'c)但它产生((A . B) . C)而不是((A.B).C)(注意额外的空格)

> (cons 2 3) 
(2 . 3)

Lisp环境只需要分配一个cons单元来连接这两个项目.

以上是来自Lisp的书"Land of Lisp".我不明白为什么这对只位于一个cons单元格中.这些数据的内存是什么样的？

理想情况下,在LISP中:

caddr[(A B C)] = car[cdr[cdr[(A B C)]]] = car[cdr[(B C)]] = car[C] = Undefined.

但该书说答案是C.有人可以解释一下吗？

非常感谢.

我们知道1:2:[]会回来[1,2].

我刚试过1:2,这给了我一个错误.

<interactive>:48:1: error:
    ? Non type-variable argument in the constraint: Num [a]
      (Use FlexibleContexts to permit this)
    ? When checking the inferred type
        it :: forall a. (Num a, Num [a]) => [a]

我知道这可能不是一个恰当的例子,因为:操作包含元素和列表.但我只是想知道它是如何运作的1:2:[]

有没有办法在Haskell中从左到右构建列表而不使用++？

cons是一个恒定的时间操作,我想保持代码有效.我觉得有一种普遍的方式来利用Haskell的懒惰来做这样的事情,但我想不到它.

现在我正在编写一个创建Collat​​z序列的函数,但它正在以错误的方向构建列表:

module CollatzSequence where

collatz :: (Integral a) => a -> [a] -> [a];
collatz n l
  | n <= 0    = error "Enter a starting number > 0"
collatz n []  = collatz n [n]
collatz n l@(x:_)
  | x == 1    = l
  | even x    = collatz n ((div x 2):l)
  | otherwise = collatz n ((x*3 + 1):l)

在GHCi中:

*CollatzSequence> collatz 13 []
[1,2,4,8,16,5,10,20,40,13]