（看了那个博文那个章节后突然发现说得好啊，而且可见王淫还是蛮有水平的（废话）

其实我刚才说的弄不懂是我在吃饭的时候考虑了一下拿 foldl 定义的 reverse 函数

Haskell（Scheme 的太长不复制了）

foldl :: (a -> r -> r) -> r -> ([a] -> r)

foldl f v [] = v
foldl f v (x : xs) = foldl f (f x v) xs

reverse = foldl (\x xs -> x : xs) []

能用（F**king 的 GHCi 里莫名其妙报 Branch exhaustivness 错误弄得我一直很麻烦）。（如果是 Prelude 里的 foldl 的话 reverse foldl 的第一个 lambda expression 参数的两个参数 x xs 调成 xs x 就可以了）

这里用 foldl 而不是 foldr 来定义是为了方便大家了解 fold operator
而且，FoldLeft 可以尾递归优化成循环的形式（can be easily modified to run in constant space），FoldRight 出于它本身的算法就必须用到非常量复杂度的栈空间（就是下面说的直觉式，好像 John Backus 最开始 20 世纪的那篇 FP 创立论文 Can Programming Be Liberated from the von Neumann Style? 说的『inseration』插入操作符）

foldr (+) 0 [1,2,3]
= (+) 1 ((+) 2 ((+) 3 0))
= 1 + 2 + 3 + 0
= 6

但我惊恐的发现我 居！ 然！
不知道它是如何工作的...

最后给可能一样的大家，顺便给自己：（反正你们不看，傲娇。

reverse 1 : 2 : 3 : []

foldl f v [] = v
foldl f v (x : xs) = foldl f (f x v) xs

= foldl (\x xs -> x : xs) [] [1,2,3]
— 这里就简化 (\x xs -> x : xs) 为 f 了
= foldl f (f 1 []) [2,3]
= foldl f (f 2 [1]) [3] — (1)
= foldl f (f 3 [2,1]) [] — (2)
= foldl f [3,2,1] []
= [3,2,1]


哦我总算知道了... 先被模式匹配出来的先压入 (:) LIFO []（本质上不是压入，而是 cons 出链表，不过我觉得这里反正都一样），和之前的汉诺塔问题一样...

foldl (\x xs -> x : xs) [] [1,2,3]

上面的程序结果其实就是 3 : (2 : (1 : []))
(1 : []) 就是式子 (1) 的结果
(2 : (1 : [])) 就是式子 (2) 的结果

