docs: rewrites to add readability

Author: Rratic

docs/advanced/cmd.md

@@ -1,6 +1,7 @@
 # 命令
 ## Cmd
 `Cmd` 是 Julia 中表示指令的数据类型，使用一对 ``` `` ``` 定义，例如 `` `cd ../` ``。
+
 用构造函数 `Cmd(cmd::Cmd; ignorestatus=false, detach=false, windows_verbatim=false, windows_hide=false, env, dir)` 定义状态，其中
 * `ignorestatus` 为 `true` 时，命令返回值非 0 不会抛出异常
 * `detach` 为 `true` 时，产生新进程运行

docs/advanced/exception.md

@@ -1,5 +1,5 @@
 # 异常分类
-**异常（Exception）**是进行[异常处理](../basic/error.md)的重要信息传递工具，所有内置的错误类型都是 `Exception` 的子类型
+**异常**类型 `Exception` 是进行[异常处理](../basic/error.md)的重要信息传递工具，所有内置的错误类型都是 `Exception` 的子类型。
 
 | 名称 | 描述 |
 | :-: | :-: |
@@ -35,55 +35,14 @@
 | `UndefVarError` | 当前作用域中某量未定义 |
 
 ## 练习
-对于以下填空题，判断抛出的异常类型，不会抛出异常则填入 `nothing`。
-```insert-test
-[global]
-name = "异常类型判断测试"
-time_limit = 300
-full_score = 100
-
-[[parts]]
-type = "group"
-ch_type = "fill"
-score = 10
-
-[[parts]]
-content = "`NaN/0`"
-ans = "nothing"
-
-[[parts]]
-content = "`1÷0`"
-ans = "DivideError"
-
-[[parts]]
-content = "`[1, 2, 3, 4][8]`"
-ans = "BoundsError"
-
-[[parts]]
-content = "`\"cat\"/0`"
-ans = "MethodError"
-
-[[parts]]
-content = "`foo() = foo(); foo()`"
-ans = "StackOverflowError"
-
-[[parts]]
-content = "`[1 2; 3 4] - [1, 1, 1, 1]`"
-ans = "DimensionMismatch"
-
-[[parts]]
-content = "`\"猫猫\"[2]`"
-ans = "StringIndexError"
-
-[[parts]]
-content = "`Dict(0 => 1)[1]`"
-ans = "KeyError"
-
-[[parts]]
-content = "`@assert 1==0`"
-ans = "AssertionError"
-
-[[parts]]
-content = "`typeassert(0.0, Int)`"
-ans = "TypeError"
-```
+猜测一下代码会导致什么类型的错误结果（或者不会发生错误），并验证：
+* `NaN/0`
+* `1÷0`
+* `[1, 2, 3, 4][8]`
+* `\"cat\"/0`
+* `foo() = foo(); foo()`
+* `[1 2; 3 4] - [1, 1, 1, 1]`
+* `\"猫猫\"[2]`
+* `Dict(0 => 1)[1]`
+* `@assert 1==0`
+* `typeassert(0.0, Int)`

docs/advanced/string_code.md

@@ -1,7 +1,7 @@
 # 字符串编码
 Julia 中的 `String` 并不具有一个特定的编码类型，包括但不限于 `ASCII`、`Latin-1`、`UTF-8`、`UCS-2`、`UTF-16` 和 `UTF-32`，每个字符占据一定的连续空间，但仍以 `Char` 形式导出。
 
-Julia 中 `String` 所采用的编码的基本假设是**自同步（self-synchronizing）**。
+Julia 中的 `String` 要求采用的编码是**自同步**（self-synchronizing）的，也就是说：从任意位置开始读取字节流，都可快速识别字符边界，恢复正确的解码状态。
 
 以该字符串 `s` 为例（`UTF-8`）：
 | 直观编号 | `Char` | 所占字节数 |

docs/advanced/typesystem.md

@@ -672,9 +672,7 @@ julia> show(stdout, "text/html", Polar(3.0, 4.0))
 ```
 
 展示结果：
-```insert-html
 <code>Polar{Float64}</code> complex number: 3.0 <i>e</i><sup>4.0 <i>i</i></sup><br />
-```
 
 根据经验，单行 `show` 方法应为创建的显示对象打印有效的 Julia 表达式。当这个 `show` 方法包含中缀运算符时，比如上面的 `Polar` 的单行 `show` 方法里的乘法运算符（`*`），在作为另一个对象的部分打印时，它可能无法被正确解析。要查看此问题，请考虑下面的表达式对象（请参阅[Expr](expr.md)），它代表 `Polar` 类型的特定实例的平方：
 ```julia-repl

docs/basic/basicio.md

@@ -1,7 +1,10 @@
 # 基础I/O
 ## 字符串基础
