docs: format

Author: Rratic

docs/advanced/method.md

@@ -1,7 +1,7 @@
 # 模块
 ## 简介
-Julia 中的模块（module）是一些互相隔离的可变工作空间，会引入新的全局作用域。模块允许创建顶层定义（也称为全局变量），而无需担心命名冲突。
-在模块中，利用导入（importing）控制其它模块中的哪些名称是可见的；利用导出（exporting）控制自己的模块中哪些名称是公开的。
+Julia 中的**模块**（module）是一些互相隔离的可变工作空间，会引入新的全局作用域。模块允许创建顶层定义（也称为全局变量），而无需担心命名冲突。
+在模块中，利用**导入**（importing）控制其它模块中的哪些名称是可见的；利用**导出**（exporting）控制自己的模块中哪些名称是公开的。
 
 模块的[类型](typesystem.md)名是 `Module`。
 
@@ -13,7 +13,7 @@ Julia 中的模块（module）是一些互相隔离的可变工作空间，会
 ## 当前模块
 在使用时，你需要搞清楚当前模块的位置。模块中的所有代码，若无特别标注，都是作用于当前模块的。
 !!! tips
-	可以利用 `@__MODULE__` 获取当前模块名
+    可以利用 `@__MODULE__` 获取当前模块名
 
 ## 语法
 使用 `module ... end` 声明一个模块，它会默认导入 `Base` 和 `Core`（特别地，可以使用 `baremodule ... end` 从而不导入 `Base`，也不在本地定义 `eval` 和 `include`）。

docs/advanced/module.md

@@ -159,7 +159,8 @@ julia> foo.baz
 ```
 
 ### 默认构造函数
-但在没有任何特别的构造函数声明的情况下，有两种默认方式可以创建新的复合对象，一种是显式地给出类型参数，另一种是通过传给对象构造函数的参数隐式地推断出\
+但在没有任何特别的构造函数声明的情况下，有两种默认方式可以创建新的复合对象，一种是显式地给出类型参数，另一种是通过传给对象构造函数的参数隐式地推断出。
+
 由于 `Point{Float64}` 类型等价于在 `Point` 声明时用 `Float64` 替换 `T` 得到的具体类型，它可以相应地作为构造函数使用
 ```julia-repl
 julia> p = Point{Float64}(1.0, 2.0)

docs/advanced/struct.md

@@ -85,20 +85,28 @@ end
 	Julia < 1.8.0 不支持对全局变量进行类型标注
 
 ## 抽象类型
