+ Java8 with Android 简单入门

我很想写一本关于这个的书... 后来 toc（Table of contents，目录）写着写着就变成杂学书了... 一会还扯到 CPU 应用层面的玩意... 还扯到了解释器什么求值顺序什么的

+ CABuild

我也忘记原义了，大概就是些构建（依赖型）系统啥的项目

+ RegularPP LALR

... 算了，LALR 那种大佬级别的解析算法我写不起啊，跟写红黑树一样的...

+ Kookle lang

这玩意是我打算写编译到 C 的语言... 当 C 的扩展吧，其实同样的东西大概有许多名字（maybe）

+ Haskell 模式匹配

我之前才知道... Haskell 的 function 貌似都是模式匹配定义出来的，也就是说其实我说的不在所有情况下全是对的（废话）（而且我说的错误往往比较多）

比如说

factorial :: Int -> Int
factorial 0 = 1
factorial n = (factorial n - 1) * n

fac :: (Integral a) => a -> a
fac 0 = 1
fac n = n * fac (n - 1)

这个例子不好，而且你们最好不要在 REPL 上试... 可能会死机（Haskell 蜜汁 BigDecimal 实现？）
（而且堆栈的深度又不是无限的... 但在栈爆之前溢出的 Disk IO 就要把泥的 PC 撑炸）

lenList :: [x] -> Integer
lenList [] = 0
lenList (_:xs) = 1 + lenList xs

sumList :: Num n => [x] -> n
sumList [] = 0
sumList (x:xs) = x + (sumList xs)

main = print  $ sumList [1..10]

我们举个栗子（使用 : 来表示列表「Cons」是另一种表示方式）

sumList [1, 2, 3]

sumList 1 : (2 : 3) = 1 + sumList (2 : 3)
sumList 2 : (3)     = 2 + sumList (3 : [])
sumList 3 : ([])    = 

3 + sumList []


sumList [] = 0

1 + (2 + (3 + 0)) = 6

这就是所谓的模式匹配，Rust 里也有

+ naive bfs

呃，之前怀疑自己写的那个 naive bfs GC 是不是写错为 naive DFS GC 了，要真是那样我老脸可就真 naive 了 🐸

个人感觉深度优先搜索记录搜索路径并且要求深查找到顶端枝叶，广度的不需要记录路径

+ 线程同步与枪战游戏

教程灵感...

就是说现在的网游数据同步问题（当然不只是现在的）（当然现实生活一般不会考虑这个问题，有人处理）

e.g. 两个人同时捡起一个医疗包，但第一个人「a」捡起来的时候，第二个人「b」的设备不知道医药包已经被人捡走了，结果两个人都捡到了一个医疗包... 所以我们要想办法「同步」解决这个问题

<第一次同步>
[a] 捡拾医疗包（状态：医疗包存在）
[b] 捡拾医疗包（状态：医疗包存在）
[a] 捡到医疗包，请求删除对象
[b] 捡到医疗包，请求删除对象
<最终>
[a] [b] 获得医疗包

结果嘛... 有很多种可能，数据竞争造成的后果一般比较迷

个人感觉这种抽象程度更低一些，所以会容易理解很多，本质上的东西「发布啊... 原子性啊...」是没有变的

就是教线程同步的... 大概 虽然我也不会

+ MOD 和 XOR

Modulo 和 Xor 是非常常见的数学运算符

Java 8 里 Modulo（余数 aka. 模数） 10 / 3 = 3 ··· 1 是 10 % 3 //=> 1
Xor （异或）则是经典位运算，真值表「输入 a 和 b 相同就输出假，否则输出真」

a | b | o
1 | 0 | 1
0 | 1 | 1
1 | 1 | 0
0 | 0 | 0

0b10010 ^ 0b00000 什么的... Xor 还有很好玩的特性可以自己找

+ MinBase64 和 randomSelection：极简设计自豪

... 我觉得没啥好自豪的呢... 不过我觉得 MinBase64 的交互设计得真的比很多同类应用要好，虽然代码很不怎么样
rs 现在也就一个晚上的熬夜战而已，不能说明什么...

+ Net、Async、Mixin、ApplectiveOrder Y Combinator、JavaVM、Algorithm 不会 和 Bottleneck

....就是说我 duangsuse 计算机网络、异步和并发编程、面向对象理论和流行技巧、某种 Y 组合子不会而已

