数据类型抽象：从接口到代数数据类型

if (obj instanceof String) {
    // 处理字符串
} else if (obj instanceof Integer) {
    // 处理整数
} else if (obj instanceof Double) {
    // 处理浮点数
}

def calculate_area(shape):
    if isinstance(shape, Circle):
        return 3.14159 * shape.radius ** 2
    elif isinstance(shape, Rectangle):
        return shape.width * shape.height
    elif isinstance(shape, Triangle):
        return 0.5 * shape.base * shape.height
    # 如果新增了Square类型，这里很容易遗漏！

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self) -> float:
        pass

class Circle(Shape):
    def __init__(self, radius: float):
        self.radius = radius

    def area(self) -> float:
        return 3.14159 * self.radius ** 2

class Rectangle(Shape):
    def __init__(self, width: float, height: float):
        self.width = width
        self.height = height

    def area(self) -> float:
        return self.width * self.height

# 现在可以统一处理所有形状，不需要instanceof
def calculate_total_area(shapes: list[Shape]) -> float:
    return sum(shape.area() for shape in shapes)

// 定义一个支付处理器的接口
interface PaymentProcessor {
    boolean processPayment(Payment payment);
    void refundPayment(String transactionId);
    PaymentStatus getPaymentStatus(String transactionId);
}

// 不同的实现方式
class CreditCardProcessor implements PaymentProcessor {
    public boolean processPayment(Payment payment) {
        // 信用卡支付逻辑
        return validateCard(payment) && chargeCard(payment);
    }

    public void refundPayment(String transactionId) {
        // 信用卡退款逻辑
        refundToCard(transactionId);
    }

    public PaymentStatus getPaymentStatus(String transactionId) {
        // 查询信用卡支付状态
        return queryCardStatus(transactionId);
    }
}

class PayPalProcessor implements PaymentProcessor {
    public boolean processPayment(Payment payment) {
        // PayPal支付逻辑
        return authenticateWithPayPal(payment) && executePayment(payment);
    }

    public void refundPayment(String transactionId) {
        // PayPal退款逻辑
        refundViaPayPal(transactionId);
    }

    public PaymentStatus getPaymentStatus(String transactionId) {
        // 查询PayPal支付状态
        return queryPayPalStatus(transactionId);
    }
}

// 使用接口的代码，不关心具体实现
class PaymentService {
    private PaymentProcessor processor;

    public PaymentService(PaymentProcessor processor) {
        this.processor = processor; // 依赖注入
    }

    public boolean handlePayment(Payment payment) {
        return processor.processPayment(payment);
    }
}

interface Renderer {
    void render(Document doc);
}

class HtmlRenderer implements Renderer {
    public void render(Document doc) { /* ... */ }
}

interface Repository<T> {
    void save(T entity);
    Optional<T> findById(UUID id);
}

template <typename T>
T clamp(T value, T min, T max) {
    if (value < min) return min;
    if (value > max) return max;
    return value;
}

// 使用示例
int x = clamp(42, 0, 100);        // T = int
double y = clamp(3.14, 0.0, 1.0); // T = double

// 编译期计算：模板元编程
template <int N>
struct Factorial {
    static constexpr int value = N * Factorial<N - 1>::value;
};

template <>
struct Factorial<0> {
    static constexpr int value = 1;
};

// 使用：Factorial<5>::value 在编译时计算为 120

template <typename T>
class Vector {
private:
    T* data;
    size_t size;
    size_t capacity;

public:
    Vector() : data(nullptr), size(0), capacity(0) {}

    void push_back(const T& value) {
        if (size >= capacity) {
            resize(capacity == 0 ? 1 : capacity * 2);
        }
        data[size++] = value;
    }

    T& operator[](size_t index) { return data[index]; }
    const T& operator[](size_t index) const { return data[index]; }

    size_t getSize() const { return size; }

private:
    void resize(size_t new_capacity) {
        T* new_data = new T[new_capacity];
        for (size_t i = 0; i < size; ++i) {
            new_data[i] = data[i];
        }
        delete[] data;
        data = new_data;
        capacity = new_capacity;
    }
};

// 不同的T生成完全不同的类
Vector<int> intVector;        // 生成 Vector<int>
Vector<std::string> strVector; // 生成 Vector<std::string>