-抽象类型不能实例化，只能作为类型图中的节点使用，从而描述相关具体类型的集，即那些作为其后代的具体类型。即便抽象类型没有实例， 由于它们是类型系统的主干，故我们首先从抽象类型谈起：抽象类型形成了概念的层次结构，这使得 Julia 的类型系统不只是对象实现的集合\
-回想一下，在[整数](../basic/int.md)和[浮点数](../basic/float.md)中，我们介绍了各种数值的具体类型：`Int8`、`UInt8`、`Int16`、`UInt16`、`Int32`、`UInt32`、`Int64`、`UInt64`、`Int128`、`UInt128`、`Float16`、`Float32` 和 `Float64`\
-尽管 `Int8`、`Int16`、`Int32`、`Int64` 和 `Int128` 具有不同的表示大小，但都具有共同的特征，即它们都是带符号的整数类型。类似地，`UInt8`、`UInt16`、`UInt32`、`UInt64` 和 `UInt128` 都是无符号整数类型，而 `Float16`、`Float32` 和 `Float64` 是不同的浮点数类型而非整数类型。\
-一段代码只对某些类型有意义是很常见的，比如，只在其参数是某种类型的整数，而不真正取决于特定*类型*的整数时有意义。例如，最大公约数适用于所有类型的整数，但不适用于浮点数。抽象类型允许构造类型的层次结构，这给具体类型提供了可以适应的环境。例如，你可以轻松地为任何类型的整数编程，而不用将算法限制为某种特殊类型的整数。\
-抽象类型可以由`abstract type`关键字来声明。声明抽象类型的一般语法是：
+抽象类型不能实例化，只能作为类型图中的节点使用，从而描述相关具体类型的集，即那些作为其后代的具体类型。即便抽象类型没有实例， 由于它们是类型系统的主干，故我们首先从抽象类型谈起：抽象类型形成了概念的层次结构，这使得 Julia 的类型系统不只是对象实现的集合。
+
+回想一下，在[整数](../basic/int.md)和[浮点数](../basic/float.md)中，我们介绍了各种数值的具体类型：`Int8`、`UInt8`、`Int16`、`UInt16`、`Int32`、`UInt32`、`Int64`、`UInt64`、`Int128`、`UInt128`、`Float16`、`Float32` 和 `Float64`
+
+尽管 `Int8`、`Int16`、`Int32`、`Int64` 和 `Int128` 具有不同的表示大小，但都具有共同的特征，即它们都是带符号的整数类型。类似地，`UInt8`、`UInt16`、`UInt32`、`UInt64` 和 `UInt128` 都是无符号整数类型，而 `Float16`、`Float32` 和 `Float64` 是不同的浮点数类型而非整数类型。
+
+一段代码只对某些类型有意义是很常见的，比如，只在其参数是某种类型的整数，而不真正取决于特定*类型*的整数时有意义。例如，最大公约数适用于所有类型的整数，但不适用于浮点数。抽象类型允许构造类型的层次结构，这给具体类型提供了可以适应的环境。例如，你可以轻松地为任何类型的整数编程，而不用将算法限制为某种特殊类型的整数。。
+
+抽象类型可以由 `abstract type` 关键字来声明。声明抽象类型的一般语法是：
 ```jl
 abstract type «名称» end
 abstract type «名称» <: «上级抽象类型» end
 ```
 
