enum ruby_basic_operators {
    BOP_PLUS,      // +
    BOP_MINUS,     // -
    BOP_MULT,      // *
    BOP_DIV,       // /
    BOP_MOD,       // %
    BOP_EQ,        // ==
    BOP_EQQ,       // ===
    BOP_LT,        // <
    BOP_LE,        // <=
    BOP_LTLT,      // <<
    BOP_AREF,      // []
    BOP_ASET,      // []=
    BOP_LENGTH,    // .length
    BOP_SIZE,      // .size
    BOP_EMPTY_P,   // .empty?
    BOP_NIL_P,     // .nil?
    // ... 共30多種基本運算符
};

#define INTEGER_REDEFINED_OP_FLAG (1 << 0)
#define FLOAT_REDEFINED_OP_FLAG   (1 << 1)
#define STRING_REDEFINED_OP_FLAG  (1 << 2)
#define ARRAY_REDEFINED_OP_FLAG   (1 << 3)
// ... 其他類型標(biāo)志

VALUE vm_opt_plus(VALUE recv, VALUE obj) {
    if (FIXNUM_2_P(recv, obj) &&
        BASIC_OP_UNREDEFINED_P(BOP_PLUS, INTEGER_REDEFINED_OP_FLAG)) {
        // 快速整數(shù)加法路徑
        return rb_fix_plus_fix(recv, obj);
    }
    else if (FLONUM_2_P(recv, obj) &&
             BASIC_OP_UNREDEFINED_P(BOP_PLUS, FLOAT_REDEFINED_OP_FLAG)) {
        // 快速浮點數(shù)加法路徑  
        return rb_float_plus(recv, obj);
    }
    else {
        // 回退到普通方法調(diào)用
        return rb_funcall(recv, '+', 1, obj);
    }
}

class Vector
  attr_reader :x, :y
  
  def initialize(x, y)
    @x = x
    @y = y
  end
  
  def +(other)
    # 類型檢查確保安全
    raise TypeError unless other.is_a?(Vector)
    Vector.new(@x + other.x, @y + other.y)
  end
  
  def *(scalar)
    # 支持標(biāo)量乘法
    raise TypeError unless scalar.is_a?(Numeric)
    Vector.new(@x * scalar, @y * scalar)
  end
  
  def ==(other)
    # 相等性判斷
    other.is_a?(Vector) && @x == other.x && @y == other.y
  end
  
  def coerce(other)
    # 支持反向操作：數(shù)字 * 向量
    [self, other] if other.is_a?(Numeric)
  end
end

# 使用示例
v1 = Vector.new(1, 2)
v2 = Vector.new(3, 4)
v3 = v1 + v2       # => Vector(4, 6)
v4 = v1 * 2        # => Vector(2, 4)
v5 = 2 * v1        # => Vector(2, 4) - 感謝coerce!

class Version
  include Comparable
  
  attr_reader :major, :minor, :patch
  
  def initialize(version_string)
    @major, @minor, @patch = version_string.split('.').map(&:to_i)
  end
  
  def <=>(other)
    return nil unless other.is_a?(Version)
    
    # 逐級比較版本號
    comparison = major <=> other.major
    return comparison unless comparison == 0
    
    comparison = minor <=> other.minor  
    return comparison unless comparison == 0
    
    patch <=> other.patch
  end
  
  def hash
    # 用于Hash鍵值，確保相等對象有相同hash
    [major, minor, patch].hash
  end
  
  def eql?(other)
    # 嚴(yán)格的相等性判斷
    self == other
  end
end

# 傳統(tǒng)方式 - 容易產(chǎn)生NoMethodError
user = find_user(id)
name = user && user.profile && user.profile.name

# 安全導(dǎo)航方式 - 優(yōu)雅且安全
name = find_user(id)&.profile&.name

# 實現(xiàn)原理：編譯器轉(zhuǎn)換為條件方法調(diào)用
# user&.profile 編譯為: (user.nil? ? nil : user.profile)

# Case語句中的隱式使用
case value
when /regex/    # 調(diào)用: /regex/ === value
when (1..10)    # 調(diào)用: (1..10) === value  
when String     # 調(diào)用: String === value
end

# 自定義===實現(xiàn)
class EmailMatcher
  def initialize(domain)
    @domain = domain
  end
  
  def ===(other)
    other.is_a?(String) && other.end_with?("@#{@domain}")
  end
end

gmail_matcher = EmailMatcher.new('gmail.com')
case email
when gmail_matcher then puts "Gmail用戶"
end

# 錯誤示范：過度重載導(dǎo)致性能下降
class SlowVector
  def +(other)
    # 每次調(diào)用都進(jìn)行復(fù)雜的類型檢查
    if other.is_a?(Numeric)
      # 處理標(biāo)量
    elsif other.is_a?(Array) 
      # 處理數(shù)組
    elsif other.is_a?(Vector)
      # 處理向量
    else
      raise TypeError
    end
  end
end

# 正確做法：明確接口，減少運行時判斷
class FastVector
  def add_vector(other)
    # 專門處理向量加法
  end
  
  def multiply_scalar(scalar)
    # 專門處理標(biāo)量乘法
  end
end

// JIT編譯器會檢測熱點運算符調(diào)用
if (body->jit_entry == NULL && rb_yjit_enabled_p) {
    body->jit_entry_calls++;
    if (rb_yjit_threshold_hit(iseq, body->jit_entry_calls)) {
        rb_yjit_compile_iseq(iseq, ec, false); // 編譯優(yōu)化
    }
}

class MemoryEfficient
  def +(other)
    # 避免創(chuàng)建臨時對象
    result = self.class.new
    # 直接修改內(nèi)部狀態(tài)
    result.initialize_copy(self)
    result.internal_add(other)
    result
  end
  
  def ==(other)
    # 快速路徑：先檢查對象標(biāo)識
    return true if equal?(other)
    # 然后檢查類型和內(nèi)容
    other.is_a?(self.class) && content_equal?(other)
  end
end

# 問題：浮點數(shù)運算精度誤差
0.1 + 0.2 == 0.3 # => false

# 解決方案：使用Rational或精度比較
(0.1r + 0.2r) == 0.3r # => true
# 或使用誤差范圍比較
(0.1 + 0.2 - 0.3).abs < 1e-10 # => true

# 問題：運算符修改了接收者
class Mutable
  attr_accessor :value
  
  def +(other)
    @value += other.value # 錯誤：修改了self
    self
  end
end

# 正確：返回新對象
def +(other)
  result = self.class.new
  result.value = @value + other.value
  result
end

# 實現(xiàn)對稱的運算符
class Symmetric
  def ==(other)
    # 處理 nil 和其他類型
    return false if other.nil?
    return true if equal?(other)
    return false unless other.is_a?(self.class)
    # 內(nèi)容比較
  end
  
  def eql?(other)
    # 用于Hash的嚴(yán)格相等
    self == other
  end
  
  def hash
    # 確保相等對象有相同hash值
  end
end