Carbon语法基础 #

// 有效标识符
MyFunction
my_variable
_private_var
var123
__special__

// 无效标识符
123var       // 不能以数字开头
my-var       // 不能包含连字符
my var       // 不能包含空格

api      as       auto     base     break    case
class    continue default  else     extends  extern
fn       for      function if       impl     import
in       interface let      match    me       namespace
package  partial  private  protected public   return
template that     then     typealias var      virtual
where    while    where

// 关键字不能用作标识符
fn fn() {}     // 错误：fn是关键字
var class: i32; // 错误：class是关键字

var x: i32 = 42;        // 变量声明语句
Print("Hello");         // 函数调用语句
return 0;               // 返回语句

fn Example() -> i32 {
  // 函数体是一个代码块
  var x: i32 = 42;
  {
    // 嵌套代码块
    var y: i32 = x + 8;
  }
  return x;
}

// 空白字符不影响语义
var x: i32 = 42;
var  y  :  i32  =  42  ;  // 等价于上面

// 但建议保持一致的格式
var x: i32 = 42;
var y: i32 = 42;

// 这是单行注释
var x: i32 = 42;  // 行尾注释

/*
 * 这是多行注释
 * 可以跨越多行
 */
var x: i32 = 42;

/// 计算两个数的和
/// 
/// 参数:
///   a - 第一个数
///   b - 第二个数
/// 
/// 返回:
///   两数之和
fn Add(a: i32, b: i32) -> i32 {
  return a + b;
}

var a: i32 = 10 + 5;   // 15
var b: i32 = 10 - 5;   // 5
var c: i32 = 10 * 5;   // 50
var d: i32 = 10 / 5;   // 2
var e: i32 = 10 % 3;   // 1

var eq: bool = (5 == 5);    // true
var ne: bool = (5 != 3);    // true
var lt: bool = (3 < 5);     // true
var gt: bool = (5 > 3);     // true
var le: bool = (5 <= 5);    // true
var ge: bool = (5 >= 3);    // true

var a: bool = true and false;   // false
var b: bool = true or false;    // true
var c: bool = not true;         // false

var a: i32 = 5 & 3;    // 1
var b: i32 = 5 | 3;    // 7
var c: i32 = 5 ^ 3;    // 6
var d: i32 = ~5;       // -6
var e: i32 = 5 << 2;   // 20
var f: i32 = 20 >> 2;  // 5

var x: i32 = 10;
x += 5;   // x = x + 5 = 15
x -= 3;   // x = x - 3 = 12
x *= 2;   // x = x * 2 = 24
x /= 4;   // x = x / 4 = 6
x %= 4;   // x = x % 4 = 2

// 使用括号明确优先级
var result: i32 = (2 + 3) * 4;  // 20
var result2: i32 = 2 + 3 * 4;   // 14

// 整数字面量
var int_dec: i32 = 42;       // 十进制
var int_hex: i32 = 0x2A;     // 十六进制
var int_bin: i32 = 0b101010; // 二进制

// 浮点字面量
var float_val: f64 = 3.14;
var float_exp: f64 = 1.5e10;

// 布尔字面量
var bool_true: bool = true;
var bool_false: bool = false;

// 字符串字面量
var str: String = "Hello, Carbon!";

var a: i32 = 10;
var b: i32 = 20;
var sum: i32 = a + b;
var product: i32 = a * b;
var complex: i32 = (a + b) * (a - b);

var x: i32 = 10;
var is_positive: bool = x > 0;
var is_even: bool = x % 2 == 0;
var in_range: bool = x >= 0 and x <= 100;

var a: bool = true;
var b: bool = false;
var result: bool = a and not b or (a == b);

// 使用var关键字声明变量
var name: String = "Carbon";
var age: i32 = 25;
var pi: f64 = 3.14159;

// 自动推断类型
var x = 42;           // 推断为 i32
var y = 3.14;         // 推断为 f64
var z = "Hello";      // 推断为 String

// 使用let声明不可变值
let MaxSize: i32 = 100;
let Pi: f64 = 3.14159265359;
let AppName: String = "MyApp";

var i: i32 = 42;
var d: f64 = f64(i);    // 整数转浮点
var s: i8 = i8(i);      // 截断转换

typealias UserID = i64;
typealias Point = (f64, f64);

var id: UserID = 1001;
var p: Point = (1.0, 2.0);

package MyPackage api;

// 公开API
fn PublicFunction() -> i32;

// 内部实现
private impl {
  fn HelperFunction() -> i32;
}

package Main api;
import MyPackage;
import AnotherPackage;

fn Main() -> i32 {
  MyPackage.PublicFunction();
  return 0;
}

namespace Math {
  fn Add(a: i32, b: i32) -> i32 {
    return a + b;
  }
  
  fn Subtract(a: i32, b: i32) -> i32 {
    return a - b;
  }
}

// 使用
var result: i32 = Math.Add(10, 5);

// 好的风格
fn CalculateTotal(
  prices: [f64],
  discount: f64
) -> f64 {
  var total: f64 = 0.0;
  for (price in prices) {
    total += price;
  }
  return total * (1.0 - discount);
}

// 避免的风格
fn calc(p:[f64],d:f64)->f64{var t:f64=0.0;for(x in p){t+=x;}return t*(1.0-d);}

// 有意义的命名
var user_count: i32 = 100;
var is_active: bool = true;
var total_price: f64 = 99.99;

// 避免无意义命名
var x: i32 = 100;
var flag: bool = true;
var tp: f64 = 99.99;

/// 计算用户的折扣价格
/// 
/// 根据用户的会员等级计算最终价格
/// - 参数 price: 原始价格
/// - 参数 level: 会员等级 (1-5)
/// - 返回: 折扣后的价格
fn CalculateDiscount(price: f64, level: i32) -> f64 {
  var discount: f64 = 0.1 * f64(level);
  return price * (1.0 - discount);
}