学到教学大纲这一步，你已经见过很多函数定义。通常，这些定义在 REPL 中展示时，并没有对输出做太多说明：
julia> f(x) = x^2
f (generic function with 1 method)
为什么会显示 "generic function with 1 method"？
假设我们想更具体地指定实参类型。
julia> f(x::Integer) = x^2
f (generic function with 2 methods)
julia> f(x::Real) = x^2
f (generic function with 3 methods)
或者，我们也可以改变实参的个数：
julia> f(x, y) = x * y
f (generic function with 4 methods)
看来，同一个函数的这些新定义被称为“方法”。方法会被加到一个列表里，而不是覆盖旧的定义。
我们可以很方便地列出这些方法：
julia> methods(f) # output edited for brevity
# 4 methods for generic function "f" from Main:
[1] f(x, y)
[2] f(x::Integer)
[3] f(x::Real)
[4] f(x)
当我们调用函数f时，Julia 能以某种方式知道该用哪个方法：
julia> f(2.5) # Float64
6.25
julia> f(2) # Int64
4
julia> f(2, 3) # Int64, Int64
6
什么是函数？
根据手册，函数是一种对象，它把实参组成的元组映射为一个返回值。
我们通常会把f(2, 3)中的函数实参看作两个独立的东西，但编译器把它们看作一个元组。即使只有一个实参也是如此（不过需要加一个逗号才能看得更清楚）：
julia> typeof( (2, 3) )
Tuple{Int64, Int64}
julia> typeof( (2,) )
Tuple{Int64}
把函数看作一个黑箱，我们可以说进去的是一个元组，出来的是一个返回值。更正式地说，元组被_映射_为返回值。
函数如何处理不同数量和类型的实参？
这通常被称为“多态”。
几十年来，这一直是计算机科学中的一个重要课题，也出现了各种不同的处理方式。
Julia 的做法很不寻常，但并非独此一家。
- 函数是“泛型”的，也就是说一个函数可以挂载多个方法。
- 在挂上方法之前，函数只是一个名字。
- 方法可以按需添加，数量可能很大（目前
+运算符就是一个拥有 161 个方法的函数）。
- 调用函数时，Julia 会检查调用签名：实参的个数以及每个实参当前的类型。
- 类型与调用签名最匹配的方法会被选中。
- 一般来说，实参个数必须完全一致（不过 splat/slurp 运算符
...可以部分绕过这一限制）。
- 类型与调用签名完全匹配的方法优先。
- 必要时，Julia 会查看调用签名中每个实参的父类型，以找到匹配最接近、最具体的方法。
- 被选中的方法会带着给定的实参被
dispatched，并返回结果。
- 如果没有找到合适的方法，就会抛出一个
MethodError。
注意，Julia 是动态类型的，因此方法分派发生在_运行期_。
多重分派：一个例子
上一节文字很多，下面我们把这些想法变成代码。为简单起见，下面的函数都只有一个实参，但拥有几十个实参的函数并不少见（比如绘图包或机器学习中的函数）。
先定义几个自定义类型，用来表示几何图形。
julia> abstract type Shape end
julia> struct Circle <: Shape
radius::Float64
end
julia> struct Square <: Shape
side::Float64
end
julia> struct Rectangle <: Shape
length::Float64
width::Float64
end
接下来，我们可以定义计算各种图形面积的方法。每个方法都接收一个实参，而且各自接收的都是不同的具体用户自定义类型。
julia> area(c::Circle) = π * c.radius^2
area (generic function with 1 method)
julia> area(s::Square) = s.side^2
area (generic function with 2 methods)
julia> area(r::Rectangle) = r.length * r.width
area (generic function with 3 methods)
现在我们可以创建一些图形并计算面积，依靠 Julia 的分派机制为每个图形选用正确的公式。
julia> circle = Circle(2.3)
Circle(2.3)
julia> area(circle) # call signature Tuple{Circle}
16.619025137490002
julia> square = Square(1.6)
Square(1.6)
julia> area(square) # call signature Tuple{Square}
2.5600000000000005
julia> rectangle = Rectangle(1.4, 2.1)
Rectangle(1.4, 2.1)
julia> area(rectangle) # call signature Tuple{Rectangle}
2.94
参数化方法
方法签名可以接受占位的类型值，方式和参数化类型大致相同。
这种语法很有特点，需要用到where子句：
julia> same_type(v::Vector{T}, x::T) where {T} = true
same_type (generic function with 1 method)
julia> same_type([1, 2], 3)
true
julia> same_type([1, 2], "three")
ERROR: MethodError: no method matching same_type(::Vector{Int64}, ::String)
上面的例子要求两个实参使用同一个类型T，无论T具体是什么。
我们可以给T加上约束，让它更具体：
julia> same_type(v::Vector{T}, x::T) where {T<:Number} = true
same_type (generic function with 2 methods)
有了这个方法，只有完全相同的数值类型才会返回true。
也可以有多个占位变量，在where子句中用逗号分隔。
julia> myfunc(a::S, b::T) where {S, T} = true
myfunc (generic function with 1 method)
总结
多重分派在 Julia 中非常灵活、性能也很高，因此被广泛使用。
正如+拥有 161 个方法这个例子所示，Julia 程序员会力求让方法所指定的类型尽量窄。在字节码层面，两个整数相加与两个浮点数相加差别很大，而整数与浮点数相加还会多出类型提升这一层复杂性。
类型越具体，编译器能做的优化就越多：在 Exercism 的小练习里这无关紧要，但在 Julia 所擅长的大型数值模拟中，这对性能至关重要。
如果你知道一个方法会接收到什么输入，请告诉编译器！
学习练习