JavaVM 不会是因为我不理解类加载机制（真的？）
算法不是我的强项，或许（
瓶颈（就是字面上的意思）（好吧不是）
总感觉最近看书没啥效果一样，该菜的还是菜

附赠 Y 组合子一份（lambda 演算）

Y = λf. (λx. f (x x)) (λx. f (x x))

https://en.wikipedia.org/wiki/Fixed-point_combinator

附赠一些 FP 概念，从《极简 #Kotlin 教程取用》（叫你们买这本书... 因为的确是好书啊（跑））

函数式编程又称泛函编程，是一种编程范式（programming paradigm），也就是如何编写程序的方法论。它的基础是 λ 演算（lambda calculus），λ 演算可以接受函数当作输入（参数）和输出（返回值）

和指令式相比，函数式的思维方式更加注重函数的计算，它的主要思想是把问题的解决方式写成一系列嵌套的函数调用。

在 OOP 里，一切皆是对象，程序是由对象交织构成的世界，而 FP 里，一切皆为函数，程序是由函数交合创造的世界。

（推荐使用 Common Lisp、Scheme 什么的入门）

「OOP 中常用模式，FP 里基本都可以使用高阶函数（Higer-Order Function）实现」

Strategy = HigherOrderFunction
|
——-----/—--————/———————/—————----------—/———---—/————-
Command Observer AbstractFactory State Visitor


「范畴」
函数式编程中，一切皆是函数，也就是面向函数编程。

范畴论里，一个范畴由三部分组成

+ 对象（object）
+ 态射（morphism）
+ 组合（composition）操作符

如果把函数式编程看作一个范畴，那么函数就是其中的对象，函数之间的组合就是对应的态射和组合操作符

『范畴的对象』
这里可以看作一类东西，如 Boolean、String、Integer 或者数学上的群、环有理数等
『范畴的态射』
态射就是映射，用箭头表示

element -> element

e.g.

translate :: String -> String
translate "Hello" = "你好"
translate "Bye" = "再见"
translate "Thanks" = "谢谢"

『范畴的组合』
组合用「·」来描述，用于将态射进行组合

f :: A -> B
g :: B -> C

g·f :: A -> C

一个结构要想成为一个范畴，必须满足以下三个限制：

〖结合律（colsure）〗
f · (g · h) = (f · g) · h
〖封闭律（associative）〗
如果存在态射 f 和 g，则一定存在态射 h = f · g
〖同一律（identity）〗
对结构内的每个对象 a，存在一个单位态射 I :: A -> A 使得 I · a = a

群论中，一个群只满足上前两点被称为半群（semigroup），全部满足被称为含宏半群（monoid）

正如范畴论对象和对象之间有映射关系一样，范畴和范畴之间也有映射关系，能将一个范畴映射为另一个范畴，这种关系被称为「Functor」（函子）
函子反映了不同范畴之间的内在联系，这和函数式编程中泛函数（高阶函数）的思想是相通的

+ Foldl 和 reduce

Fold （foldr 的简称）是有初始值版本的 reduce

+ E2IM wait() notify()

就是说 duangsuse/e2im 这个函数库异步没有做好...

睡觉了，还有很多很多很多没有说的..... 有一大堆两页的内容

是的

111 Members 吉利（迫真）数字庆祝（

不过其实我比较好奇，因为本频道发的很多内容都不是大部分工业系（或者说，非真正的「工业系」）程序员看得懂的，但居然还有人要关注

#telegram 频道主 duangsuse 预计，这种 subscriber 的动机和我自己以前 star 那些 #GitHub 代码库的动机一致，只是觉得很厉害就 Star 了一个，实际上，看的人也是比较少了

我以前都是那种看都不看一眼就 Star 的。现在我没有了，这后面也有我程序设计项目分析能力提升的原因 — 以前可能要看的话，根本不知道哪是哪，现在三分钟就能快速理解项目结构，找到工程构建、界面、定义文件的位置

不过，在此也建议大家不要为了 Star 或者让别人看到而 Star，最好还是多看一下

🐱

毕竟现在很多甚至是（资深）「工程师」
都没看过本本的。我很尊敬看书的人，但其实不看本本们也有能做高级一点工程（e.g. @RikkaW's Riru framework）的人也有很多

现在嘛... 感觉自己技能和理解能力都有很大的提升了（真的？）

论文和编译原理方面的，表达方式比较数学化的偏序原理也能看懂了，虽然还是有点没耐心看完

