ccc草案2.0

ccc，简写c3

有道云地址 http://note.youdao.com/noteshare?id=8f503f3830ded4be4bdf7ef25f40fbc9

基础语法

print('hello world')

没有printf
单引号为字符串
分号是可选的

• 变量定义

  int a
  int a = 1

  • 变量定义自动推断类型

    var a = 1

  • 不可变变量

    不可变变量必须马上赋值
    csharp int! a = 1 var! a = 1

    • 使用lazyinit块延迟初始化不可变变量

      int! a = lazyinit {
          2 ^ 6
      }

• 变量修改语句

  a = 2
  a++
  a += 1

• 注释

  // 单行
  /* 多
  行*/

• 数字中间符

  1_000_000

• 字符串模板

  '{{some}}'

基础类型

c语言名	类型名	大小(字节)	字面量
_Bool	bool	1，1/8	true，false
char	i8	1	0i8
unsigned char	u8，char	1	"x"，0u8
short	i16	2	0i16
int	i32，int	4	0，0i32
long	i64	8	0i64
long long	i128	16	0i128
unsigned short	u16	2	0u16
unsigned int	u32，uint	4	0u，0u32
unsigned long	u64	8	0u64
unsigned long long	u128	16	0u128
float	float，f32	4	0.0，0f，0f32
double	double，f64	8	0d，0f64
long double	f128	16	0f128

抽象类型

c/c艹语言名	类型名	字面量
void	void	void
nullptr	null	null

高级类型

c/c艹语言名	类型名	字面量
char*/string	string	'x'

指针和可空类型

名称	c语言内	ccc内
指针	type *name	type* name
常量的指针	const type *name	type!* name
指针的常量	type * const name	type*! name
常量的指针的常量	const type * const name	type!*! name
可空	N/A	type? name
常量的可空	N/A	type?! name
可空的常量	N/A	type!? name
常量的可空的常量	N/A	type!?! name

指针是不安全的，必须在unsafe块内使用
指针和可空类型的区别在于
指针可以运算来改变地址
而可空类型不能
并且可空类型受gc托管而指针不受

函数

void main() {
    print(add(1, 2))
}

• 函数最后省略return

  int add(int a, int b) {
      a + b
  }

• 类型自动推断

  int add(var a, var b) {
      a + b
  }
  int add(a, b) {
      a + b
  }

  • 返回值自动推导

    var mul(int a, b) {
        a * b
    }

• 函数参数重载

  int add(int a, int b) {
      a + b
  }
  int add(int a, int b, int c) {
      a + b + c
  }
  float add(float a, float b) {
      a + b
  }

• 表达式函数简写

  int add(a, b) a + b
  int add(a, b) = a + b

• 内链函数

  inline bool eq(a, b) a == b

• lambda

  var l = (x){ x + 1 }
  l(1)
  
  var l2 = { it + 1 }
  l2(1)

数据结构

struct Vector3 {
    int x
    int y
    int z
}

• 构造函数

  struct Vector3 {
      int x, y, z
      Vector3(x, y, z) {
          this.x = x
          this.y = y
          this.z = z
      }
  }

  • 构造函数语法糖

  struct Vector3(x, y, z){
      int x = x
      int y = y
      int z = z
  }

  • 构造函数内成员定义

  struct Vector3(val int x, val int y, val int z) {}

• 成员函数

  struct Some {
      int a
      int add(int v) {
          a + v
      }
  }

• 分部定义

  对于结构的分部定义，只能在同个程序集内
  csharp struct Some { int a } struct Some { int add(int v) a + v }

特征

特征是一种不能扩展的
对结构实现的约束和提供
对特征的实现必须在结构上声明
并且必须在同一个程序集内

trait SomeTrait {
    int add(int o)
}
struct Some : SomeTrait {
    int v
    int add(int o) {
        v + o
    }
}

特征默认实现

特征可以有默认实现
但如果结构同时实现了多个特征具有同个成员
那么忽略默认实现并要求结构必须实现

trait SomeTrait {
    int v
    int add(int o) {
        v + o
    }
}
struct Some : SomeTrait {}

泛型

泛型类型必须在类型前面加上`

`T some(`T v) {
    return v
}

• 自动泛化

  val add(a, b){
      return a + b
  }

• 泛型参数

  void some<`T>(`T v) {}

• 泛型注解

  #<`T>
  void some(`T v) {}

• 泛型实际传递了类型值

  #<`T>
  Type a() {
      return `T
  }
  

• 泛型约束

  `T some(`T v) where `T : Eq<`T> {
      return v
  }
  
  `T some<`T : Eq<`T>>(`T v) {
      return v
  }
  
  #<`T : Eq<`T>>
  `T some(`T v) {
      return v
  }

概念

使用concept定义一个概念
使用instance提供概念的实现

概念和特征的区别是
特征是对结构的实现约束和提供
而概念是存在量化
特征不可扩展，概念可扩展

对函数的概念
定义概念时，如果需要泛型，不能省略<>

concept Eq<`A, `B> {
    bool Equals(`A a, `B b)
}
instance Eq<int, int> {
    bool Equals(int a, int b) {
        return a == b
    }
}
Equals(1, 2)

对对象的概念
对对象概念的对象泛型可以省略<>
如果不省略<>，需要把<>加在concept、instance上

concept<`A> `A.Eq<`B> {
    bool Equals(B b)
}
instance int.Eq<int> {
    bool Equals(int b) {
        return this == b
    }
}
1.Equals(b)

对泛型实现

concept Eq<`T> {
    bool Equals(`T a, `T b)
}
instance Eq<`A[]> where `A: Eq<`A> {
    bool Equals(`A[] a, `A[] b) {
        if(a.length != b.length) return false
        for(var i in a) {
          if(!Equals(a[i], b[i)) return false  
        }
        return true
    }
}

概念依赖

概念依赖会要求实现这个概念之前必须实现依赖的概念
但可以在实现的时候写在一起

concept Some<`T>: Eq<`T> { 
    void some(`T t){}
}
instance Some<`T> {
    void some(`T t) { }
    bool Equals(`T a, `T b) { return false }
}

概念中的不允许

概念中不允许描述无关函数

concept Some<`T> {
    void some()     //不允许
    void some(`T v) //允许
}

实现与现存定义重复

同时存在概念内实现和独立定义
并且签名完全重复时
优先使用独立定义
如果需要使用概念内实现
可以用::在目标名字后面加上路径

concept Some<`T> {
    void some(`T v)
}
instance Some<int> {
    void some(int v) {}
}
void some(int v) {} // 优先使用

some(1)             //使用独立定义
some::Some<int>(1)  // 使用 instance