# typeof — 获取值的类型
typeof(42)           # Int64
typeof(3.14)         # Float64
typeof("hello")      # String
typeof([1, 2, 3])    # Vector{Int64}
typeof(sin)          # typeof(sin)（内置函数类型）

# isa — 检查值是否属于某个类型
isa(42, Int)         # true
isa(42, Number)      # true（Number 是 Int 的祖先）
isa(42, Float64)     # false
isa(42, Any)         # true（所有值都是 Any）

# 中缀形式
42 isa Int           # true
42 isa Number        # true

# 类型检查
isconcretetype(Int64)    # true（具体类型）
isconcretetype(Number)   # false（抽象类型）
isconcretetype(Array)    # false（参数未指定）
isconcretetype(Vector{Int}) # true（参数已指定）

# 类型关系
supertype(Int64)          # Signed
supertype(Signed)         # Integer
supertype(Integer)        # Real
supertype(Real)           # Number
supertype(Number)         # Any

subtypes(Integer)         # [Signed, Unsigned, Bool]
subtypes(Real)            # [AbstractFloat, AbstractIrrational, Integer, Rational]

# 变量类型注解
x::Int = 42
x::Int = 3.14    # InexactError: 不能将 Float64 转为 Int

# 函数参数类型注解
function add(a::Int, b::Int)
    return a + b
end

add(1, 2)       # 3
# add(1.0, 2.0) # MethodError

# 结构体字段类型注解
struct Person
    name::String
    age::Int
end

# 断言表达式的类型
x = 42
x::Int           # 42（通过）
# x::Float64     # TypeError

# 在函数中断言返回值
function safe_divide(a, b)
    result = a / b
    return result::Float64
end

# Union 表示"或"关系
IntOrString = Union{Int, String}

x::IntOrString = 42      # OK
x::IntOrString = "hello" # OK
# x::IntOrString = 3.14  # TypeError

# 内置的 Union 类型
Union{Int, Nothing}      # 可空整数
Union{String, Missing}   # 可缺失字符串

# Union 类型的方法分发
function process(x::Union{Int, String})
    if x isa Int
        println("整数: $x")
    else
        println("字符串: $x")
    end
end

process(42)       # 整数: 42
process("hello")  # 字符串: hello

# nothing 是 Nothing 类型的单例
x = nothing
typeof(x)    # Nothing

# 常见用法：可选值
function find_first(predicate, collection)
    for item in collection
        predicate(item) && return item
    end
    return nothing    # 未找到
end

result = find_first(x -> x > 5, [1, 3, 7, 9])
if result !== nothing
    println("找到: $result")
end

# nothing 作为默认值
function greet(name=nothing)
    if name === nothing
        return "Hello, anonymous!"
    else
        return "Hello, $name!"
    end
end

# missing 是 Missing 类型的单例
x = missing
typeof(x)    # Missing

# 缺失值传播
missing + 1         # missing
missing * 0         # missing（注意：不等于 0）
sin(missing)        # missing
max(missing, 1)     # missing

# 检查缺失值
ismissing(missing)    # true
ismissing(nothing)    # false
ismissing(42)         # false

# 跳过缺失值
skipmissing([1, missing, 3, missing, 5]) |> collect    # [1, 3, 5]
sum(skipmissing([1, missing, 3]))    # 4
mean(skipmissing([1, missing, 3]))   # 2.0（需要 using Statistics）

# 替换缺失值
coalesce(missing, 0)         # 0（第一个非 missing 值）
coalesce(missing, missing, 3) # 3

# 参数化结构体
struct Point{T}
    x::T
    y::T
end

# 类型推断
p1 = Point(1, 2)           # Point{Int64}
p2 = Point(1.0, 2.0)       # Point{Float64}
p3 = Point{Float32}(1, 2)  # Point{Float32}

# 参数化函数
function midpoint(a::Point{T}, b::Point{T}) where T
    return Point((a.x + b.x) / 2, (a.y + b.y) / 2)
end

# 类型约束
function scale(p::Point{T}, factor::T) where T<:Real
    return Point(p.x * factor, p.y * factor)
end

# 多个类型参数
struct Pair{A, B}
    first::A
    second::B
end

Pair("name", 42)    # Pair{String, Int64}

# 数组是参数化类型
Vector{Int}        # = Array{Int, 1}
Matrix{Float64}    # = Array{Float64, 2}
Dict{String, Int}  # 键类型 String，值类型 Int

# 类型的类型
eltype([1, 2, 3])         # Int64
keytype(Dict("a" => 1))   # String
valtype(Dict("a" => 1))   # Int64

# <: 检查子类型关系
Int <: Integer          # true
Int <: Real             # true
Int <: Number           # true
Int <: Any              # true
Int <: Float64          # false