一直以来自我感觉智力水平都比身边的同学差个一年的（果然？

热爱技术的人从来都是不知足的？（

但是嘛... 其实感觉好像自己的技术又没有提升多少而已，大概是工程做少了书看多了的那种。而且，我也还不了解计算机网络、TCP、Internet 系统呢
人工智能特别想学，没有时间和资料（因为打印机没墨了...），但是，先把基础的并发、操作系统、计算机结构、计算机图形学、计算机网络、编译原理、软件工程、面向对象设计模式、渐进式、模块化开发等基础学好了才能继续吧（ 🐱

« last pinned message

我上面也说了，建议大家还是尽可能去了解一下自己 Star 的那些东西真正是什么，其实从觉得很酷到懂只差一份好奇心和两年左右的持续努力（或许更短）

@drakeet 那件事（我现在居然还经常说...）其实我后来注意到他偶尔提到王垠

个人感觉... drakeet 目前还是对程序设计语言方面的理论不是特别了解，当然人各有所长，所以单凭某个方面去判断一个人的能力是不正确的。（当然，之前搞出那么大篓子的原因是我语文没学好，不知道别人还有自尊心，或者说，我个人比较「不要脸」，即使技术被人批评了也只是想着怎么提升而不会觉得丢脸，因为我还是很能做到「己所不欲勿施于人」的）

（当然，其实我之前也考虑到了自尊心？可能是我说的太直白了吧... 我明明说了他很擅长 Android 开发的... 只不过想让他不要在自己不是很擅长的方向发表太多看法）

（当然，或许我在之前那个我以为他不擅长的方面还不如他呢，或许他真的是对的，现在不重要了 :P）

其实嘛... 王垠的「40 行代码」
我开始来到 CS 大门前的时候当然就啥都不知道，比较好笑，我真的就是不明觉厉

不过，真的只有我一个人是不明觉厉吗？

不要害怕学习，不要和那群前端一样成天叫着别更新了、再学就要猝死了，人类社会就是向前发展的、技术就是向越来越好发展的，自己不努力追赶也有人追赶

现在上亚马逊去买书，跟着不管什么平台，知乎、CodeWars、各类 OJ、甚至 QQ 上的大佬们学习（其实只需要看他们的博文和代码即可）

相信 10000（10k，一万）个小时定律，只要付出的足够多，就能理解你之前不明觉历的那些东西

#inscript #PL #CS #java #code #recommended

同时，InScript 又新加了几个特性，包括模式匹配、惰性求值等等函数式 declarative （定义式）编程的特性

下面给大家一些代码，这周我不说其他（InScript 外）的东西了，先解决 InScript 语言定义的问题，FIFO 队列溢出就溢出吧（当然，这里溢出指「先进入的信息已经失去时效性」）...

有 imperative （表述式 e.g. Kotlin、JavaScript）的也有 declarative （声明式 e.g. Haskell、Scheme、Idris）的，全部都是 InScript（

其实后来感叹到 InScript 越设计越像 Haskell 了... not CFG（上下文无关）文法的锅？（迫真
不过真的不打算弄成 Haskell 一样，而且又加入类型检查推导和模式识别特性是很耗力气的... 估计不是现在可能做出来的那种设计
（duangsuse 的 Haskell 还有待入门，不过 Haskell 也怪好玩的，递归也比较熟悉了，就差拿 InScript 分支函数写 The Little Schemer 了（

（InScript 现在添加了这种函数式扩展以后语法歧义估计可是比 Julia 还多？（迫真

（把 imperative 或 declarative 作为一门语言的特点是不对的？）（怀疑

{- Toy progream: FizzBuzz judger-}

type scannerIter : Iterator<Int>
type judge : Int => String
type main : String[] => Nil



scannerIter = object : Iterator<Int>

new def next = gets.parseInt
new def hasNext = IN.open?

judge(x) = when x
% 3 zero -> 'Buzz'
% 5 zero -> 'Fizz'
both 1, 2 -> 'FizzBuzz'
otherwise -> x as String

main(args) = puts << judge <$> scannerIter

{- Toy program: Guessing game -}
using randInt from std.math

main(String[] args): Nil = |>
scope let answer = randInt(1..100)
where while input = gets.parseInt
puts when input where
> answer -> 'Too big'
< answer -> 'Too small'
answer -> "$answer, Just right!"; break

{- Toy program: Selection sort -}