-[关于字符串的详细信息](string.md)。
-此处你暂时只需要知道的是，你可以在一对 `""` 中放若干文字，它们可以构成字符串：
+你将[在之后读到](string.md)关于字符串更详细的信息。
+
+字符串可用于存储一串文字。
+
+在一对 `""` 中放若干文字，它们可以构成字符串字面量：
 ```julia-repl
 julia> "A quick brown fox jumps over the lazy dog."
 "A quick brown fox jumps over the lazy dog."
@@ -10,53 +13,91 @@ julia> "喵(　o=^•ェ•)o"
 "喵(　o=^•ェ•)o"
 ```
 
-字符串与字符串中的内容通常不是同一个东西：
+字符串与字符串中的内容通常是不相等的：
 ```julia-repl
-julia> "0"==0
+julia> "0" == 0
+false
+
+julia> "sqrt(2)" == sqrt(2)
 false
 
-julia> A quick brown fox jumps over the lazy dog.
-ERROR: syntax: extra token "quick" after end of expression
+julia> "a" == a
+ERROR: UndefVarError: `a` not defined in `Main`
 ```
 
 ## print
-`print` 是基本的输出方式
+`print` 是最基本与常用的输出方式。在 REPL 中，输出结果会出现在代码后。
 ```julia-repl
 julia> print(0)
 0
-julia> print(1, 2, 3) # 允许接受多个参数
+julia> print(1, 2, 3) # 允许接受多个参数，它们的输出间没有空隙
 123
-julia> print("world.me.say_hello()") # （这个字符串内容看上去像代码
+julia> print("world.me.say_hello()") # 输出字符串
 world.me.say_hello()
-julia>
+julia> print(1, " ", 2, " ", 3) # 手动填充空格
+1 2 3
 ```
 
 ## println
-`println` 与 `print` 相似，不同的是在末尾会多进行一次换行。
-为了美观，许多人会在输出时选择它而不是 `print`。两者配合也可以完成更好的输出效果。
+`println` 除完成 `print` 的职责之外在末尾会多进行一次换行。
+
+为了代码简洁和输出结果美观，有时会在输出时选择它而不是 `print`。两者配合也可以完成更好的输出效果。
 ```julia-repl
+julia> print(0, "\n")
+0
+
 julia> println(0)
 0
 
-julia> println(1,2,3)
+julia> println(1, 2, 3)
 123
 
-julia>
+julia> println("╭╮"); println("╰╯")
+╭╮
+╰╯
 ```
 
 ## printstyled
-`printstyled` 可以在环境允许的情况下输出有风格的文字（当前功能包括彩色与粗体）
+`printstyled` 可以在环境允许的情况下输出有风格的文字。可配置的选项包括粗体、斜体、下划线、闪烁、前景背景反转、隐藏与色彩。
 ```julia-repl
 julia> printstyled(1, 2, 3; color=:red)
-123 # 你看，这里不允许这个功能，使用它输出没有特殊效果（
+123 # 如果系统支持，在 REPL 中显示红色
 ```
 
