Carbon布尔类型与逻辑运算 #

var is_true: bool = true;
var is_false: bool = false;

let Enabled: bool = true;
let Disabled: bool = false;

var is_active: bool = true;
var has_permission: bool = false;
var is_valid: bool = true;

// 修改布尔值
is_active = false;
has_permission = true;

var flag: bool;  // 使用前必须初始化
flag = false;

var a: i32 = 10;
var b: i32 = 10;
var c: i32 = 20;

var eq: bool = a == b;   // true
var ne: bool = a != c;   // true

var x: i32 = 10;
var y: i32 = 20;

var lt: bool = x < y;    // true (小于)
var gt: bool = x > y;    // false (大于)
var le: bool = x <= y;   // true (小于等于)
var ge: bool = x >= y;   // false (大于等于)

var s1: String = "Hello";
var s2: String = "World";

var eq: bool = s1 == s2;   // false
var lt: bool = s1 < s2;    // true (字典序)

var a: f64 = 0.1 + 0.2;
var b: f64 = 0.3;

// 直接比较可能不准确
// var eq: bool = a == b;  // 可能为false

// 推荐使用近似比较
var epsilon: f64 = 1e-9;
var approx_eq: bool = (a - b).Abs() < epsilon;  // true

var a: bool = true;
var b: bool = false;

var result: bool = a and b;  // false

// 短路求值：如果第一个为false，不计算第二个
var x: i32 = 0;
var check: bool = (x != 0) and (10 / x > 1);  // 安全，不会除以零

var a: bool = true;
var b: bool = false;

var result: bool = a or b;  // true

// 短路求值：如果第一个为true，不计算第二个
var y: i32 = 5;
var check: bool = (y > 0) or (ComputeExpensiveValue());  // 不调用函数

var a: bool = true;
var b: bool = false;

var not_a: bool = not a;  // false
var not_b: bool = not b;  // true

// 常用于条件取反
var is_empty: bool = s.Length() == 0;
var not_empty: bool = not is_empty;

// not > and > or
var result: bool = not a and b or c;
// 等价于: ((not a) and b) or c

// 使用括号明确优先级
var result2: bool = not (a and b) or c;

var age: i32 = 20;
var is_adult: bool = age >= 18;

if (is_adult) {
  Print("成年人");
}

var score: i32 = 75;
var passed: bool = score >= 60;

if (passed) {
  Print("通过");
} else {
  Print("未通过");
}

var age: i32 = 20;
var status: String = if age >= 18 then "成年" else "未成年";

// 更复杂的表达式
var score: i32 = 85;
var grade: String = 
  if score >= 90 then "A"
  else if score >= 80 then "B"
  else if score >= 70 then "C"
  else if score >= 60 then "D"
  else "F";

fn IsEven(n: i32) -> bool {
  return n % 2 == 0;
}

fn IsPositive(n: i32) -> bool {
  return n > 0;
}

// 使用
if (IsEven(4)) {
  Print("偶数");
}

fn Process(data: [i32], verbose: bool) -> i32 {
  if (verbose) {
    Print("处理 {0} 个元素", data.Length());
  }
  return data.Length();
}

Process(items, true);   // 详细输出
Process(items, false);  // 静默处理

// 谓词函数通常以Is、Has、Can等开头
fn IsEmpty(s: String) -> bool {
  return s.Length() == 0;
}

fn HasPermission(user: User, perm: String) -> bool {
  // 检查权限
  return true;
}

fn CanAccess(user: User, resource: Resource) -> bool {
  // 检查访问权限
  return true;
}

// 整数转布尔
var n: i32 = 42;
var b1: bool = bool(n);  // true (非零为true)

var zero: i32 = 0;
var b2: bool = bool(zero);  // false

// 字符串转布尔
var s1: String = "true";
var b3: bool = bool(s1);  // true

var s2: String = "false";
var b4: bool = bool(s2);  // false

var b: bool = true;
var s: String = String(b);  // "true"

var b2: bool = false;
var s2: String = String(b2);  // "false"

var a: bool = true;
var b: bool = false;

var bit_and: bool = a & b;  // false

var a: bool = true;
var b: bool = false;

var bit_or: bool = a | b;  // true

var a: bool = true;
var b: bool = true;

var bit_xor: bool = a ^ b;  // false

// 逻辑运算：短路求值
var result1: bool = a and b;  // 如果a为false，不计算b

// 位运算：不短路
var result2: bool = a & b;    // 总是计算两个操作数

var flags: [bool; 3] = (true, false, true);
var all_true: [bool; 5] = (true, true, true, true, true);

var flags: [bool; 4] = (true, false, true, false);

// 检查是否全为true
var all: bool = flags.All();  // false

// 检查是否有true
var any: bool = flags.Any();  // true

// 统计true的数量
var count: i32 = flags.Count(true);  // 2

fn ValidateUser(name: String, age: i32) -> bool {
  var name_valid: bool = name.Length() >= 2;
  var age_valid: bool = age >= 0 and age <= 150;
  
  return name_valid and age_valid;
}

if (ValidateUser("Alice", 25)) {
  Print("验证通过");
}

class User {
  var is_active_: bool;
  var is_verified_: bool;
  var is_premium_: bool;
  
  fn CanAccessPremiumContent(me) -> bool {
    return me.is_active_ and me.is_verified_ and me.is_premium_;
  }
  
  fn IsEligibleForTrial(me) -> bool {
    return me.is_active_ and not me.is_premium_;
  }
}

let FeatureAEnabled: bool = true;
let FeatureBEnabled: bool = false;

fn ProcessWithFeatures() {
  if (FeatureAEnabled) {
    // 执行特性A
  }
  
  if (FeatureBEnabled) {
    // 执行特性B
  }
}

// 好的命名
var is_valid: bool = true;
var has_permission: bool = false;
var can_edit: bool = true;

// 避免的命名
var flag: bool = true;
var f: bool = false;
var status: bool = true;

// 好的做法
if (is_valid) {
  // ...
}

// 避免
if (is_valid == true) {
  // ...
}

// 避免
if (is_valid == false) {
  // ...
}

// 使用not
if (not is_valid) {
  // ...
}

// 复杂的条件
var is_valid: bool = (age >= 18) and (age <= 65) and (not is_blocked) and (has_permission);

// 分解为多个变量
var age_valid: bool = age >= 18 and age <= 65;
var access_valid: bool = not is_blocked and has_permission;
var is_valid: bool = age_valid and access_valid;

var x: i32 = 10;

// 正确：比较
if (x == 10) {
  Print("等于10");
}

// 错误：赋值（编译错误）
// if (x = 10) { ... }

var a: f64 = 0.1 + 0.2;
var b: f64 = 0.3;

// 可能出错
// if (a == b) { ... }

// 正确做法
var epsilon: f64 = 1e-9;
if ((a - b).Abs() < epsilon) {
  Print("近似相等");
}

// 正确：逻辑运算
var result: bool = a and b or c;

// 错误：位运算（语义不同）
// var result: bool = a & b | c;