template <typename T>
class StringConverter {
public:
    static std::string toString(const T& value) {
        return std::to_string(value);
    }
};

// 为std::string特化
template <>
class StringConverter<std::string> {
public:
    static std::string toString(const std::string& value) {
        return value;
    }
};

// 为指针特化
template <typename T>
class StringConverter<T*> {
public:
    static std::string toString(T* ptr) {
        return ptr ? "0x" + std::to_string(reinterpret_cast<uintptr_t>(ptr)) : "nullptr";
    }
};

template <typename T>
concept Numeric = std::is_integral_v<T> || std::is_floating_point_v<T>;

template <Numeric T>
T add(T a, T b) {
    return a + b;
}

// 使用
add(3, 4);        // 正确：int是Numeric
add(3.5, 2.1);    // 正确：double是Numeric
add("hello", "world"); // 错误：string不是Numeric

// Java的Comparator接口
public interface Comparator<T> {
    int compare(T o1, T o2);
    boolean equals(Object obj);

    // 默认方法（Java 8+）
    default Comparator<T> reversed() {
        return Collections.reverseOrder(this);
    }

    default Comparator<T> thenComparing(Comparator<? super T> other) {
        return (c1, c2) -> {
            int res = compare(c1, c2);
            return (res != 0) ? res : other.compare(c1, c2);
        };
    }
}

// 具体实现
class StudentComparator implements Comparator<Student> {
    @Override
    public int compare(Student s1, Student s2) {
        return Integer.compare(s1.getGrade(), s2.getGrade());
    }
}

// 使用
List<Student> students = ...;
students.sort(new StudentComparator());

// C++传统方式：抽象基类
template <typename T>
class Comparator {
public:
    virtual ~Comparator() = default;
    virtual int compare(const T& a, const T& b) const = 0;
};

class StudentComparator : public Comparator<Student> {
public:
    int compare(const Student& a, const Student& b) const override {
        return a.getGrade() < b.getGrade() ? -1 :
               a.getGrade() > b.getGrade() ? 1 : 0;
    }
};

// 现代C++：Concepts（C++20）
template <typename T>
concept Comparable = requires(const T& a, const T& b) {
    { a < b } -> std::convertible_to<bool>;
    { a > b } -> std::convertible_to<bool>;
    { a == b } -> std::convertible_to<bool>;
};

// 基于Concepts的排序函数
template <typename T, typename Comp>
requires requires(const Comp& comp, const T& a, const T& b) {
    { comp(a, b) } -> std::convertible_to<int>;
}
void sort(T begin, T end, Comp comparator) {
    // 实现排序逻辑
}

// Java函数式接口
@FunctionalInterface
public interface EqualityChecker<T> {
    boolean areEqual(T a, T b);

    // 组合操作
    default EqualityChecker<T> and(EqualityChecker<? super T> other) {
        return (a, b) -> areEqual(a, b) && other.areEqual(a, b);
    }

    default EqualityChecker<T> or(EqualityChecker<? super T> other) {
        return (a, b) -> areEqual(a, b) || other.areEqual(a, b);
    }

    default EqualityChecker<T> negate() {
        return (a, b) -> !areEqual(a, b);
    }
}

// 使用示例
class Person {
    private String name;
    private int age;

    // 静态工厂方法
    public static EqualityChecker<Person> byName() {
        return (p1, p2) -> p1.name.equals(p2.name);
    }

    public static EqualityChecker<Person> byAge() {
        return (p1, p2) -> p1.age == p2.age;
    }

    public static EqualityChecker<Person> byNameAndAge() {
        return byName().and(byAge());
    }
}

// C++传统方式：函数对象
template <typename T>
struct EqualityChecker {
    virtual bool operator()(const T& a, const T& b) const = 0;
    virtual ~EqualityChecker() = default;
};

// 具体实现
struct PersonNameEquality : EqualityChecker<Person> {
    bool operator()(const Person& a, const Person& b) const override {
        return a.getName() == b.getName();
    }
};

// 现代C++：lambda和Concepts
template <typename T>
concept EqualityCheckable = requires(const T& a, const T& b) {
    { a == b } -> std::convertible_to<bool>;
};

