Klang

导入{
    打印: "gitee/HTWX/打印"
}
启动(){
    打印.打印行("您好, 我是Klang.")
}

// 整体导入
导入{
    打印: "gitee/HTWX/打印"    
}
// 解构导入
导入{
    // 给打印行指定别名为 '打印', 可以避免命名冲突
    打印: 打印行
} 来自 "gitee/HTWX/打印"

// 整体导入
导入{
    打印: "gitee/HTWX/打印"    
}
// 解构导入
导入{
    // 给打印行指定别名为 '打印', 可以避免命名冲突
    打印: 打印行
} 来自 "gitee/HTWX/打印"

// `启动程序声明` 是程序声明的特例, 包含 `启动程序声明` 的模块可编译为 `exe` 格式可执行文件.
// `启动程序` 可以由多个文件组成, 且必须只能有一个启动函数, 且此(包含启动函数的启动程序文件)源码文件为`主启动文件`.
// `程序声明` 可以省略的, 如果省略了程序声明, 位于 `./源码/` 目录下的文件被视为 启动程序声明
// `./源码/其他目录` 内的文件被视为 `内部模块`, 子目录被视为 `子内部模块`.
// `内部模块` 及 ``子内部模块` 可以用导入语法导入到引用他的文件.
程序 启动

// 启动程序内必须包含 启动函数
启动(){
    // ... 可执行代码
}

// 单行注释

/**
 * 多行注释
 */

函数 创建<T>(长度:整数, 容量?:整数): T

li := 创建<整数[...]>(3, 5)
如果(li){
    //...
    // 表示创建成功
}

ch := 创建<整数:>>(3, 5)
如果(ch){
    // ...
    // 表示创建成功
}

ch2 := 创建<整数<->(3, 5)
如果(ch2){
    // ...
    // 表示创建成功
}

ch3 := 创建<整数->>(3, 5)
如果(ch3){
    // ...
    // 表示创建成功
}

map := 创建<[整数 : 文本]>(3, 5)
如果(map){
    // ...
    // 表示创建成功
}

函数 长度<T>(参数: T): 整数
str := "我是文本"
l := 长度(str)

// 类型参数是未实例化的类型, 在使用的时候指定类型参数实例化
// 一下语句声明了一个 类型别名A, 其中包括一个类型参数T, 
// 类型声明\类型别名声明\结构声明\接口声明\方法声明\函数声明\函数表达式
// 可以声明类型参数.
// 下面是类型别名声明包含类型参数的例子:
类型 类型别名A<T> = S<T>

// 泛型参数具有 `类型约束` 和 `默认类型` 等语法
// 下面 的类型参数T 约束为 整数包括整数的子类型
类型 类型声明B<T: 整数> = S<T>

类型 我的整数 := 整数

方法 我的整数.加加(): 整数{
    返回 整数.(本体)++
}

函数 使用泛型类型(){ 
    b := 类型声明B<我的整数>{
        s = 我的整数.(100) // 类型转换表达式
    }
    // 可以通过 属性访问 加加 方法
    b.s.加加()
}

函数 使用泛型类型1(){
    // 使用 整数类型 实例化 类型别名A<T>
    a := 类型别名A<整数>{
        s = 100
    }
}

// 声明一个整数及文本的联合类型, 声明类型是一个新类型
类型 新声明的类型 := 整数 | 文本
// 类型别名 类型别名只作为 类型的别名 不是一个新的类型
类型 类型的别名 = 整数 | 文本
// 类型别名或类型声明可以有类型参数
类型 泛型数组<T> := T[...]

// 这是泛型的结构类型声明
// 结构类型的元素是属性声明, 且属性的类型不能是函数类型, 函数类型的属性可考虑用方法
结构 S<T>{
    s: T // 元素 s 的类型为 T
}
// 结构类型可以继承, 结构类型的基类只能是结构类型或结构类型的别名或者是结构类型的声明类型
结构 SS<T, T2> : S<T2>{
    ss: T
}