type <A : Comparable<A>> selectionSort : (A[]) -> A[]

scope let opt = |orig@(v, i), b, j| v > b ? orig : （b, j)
where findSmallest(xs) = let (_, res) =
foldWithIndex(opt, (Int::MIN, 0), xs) in res

selectionSort [] = []
selectionSort [findSmallest x in xs] = x >> tailrec

main(args) = puts selectionSort [2, 4, 1, 5, 3]

{- Toy program: binarySearch -}

type <A : Comparable<A>> binarySearch : |A[]| |A| |Range| Int

binarySearch xs o <srch = xs.indexRange> = |>
let index = srch.mid, guess = xs[index] in when
| srch.len zero -> nil
| guess is o -> index
| guess > o -> tailrec(srch.a..srch.mid.sub1)
| guess < o -> tailrec(srch.mid.add1..srch.b)


{- Toy program: dfs 在盒子堆里找指定物品，并且获得其路径 -}
data Box = BoxItem[] items, String name
data Item = String name
data BoxItem = Box box ^ Item item

findItemInBox(Box box, String target_name, String[] path = "")
box.items.each |>[:findItemInBox, "$box.name/$path"]

findItemInBox(Item item, String target_name, String[] path) = puts path if item.name is target_name



{- Toy program: Coroutine Fibonacci 序列 -}

using std.sequence

def fibonacciSequence: Sequence
let suspend fib(a, b) = tailrec(suspend b, a + b) in
return new Sequence(fib(1, 2))


def main(args) = puts fibonacciSequence().take(args.first.parseInt ?: 100)

... 不好意思蛤，刚才一激动（因为新设计加入的模式匹配特性）全写的是定义式，待会写点表述式的对照一下

#blog #recommended https://ice1000.org/2018/11/16/BeyondDependentType/

顺推冰封哥新文 dependent type 之上还有更高级的类型系统吗？

当然我个人 PLT（这里意味 Programming Language Types）毫无水平，只会 Kotlin、Jawa、Crystal 系简单语言的类型系统
可以说是非常菜了

当然这个是要看发展的，拿别人的水平批判 duangsuse 的话是不接受的（比如，冰封几年前就在写 C++ 搞 OI，我去年才会写简单的 Java 7），拿没有作品批判也是不接受的（原因我在本频道上说过）

btw. 真是高产啊，才一周不见就更了两篇文章

duangsuse 自己对程序静态分析检查还不是很了解，when 表达式的语法上面各种糖都还好说（毕竟手写 Recursive Descent 我还是熟悉的）
啥分支覆盖问题我也想过，不过啥都不懂就是了，打算如果以后就这种水平去实现的话，尽可能多做一点（或许是启发式的...（这里启发式和机器学习无关，意思是「假设各种情况做检查」））检查，不要求绝对正确，保证体积和解释器本身健壮即可，类型检查器重要性优先于类型推导器

〖对应用层开发者（e.g. Android 开发工程师、PHP 或者管他什么没有达到完全抛弃任何框架的程度能力者，尤其是语言特性贫瘠或非底层语言 Lua、ES5、Java、Groovy、Python 程序员）来说〗
像这种写 Agda、Idris、ML 等「具有证明程序正确性的程度能力」语言水平的人，最好还是不要在他们面前炫耀自己写了多少前端应用什么的，说实话，等你以后（或许）有了更高的视角，你会发现你死记硬背的那些 CSS 属性，学的反编译器使用、Bash 编程、GNU/Linux 系统配置、Git/Gradle/CMake 等「最佳实践」等等根本不值得一提，不是一个抽象复杂层次上的东西

不过至少是冰封来看，他没有那种高高在上的架子，比较平易近人（虽然最喜欢研究的理论不平易近人，笑），但如果自己没有足够的水平，有些圈子不必强融就是了（反正以后赶上了可以再进嘛）

优化版的盒子堆（Haskell）（因为 InScript 还没有形式化的被定义出来，也暂时没有人实现它，我想看到自己的程序实打实在电子计算机而不是我的脑子里运行起来 XD）： 😸

其实这玩意是我从《算法图解》（内容简单像「故事书」，其实教的东西大学里都要上，体现了知识系统相同表达教学方式简单一点的确可以让学习更高效）里弄的一个伪代码例子