# 抽象类型比较
Float64 <: AbstractFloat # true
String <: AbstractString # true

# Union 类型
Int <: Union{Int, String}     # true
String <: Union{Int, String}  # true

# 复杂类型参数
Vector{Int} <: Vector{Number}   # false！（Julia 类型不变性）
Vector{Int} <: AbstractVector{Int}  # true

# 为什么 Vector{Int} <: Vector{Number} 是 false？
# 因为如果允许，就会出现：
v_int = [1, 2, 3]
v_num::Vector{Number} = v_int    # 假设允许
push!(v_num, 3.14)               # 3.14 被放入 v_int！类型安全被破坏

# Julia 的 JIT 编译器会推断表达式的类型
x = 1 + 2         # 编译器推断为 Int64
y = sin(3.14)      # 编译器推断为 Float64

# 类型稳定的函数
function stable_sum(xs)
    s = zero(eltype(xs))
    for x in xs
        s += x
    end
    return s
end

# 类型不稳定的函数（应避免）
function unstable_sum(xs)
    s = 0          # 这里 0 是 Int，但 xs 可能是 Float64
    for x in xs
        s += x     # 类型会变化！
    end    return s
end

# 类型不稳定的另一个例子
function unstable_get(d, key)
    if haskey(d, key)
        return d[key]    # 返回具体类型
    else
        return nothing   # 返回 Nothing
    end
    # 返回类型是 Union{T, Nothing}，类型不稳定
end

# 类型稳定的函数
function stable_example(x)
    return x * 2 + 1
end

@code_warntype stable_example(42)
# 输出中 Body 应显示为 Int64（红色标注的为问题类型）

# 类型不稳定的函数
function unstable_example(x)
    if x > 0
        return x        # Int
    else
        return "negative"  # String
    end
end

@code_warntype unstable_example(42)
# 输出中 Body 显示为 Union{Int64, String}（标红 = 不稳定）

# 关注 Body 行的颜色：
# - 绿色/白色：类型稳定（好）
# - 红色：类型不稳定（需要优化）

# 关键标识：
# - Int64 / Float64：具体类型（好）
# - Any：完全未知（最差）
# - Union{...}：联合类型（需注意）
# - ::Int64：类型注解（好）

# ❌ 避免：抽象类型字段
struct BadExample
    data::Number       # 抽象类型，性能差
end

# ✅ 推荐：参数化具体类型
struct GoodExample{T<:Number}
    data::T            # 具体类型，性能好
end

# ✅ 不可变类型（性能好）
struct ImmutablePoint
    x::Float64
    y::Float64
end

# ❌ 除非需要修改字段
mutable struct MutablePoint
    x::Float64
    y::Float64
end

# ❌ 避免
data::Any

# ✅ 推荐：更精确的类型
data::Union{Int, String, Nothing}
data::Union{Vector{Int}, Nothing}

# ✅ 确保函数的所有分支返回相同类型
function safe_sqrt(x::Float64)::Float64
    if x >= 0
        return sqrt(x)
    else
        return NaN    # 返回 Float64，不是抛异常
    end
end

# ✅ 使用 Val 进行编译期分发
function compute(::Val{:fast}, x)
    return x * 2
end

function compute(::Val{:accurate}, x)
    return x * 2.0
end

compute(Val(:fast), 5)      # 10
compute(Val(:accurate), 5)  # 10.0

# ✅ 明确的可选值设计
function find_user(id::Int)::Union{User, Nothing}
    # ...
end

# ✅ 使用 coalesce 提供默认值
user = coalesce(find_user(1), default_user)

# ✅ 使用 something（非 nothing 默认值）
config = something(user_config, default_config)

struct DatabaseConfig
    host::String
    port::Int
    name::String
    pool_size::Int
end

struct RedisConfig
    host::String
    port::Int
    db::Int
end

struct AppConfig
    database::DatabaseConfig
    redis::Union{RedisConfig, Nothing}    # Redis 可选
    debug::Bool
    max_workers::Int
end

# 类型安全的构造
function load_config(;
    db_host="localhost", db_port=5432, db_name="app",
    redis_host=nothing, redis_port=6379, redis_db=0,
    debug=false, max_workers=4
)
    db = DatabaseConfig(db_host, db_port, db_name, 10)
    redis = redis_host !== nothing ? 
        RedisConfig(redis_host, redis_port, redis_db) : nothing
    return AppConfig(db, redis, debug, max_workers)
end

# 使用
cfg = load_config(db_host="192.168.1.100", redis_host="192.168.1.101")
cfg.database.host    # "192.168.1.100"
cfg.redis.host       # "192.168.1.101"
cfg.debug            # false