Carbon泛型编程 #

fn Identity[T](x: T) -> T {
  return x;
}

var a: i32 = Identity(42);
var b: String = Identity("Hello");

fn Pair[T, U](first: T, second: U) -> (T, U) {
  return (first, second);
}

var p = Pair(1, "hello");  // (i32, String)

interface Numeric {
  fn Add(me, other: me) -> me;
  fn Zero() -> me;
}

fn Sum[T:! Numeric](values: [T]) -> T {
  var total: T = T.Zero;
  for (v in values) {
    total = total.Add(v);
  }
  return total;
}

interface Printable {
  fn Print(me);
}

interface Comparable {
  fn Compare(me, other: me) -> i32;
}

fn Max[T:! Printable and Comparable](a: T, b: T) -> T {
  if (a.Compare(b) >= 0) {
    a.Print();
    return a;
  }
  b.Print();
  return b;
}

class Box[T] {
  var value: T;
  
  fn New(value: T) -> Box[T] {
    return Box(value = value);
  }
  
  fn Get(me) -> T {
    return me.value;
  }
  
  fn Set(me&, value: T) {
    me.value = value;
  }
}

var int_box: Box[i32] = Box.New(42);
var str_box: Box[String] = Box.New("Hello");

class Stack[T] {
  var items: [T] = ();
  
  fn Push(me&, item: T) {
    me.items.Push(item);
  }
  
  fn Pop(me&) -> Optional(T) {
    if (me.items.Length() == 0) {
      return None;
    }
    return Some(me.items.Pop());
  }
  
  fn Peek(me) -> Optional(T) {
    if (me.items.Length() == 0) {
      return None;
    }
    return Some(me.items.Last());
  }
  
  fn IsEmpty(me) -> bool {
    return me.items.Length() == 0;
  }
}

var stack: Stack[i32] = Stack();
stack.Push(1);
stack.Push(2);
match (stack.Pop()) {
  case Some(v) => Print("{0}", v);  // 2
  case None => Print("空栈");
}

class SortedList[T:! Comparable] {
  var items: [T] = ();
  
  fn Insert(me&, item: T) {
    var i: i32 = 0;
    while (i < me.items.Length() and me.items[i].Compare(item) < 0) {
      i += 1;
    }
    me.items.Insert(i, item);
  }
  
  fn Contains(me, item: T) -> bool {
    for (v in me.items) {
      var cmp: i32 = v.Compare(item);
      if (cmp == 0) {
        return true;
      }
      if (cmp > 0) {
        return false;
      }
    }
    return false;
  }
}

interface Container[Element] {
  fn Size(me) -> i32;
  fn IsEmpty(me) -> bool;
  fn Add(me&, element: Element);
  fn Get(me, index: i32) -> Optional(Element);
}

class ArrayList[T] {
  var items: [T] = ();
  
  impl Container[T] {
    fn Size(me) -> i32 {
      return me.items.Length();
    }
    
    fn IsEmpty(me) -> bool {
      return me.items.Length() == 0;
    }
    
    fn Add(me&, element: T) {
      me.items.Push(element);
    }
    
    fn Get(me, index: i32) -> Optional(T) {
      if (index >= 0 and index < me.items.Length()) {
        return Some(me.items[index]);
      }
      return None;
    }
  }
}

interface Hashable {
  fn Hash(me) -> u64;
}

class HashMap[Key:! Hashable and Comparable, Value] {
  var buckets: [[(Key, Value)]];
  
  fn New(size: i32 = 16) -> HashMap[Key, Value] {
    return HashMap(buckets = [[(Key, Value)]].New(size));
  }
  
  fn Insert(me&, key: Key, value: Value) {
    var index: i32 = i32(key.Hash() % u64(me.buckets.Length()));
    me.buckets[index].Push((key, value));
  }
  
