Carbon结构体 #

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

var p1: Point = Point(x = 1.0, y = 2.0);
var p2: Point = Point {.x = 1.0, .y = 2.0};

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

var origin: Point = Point();  // x=0.0, y=0.0

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

Print("x = {0}", p.x);  // 3.0
Print("y = {0}", p.y);  // 4.0

// 修改成员
p.x = 5.0;
p.y = 12.0;

var p: Point = Point(x = 3.0, y = 4.0);
var (x, y) = p;
Print("({0}, {1})", x, y);

struct Point {
  var x: f64;
  var y: f64;
  
  fn Distance(me) -> f64 {
    return (me.x * me.x + me.y * me.y).Sqrt();
  }
  
  fn Translate(me, dx: f64, dy: f64) -> Point {
    return Point(x = me.x + dx, y = me.y + dy);
  }
}

var p: Point = Point(x = 3.0, y = 4.0);
Print("距离: {0}", p.Distance());  // 5.0

struct Rectangle {
  var width: f64;
  var height: f64;
  
  fn Area(me) -> f64 {
    return me.width * me.height;
  }
  
  fn Perimeter(me) -> f64 {
    return 2.0 * (me.width + me.height);
  }
  
  fn IsSquare(me) -> bool {
    return me.width == me.height;
  }
}

var rect: Rectangle = Rectangle(width = 5.0, height = 3.0);
Print("面积: {0}", rect.Area());        // 15.0
Print("周长: {0}", rect.Perimeter());   // 16.0
Print("是正方形: {0}", rect.IsSquare()); // false

struct Counter {
  var count: i32 = 0;
  
  fn Increment(me&) {
    me.count += 1;
  }
  
  fn Reset(me&) {
    me.count = 0;
  }
}

var c: Counter = Counter();
c.Increment();
c.Increment();
Print("{0}", c.count);  // 2

struct Point {
  var x: f64;
  var y: f64;
  
  fn Origin() -> Point {
    return Point(x = 0.0, y = 0.0);
  }
  
  fn New(x: f64, y: f64) -> Point {
    return Point(x = x, y = y);
  }
}

var origin: Point = Point.Origin();
var p: Point = Point.New(3.0, 4.0);

struct Person {
  var name: String;
  var age: i32;
  
  fn New(name: String, age: i32) -> Person {
    return Person(name = name, age = age);
  }
  
  fn Default() -> Person {
    return Person(name = "Unknown", age = 0);
  }
}

var p1: Person = Person.New("Alice", 30);
var p2: Person = Person.Default();

struct PositiveNumber {
  var value: i32;
  
  fn New(value: i32) -> Optional(PositiveNumber) {
    if (value > 0) {
      return Some(PositiveNumber(value = value));
    }
    return None;
  }
}

match (PositiveNumber.New(5)) {
  case Some(n) => Print("值: {0}", n.value);
  case None => Print("无效输入");
}

fn PrintPoint(p: Point) {
  Print("({0}, {1})", p.x, p.y);
}

fn DistanceBetween(p1: Point, p2: Point) -> f64 {
  var dx: f64 = p2.x - p1.x;
  var dy: f64 = p2.y - p1.y;
  return (dx * dx + dy * dy).Sqrt();
}

fn Midpoint(p1: Point, p2: Point) -> Point {
  return Point(
    x = (p1.x + p2.x) / 2.0,
    y = (p1.y + p2.y) / 2.0
  );
}

fn Scale(p: Point&, factor: f64) {
  p.x *= factor;
  p.y *= factor;
}

var p: Point = Point(x = 3.0, y = 4.0);
Scale(p, 2.0);
Print("({0}, {1})", p.x, p.y);  // (6.0, 8.0)

struct Address {
  var street: String;
  var city: String;
  var country: String;
}

struct Person {
  var name: String;
  var address: Address;
}

var person: Person = Person(
  name = "Alice",
  address = Address(
    street = "123 Main St",
    city = "New York",
    country = "USA"
  )
);