// 组合操作的实现
template <typename T, typename F1, typename F2>
class AndEquality : public EqualityChecker<T> {
    F1 f1;
    F2 f2;
public:
    AndEquality(F1 f1, F2 f2) : f1(f1), f2(f2) {}

    bool operator()(const T& a, const T& b) const override {
        return f1(a, b) && f2(a, b);
    }
};

// 工厂函数
template <typename T, typename F1, typename F2>
auto make_and_equality(F1 f1, F2 f2) {
    return AndEquality<T, F1, F2>(f1, f2);
}

// 使用lambda的现代化方式
auto personByNameEquality = [](const Person& a, const Person& b) {
    return a.getName() == b.getName();
};

auto personByAgeEquality = [](const Person& a, const Person& b) {
    return a.getAge() == b.getAge();
};

auto personByNameAndAge = make_and_equality<Person>(
    personByNameEquality, personByAgeEquality
);

import java.math.BigDecimal

sealed interface PaymentCommand {
    val amount: BigDecimal
}

data class Charge(
    override val amount: BigDecimal,
    val cardToken: String
) : PaymentCommand

object RefundAll : PaymentCommand {
    override val amount = BigDecimal.ZERO
}

fun PaymentCommand.describe(): String = when (this) {
    is Charge -> "Charge ${amount} to card ${cardToken}"
    RefundAll -> "Refund all remaining balance"
}

// 使用示例
fun processCommands(commands: List<PaymentCommand>) {
    commands.forEach { command ->
        println(command.describe())
    }
}

import java.math.BigDecimal;

public sealed interface PaymentCommand {
    BigDecimal amount();

    // 处理方法
    default String describe() {
        return switch (this) {
            case Charge charge ->
                "Charge " + charge.amount() + " to card " + charge.cardToken();
            case RefundAll refundAll ->
                "Refund all remaining balance";
        };
    }
}

// 实现类必须在同一个文件中嵌套声明
public record Charge(BigDecimal amount, String cardToken)
    implements PaymentCommand {}

public final class RefundAll implements PaymentCommand {
    private static final RefundAll INSTANCE = new RefundAll();

    private RefundAll() {}

    public static RefundAll getInstance() {
        return INSTANCE;
    }

    @Override
    public BigDecimal amount() {
        return BigDecimal.ZERO;
    }
}

// 使用示例
public class PaymentProcessor {
    public void processCommands(List<PaymentCommand> commands) {
        commands.forEach(command -> {
            System.out.println(command.describe());
        });
    }
}

// 定义形状，不关心具体类型
interface Point2D {
  x: number;
  y: number;
}

interface Point3D {
  x: number;
  y: number;
  z: number;
}

// 任何具有x和y属性的对象都可以
function distance(p1: Point2D, p2: Point2D): number {
  return Math.sqrt((p1.x - p2.x) ** 2 + (p1.y - p2.y) ** 2);
}

// 结构类型让Point3D自动兼容Point2D
const point3d: Point3D = { x: 1, y: 2, z: 3 };
const point2d: Point2D = { x: 4, y: 5 };

console.log(distance(point3d, point2d)); // 完全合法！

// 支付命令的判别联合
type PaymentCommand =
  | { kind: "charge"; amount: number; cardToken: string }
  | { kind: "refund"; transactionId: string; amount: number }
  | { kind: "query"; transactionId: string };

// 穷尽性检查的类型安全处理
function processPayment(command: PaymentCommand): string {
  switch (command.kind) {
    case "charge":
      return `Charging $${command.amount} to card ${command.cardToken}`;
    case "refund":
      return `Refunding $${command.amount} for transaction ${command.transactionId}`;
    case "query":
      return `Querying status for transaction ${command.transactionId}`;
    default:
      // TypeScript会确保这里永远执行不到
      const _exhaustiveCheck: never = command;
      return _exhaustiveCheck;
  }
}

// 映射类型：基于现有类型创建新类型
type Optional<T> = {
  [P in keyof T]?: T[P];
};

type ReadOnly<T> = {
  readonly [P in keyof T]: T[P];
};

interface User {
  id: number;
  name: string;
  email: string;
}

type OptionalUser = Optional<User]; // 所有属性都变为可选
type ReadOnlyUser = ReadOnly<User>; // 所有属性都变为只读