-该 `abstract type` 关键字引入了一个新的抽象类型，`«名称»` 为其名称。此名称后面可以跟`<:`和一个已存在的类型，表示新声明的抽象类型是此「上级」类型的子类型\
-如果没有给出超类型，则默认超类型为 `Any`——一个已经定义好的抽象类型，所有对象都是 `Any` 的实例并且所有类型都是 `Any` 的子类型。在类型理论中，`Any` 通常称为「top」，因为它位于类型图的顶点。Julia 还有一个预定义了的抽象「bottom」类型，在类型图的最低点，写成 `Union{}`。这与 `Any` 完全相反：任何对象都不是 `Union{}` 的实例，所有的类型都是 `Union{}` 的超类型\
-让我们考虑[一些构成 Julia 数值类型层次结构的抽象类型](../lists/typetree1.6.txt#L795-L820)\
-`Number` 类型为 `Any` 类型的直接子类型，并且 `Real` 为它的子类型。接下来，`Real` 有子类型`Integer`和`AbstractFloat`，将世界分为整数的表示和实数的表示。实数的表示当然包括浮点类型，但也包括其他类型，例如有理数。因此，`AbstractFloat` 是一个 `Real` 的子类型，仅包括实数的浮点表示。整数被进一步细分为`Signed`和`Unsigned`\
+该 `abstract type` 关键字引入了一个新的抽象类型，`«名称»` 为其名称。此名称后面可以跟`<:`和一个已存在的类型，表示新声明的抽象类型是此「上级」类型的子类型。
+
+如果没有给出超类型，则默认超类型为 `Any`——一个已经定义好的抽象类型，所有对象都是 `Any` 的实例并且所有类型都是 `Any` 的子类型。在类型理论中，`Any` 通常称为「top」，因为它位于类型图的顶点。Julia 还有一个预定义了的抽象「bottom」类型，在类型图的最低点，写成 `Union{}`。这与 `Any` 完全相反：任何对象都不是 `Union{}` 的实例，所有的类型都是 `Union{}` 的超类型。
+
+让我们考虑[一些构成 Julia 数值类型层次结构的抽象类型](../lists/typetree1.6.txt#L795-L820)
+
+`Number` 类型为 `Any` 类型的直接子类型，并且 `Real` 为它的子类型。接下来，`Real` 有子类型 `Integer` 和`AbstractFloat`，将世界分为整数的表示和实数的表示。实数的表示当然包括浮点类型，但也包括其他类型，例如有理数。因此，`AbstractFloat` 是一个 `Real` 的子类型，仅包括实数的浮点表示。整数被进一步细分为 `Signed` 和 `Unsigned`
+
 `<:` 运算符的通常意义为「是······的子类型（is a subtype of）」，可以用在声明中，声明右侧类型是新声明类型的直接超类型；也可以在表达式中用作子类型运算符，在其左操作数为其右操作数的子类型时返回 `true`
 ```julia-repl
 julia> Integer <: Number
@@ -110,17 +118,20 @@ false
 
 抽象类型的一个重要用途是为具体类型提供默认实现。例如：
 ```jl
-myplus(x,y)=x+y
+myplus(x, y) = x + y
 ```
 
-首先需要注意的是上述的参数声明等价于 `x::Any,y::Any`。当函数被调用时，例如 `myplus(2,5)`，派发器会选择与给定参数相匹配的名称为 `myplus` 的最具体方法。（有关多重派发的更多信息，请参阅[方法](method.md)。）\
+首先需要注意的是上述的参数声明等价于 `x::Any, y::Any`。当函数被调用时，例如 `myplus(2,5)`，派发器会选择与给定参数相匹配的名称为 `myplus` 的最具体方法（有关多重派发的更多信息，请参阅[方法](method.md)）。
+
 假设没有找到比上述方法更具体的方法，Julia 则会基于上面给出的泛型函数，在内部定义并编译一个名为 `myplus` 的方法，专门用于处理两个 `Int` 参数，即它隐式地定义并编译：
 ```jl
-myplus(x::Int,y::Int)=x+y
+myplus(x::Int, y::Int) = x + y
 ```
 
-最后，调用这个具体的方法\
-因此，抽象类型允许程序员编写泛型函数，泛型函数可以通过许多具体类型的组合用作默认方法。多重派发使得程序员可以完全控制是使用默认方法还是更具体的方法。\
+最后，调用这个具体的方法。
+
+因此，抽象类型允许程序员编写泛型函数，泛型函数可以通过许多具体类型的组合用作默认方法。多重派发使得程序员可以完全控制是使用默认方法还是更具体的方法。
+
 需要注意的重点是，即使程序员依赖参数为抽象类型的函数，性能也不会有任何损失，因为它会针对每个调用它的参数元组的具体类型重新编译。（但在函数参数是抽象类型的容器的情况下，可能存在性能问题；请参阅[性能建议](https://docs.juliacn.com/latest/manual/performance-tips)）
 
 ## 原始类型

docs/advanced/typesystem.md

@@ -1,7 +1,7 @@
 # 异常处理
-在程序出现不应有的错误时，会**抛出（throw）**异常。
+在程序出现错误/主动发现不应出现的情况时，会**抛出异常**。
 
-数学错误是典型的异常：
+数学错误是典型的异常（你之后会在[这里](../advanced/exception.md)看到常用错误类型信息）。
 ```julia-repl
 julia> sqrt(-1)
 ERROR: DomainError with -1.0:
@@ -42,7 +42,6 @@ end
 ```
 
 也可以使用 `error(x)` 函数，相当于 `throw(ErrorException(x))`。
-常用错误类型信息[见此](../advanced/exception.md)
 
 ## finally
 `try-catch` 结构中可以嵌入 `finally`，标注无论代码如何结束，都会运行 `finally` 中的代码块

docs/basic/error.md

@@ -22,24 +22,33 @@
 
 根据 IEEE 754 的规定，存在 2 类特殊浮点数：
 
-**Inf（Infinite/无穷）**：包括正无穷 `Inf` 和负无穷 `-Inf`。它在部分运算中有奇怪的表现
+无穷 **Inf**（infinity）：包括正无穷 `Inf` 和负无穷 `-Inf`。它在部分运算中有奇怪的表现
 ```julia-repl
-julia> 1/0
+julia> 1 / 0
 Inf
 
-julia> Inf*2
+julia> Inf * 2
 Inf
 
-julia> Inf*Inf
+julia> Inf * Inf
+Inf
+
+julia> Inf * -Inf
+-Inf
+
+julia> log(Inf)
 Inf
 ```
 
-**NaN(Not-any-Number)**：运算中若有NaN则结果往往也是NaN
+“不是数” **NaN**（not-any-number）：运算中若有 `NaN` 则结果往往也是 `NaN`
 ```julia-repl
 julia> Inf*0
 NaN
 
-julia> Inf-Inf
+julia> Inf - Inf
+NaN
+
+julia> sin(NaN)
 NaN
 ```
 
@@ -58,7 +67,7 @@ false
 ## 高精度浮点数
 高精度浮点数的类型名为 `BigFloat`，也可以使用 `big(值)` 定义
 ```julia-repl
-julia> v=BigFloat(3.14;precision=64)
+julia> v = BigFloat(3.14; precision=64)
 3.14000000000000012434
 
 julia> sin(v)
@@ -76,7 +85,7 @@ julia> sin(v)
 julia> div(1.0, 9.0)
 0.0
 
-julia> 1.0%9.0
+julia> 1.0 % 9.0
 1.0
 ```
 
@@ -125,18 +134,18 @@ Julia 支持三种数值转换，它们在处理不精确转换上有所不同
 ### 除法函数
 | 函数 | 描述 |
 | --- | --- |
-| `div(x, y)`, `x÷y` | 截断除法；商向 0 近似 |
+| `div(x, y)`, `x ÷ y` | 截断除法；商向 0 近似 |
 | `fld(x, y)` | 向下取整除法；商向负无穷近似 |
 | `cld(x, y)` | 向上取整除法；商向正无穷近似 |
-| `rem(x, y)` | 取余；满足 `x = div(x,y)*y + rem(x,y)`；符号与 `x` 一致 |
-| `mod(x, y)` | 取模；满足 `x = fld(x,y)*y + mod(x,y)`；符号与 `y` 一致 |
+| `rem(x, y)` | 取余；满足 `x = div(x, y)*y + rem(x,y)`；符号与 `x` 一致 |
+| `mod(x, y)` | 取模；满足 `x = fld(x, y)*y + mod(x,y)`；符号与 `y` 一致 |
 | `mod1(x, y)` | 偏移 1 的 mod；若 `y` 大于 0，则返回 `r∈(0,y]`；若 `y` 小于 0，则 `r∈[y,0)` 且满足 `mod(r, y) = mod(x, y)` |
 | `mod2pi(x)` | 对 $2\pi$ 取模 |
 | `divrem(x, y)` | 返回 `(div(x, y), rem(x, y))` |
 | `fldmod(x, y)` | 返回 `(fld(x, y), mod(x, y))` |
 
 ```julia-repl
-julia> divrem(13,3)
+julia> divrem(13, 3)
 (4, 1)
 ```
 
@@ -158,7 +167,7 @@ julia> divrem(13,3)
 | `hypot(x, y)` | $\sqrt{x^2+y^2}$ |
 | `exp(x)` | 自然指数函数在 x 处的值 |
 | `expm1(x)` | 当 x 接近 0 时的 $\exp{x}-1$ 的精确值 |
-| `ldexp(x, n)` | `x*2^n` 的高效算法，n 为整数 |
+| `ldexp(x, n)` | $x \times 2^n$ 的高效算法，n 为整数 |
 | `log(x)` | x 的自然对数 |
 | `log(b, x)` | 以 b 为底 x 的对数 |
 | `log2(x)` | 以 2 为底 x 的对数 |
@@ -190,11 +199,11 @@ asind  acosd  atand  acotd  asecd  acscd
 ### 杂项
 | 函数 | 描述 |
 | --- | --- |
-| `sum(x,y...)` | 和 |
-| `max(x,y...)` | 最大值 |
-| `min(x,y...)` | 最小值 |
-| `gcd(x,y...)` | 最大公约数，只接受整数 |
-| `lcm(x,y...)` | 最小公倍数，只接受整数 |
+| `sum(x, y...)` | 和 |
+| `max(x, y...)` | 最大值 |
+| `min(x, y...)` | 最小值 |
+| `gcd(x, y...)` | 最大公约数，只接受整数 |
+| `lcm(x, y...)` | 最小公倍数，只接受整数 |
 
 ### 特殊函数
 [特殊数学函数 - SpecialFunctions](../packages/specialfunctions.md)

docs/basic/float.md

@@ -5,7 +5,7 @@
 
 ## 注释
 注释通常是一种解释性文本（即给人读的），它们不会被解释器运行。
-你可以打开 [REPL](setup_environment.md#简单测试)，然后尝试以下操作：
+你可以打开 [REPL](setup_environment.md#运行%20REPL)，然后尝试以下操作：
 ```julia-repl
 julia> # 以 '#' 开头的是单行注释
 
@@ -18,6 +18,9 @@ julia> # 如果你发现除了新的一行以外什么都没显示，说明您
 
 ```
 
+!!! tips
+	如果你有一段代码暂时不用，但觉得以后可能用到/扔了可惜，可以把它用多行注释注释掉
+
 ## 输出
 为了让你得到系统性的概念，之后的几章理论内容偏多。因此，你有必要先了解点东西：
 ```julia-repl
@@ -37,7 +40,7 @@ Hello, world!
 是的，Julia 的自带 REPL 中没有 Python IDLE 那样的高级文件功能。
 因此，如果想一次运行多行代码，你可以
 * 使用高级编辑器
-* [如何运行文件里的代码](setup_environment.md#命令行选项)
+* [运行文件里的代码](setup_environment.md#运行文件)
 * 这样
  	```julia-repl
 	julia> begin
@@ -48,9 +51,6 @@ Hello, world!
 	2
 	```
 
-!!! tips
-	如果你有一段代码暂时不用，但觉得以后可能用到/扔了可惜，可以把它用多行注释注释掉
-
 ## 练习
 - 已知某行代码以 `#` 开头，试找到在该行中写会被运行的代码的方法。
 - 使用代码输出「这句话」

docs/basic/hello.md

@@ -1,13 +1,13 @@
 # 变量简介
-Julia 有丰富的**变量（variable）**类型，包括但不限于整数、浮点数、字符串、指针。它也是一种弱类型语言，允许同一变量前后的类型不同。
+Julia 有丰富的**变量**（variable）类型，包括但不限于整数、浮点数、字符串、指针。它也是一种弱类型语言，允许同一变量前后的类型不同。
 
 等等，你是不是想问“变量”是什么？
 简单来说，变量是使用一个名称（称为“变量名”）与一个值进行绑定。
 这个变量名所代表的值是可变的，即在一段代码前后绑定的值可以不同。
 
 可以在 REPL 中尝试以下示例：
 
-变量的**初始化（initialize）**与**赋值（assign）**。
+变量的**初始化**（initialize）与**赋值**（assign）。
 ```julia-repl
 julia> v = 1
 1
@@ -105,8 +105,9 @@ ERROR: cannot assign a value to variable Base.cos from module Main
 	* 会对参数进行更改的函数使用`!`结尾
 
 ## 常量
-**常量（constant）**是程序中原则上值不能被改变的量。
-它可以被用于指示「圆周率」这种固定的值，或者「你程序的默认标题」这种运行时不会去改变的量。
+**常量**（constant）是程序中原则上值不能被改变的量。这可能包括
+* 「圆周率」这种固定的值
+* 「你程序的默认标题」这种运行时不会去改变、被多次使用的值
 
 你可以在变量名前加 `const ` 来表示常量。
 ```julia-repl