可出对应 OI 题，不过就是那种小学生都会写的那种（迫真），好吧，我不知道现在 OI 生们都是啥水平，有没有 OI 生给我科普一下？排序算法理解否？各种图各种树算法会否？动态规划 diff 会写否？线性规划会吗？网络流？

duangsuse 的算法水平依然需要严重学习（XD #algorithm #cs #china #tech #haskell #functional

（在网上找不到单独的中文 Haskell 社区，看来中国特色的（伪工业系）工程师们都喊着口号其实懒得动 FP（函数式编程），第一次作为小众群体感到由衷的自豪，哈哈（迫真））

（好吧，其实有一个，但包装得实在是不咋样（还不如 LetITFly BBS，甚至 LWL12 的个人博客），而且连论坛都是 GitHub issue 讨论版并且没有自己的服务，没啥实用价值，233）

可惜，一个星期只放假半天，所以我只能做这些实际上没啥卵用的玩意，哪怕写个 Sexp 解释器给自己玩玩或者写个 AXML 二进制流解析器都是好的，甚至写点 Gradle Groovy DSL 都行啊... 写点 Kotlin 的 Android 应用... Android 核心模型哪几个来着... 好像是 Intents... Boardcast Receivers, Activities, Services, Notificatoins...

（by the way, 刚才写的时候突然停电了，还好 Telegram 支持跨设备 draft 缓存，不会丢失写了半天的辣鸡玩意😋）

（再讲个很好笑的事情先😄）
Learn You a Haskell for Great Good(EN) 有个中文翻译，不过是我们台湾的同志们搞出来的，人家顺便弄了个简体的翻译 🙃

我之前把 Haskell 当 Ruby 用，我写过这种代码并且臆想它能正常工作的样子（你们知道，Haskell 里不兴 Helloworld 这种幼儿园小朋友写的代码）（吐嘈：你知道还坚持要写这种只比 HelloWorld 复杂二分之一的代码...）：

putStrLn getLine

原因很简单：我在 GHCi 里各使用这两个函数都能正常工作。然后我想说的其实是类似这样（之前嘛，我是完全不懂的，包括我也无法理解函数类型符号 Integer -> Integer 啥意思（并且，冰封博文上讲了我也看不懂，233333333））

do ln <- getLine; putStrLn ln

... 其实也不是理论上有问题，我之前一厢情愿的认为我是把一个 () -> IO String （一个无参闭包，或者说匿名函数，一般这俩都等价的）传给了 putStrLn :: String -> IO ()
（当然，据说 Haskell 里无参函数和变量是等价的，就是惰性求值变量？或者不是，是 call-by-need 变量？如果是纯函数的话，二者都差不多吧...）
所以现在我这么修改之前那个幼稚的例子（是的，我又 TM 去看了点 Haskell tourial） putStrLn $ getLine

其实是 IO String 不是 String 的问题，用 getLine >>= putStrLn 即可

getLine 是 IO String （没错，这厮不是函数...）
putStrLn 是 String -> IO () （type String = [Char]）
(>>=) 是 IO a -> (a -> IO b) -> IO b，绝配，稳如老狗（确信）。

IO String -> (String -> IO ()) -> IO ()

然后代码

module Main where

data Item = Item { name :: String } deriving (Eq, Show)
data Box a = Box { name :: String, items :: [a] } deriving (Show)
{- 打住，我不会写这种... 老出问题证明我 Haskell 还太菜 -}

data Item = Box (String, [Item]) | Atom String deriving Show
findItem :: Item -> String -> [String]
findItem b o v = []
| (Box n is) o v = findItem is o (n : v)
| (Atom n) o v = if o == n then print v

Haskell 弄分支函数老说我语法错误还不告诉我为啥，弄得我没法修... 只好自己又弄一个手动分支来的

module BoxDfs where

data Item = Box (String, [Item]) | Atom String
  deriving (Eq, Show) 

findItem :: String -> [String] -> [Item] -> [String]

findItem m v [] = []

findItem m v ((Box (n, xs)):bs) = findItem m (n:v) xs
findItem m v ((Atom n):bs) = if n == m then v else []

{-
findItem m v (b:bs) =
  case b of   
    Box (n, xs) -> findItem m (n : v) xs
    Atom n      -> if n == m then v else []
-}

还没测试，等下发文件。待会会弄（写、找）点 Haskell 和 FP 系教程发来，欢迎喜欢的来看

直接写出来我们再分析一下算了：

分析结果：如果找到元素的路径不止一个，可能会找不到元素，原因自推