// 类型保护函数
function isString(value: unknown): value is string {
  return typeof value === "string";
}

function processValue(value: unknown) {
  if (isString(value)) {
    // TypeScript知道这里是string类型
    console.log(value.toUpperCase());
  }

  // typeof收窄
  if (typeof value === "number") {
    console.log(value.toFixed(2));
  }

  // 实例收窄
  if (value instanceof Date) {
    console.log(value.toISOString());
  }
}

// 字面量类型收窄
type Status = "pending" | "processing" | "completed" | "failed";

function updateStatus(status: Status) {
  if (status === "completed") {
    // 只有"completed"能进入这个分支
    console.log("任务已完成！");
  }
}

// 带约束的泛型
interface Identifiable {
  id: string;
}

function findById<T extends Identifiable>(
  items: T[],
  id: string
): T | undefined {
  return items.find(item => item.id === id);
}

// 泛型默认值
interface Repository<T = any> {
  findById(id: string): Promise<T>;
  save(entity: T): Promise<void>;
  delete(id: string): Promise<boolean>;
}

// 键of泛型
function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}

const user = { id: "1", name: "张三", age: 25 };
const userName = getProperty(user, "name"); // 类型为string
const userAge = getProperty(user, "age");   // 类型为number

// 利用判别字段与 never 回退实现穷尽性检查
type PaymentCommand =
  | { kind: "charge"; amount: number; cardToken: string }
  | { kind: "refund"; transactionId: string; amount: number }
  | { kind: "query"; transactionId: string };

function assertNever(x: never): never {
  throw new Error("Unexpected object: " + x);
}

function processPayment(command: PaymentCommand): string {
  switch (command.kind) {
    case "charge":
      return `Charging $${command.amount} to card ${command.cardToken}`;
    case "refund":
      return `Refunding $${command.amount} for transaction ${command.transactionId}`;
    case "query":
      return `Querying status for transaction ${command.transactionId}`;
    default:
      // 如果遗漏了某个 kind，TypeScript 会报错：
      // Type 'string' is not assignable to type 'never'
      return assertNever(command);
  }
}

-- 定义基础类型
type Money = Double
type Text = String

-- 支付命令：和类型（OR关系）
data PaymentCommand
  = Charge { amount :: Money, cardToken :: Text }
  | Refund { transactionId :: Text, amount :: Money }
  | Query { transactionId :: Text }
  | RefundAll
  deriving (Show, Eq)

-- 用户：积类型（AND关系）
data User = User
  { userId      :: Int
  , userName    :: Text
  , userEmail   :: Text
  , userAge     :: Int
  , isActive    :: Bool
  } deriving (Show, Eq)

-- 递归数据类型：二叉树
data BinaryTree a
  = Leaf
  | Node (BinaryTree a) a (BinaryTree a)
  deriving (Show, Eq, Functor)

-- 处理支付命令，编译器会确保处理所有情况
processPayment :: PaymentCommand -> Text
processPayment (Charge amount cardToken) =
  "Charging " ++ show amount ++ " to card " ++ cardToken
processPayment (Refund transactionId amount) =
  "Refunding " ++ show amount ++ " for transaction " ++ transactionId
processPayment (Query transactionId) =
  "Querying status for transaction " ++ transactionId
processPayment RefundAll =
  "Refund all remaining balance"

-- 使用模式匹配处理递归数据类型
treeSum :: Num a => BinaryTree a -> a
treeSum Leaf = 0
treeSum (Node left value right) = treeSum left + value + treeSum right

-- 复杂的模式匹配
validateCommand :: PaymentCommand -> Either Text PaymentCommand
validateCommand cmd@(Charge amount _)
  | amount <= 0 = Left "Charge amount must be positive"
  | otherwise   = Right cmd
validateCommand cmd@(Refund _ amount)
  | amount < 0  = Left "Refund amount cannot be negative"
  | otherwise   = Right cmd
validateCommand cmd = Right cmd

-- 基础类型类：可比较
class Comparable a where
  compare :: a -> a -> Ordering
  (<), (>), (<=), (>=) :: a -> a -> Bool

  -- 默认实现
  x < y  = compare x y == LT
  x > y  = compare x y == GT
  x <= y = compare x y /= GT
  x >= y = compare x y /= LT

