pipeline-script 0.3.12

import core
// 测试例子：结构体定义，方法绑定以及泛型实例化
struct Vec<T> {
    data: Pointer<T>,
    len: Int64,
    cap: Int64,
}
fn Vec<T>.new() -> Vec<T> {
    const n = 10
    return Vec<T>{
        data: malloc(n*sizeof::<T>()),
        len: 0,
        cap: n,
    }
}
fn Vec<T>.push(&self,x: T) {
    self.data[self.len] = x
    self.len = self.len + 1
}
fn Vec<T>.get(self,index: Int64)->Option<T>  {
    if(index > self.len -1){
        Option.None
    }
   return Option.Some(self.data[index])
}
let v = Vec<Int64>.new()
v.push(10)
const b = v.get(0)
const x = b.unwrap()
println(x)
let a = Option.Some(100)
match(a){
    Option.Some(x)->println(x),
    Option.None->println("None"),
}
// 测试例子：Option类型枚举以及if let语句
a = Option.None
if let( Option.Some(x) = a){
    println("This is:")
    println(x)
}else{
    println("This is None")
}
// 测试例子：函数参数默认值
fn add(a: Int64 = 5, b: Int64 = 7) -> Int64 {
    return a + b
}
const result = add(b=10)
println(result)
// 测试例子：递归函数以及循环语句
fn fib(n: Int64) -> Int64 {
    if (n <= 1) {
        return n
    }
    return fib(n - 1) + fib(n - 2)
}
let i = 0
while(i<10){
    println(fib(i))
    i = i + 1
}
// 测试例子：枚举类型以及match语句
enum Color {
    Red,
    Green,
    Blue,
    Yellow,
}
let c = Color.Green
match(c){
    Color.Red->println("Red"),
    Color.Green->println("Green"),
    Color.Blue->println("Blue"),
    Color.Yellow->println("Yellow"),
}

// 测试例子：数组类型以及冒泡排序算法
let a = [11,5,7,9,10]

fn bubble_sort(arr: Pointer<Int64>, len: Int64) {
    let l = len
    while (l > 1) {
        let swapped = false
        let i = 0
        while (i < l - 1) {
            if (arr[i] > arr[i + 1]) {
                let temp = arr[i]
                arr[i] = arr[i + 1]
                arr[i + 1] = temp
                swapped = true
            }
            i = i + 1
        }
        if (!swapped) {
            break
        }
        l = l - 1
    }
}
bubble_sort(a,5)
let i = 0
while (i < 5) {
    println(a[i])
    i = i + 1
}

struct Time {
    tm_sec:Int8,   // 秒 [0-60]（允许闰秒）
    tm_min:Int8,   // 分 [0-59]
    tm_hour:Int8, // 时 [0-23]
    tm_mday:Int8,  // 日 [1-31]
    tm_mon:Int8,  // 月 [0-11]（0 代表 1 月）
    tm_year:Int8,  // 年（实际年份 = tm_year + 1900）
    tm_wday:Int8,  // 星期 [0-6]（0 代表周日）
    tm_yday:Int8,  // 一年中的第几天 [0-365]
    tm_isdst:Bool // 夏令时标志（正数启用，0 不启用，负数无信息）
};
extern fn printf(format: String, ...) -> Int64
extern fn scanf(format: String,...) -> Int64
extern fn time(a:Int64) -> Time
let start = time(0)
println(start.tm_sec)
// 测试例子：数组类型以及冒泡排序算法
let a = [11,5,7,9,10]

fn bubble_sort(arr: Pointer<Int64>, len: Int64) {
    let l = len
    while (l > 1) {
        let swapped = false
        let i = 0
        while (i < l - 1) {
            if (arr[i] > arr[i + 1]) {
                let temp = arr[i]
                arr[i] = arr[i + 1]
                arr[i + 1] = temp
                swapped = true
            }
            i = i + 1
        }
        if (!swapped) {
            break
        }
        l = l - 1
    }
}
bubble_sort(a,5)
let i = 0
while (i < 5) {
    println(a[i])
    i = i + 1
}
let end = time(0)
println("sec")
println(end.tm_sec)
println(end.tm_min)
println(end.tm_hour)
println(end.tm_mday)
const a = 1
let add = |b:Int64|->Int64{
    return a+b
}
let a = add(5)