module main
pub fn main() {
println('abcd')
}
struct MyStruct {
x int
y int
}
pub fn (my_struct MyStruct) add() {
}
void main__main(void) {
println(_SLIT("abcd"));
}
struct main__MyStruct {
int x;
int y;
};
void main__MyStruct_add(main__MyStruct my_struct) {
}
module main
fn main() {
println('from main')
add(1, 3)
}
// pub的模块访问控制由V编译器负责检查，C没有pub的对应
pub fn add(x int, y int) int {
if x > 0 {
return x + y
} else {
return x + y
}
}
//生成函数声明段
VV_LOCAL_SYMBOL void main__main(void);
int add(int x, int y);
//主函数生成主函数
int main(int ___argc, char** ___argv){
g_main_argc = ___argc;
g_main_argv = ___argv;
#if defined(_VGCBOEHM)
GC_set_pages_executable(0);
GC_INIT();
#endif
_vinit(___argc, (voidptr)___argv);
main__main();
_vcleanup();
return 0;
}
//函数实现段
VV_LOCAL_SYMBOL void main__main(void) {
println(_SLIT("from main"));
main__add(1, 3);
}
int main__add(int x, int y) {
if (x > 0) {
int _t1 = x + y;
return _t1;
} else {
int _t2 = x + y;
return _t2;
}
return 0;
}
fn foo() (int, int) { //多返回值
return 2, 3
}
fn multi_return_fn(a int, b int) (int, int) {
return a + 1, b + 1 //可以返回表达式
}
fn main() {
a, b := foo()
println(a) // 2
println(b) // 3
}
typedef struct multi_return_int_int multi_return_int_int;
struct multi_return_int_int {
int arg0;
int arg1;
};
VV_LOCAL_SYMBOL multi_return_int_int main__multi_return_fn(int a, int b);
//生成的返回值组合的结构体,还可以给其他函数共用
VV_LOCAL_SYMBOL multi_return_int_int main__multi_return_fn(int a, int b) {
return (multi_return_int_int){.arg0=a + 1, .arg1=b + 1};
}
VV_LOCAL_SYMBOL void main__main(void) {
multi_return_int_int mr_271 = main__foo();
int a = mr_271.arg0;
int b = mr_271.arg1;
println(int_str(a));
println(int_str(b));
}
fn main() {
a := [1, 3, 5]
b := ['a', 'b', 'c']
println(a)
println(b)
}
pub fn (mut a array) insert(i int, val voidptr) {
...
}
void array_insert(array *a, int i, void *val) { //默认第一个参数是对应类型指针
...
}
struct Foo {
a int //私有,不可变(默认).在模块内部可访问,不可修改;模块外不可访问,不可修改
mut:
b int // 私有,可变.在模块内部可访问,可修改,模块外部不可访问,不可修改
c int // (相同访问控制的字段可以放在一起)
pub:
d int // 公共,不可变,只读.在模块内部和外部都可以访问,但是不可修改
pub mut:
e int //公共,模块内部可访问,可修改;模块外部可访问,但是不可修改
__global:
f int // 全局字段,模块内部和外部都可访问,可修改,这样等于破坏了封装性,不推荐使用
}
fn main() {
f := Foo{}
println(f)
}
typedef struct main__Foo main__Foo;
struct main__Foo {
int a;
int b;
int c;
int d;
int e;
int f;
};
VV_LOCAL_SYMBOL void main__main(void) {
main__Foo f = ((main__Foo){.a = 0,.b = 0,.c = 0,.d = 0,.e = 0,.f = 0,});
println(main__Foo_str(f));
}
fn main() {
a := 10
b := 20
if a < b {
println('a<b')
} else if a > b {
println('a>b')
} else {
println('a=b')
}
}
VV_LOCAL_SYMBOL void main__main(void) {
int a = 10;
int b = 20;
if (a < b) {
println(_SLIT("a<b"));
} else if (a > b) {
println(_SLIT("a>b"));
} else {
println(_SLIT("a=b"));
}
}
fn main() {
num := 777
s := if num % 2 == 0 {
'even'
} else {
'odd'
}
println(s) // "odd"
}
VV_LOCAL_SYMBOL void main__main(void) {
int num = 777;
string s = (num % 2 == 0 ? (_SLIT("even")) : (_SLIT("odd")));
println(s);
}
struct None {}
//定义泛型联合类型,把泛型作为联合类型中的子类
type MyOption[T] = Error | None | T
fn unwrap_if[T](o MyOption[T]) T {
if o is T {
return o
}
panic('no value')
}
fn main() {
y := MyOption[bool](false)
println(unwrap_if(y)) //输出false
}
struct User {
name string
age int
}
pub fn (m &User) str() string {
return 'name:${m.name},age:${m.age}'
}
type MySum = User | int | string //联合类型声明
pub fn add(ms MySum) {
match ms {
int {
println('ms is int,value is ${ms.str()}')
}
string {
println('ms is string,value is ${ms}')
}
User {
println('ms is User,value is ${ms.str()}')
}
}
}
pub fn main() {
i := 1
add(i)
s := 'abc'
add(s)
u := User{
name: 'n'
age: 10
}
add(u)
}
