多重派发 #

struct Cat end
struct Dog end

speak(::Cat) = "Meow!"
speak(::Dog) = "Woof!"
speak(::Cat, ::Dog) = "Cat hisses at Dog!"
speak(::Dog, ::Cat) = "Dog barks at Cat!"

speak(Cat())
speak(Dog())
speak(Cat(), Dog())
speak(Dog(), Cat())

function collide(a, b)
    "Generic collision"
end

function collide(a::Int, b)
    "Int collides with something"
end

function collide(a, b::Int)
    "Something collides with Int"
end

function collide(a::Int, b::Int)
    "Int collides with Int"
end

collide(1, "hello")
collide("hello", 1)
collide(1, 2)
collide("hello", "world")

abstract type Animal end
struct Cat <: Animal end
struct Dog <: Animal end

function meet(a::Animal, b::Animal)
    "Animals meet"
end

function meet(a::Cat, b::Animal)
    "Cat meets animal"
end

function meet(a::Animal, b::Dog)
    "Animal meets dog"
end

function meet(a::Cat, b::Dog)
    "Cat meets dog"
end

meet(Cat(), Dog())
meet(Cat(), Cat())
meet(Dog(), Dog())

function multiply(a::Int, b::Int)
    a * b
end

function multiply(a::Float64, b::Float64)
    a * b
end

function multiply(a::Int, b::Float64)
    a * b
end

function multiply(a::Float64, b::Int)
    a * b
end

multiply(2, 3)
multiply(2.0, 3.0)
multiply(2, 3.0)
multiply(2.0, 3)

abstract type Shape end
struct Circle <: Shape
    radius::Float64
end
struct Rectangle <: Shape
    width::Float64
    height::Float64
end

function draw(shape::Shape)
    error("Cannot draw generic shape")
end

function draw(c::Circle)
    println("Drawing circle with radius $(c.radius)")
end

function draw(r::Rectangle)
    println("Drawing rectangle $(r.width)×$(r.height)")
end

function draw(s1::Shape, s2::Shape)
    println("Drawing two shapes")
    draw(s1)
    draw(s2)
end

draw(Circle(5.0))
draw(Rectangle(3.0, 4.0))
draw(Circle(2.0), Rectangle(3.0, 4.0))

function serialize(x::Int)
    "int:$x"
end

function serialize(x::Float64)
    "float:$x"
end

function serialize(x::String)
    "string:$x"
end

function serialize(arr::Vector)
    "array:[" * join(serialize.(arr), ",") * "]"
end

serialize(42)
serialize(3.14)
serialize("hello")
serialize([1, 2, 3])

function f(x::Int, y)
    println("Method 1")
end

function f(x, y::Int)
    println("Method 2")
end

f(1, 1)

function f(x::Int, y::Int)
    println("Method 3")
end

f(1, 1)

abstract type GameObject end
struct Player <: GameObject
    name::String
end
struct Enemy <: GameObject
    name::String
end
struct Wall <: GameObject end

function interact(a::GameObject, b::GameObject)
    "Generic interaction"
end

function interact(p::Player, e::Enemy)
    "$(p.name) fights $(e.name)"
end

function interact(e::Enemy, p::Player)
    "$(e.name) attacks $(p.name)"
end

function interact(::Player, ::Wall)
    "Player cannot pass through wall"
end

function interact(::Enemy, ::Wall)
    "Enemy blocked by wall"
end

interact(Player("Hero"), Enemy("Goblin"))
interact(Enemy("Goblin"), Player("Hero"))
interact(Player("Hero"), Wall())

function add(a::Number, b::Number)
    a + b
end

function add(a::Vector, b::Vector)
    a .+ b
end

function add(a::Matrix, b::Matrix)
    a + b
end

function add(a::String, b::String)
    a * b
end

add(1, 2)
add([1, 2], [3, 4])
add([1 2; 3 4], [5 6; 7 8])
add("Hello, ", "Julia!")

function format(x)
    string(x)
end

function format(x::Float64)
    @sprintf("%.2f", x)
end

function format(x::Int)
    string(x)
end

function format(arr::Vector)
    "[" * join(format.(arr), ", ") * "]"
end

function format(d::Dict)
    "{" * join(["$k => $(format(v))" for (k, v) in d], ", ") * "}"
end

using Printf
format(3.14159)
format([1, 2.5, 3])
format(Dict("a" => 1, "b" => 2.5))