const (
	PI = 3.14
	WORLD = ‘世界‘
)
?
fn main() {
	println(PI)
	println(WORLD)
}

struct Color {
        r int
        g int
        b int
}
?
fn (c Color) str() string { return ‘{$c.r,$c.g,$c.b}‘ }
?
fn rgb(r,g,b int) Color { return Color{r: r,g: g,b: b} }
?
const (
        NUMBERS = [1,3]
?
        RED  = Color{r: 255,g: 0,b: 0}
        BLUE = rgb(0,255)
)
?
fn main() {
        println(NUMBERS)
        println(RED)
        println(BLUE)
} 

cd ~/code/modules
mkdir mymodule
vim mymodule/mymodule.v

// mymodule.v
module mymodule
?
// To export a function we have to use `pub`
pub fn say_hi() {
	println(‘hello from mymodule!‘)
}

module main
?
import mymodule
?
fn main() {
	mymodule.say_hi()
}

struct Dog {}
struct Cat {}
?
fn (d Dog) speak() string {
	return ‘woof‘
}
fn (c Cat) speak() string {
	return ‘meow‘
}
?
interface Speaker {
	speak() string
}
?
fn perform(s Speaker) {
	println(s.speak())
}
?
fn main() {
	dog := Dog{}
	cat := Cat{}
	perform(dog) // ==> "woof" 
	perform(cat) // ==> "meow" 
} 

enum Color {
	red,green,blue 
} 
?
fn main() {
	mut color := red  // TODO: color := Color.green  
	color = green  // TODO: color = .green 
	println(color) // ==> "1"  TODO: print "green"?  
}

Option/Result types & error handling

struct User {
	id int 
	name string
} 
?
struct Repo {
	users []User 
} 
?
fn new_repo() Repo {
	return Repo {
		users: [User{1,‘Andrew‘},User {2,‘Bob‘},User {10,‘Charles‘}]
	}
} 
?
fn (r Repo) find_user_by_id(id int) ?User { 
	for user in r.users {
		if user.id == id {
			// V automatically wraps this into an option type  
			return user 
		} 
	} 
	return error(‘User $id not found‘) 
} 
?
fn main() {
	repo := new_repo() 
	user := repo.find_user_by_id(10) or { // Option types must be handled by `or` blocks  
		return  // `or` block must end with `return`,`break`,or `continue`  
	} 
	println(user.id) // ==> "10"  
	println(user.name) // ==> ‘Charles‘
}

V将Option和Result组合成一种类型，因此您无需决定使用哪种类型。

将函数“升级”为可选函数所需的工作量很小：您必须添加一个?返回类型并在出现错误时返回错误。

如果您不需要返回错误，则只能return none。 （TODO：none还没有实现）。

这是V中处理错误的主要方法。它们仍然是值，但是错误处理要简洁很多。

当然，错误是可以被传递的：

resp := http.get(url)?
println(resp.body)

http.get返回的是?http.Response可选类型。如果错误发生，将传播到调用函数，这里是导致main函数抛出异常。

上面代码是下面代码的简写：

resp := http.get(url) or {
	panic(err)
}
println(resp.body)

V没有办法强制打开一个可选项（比如Rust的unwrap()或Swift中的!）。 你必须使用或{panic（err）}代替。

?

?

泛型(Generics)

*七月份恢复

struct Repo?T? {
	db DB
}
?
fn new_repo?T?(db DB) Repo?T? {
	return Repo?T?{db: db}
}
?
// This is a generic function. V will generate it for every type it‘s used with. 
fn (r Repo?T?) find_by_id(id int) ?T {  
	table_name := T.name // in this example getting the name of the type gives us the table name 
	return r.db.query_one?T?(‘select * from $table_name where id = ?‘,id)
}
?
db := new_db()
users_repo := new_repo?User?(db)
posts_repo := new_repo?Post?(db)
user := users_repo.find_by_id(1)? 
post := posts_repo.find_by_id(1)? 

为了方便阅读，允许使用??代替<>。vfmt最终会将??替换为<>。