所以其实蛮 effective(#fix efficient) 的（比起 foldRight 定义的那个 ++ [x] 没效率来说

(++ ys) = foldr (:) ys

#SQL #recommended #blog https://blog.lilydjwg.me/2015/1/25/nine-pitfalls-of-mysql.77680.html

#life 打印机墨盒到货了，可以继续打印文章看喽（ 😆

#Backend 这个人绝对是有很老资历的软件工程师了，非常擅长后端这一方面的事情，现在 #Rust 社区里活动的人也应该能够看到他的身影

#JetBrains #dev #Android #IDEA #Kotlin #Java

https://mobile.twitter.com/JBToolbox/status/1085853883451219968
以后可以用 JetBrains Toolbox 安装 Android Studio 啦！！！

#Android #China #Low

#recommended #Ruby #Elec https://blog.lilydjwg.me/2012/3/24/flip-flop-in-ruby-jk-latch.32635.html

（接上文）原博文

又是一个『大家可能不知道的』Ruby 语法？
（电子电路分析之类的可能比较复杂，工作集合很大，我不喜欢分析这些
（就像我不喜欢做数学运算一样，我还是喜欢弄一些耦合度（密集度）比较低的问题，方便分析一些
（否则我就会很难受，比如这个

一个 flip-flop 由两个通过..操作符相连的布尔表达式构成。
除非其左侧表达式为 true，否则一个 flip-flop 表达式就是 false，而且在左侧表达式为 true 之前，它的值都会是 false。
一旦该表达式为 true ，那么它就会“flips”到一个持久的 true 状态。

它会保持该状态，而且对其后续的求值也返回 true，直到其右侧表达式成为 true 为止。
如果其右侧表达式为 true 了，那么该 flip-flop 就会“flops”回一个持久的 false 状态，对其后续的求值也返回 false，直到其左侧表达式再次成为 true 为止

 作者还说"很难正式地描述一个 flip-flop 的精确行为"。但我不这么认为。

== 由此我们可以发现，其实即使是 #Ruby 之父松本，也不是『完人』，创造了 Ruby 的人有不知道自己做了什么的时候（flip-flop 特性是从 Perl 语言里继承的，而后者又是从 AWK、SED 这样面向文本处理的语言里复刻的）。（暴论

（其实 RednaxelaFX 也曾经在 Ruby 的啥 Conf 上向 Matz 提出过他不能回答的问题，不过其实说这个事的人也不是特别爱好技术所以他没有告诉大家具体是什么问题

我想到了学习数字电路时遇到的各种触发器，于是乎，反复读了几次以上描述确定了 flip-flop 的行为到底如何后，列出了它的真值表，其中 A、B 为点两边的表达式的值（输入），Q 为其内部状态，Qn 就是 Qnext。

flip-flop（在电子电路中就是「触发器」的意思） 就是 JK 触发器：

J K Q Qn
0 0 0 0
0 0 1 1
0 1 X 0
1 0 X 1
1 1 0 1
1 1 1 0

后来我又稍微看了一下他的博客，我真的觉得... #blog #recommended #statement #dev #FP

好像，不管你是不是了解计算机科学，都能『看懂』他的博文（
区别在于你是只看懂了故事，甚至会自以为是的找一些非常 trivial 的仅仅表述上的问题（那是曾经的我，我根本看不到他身后到底有怎样的积淀，真的是非常幼稚（而且那时候完全不了解 Rust 的我居然想讨论 Rust，真还不照镜子看看自己啥 B 样了（打住，阿 Q 告警。
还是真正看懂了他要说的东西
对于故事，你是否联想到了相应的东西？
对于他讲的技术，你是否真的 get 到了所有知识点？
还是自以为『都看懂了』但一问三不知？？？

可是，一年之隔，我再看他的博客的时候我发现我真的不止是在看带有一大堆技术名词、人名、时间的故事了...

我真的能看进去，原来我直接 skip 掉的一些知识点我都 get 了（其实只是识别出来有『它』但因为时间关系而没有深入探究），而不是自以为都看进去了（就像 MySQL 到 9012 年了能解析 CREATE TABLE 的 CHECK 子句存储引擎居然还不会执行实际的数据约束检查一样 hhhh 🌚），然后学到了什么呢？其实一大堆东西『使用』的时候才能发现，根本没有学到嘛。（最骚的是，很多理论上的东西只在你 nontrivial 的分析一些 nontrivial 的问题时才会用到）

（这是最骚的，因为你完全可以认为自己好像『完全看懂』了他的博客，但其实你『完全』没看懂，而且你『完全』可能『完全』不知道自己『完全没看懂』...） 🤪

他这个博客可以说是真正意义上是值得为之付费的，因为的确是讲了很多东西，而且是中文的，而且相当简洁
我觉得这样的博客『付费』可以说是很嘲讽某些『知识付费』IT 课堂了。
因为这个博客，它需要你自己也花很多时间和精力去理解它，而不是非常功利的去按别人的安排学习

而很多东西（比如这个）虽然也可以说是为了实际工程写的，但我估计，没有啥『工程师』看得懂吧（笑）🤔
（实际上是根本懒得看，或者只是理解了一个字面上的『编码，这里就不吐槽易混问题了』『规则』而看不到规则后面的那些本质）

好吧，我得承认我后来再看这个广播的时候觉得自己有点幼稚。

呃... 其实我知道我 #CS （或者也可以叫计算机工程，不过数学性比较强的，这里请正确理解这个『数学性』一般我还是叫计算机科学）水平其实不怎么样（真的不怎么样）

看了以后，我的确是想说这个博客内容很不错，不过我发现我推荐着推荐着就有点感觉自己很 Low 了，大概是因为例子不充足吧。显得自己好像很自以为是一样。

而且我又没有他那样的资历，话说得如此直白会显得很不自在，但点名推荐是真的（当然，我频道的内容都懒得看那就算喽，开玩笑

所以这里特别再弱弱说一句～请多指教
（当然，不得不说目前 Telegram 中文圈里我接触到的理论系都太少了，所以基本没谁会在这方面『指教』我... 有点可惜，而我平时又不到 CodeWars、知乎和一些 CS 的 QQ 群、圈子里去

现在我又不得不说，他的博客，看一年，还真的看不完啊... 😶 真的是时间可以改变一切

的确，一篇博文里引用的书、论文都够我看几个星期了... 而且还得一遍一遍的看，看几遍才能彻底 get 到大部分的知识点...

... 视角改变一切。

还总是看淫王的博客，技术水平高的人可不止他一个，他博客看了一年还看不完？

再看看这个，和我之前所认为的 Haskell，不是 #Haskell 变好看了，是我对问题的思考方式真的贴近了 Haskell...
曾经我所以为的不符合直觉，只不过是因为我的『直觉』和 Haskell 的创造者的『直觉』不一样罢了...

我根本不懂递归，不知道 GADT 是什么，没用过模式匹配，我看不见栈、看不见实际上的运行环境，我『看不到』一张数据结构图而只能看到一堆符号，也没实际去分析什么并非过程式的程序，拿倒垃圾的简单算法的思维方式去考虑使用递归定义的程序，当然觉得它莫名其妙！

以前我用 Java 程序员的思维方式看那些其实我根本没看懂的 Haskell 代码、APL 代码，我觉得他们很难看，觉得这种『自以为是』的简洁是『最智障』的方式

其实不是 Haskell 的简洁不对，只不过是因为我没有以他们的方式去思考问题，听不见音乐的人认为那些跳舞的人都疯了！😐

现在我用 Haskell 程序员的思维方式写 Haskell 代码，我发现 Haskell 的表述方式就成为了我的直觉...
其实是因为我在以 Haskell 的方式而不是 Java 的方式思考问题啊... 🤔

直觉真的不是一个『一成不变』的东西啊，值得好好培养 emmmm（

如果觉得这个例子不好的话，刚才看这篇博文（教你们拿 Racket，一个 Scheme 实现写基于 Lambda Calculus 的解释器的）的时候突然发现这个例子非常不错（实际上，很多 #Haskell 入门教程都会拿这个做例子）

(define tree-sum
  (lambda (exp)
    (match exp                         ; 对输入exp进行模式匹配
      [(? number? x) x]                ; exp是一个数x吗？如果是，那么返回这个数x
      [`(,e1 ,e2)                      ; exp是一个含有两棵子树的中间节点吗？
       (let ([v1 (tree-sum e1)]        ; 递归调用tree-sum自己，对左子树e1求值
             [v2 (tree-sum e2)])       ; 递归调用tree-sum自己，对右子树e2求值
         (+ v1 v2))])))                ; 返回左右子树结果v1和v2的和

(tree-sum '(1 2))
;; => 3
(tree-sum '(1 (2 3)))
;; => 6
(tree-sum '((1 2) 3))
;; => 6

如果用 Haskell 写几乎一样的程序呢？

首先我们的 Haskell 的确是静态强类型（statically strong typed, type inference supported）的语言，所以类似 Scheme 那样直接拿链表抽象一切就免了（

data BinaryTree a = Leaf a | PrimNode a a | CompNode (BinaryTree a) (BinaryTree a)
t1 = PrimNode 1 2
t2 = CompNode (Leaf 1) (PrimNode 2 3)
t3 = CompNode (PrimNode 1 2) (Leaf 3)
t4 = CompNode (PrimNode 1 2) (PrimNode 3 4)

treeSum :: BinaryTree Int -> Int
treeSum (Leaf n) = n
treeSum (PrimNode a b) = a + b
treeSum (CompNode l r) = treeSum l + treeSum r

main 
  = (foldl f v) $ (println . treeSum) <$> [t1, t2, t3, t4]
    where      
      println x = print x               
      f = (>>)
      v = putStr ""

（为了方便起见，大家可以看到 Haskell 的版本里那个 data 其实不是『等价』Racket 里我们所预期的表结构的）

当然，如果我们写『完全等价』的呢？

t1 = [1, 2]
t2 = [1, [2, 3]]
t3 = [[1, 2], 3]
t4 = [[1, 2], [3, 4]]

treeSum' :: [Int] -> Int
然后就写不出等价的来...

<del>
treeSum' :: [Int] -> Int
treeSum' xs
| length xs == 1 = head xs
| (x : xs) = x + treeSum' xs
| otherwise = treeSum' (head xs) + treeSum' (head (tail xs))

因为这个逻辑实在有点复杂，貌似简单一点的 Haskell Cons 模式匹配弄不了，只好使用 Guard Pattern（
</del>

『好的程序应该反映出它所处理的数据结构』
这话不是我说的，看完上面的小学生水平 Haskell/Racket 代码后，大家应该理解了这句话吧。

如果有喜欢 #Scheme 的同学，必须记得看完 The Little Schemer（轮子哥管它叫『儿童书』）先再出去『吓人』（悄悄告诉你们... 我就是还没看完所以连 #FP 的 QQ 群都不敢进... hhhh 🤔

写累死了，而且思路不清晰，算了，然后书单又没有发...（跑，不过话说了

开始写实际应用喽

#PL 题外话，这篇博文还会讲到 Lexical Scoping 和 Dynamic Scoping 的区别，其实 PL 爱好者们偶尔也会讨论这些问题，不过有时候入门的话纠缠不清... 这里讲得可以说是很友好了