// 这是 泛型的接口类型, 接口类型的元素是方法签名, 接口类型不存在属性
接口 I<T>{
    a(s: T): T
}
// 接口类型支持继承语法, 冒号后面的是 基接口, 是逗号表达式, 可以同时继承多个接口
// 接口的基类只能是接口
接口 II<T, T2> : I<T2>{
    b(s: *T): T
}
/**
 * 与上个接口声明等价
 * 接口 II<T, T2>{
 *   a(s: T2): T2
 *   b(s: T): T
 * } 
 **/

// SS<T>的方法 a 实现接口I<T> SS.a 其中SS称为方法接受者是类型引用节点
// 此写法为简写形式也可写成 SS<T>.a(s: T): T
方法 SS.a(s: 本体.T): 本体.T{
    返回 s
}

函数 函数A(参数: S<整数>):S<整数>{
    返回 参数
}

// 常量声明必须具有初始化表达式
// 初始化表达式必须能在编译时求值
常量 c = 100
// 变量可以只声明无初始化系统自动初始化为其空值
// 全局变量使用前必须初始化
变量 v: 整数

// 简洁变量声明不是顶级语句只能在函数体或方法体等局部作用域的位置声明
函数 函数A(参数: 整数): 整数{
    // := 是声明及初始化运算符
    // 使用 := 声明的变量可以省略 `变量` 修饰符
    // 简洁函数变量声明具有局部作用域
    // 局部变量 v 在此覆盖全局变量 v
    v := 参数 + 100
    返回 v
}

// 枚举值 可以是任意常量值, 常用枚举值写法编译器可自动推断其初始表达式
// 如果推断表达式与预期不符合, 可以手动修改.
枚举 E{
    e = 1,
    e2          // 推断为 2
    e3          // 推断为 3
    e4          // 推断为 4
    e5 = "我是文字枚举值"
    e6          // 推断为 6 如不符合预期可手动指定
}
枚举 E2{
    e1 = 1 << 1,
    e2           // 推断为 1 << 2
    e3           // 推断为 1 << 3
}

// 一元运算符
    // a 后缀一元运算符
        ++、--
    // b 前缀一元运算符
        -、&、*
// 二元运算符
    // 二元运算符
        +、-、*、/、%
    // 位运算符
        &、|、^、~、<<、>>

// 赋值
    =
// 复合赋值
    +=、-=、*=、/=、%=、&=、|=、^=、~=、 >>=、 <<=、
// 逻辑运算
   &&、||、!

启动(){

    // 简洁变量语句
    a := 生成随机数()

    // 如果语句
    如果(a > 0){
        打印(`变量 a 值是:${a}, 大于0.`)
    }
    另如(a > 50){
        打印(`变量 a 值是:${a}, 大于50.`)
    }
    否则{
        打印("我也不知道 a 是什么样的数")
    }

    // 循环语句
    循环(i := 0; i < a; i++){
        打印(i)
    }

    // 循环属于语句
    arr := [整数 : 文本]{1 : "1", 2 : "2"}
    循环(k, v 属于 arr){
        打印(k, v)
    }

    // 无限循环
    a := 10
    循环(真){
        如果 (a > 100){
            跳出
        }
        打印(a)
        a++
    }

    // 假如语句
    a := 10
    假如(a){
        若是 5:
            打印("a 是 5")
        若是 6, 7, 8, 9, 10:
            打印("a >= 6 且 a <= 10")
        若是 11, 12:
            打印("a是11或12")
        默认:
            打印("不知道a是什么")
    }

    // 简洁变量声明
    a := S<整数>{
        s = 10
    }
    // 类型断言表达式
    如果(a.<S<整数8>){
        打印("a.s 是 S<整数8> 类型")
    }

    // 类型转换表达式
    a := 100
    b := 我的整数.(a) // 转换 a 为 我的整数

    // 类型查询表达式
    假如(a.<类型>){
        若是 整数, 小数:
           打印("a是整数或小数类型")
        若是 S<整数>
           打印("a 是 S<整数> 类型")
        默认:
           打印("a 是未知类型")
    }
}