-它基于的标准是广泛用于现代控制台的 `ansi-escape-code/sequence`（可追溯至 `VT100`），可参阅 [windows 的相关支持](https://docs.microsoft.com/zh-CN/windows/console/console-virtual-terminal-sequences)。
+在控制台中，它基于的标准是广泛用于现代控制台的 `ansi-escape-code/sequence`，可参阅 [windows 的相关支持](https://docs.microsoft.com/zh-CN/windows/console/console-virtual-terminal-sequences)。
 
 ## 输入
-为方便进行之后的练习，现提供以下代码
+既然有输出，就要有输入。Julia 中的 `readuntil` 与 `readline` 会读入字符串。
+
+`readline` 会获取连续的字符，直到行尾。
+```julia-repl
+julia> a = readline();
+read read read!
+
+julia> a
+"read read read!"
+```
+
+`readuntil` 会获取连续的字符，直到读到空格。
+```julia-repl
+julia> a = readuntil(stdin, ' ');
+read buffered
+
+julia> buffered
+ERROR: UndefVarError: `buffered` not defined in `Main`
+Suggestion: check for spelling errors or missing imports.
+
+julia>
+
+julia> a
+"read"
+```
+
+上面的结果是在 REPL 中得到的。字符串 `buffered` 及回车没有被读取，因此仍在缓冲区中，自动变成了一行命令的输入。
+
+两者也可以配合使用：
 ```julia-repl
-julia> a=readuntil(stdin,' '); b=readline() # 前者读到空格为止，后者读到行尾
+julia> a = readuntil(stdin, ' '); b = readline()
 first second
 "second"
 
@@ -67,9 +108,9 @@ julia> b
 "second"
 ```
 
-利用 `parse` 函数将字符串转为整数的功能，你可以读入整数
+利用 `parse` 函数将字符串转为整数的功能，可以实现读入整数的效果。
 ```julia-repl
-julia> a=parse(Int,readuntil(stdin,' ')); b=parse(Int,readline());
+julia> a = parse(Int, readuntil(stdin, ' ')); b = parse(Int, readline());
 2333 4
 
 julia> a, b

docs/basic/bool.md

@@ -1,8 +1,8 @@
 # 布尔
-## 布尔代数
-通常来说，布尔代数指布尔逻辑，可参照[此处的介绍](../knowledge/bool_logic.md)。
+## 布尔逻辑
+[在此阅读](../knowledge/bool_logic.md)关于布尔逻辑的详细内容。
 
-`Bool` 是 Julia 中的布尔类型名，其值只能为 `true`、`false` 之一。
+`Bool` 是 Julia 中的布尔类型名，其值只能为 `true` 与 `false` 之一。
 
 ## 运算
 | 表达式 | 名称 |
@@ -18,9 +18,6 @@ false
 julia> true && "foo"
 "foo"
 
-julia> false && "foo" # 短路意味着前一个表达式为否时，不会关心后一个表达式
-false
-
 julia> false || "foo"
 "foo"
 
@@ -32,23 +29,44 @@ true
 
 特别地，`false` 可以用于如下功能：
 ```julia-repl
-julia> NaN*0
+julia> NaN * 0
 NaN
 
-julia> NaN*false
+julia> NaN * false
 0.0
 ```
 
+## 短路
+短路是一个重要的特性，它是说：如果一个布尔逻辑表达式的第一个参数已经确定了整个表达式的值，则第二个参数根本不会被计算。
+
+```julia-repl
+julia> a = 0
+0
+
+julia> false && begin a=1; a==2 end
+false
+
+julia> a
+0
+
+julia> true || begin a=1; a==2 end
+true
+
+julia> a
+0
+```
+
+上例中 `begin a=1; a==2 end` 没有被计算，因此没有进行 `a = 1` 的赋值操作。
+
 ## 缺失
-**缺失（Missing）**，具有唯一实例 `missing`。它用于表示字面意思，即“值缺失”。[^1]
+**缺失**类型 `Missing` 具有唯一的实例 `missing`。它表示其字面意思，即“值缺失”。[^1]这一语义在数据科学中常被用到。
 
-“值缺失”这一语义在数据科学中常被用到。
 对于大部分数学函数，`missing` 会传递：
 ```julia-repl
-julia> missing==missing
+julia> missing == missing
 missing
 
-julia> missing+8
+julia> missing + 8
 missing
 ```
 
@@ -60,22 +78,22 @@ true
 julia> isequal(missing, missing)
 true
 
-julia> missing===missing
+julia> missing === missing
 true
 ```
 
-特别地，对于 `isless`，`missing` 被认为比任何其它值大
+特别地，对于 `isless`，`missing` 被认为比任何其它值大。
 
 ## 三值逻辑
-三值逻辑是由 `true`，`false` 和 `missing` 共同组成的，对于二元运算，有：
-- 对于所有的短路运算，仍保持短路规则
-- 若有参数为 `missing`，则返回 `missing`
+三值逻辑是由 `true`，`false` 和 `missing` 共同组成的。这里 `missing` 可以视作“未知是 true 还是 false”
+
+对于二元运算，禁止将 `missing` 放在左侧，并满足短路规则。
 
 ```julia-repl
 julia> true || missing # 短路原则
 true
 
-julia> false || missing # 缺失原则
+julia> false || missing
 missing
 ```
 

docs/basic/dict.md

@@ -1,5 +1,5 @@
 # 字典
-`Dict` 可以创建一个**字典（dictionary）**，即一个**键**到**值**映射的结构，可以按照键名存放或取出数据。例如，你可以用它存储一个英文单词对应的翻译（这可能键的类型是字符串，值的类型是字符串数组）。
+使用 `Dict` 可以创建一个**字典**（dictionary），这是一个**键**到**值**映射的结构，可以按照键名存放或取出数据。例如，你可以用它存储一个英文单词对应的翻译（这可能键的类型是字符串，值的类型是字符串数组）。
 
 ## 初始化
 ```julia-repl

docs/basic/error.md

@@ -44,7 +44,7 @@ end
 也可以使用 `error(x)` 函数，相当于 `throw(ErrorException(x))`。
 
 ## finally
-`try-catch` 结构中可以嵌入 `finally`，标注无论代码如何结束，都会运行 `finally` 中的代码块
+`try-catch` 结构中可以嵌入 `finally`，标注无论代码如何结束，都会运行 `finally` 中的代码块。
 ```jl
 io = open("1.txt", "w")
 try
@@ -53,3 +53,5 @@ finally
 	close(io)
 end
 ```
+
+上例中保证运行 `close(io)` 避免了发生“你无法……因为有程序打开了……”的错误。

docs/basic/function.md

@@ -97,9 +97,10 @@ julia> baz(1; o=0)
 10
 ```
 
-## lambda表达式
-一种常用于创建局部匿名函数的方式是使用**Lambda 表达式**。
-它的格式是 `(参数列表) -> 表达式`，为了方便，有时把表达式放入 `begin ... end`
+## lambda 表达式
+一种常用于创建局部匿名函数的方式是使用类似于[**Lambda 表达式**](https://rratic.github.io/posts/lambda-calculus/)的语法。
+
+它的格式是 `(参数列表) -> 表达式`，为了方便，有时把表达式放入 `begin ... end` 中。
 ```julia-repl
 julia> f = (x::Int) -> x+1
 #2 (generic function with 1 method)