  fn Get(me, key: Key) -> Optional(Value) {
    var index: i32 = i32(key.Hash() % u64(me.buckets.Length()));
    for ((k, v) in me.buckets[index]) {
      if (k.Compare(key) == 0) {
        return Some(v);
      }
    }
    return None;
  }
}

fn Process[T:! String or i32](value: T) -> String {
  return match (T) {
    case String => value;
    case i32 => String(value);
  };
}

class Result[T, E: Error = DefaultError] {
  var value: Optional(T);
  var error: Optional(E);
  
  fn Ok(value: T) -> Result[T, E] {
    return Result(value = Some(value), error = None);
  }
  
  fn Err(error: E) -> Result[T, E] {
    return Result(value = None, error = Some(error));
  }
  
  fn IsOk(me) -> bool {
    return me.value.HasValue();
  }
  
  fn IsErr(me) -> bool {
    return me.error.HasValue();
  }
}

// 通用版本
fn ToString[T](value: T) -> String {
  return "Unknown";
}

// 特化版本：i32
fn ToString[i32](value: i32) -> String {
  return String(value);
}

// 特化版本：String
fn ToString[String](value: String) -> String {
  return value;
}

fn Process[T:! Numeric](value: T) -> T {
  return value * 2;
}

fn Process[T:! String](value: T) -> T {
  return value + value;
}

fn Sort[T:! Comparable](arr: [T]&) {
  for (i in 0..arr.Length()) {
    for (j in i + 1..arr.Length()) {
      if (arr[i].Compare(arr[j]) > 0) {
        var temp: T = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
      }
    }
  }
}

fn Find[T:! Comparable](arr: [T], target: T) -> Optional(i32) {
  for (i, item in arr.Enumerate()) {
    if (item.Compare(target) == 0) {
      return Some(i);
    }
  }
  return None;
}

fn BinarySearch[T:! Comparable](arr: [T], target: T) -> Optional(i32) {
  var left: i32 = 0;
  var right: i32 = arr.Length() - 1;
  
  while (left <= right) {
    var mid: i32 = (left + right) / 2;
    var cmp: i32 = arr[mid].Compare(target);
    
    if (cmp == 0) {
      return Some(mid);
    } else if (cmp < 0) {
      left = mid + 1;
    } else {
      right = mid - 1;
    }
  }
  
  return None;
}

fn MakeTuple[T...](values: T...) -> (T...) {
  return values;
}

var t1 = MakeTuple(1, 2, 3);           // (i32, i32, i32)
var t2 = MakeTuple(1, "hello", 3.14);  // (i32, String, f64)

fn Factorial[T:! Numeric](n: T) -> T {
  if (n <= T.One) {
    return T.One;
  }
  return n * Factorial(n - T.One);
}

fn Apply[T, U](value: T, f: fn (T) -> U) -> U {
  return f(value);
}

fn Compose[T, U, V](f: fn (U) -> V, g: fn (T) -> U) -> fn (T) -> V {
  return fn (x: T) -> V { return f(g(x)); };
}

// 好的做法：明确约束
fn Max[T:! Comparable](a: T, b: T) -> T {
  return if a.Compare(b) >= 0 then a else b;
}

// 避免：过度约束
fn Max[T:! Comparable and Printable and Serializable](a: T, b: T) -> T {
  return if a.Compare(b) >= 0 then a else b;
}

interface Comparable {
  fn Compare(me, other: me) -> i32;
  
  fn LessThan(me, other: me) -> bool {
    return me.Compare(other) < 0;
  }
  
  fn GreaterThan(me, other: me) -> bool {
    return me.Compare(other) > 0;
  }
  
  fn Equal(me, other: me) -> bool {
    return me.Compare(other) == 0;
  }
}

/// 泛型栈容器
/// 
/// 类型参数:
///   T - 栈中存储的元素类型
/// 
/// 示例:
///   var stack: Stack[i32] = Stack();
///   stack.Push(1);
///   stack.Pop();
class Stack[T] {
  // ...
}