Carbon高级特性 #

var value: i32 = 42;

match (value) {
  case 0 => Print("零");
  case 1..10 => Print("个位数");
  case 10..100 => Print("两位数");
  default => Print("大数");
}

struct Point {
  var x: f64;
  var y: f64;
}

var p: Point = Point(x = 3.0, y = 4.0);

match (p) {
  case Point(x = 0.0, y = 0.0) => Print("原点");
  case Point(x = 0.0, y) => Print("Y轴上: {0}", y);
  case Point(x, y = 0.0) => Print("X轴上: {0}", x);
  case Point(x, y) => Print("坐标: ({0}, {1})", x, y);
}

struct Line {
  var start: Point;
  var end: Point;
}

var line: Line = Line(
  start = Point(x = 0.0, y = 0.0),
  end = Point(x = 3.0, y = 4.0)
);

match (line) {
  case Line(start = Point(x = 0.0, y = 0.0), end) => Print("从原点到 ({0}, {1})", end.x, end.y);
  case Line(start, end) if start.x == end.x => Print("垂直线");
  case Line(start, end) if start.y == end.y => Print("水平线");
  default => Print("普通线段");
}

var arr: [i32; 5] = (1, 2, 3, 4, 5);

match (arr) {
  case () => Print("空数组");
  case (x) => Print("单元素: {0}", x);
  case (x, y) => Print("两元素: {0}, {1}", x, y);
  case (first, ...rest) => Print("首元素: {0}, 其余: {1}", first, rest);
}

enum Result[T, E] {
  Ok(T),
  Err(E)
}

var result: Result[i32, String] = Ok(42);

match (result) {
  case Ok(value) => Print("成功: {0}", value);
  case Err(error) => Print("错误: {0}", error);
}

enum Optional[T] {
  Some(T),
  None
}

fn FindUser(id: i32) -> Optional(User) {
  if (id == 1) {
    return Some(User(name = "Alice"));
  }
  return None;
}

match (FindUser(1)) {
  case Some(user) => Print("找到: {0}", user.name);
  case None => Print("未找到");
}

var opt: Optional(i32) = Some(42);

// 检查是否有值
if (opt.HasValue()) {
  Print("{0}", opt.Value());
}

// 获取值或默认值
var value: i32 = opt.ValueOr(0);

// 转换
var doubled: Optional(i32) = opt.Map(fn (x: i32) -> i32 { return x * 2; });

// 链式调用
var result: Optional(String) = FindUser(1)
  .Map(fn (u: User) -> String { return u.name; })
  .Map(fn (n: String) -> String { return n.ToUpper(); });

fn Divide(a: i32, b: i32) -> Optional(i32) {
  if (b == 0) {
    return None;
  }
  return Some(a / b);
}

// 链式操作
var result: Optional(i32) = Divide(10, 2)
  .AndThen(fn (x: i32) -> Optional(i32) { return Divide(x, 2); });

enum Result[T, E] {
  Ok(T),
  Err(E)
}

class Error {
  var message: String;
  var code: i32;
}

fn ReadFile(path: String) -> Result(String, Error) {
  if (path == "valid.txt") {
    return Ok("文件内容");
  }
  return Err(Error(message = "文件不存在", code = 404));
}

match (ReadFile("valid.txt")) {
  case Ok(content) => Print("内容: {0}", content);
  case Err(error) => Print("错误: {0} (代码: {1})", error.message, error.code);
}

var result: Result(i32, String) = Ok(42);

// 检查
if (result.IsOk()) {
  Print("{0}", result.Value());
}

// 获取值或默认值
var value: i32 = result.ValueOr(0);

// 获取错误
if (result.IsErr()) {
  Print("错误: {0}", result.Error());
}

// 转换
var doubled: Result(i32, String) = result.Map(fn (x: i32) -> i32 { return x * 2; });

fn ProcessFile(path: String) -> Result(i32, Error) {
  var content: String = try ReadFile(path);
  var parsed: i32 = try ParseInt(content);
  return Ok(parsed * 2);
}

// 等价于
fn ProcessFile(path: String) -> Result(i32, Error) {
  var content_result: Result(String, Error) = ReadFile(path);
  if (content_result.IsErr()) {
    return Err(content_result.Error());
  }
  var content: String = content_result.Value();
  
  var parsed_result: Result(i32, Error) = ParseInt(content);
  if (parsed_result.IsErr()) {
    return Err(parsed_result.Error());
  }
  var parsed: i32 = parsed_result.Value();
  
  return Ok(parsed * 2);
}

enum AppError {
  FileNotFound(String),
  ParseError(String),
  NetworkError(String),
  Unknown
}

fn ReadConfig(path: String) -> Result(Config, AppError) {
  if (not FileExists(path)) {
    return Err(AppError.FileNotFound(path));
  }
  
  var content: String = try ReadFile(path);
  var config: Config = try ParseConfig(content);
  
  return Ok(config);
}

fn LoadConfig() -> Config {
  match (ReadConfig("config.json")) {
    case Ok(config) => return config;
    case Err(AppError.FileNotFound(_)) => {
      Print("配置文件不存在，使用默认配置");
      return Config.Default();
    }
    case Err(error) => {
      Print("加载配置失败: {0}", error);
      return Config.Default();
    }
  }
}

fn WrapError[T, E, E2](result: Result(T, E), wrap: fn (E) -> E2) -> Result(T, E2) {
  return match (result) {
    case Ok(value) => Ok(value);
    case Err(error) => Err(wrap(error));
  };
}

fn HighLevelOperation() -> Result(Data, HighLevelError) {
  var raw: RawData = try WrapError(LowLevelOperation(), fn (e: LowLevelError) -> HighLevelError {
    return HighLevelError.LowLevel(e);
  });
  return Ok(Process(raw));
}

fn Factorial(n: i32) -> i32 {
  if (n <= 1) {
    return 1;
  }
  return n * Factorial(n - 1);
}

// 编译时计算
let Factorial5: i32 = Factorial(5);  // 编译时计算为120

fn TypeName[T]() -> String {
  return T.Name;
}

Print("{0}", TypeName[i32]());  // "i32"
Print("{0}", TypeName[String]());  // "String"

// 生成getter方法
macro GenerateGetters[T](fields: (String, Type)...) {
  for (name, type in fields) {
    fn Get##name(me) -> type {
      return me.name##_;
    }
  }
}

class Person {
  var name_: String;
  var age_: i32;
  
  GenerateGetters(("Name", String), ("Age", i32));
}

fn AsyncOperation() -> Future(i32) {
  return async {
    // 异步操作
    return 42;
  };
}

var future: Future(i32) = AsyncOperation();
var result: i32 = await future;
Print("{0}", result);

fn ParallelProcess(items: [Data]) -> [Result] {
  return Parallel.Map(items, fn (item: Data) -> Result {
    return ProcessItem(item);
  });
}

class Counter {
  var value_: i32 = 0;
  var mutex_: Mutex;
  
  fn Increment(me&) {
    me.mutex_.Lock();
    defer { me.mutex_.Unlock(); };
    me.value_ += 1;
  }
  
  fn Value(me) -> i32 {
    me.mutex_.Lock();
    defer { me.mutex_.Unlock(); };
    return me.value_;
  }
}