Print("{0}住在{1}", person.name, person.address.city);

fn GetCity(person: Person) -> String {
  return person.address.city;
}

fn UpdateCity(person: Person&, new_city: String) {
  person.address.city = new_city;
}

struct Builder {
  var name: String = "";
  var age: i32 = 0;
  var email: String = "";
  
  fn SetName(me&, name: String) -> Builder& {
    me.name = name;
    return me;
  }
  
  fn SetAge(me&, age: i32) -> Builder& {
    me.age = age;
    return me;
  }
  
  fn SetEmail(me&, email: String) -> Builder& {
    me.email = email;
    return me;
  }
  
  fn Build(me) -> Person {
    return Person(name = me.name, age = me.age);
  }
}

var person: Person = Builder()
  .SetName("Alice")
  .SetAge(30)
  .SetEmail("alice@example.com")
  .Build();

struct Vector {
  var x: f64;
  var y: f64;
  
  fn OpAdd(me, other: Vector) -> Vector {
    return Vector(x = me.x + other.x, y = me.y + other.y);
  }
  
  fn OpSub(me, other: Vector) -> Vector {
    return Vector(x = me.x - other.x, y = me.y - other.y);
  }
  
  fn OpMul(me, scalar: f64) -> Vector {
    return Vector(x = me.x * scalar, y = me.y * scalar);
  }
}

var v1: Vector = Vector(x = 1.0, y = 2.0);
var v2: Vector = Vector(x = 3.0, y = 4.0);
var sum: Vector = v1 + v2;
var scaled: Vector = v1 * 2.0;

interface Drawable {
  fn Draw(me);
}

struct Circle {
  var x: f64;
  var y: f64;
  var radius: f64;
  
  impl Drawable {
    fn Draw(me) {
      Print("绘制圆形，半径: {0}", me.radius);
    }
  }
}

struct Rectangle {
  var x: f64;
  var y: f64;
  var width: f64;
  var height: f64;
  
  impl Drawable {
    fn Draw(me) {
      Print("绘制矩形，大小: {0}x{1}", me.width, me.height);
    }
  }
}

interface Printable {
  fn Print(me);
}

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

struct Point {
  var x: f64;
  var y: f64;
  
  impl Printable {
    fn Print(me) {
      Print("({0}, {1})", me.x, me.y);
    }
  }
  
  impl Comparable {
    fn Compare(me, other: Point) -> i32 {
      var d1: f64 = me.x * me.x + me.y * me.y;
      var d2: f64 = other.x * other.x + other.y * other.y;
      return if d1 < d2 then -1 else if d1 > d2 then 1 else 0;
    }
  }
}

struct BankAccount {
  var balance_: f64;
  
  fn New(initial: f64) -> BankAccount {
    return BankAccount(balance_ = initial);
  }
  
  fn Balance(me) -> f64 {
    return me.balance_;
  }
  
  fn Deposit(me&, amount: f64) {
    if (amount > 0) {
      me.balance_ += amount;
    }
  }
  
  fn Withdraw(me&, amount: f64) -> bool {
    if (amount > 0 and me.balance_ >= amount) {
      me.balance_ -= amount;
      return true;
    }
    return false;
  }
}

struct ImmutablePoint {
  var x: f64;
  var y: f64;
  
  fn New(x: f64, y: f64) -> ImmutablePoint {
    return ImmutablePoint(x = x, y = y);
  }
  
  fn WithX(me, new_x: f64) -> ImmutablePoint {
    return ImmutablePoint(x = new_x, y = me.y);
  }
  
  fn WithY(me, new_y: f64) -> ImmutablePoint {
    return ImmutablePoint(x = me.x, y = new_y);
  }
}

struct Email {
  var address: String;
  
  fn New(address: String) -> Optional(Email) {
    if (address.Contains("@")) {
      return Some(Email(address = address));
    }
    return None;
  }
}