The initial version of V had generics because arrays and maps were built with them. Later I figured out a way to implement these data structures without generics. This simplified code greatly.

Since I no longer needed them,they were moved to a branch,because maintaining generics is tough. Generics will not be available when the language is released in June,but they should be back by July.

摘录自V语言作者 Alex

并发(Concurrency)

?

Vlang的并发模型与Go非常相似。 要同时运行foo()，只需使用go foo()来调用它。 目前它在一个新的系统线程中运行该函数，很快就会实现goroutines和调度程序。

?

?

?

JSON解析(Decoding JSON)

import json
struct User {
	name string
	age  int
}
?
fn main() {
	data := ‘{ "name": "Frodo","age": 25 }‘
	user := json.decode(User,data) or {
		eprintln(‘Failed to decode json‘)
		return
	}
	println(user.name)
	println(user.age)
} 

?

JSON现在非常流行，这就是内置JSON支持的原因。

json.decode函数的第一个参数是要解码的类型。 第二个参数是要解析的json字符串。

V语言生成用于json编码和解码的代码，没有使用反射，这样性能更好。

?

?

测试(Testing)

// hello.v 
fn hello() string {
	return ‘Hello world‘
}
?
// hello_test.v 
fn test_hello() {
    assert hello() == ‘Hello world‘
} 

?

所有测试函数都必须放在?*_test.v文件中，并以?test_开头。 要运行测试，请执行?v hello_test.v。 要测试整个模块，请运行?v test mymodule。

?

?

内存管理(Memory management)

Vlang中没有垃圾收集或引用计数，在编译期间清理它能做的事情，比如:

fn draw_text(s string,x,y int) {
	...
}
?
fn draw_scene() {
	... 
	draw_text(‘hello $name1‘,10,10)
	draw_text(‘hello $name2‘,100,10)
	draw_text(strings.repeat(‘X‘,10000),50)
	... 
}

?

字符串不会转义draw_text，因此在函数退出时会清除它们。

事实上，前两个调用根本不会产生任何分配。 这两个字符串很小，V将为它们使用预分配的缓冲区。

对于更复杂的情况，需要手动内存管理。 这将很快修复。

V将在运行时检测内存泄漏并报告它们。 要清理（例如）数组，请使用free()方法：

numbers := [0; 1000000] 
...
numbers.free()

#flag -lsqlite3
?
#include "sqlite3.h"
?
struct C.sqlite3
struct C.sqlite3_stmt
?
fn C.sqlite3_column_int(C.sqlite_stmt,int) int
?
fn main() {
	path := ‘sqlite3_users.db‘
	db := &C.sqlite3{}
	C.sqlite3_open(path.cstr(),&db)
?
	query := ‘select count(*) from users‘
	stmt := &C.sqlite3_stmt{}
	C.sqlite3_prepare_v2(db,query.cstr(),- 1,&stmt,0)
	C.sqlite3_step(stmt)
	nr_users := C.sqlite3_column_int(res,0)
	C.sqlite3_finalize(res)
	println(nr_users)
} 

struct Vec {
	x int
	y int
}
?
fn (a Vec) str() string { 
	return ‘{$a.x,$a.y}‘ 
}
?
fn (a Vec) + (b Vec) Vec {
	return Vec {
		a.x + b.x,a.y + b.y 
	}
}
?
fn (a Vec) - (b Vec) Vec {
	return Vec {
		a.x - b.x,a.y - b.y
	}
}
?
fn main() { 
	a := Vec{2,3}
	b := Vec{4,5}
	println(a + b) // ==> "{6,8}"  
	println(a - b) // ==> "{-2,-2}"  
} 

#include <vector>
#include <string>
#include <iostream>
?
int main() {
        std::vector<std::string> s;
        s.push_back("V is ");
        s.push_back("awesome");
        std::cout << s.size() << std::endl;
        return 0;
} 

fn main {
        mut s := []string
	s << ‘V is ‘
	s << ‘awesome‘
	println(s.len)
}