-- 为Int实例化
instance Comparable Int where
  compare x y | x == y    = EQ
              | x < y     = LT
              | otherwise = GT

-- 半群：结合性操作
class Semigroup a where
  (<>) :: a -> a -> a

-- 幺半群：带有单位元的半群
class Semigroup a => Monoid a where
  mempty :: a
  mappend :: a -> a -> a
  mappend = (<>)

-- 列表的幺半群实例
instance Semigroup [a] where
  (<>) = (++)

instance Monoid [a] where
  mempty = []

-- 数字的乘法幺半群
newtype Product a = Product { getProduct :: a }
  deriving (Show, Eq)

instance Num a => Semigroup (Product a) where
  (Product x) <> (Product y) = Product (x * y)

instance Num a => Monoid (Product a) where
  mempty = Product 1

-- 简单的验证类型类
class Validatable a where
  validate :: a -> Either Text a

-- 为PaymentCommand添加验证
instance Validatable PaymentCommand where
  validate (Charge amount _)
    | amount <= 0 = Left "Charge amount must be positive"
    | otherwise   = Right (Charge amount _)
  validate (Refund _ amount)
    | amount < 0  = Left "Refund amount cannot be negative"
    | otherwise   = Right (Refund _ amount)
  validate cmd = Right cmd

-- 使用验证
processValidatedCommand :: PaymentCommand -> Either Text Text
processValidatedCommand cmd = do
  validatedCmd <- validate cmd
  return $ processPayment validatedCmd

// Java Comparator：需要显式实现接口
public interface Comparator<T> {
    int compare(T a, T b);
}

// 具体实现类
class StudentGradeComparator implements Comparator<Student> {
    @Override
    public int compare(Student a, Student b) {
        return Integer.compare(a.getGrade(), b.getGrade());
    }
}

class StudentNameComparator implements Comparator<Student> {
    @Override
    public int compare(Student a, Student b) {
        return a.getName().compareTo(b.getName());
    }
}

// 使用：运行时动态选择
Comparator<Student> comparator = getComparatorFromUser();
students.sort(comparator);

-- Haskell Ord类型类：编译期推导
class Ord a where
    compare :: a -> a -> Ordering
    (<), (<=), (>), (>=) :: a -> a -> Bool

    -- 默认实现
    x < y = compare x y == LT
    x <= y = compare x y /= GT
    x > y = compare x y == GT
    x >= y = compare x y /= LT

-- 为Student类型实例化
data Student = Student
    { name :: String
    , grade :: Int
    } deriving (Show, Eq)

instance Ord Student where
    compare (Student n1 g1) (Student n2 g2)
        | g1 /= g2  = compare g1 g2
        | otherwise = compare n1 n2

-- 使用：编译期就确定了比较行为
sortStudents :: [Student] -> [Student]
sortStudents = sort  -- sort自动使用Ord实例

// Java：需要多个接口和实现
public interface EqualityChecker<T> {
    boolean areEqual(T a, T b);
}

public interface HashProvider<T> {
    int hashCode(T obj);
}

// 复合接口
public interface HashableEquality<T> extends EqualityChecker<T>, HashProvider<T> {}

// 具体实现
public class PersonHashableEquality implements HashableEquality<Person> {
    @Override
    public boolean areEqual(Person a, Person b) {
        return a.getName().equals(b.getName()) &&
               a.getAge() == b.getAge();
    }

    @Override
    public int hashCode(Person obj) {
        return Objects.hash(obj.getName(), obj.getAge());
    }
}

-- Haskell：一个类型类解决所有问题
class Eq a where
    (==) :: a -> a -> Bool
    (/=) :: a -> a -> Bool

    -- 默认实现
    x == y = not (x /= y)
    x /= y = not (x == y)

-- 自动推导Eq实例
data Person = Person
    { name :: String
    , age  :: Int
    } deriving (Show, Eq)

-- Haskell可以自动生成：
-- 1. 两个Person的相等比较
-- 2. 基于字段的hashCode实现
-- 3. 编译期类型检查

物理层 → 逻辑门 → 指令集 → 汇编语言 → 高级语言 → 抽象设计模式

data PaymentCommand = Charge ... | Refund ... | Query ...
-- 这是一个和类型，对应数学中的不交并