鄙视链总感觉是在浪费时间。。我个人认为语言没那么重要，能完成想要的工作就行了

说真的感觉这个更友善。。

from itertools import islice
def zipWithNext(xs): return zip(xs, islice(xs, 1, None))

list(zipWithNext([1,2,3]))
==[(1, 2), (2, 3)]

#Python
关于 fibonacci 数列， #Haskell 里容易定义：
fibs = 1:1:(zipWith (+) fibs (drop 1 fibs))
这是基于 Haskell 的可复现(无副作用/纯)序列+惰性求值实现的，而 Python 里若用等价的 fibs = chain([1,1], map(operator.add, zip(fibs, islice(1,None)))) 不能成功——表达式组织出generator对象的关键在于 map(add, zip(xs, xs[1:])) 里 zip 的流视口，它肯定要引用靠 zip() 本身生成的数字。

再看 Haskell 的定义等式，其生成式缓存是全局的（当然实现法有很多种但），可以理解为 fibs, (drop 1 fibs) 持 length -2、-1 的索引（此时就没有“预支”流导致循环引用的问题）
fibs = [1,1]
def _fibs_gen(i,n):
fibz = islice(fibs,i,None)
fibz1 = islice(fibz,1,None)
fibs[i:i+n] = map(operator.add, zip(fibz,fibz1))
def gen(buf, op, n_chunk=5):
i0 = 0
while True:
op(i0, n_chunk)
i0 += n_chunk
yield* buf[i:i+n]

如果想写在一行内也可以，但需要 iself() 提供一个隐式上下文的流位置（才能引用自身 不然只能从流头开始），既然这样也就不得不使用 gen() 生成带视口的流了。
举个用例，当然索引的可变 boxed ref 弄 it=[i] 就行，关键在于让惰性流(其参数 lambda 的参数1)知道自己在对应 iself() 的什么位置就行。
fibs = iself(lambda fibs: chain([1,1], map(add, zip(fibs, drop(1,fibs)) )) )

Haskell GHC 可能没有这样简单，或许它是对 (drop 1 fibs) 进行了仅 1层 的惰性求值？这样性能很差，但写起来更有意思
（不对…… 理解错了， (drop1 fibs) 实际上不需要对「未求值的项」进行计算，它从一开始的 (1:1:) 就已经落后于序列尾2项了）
（所以说有些看起来了不得的东西原来只是太晦涩、不直接了吗……到底还是要缓存）

一般来说
fib 1 = 1
fib 2 = 1 -- (f 3) = (f 2)+(f 1)
fib n = (fib n-1)+(fib n-2) #Haskell #code

这是递推法，理论上无缓存性能很渣（当然真的函数式里 memo,cps 属于基础），而上面实现的 py 版则是动态规划（迫真）

「没想到我这么没文化」 #Python #algorithm #listproc https://pastebin.ubuntu.com/p/SCcqTHhTTV/

#Haha #meme #dev #cplusplus [x,] 后删,吗，可 empty/single 情况都需要特殊处理啊，一般都是判[0] 与余下部分循环前置,的

https://twitter.com/johnregehr/status/1347231926780715008?s=20
“我在考虑要不要给我这个避免结尾逗号的宏申请个专利。”

#Web #ocr #dev #php #meme