git clone https://github.com/vlang/v
cd v
make
# ヒント: Windows をお使いですか?: cmd.exe シェルで make.bat を実行してみましょう

fn main() {
	println('hello world')
}

println('hello world')

import os

println(os.args)

// これは単行コメント。
/*
これは複行コメント。
   /* ネストできます。 */
*/

fn main() {
    println(add(77, 33))
    println(sub(100, 50))
}

fn add(x int, y int) int {
    return x + y
}

fn sub(x, y int) int {
    return x - y
}

fn foo() (int, int) {
    return 2, 3
}

a, b := foo()
println(a) // 2
println(b) // 3
c, _ := foo() // `_` で値を無視します

pub fn public_function() {
}

fn private_function() {
}

name := 'Bob'
age := 20
large_number := i64(9999999999)
println(name)
println(age)
println(large_number)

mut age := 20
println(age)
age = 21
println(age)

fn main() {
    age = 21
}

fn main() {
    age := 21
}

mut a := 0
mut b := 1
println('${a}, ${b}') // 0, 1
a, b = b, a
println('${a}, ${b}') // 1, 0

fn main() {
    a := 10
    if true {
        a := 20 // エラー: 変数の再定義
    }
    // 警告: 未使用の変数 `a`
}

bool

string

i8    i16  int  i64      i128 (そのうち)
u8    u16  u32  u64      u128 (そのうち)

rune // Unicode コードポイントに相当

f32 f64

isize, usize // プラットフォーム依存の、メモリ上の位置を表すのに必要なサイズ

voidptr // C との相互運用に用いられる

any // C の void* や Go の interface{} のようなもの

   i8 → i16 → int → i64
                  ↘     ↘
                    f32 → f64
                  ↗     ↗
   u8 → u16 → u32 → u64 ⬎
      ↘     ↘     ↘      ptr
   i8 → i16 → int → i64 ⬏

u := u16(12)
v := 13 + u    // v の型は `u16` - 拡大変換なし
x := f32(45.6)
y := x + 3.14  // y の型は `f32` - 拡大変換なし
a := 75        // a の型は `int` - int リテラルなのでデフォルト通り
b := 14.7      // b の型は `f64` - float リテラルなのでデフォルト通り
c := u + a     // c の型は `int` - `u` の値を自動的に拡大変換
d := b + x     // d の型は `f64` - `x` の値を自動的に拡大変換

name := 'Bob'
assert name.len == 3       // 3 を返します
assert name[0] == u8(66) // 添字アクセスはバイトとして、u8(66) == `B` を与えます
assert name[1..3] == 'ob'  // スライスは文字列 'ob' を与えます

// エスケープコード
windows_newline := '\r\n'      // エスケープ特殊文字は C のようにします
assert windows_newline.len == 2

// 任意バイトは `\x##` 記法で直接指定でき、`#` は
// 16 進数の一桁です。
aardvark_str := '\x61ardvark'
assert aardvark_str == 'aardvark'
assert '\xc0'[0] == u8(0xc0)

// また `\###` 記法では、`#` を 8 進数の一桁とした 8 進エスケープができます。
aardvark_str2 := '\141ardvark'
assert aardvark_str2 == 'aardvark'

// Unicode は `\u####` で直接指定でき、この `#` 16 進数の一桁です。
// そしてこれは内部で UTF-8 表現へと変換されます。
star_str := '\u2605' // ★
assert star_str == '★'
assert star_str == '\xe2\x98\x85' // UTF-8 はこのように指定することもできます。

s := 'hello 🌎' // 絵文字が 4 バイト使う
assert s.len == 10

arr := s.bytes() // `string` を `[]u8` へ変換
assert arr.len == 10

s2 := arr.bytestr() // `[]u8` を `string` へ変換
assert s2 == s

mut s := 'hello 🌎'
s[0] = `H` // 不可能

country := 'Netherlands'
println(country[0]) // 出力: 78
println(country[0].ascii_str()) // 出力: N

s := r'hello\nworld'
println(s) // "hello\nworld"

s := '42'
n := s.int() // 42

// すべての整数リテラルをサポートしています
assert '0xc3'.int() == 195
assert '0o10'.int() == 8
assert '0b1111_0000_1010'.int() == 3850
assert '-0b1111_0000_1010'.int() == -3850

name := 'Bob'
println('Hello, ${name}!') // Hello, Bob!

x := 123.4567
println('[${x:.2}]') // 小数点以下第二位で丸める => [123.46]
println('[${x:10}]') // 左に空白の右寄せ => [   123.457]
println('[${int(x):-10}]') // 右に空白の左寄せ => [123       ]
println('[${int(x):010}]') // 左を 0 埋め => [0000000123]
println('[${int(x):b}]') // 2 進数として出力 => [1111011]
println('[${int(x):o}]') // 8 進数として出力 => [173]
println('[${int(x):X}]') // 大文字の 16 進数として出力 => [7B]

println('[${10.0000:.2}]') // 末尾の無効な 0 を取り除く => [10]
println('[${10.0000:.2f}]') // 数に影響しない末尾の 0 でも表示する => [10.00]

name := 'Bob'
bobby := name + 'by' // 文字列結合には + を使います
println(bobby) // "Bobby"
mut s := 'hello '
s += 'world' // 文字列の追加は `+=` です
println(s) // "hello world"

age := 10
println('age = ' + age) // 不可能

age := 11
println('age = ' + age.str())

age := 12
println('age = ${age}')

rocket := `🚀`

rocket := `🚀`
assert rocket.str() == '🚀'

rocket := `🚀`
assert rocket.bytes() == [u8(0xf0), 0x9f, 0x9a, 0x80]

assert `\x61` == `a`
assert `\141` == `a`
assert `\u0061` == `a`

// マルチバイトリテラルも同じく動作します
assert `\u2605` == `★`
assert `\u2605`.bytes() == [u8(0xe2), 0x98, 0x85]
assert `\xe2\x98\x85`.bytes() == [u8(0xe2), 0x98, 0x85]
assert `\342\230\205`.bytes() == [u8(0xe2), 0x98, 0x85]

rocket_string := '🚀'
assert rocket_string[0] != `🚀`
assert 'aloha!'[0] == `a`

hello := 'Hello World 👋'
hello_runes := hello.runes() // [`H`, `e`, `l`, `l`, `o`, ` `, `W`, `o`, `r`, `l`, `d`, ` `, `👋`]

a := 123

a := 0x7B
b := 0b01111011
c := 0o173

num := 1_000_000 // 1000000 と同じ
three := 0b0_11 // 0b11 と同じ
float_num := 3_122.55  // 3122.55 と同じ
hexa := 0xF_F // 255 と同じ
oct := 0o17_3 // 0o173 と同じ

a := i64(123)
b := u8(42)
c := i16(12345)

f := 1.0
f1 := f64(3.14)
f2 := f32(3.14)

f0 := 42e1 // 420
f1 := 123e-2 // 1.23
f2 := 456e+2 // 45600

mut nums := [1, 2, 3]
println(nums) // `[1, 2, 3]`
println(nums[0]) // `1`
println(nums[1]) // `2`

nums[1] = 5
println(nums) // `[1, 5, 3]`

mut nums := [1, 2, 3]
nums << 4
println(nums) // "[1, 2, 3, 4]"

// 配列を追加する
nums << [5, 6, 7]
println(nums) // "[1, 2, 3, 4, 5, 6, 7]"

mut names := ['John']
names << 'Peter'
names << 'Sam'
// names << 10  <-- これはコンパイルされません。`names` は文字列の配列です。

names := ['John', 'Peter', 'Sam']
println('Alex' in names) // "false"

mut nums := [1, 2, 3]
println(nums.len) // "3"
println(nums.cap) // "3" 以上
nums = [] // 配列が空になります
println(nums.len) // "0"

mut a := []int{len: 10000, cap: 30000, init: 3}

arr := []int{len: 5, init: -1}
// `arr == [-1, -1, -1, -1, -1]`, arr.cap == 5

// 空の配列の宣言:
users := []int{}

mut numbers := []int{ cap: 1000 }
println(numbers.len) // 0
// この要素の追加では再確保しない
for i in 0 .. 1000 {
    numbers << i
}

count := []int{len: 4, init: index}
assert count == [0, 1, 2, 3]

mut square := []int{len: 6, init: index * index}
// square == [0, 1, 4, 9, 16, 25]

struct Point {
	x int
	y int
}

struct Line {
	p1 Point
	p2 Point
}

type ObjectSumType = Line | Point

mut object_list := []ObjectSumType{}
object_list << Point{1, 1}
object_list << Line{
	p1: Point{3, 3}
	p2: Point{4, 4}
}
dump(object_list)
/*
object_list: [ObjectSumType(Point{
    x: 1
    y: 1
}), ObjectSumType(Line{
    p1: Point{
        x: 3
        y: 3
    }
    p2: Point{
        x: 4
        y: 4
    }
})]
*/

mut a := [][]int{len:2, init: []int{len:3}}
a[0][1] = 2
println(a) // [[0, 2, 0], [0, 0, 0]]

mut a := [][][]int{len:2, init: [][]int{len:3, init: []int{len:2}}}
a[0][1][1] = 2
println(a) // [[[0, 0], [0, 2], [0, 0]], [[0, 0], [0, 0], [0, 0]]]

nums := [1, 2, 3]
nums_copy := nums.clone()

nums := [1, 2, 3, 4, 5, 6]
even := nums.filter(it % 2 == 0)
println(even) // [2, 4, 6]
// filter には無名関数が使える
even_fn := nums.filter(fn (x int) bool {
	return x % 2 == 0
})
println(even_fn)

words := ['hello', 'world']
upper := words.map(it.to_upper())
println(upper) // ['HELLO', 'WORLD']
// map にも無名関数が使える
upper_fn := words.map(fn (w string) string {
	return w.to_upper()
})
println(upper_fn) // ['HELLO', 'WORLD']

nums := [1, 2, 3]
println(nums.any(it == 2)) // true
println(nums.all(it >= 2)) // false

mut numbers := [1, 3, 2]
numbers.sort() // 1, 2, 3
numbers.sort(a > b) // 3, 2, 1

struct User {
	age  int
	name string
}

mut users := [User{21, 'Bob'}, User{20, 'Zarkon'}, User{25, 'Alice'}]
users.sort(a.age < b.age) // User.age int フィールドでソート
users.sort(a.name > b.name) // User.name string フィールドで逆順にソート

struct User {
	age  int
	name string
}

mut users := [User{21, 'Bob'}, User{65, 'Bob'}, User{25, 'Alice'}]

custom_sort_fn := fn (a &User, b &User) int {
	// a が b より前なら -1 を返す
	// 療法が同じ順番なら 0 を返す
	// b が a より前なら 1 を返す
	if a.name == b.name {
		if a.age < b.age {
			return 1
		}
		if a.age > b.age {
			return -1
		}
		return 0
	}
	if a.name < b.name {
		return -1
	} else if a.name > b.name {
		return 1
	}
	return 0
}
users.sort_with_compare(custom_sort_fn)

nums := [0, 10, 20, 30, 40]
println(nums[1..4]) // [10, 20, 30]
println(nums[..4]) // [0, 10, 20, 30]
println(nums[1..]) // [10, 20, 30, 40]

array_1 := [3, 5, 4, 7, 6]
mut array_2 := [0, 1]
array_2 << array_1[..3]
println(array_2) // [0, 1, 3, 5, 4]

mut a := [0, 1, 2, 3, 4, 5]
mut b := a[2..4]
b[0] = 7 // `b[0]` は `a[2]` を参照しています
println(a) // `[0, 1, 7, 3, 4, 5]`
b << 9
// `b` は再確保され `a` から独立するようになります
println(a) // `[0, 1, 7, 3, 4, 5]` - 変更なし
println(b) // `[7, 3, 9]`

mut a := []int{len: 5, cap: 6, init: 2}
mut b := unsafe { a[1..4] }
a << 3
// 再確保なし - `cap` に収まります
b[2] = 13 // `a[3]` が変更されます
a << 4
// `a` は再確保され `b` から独立するようになります (`cap` が増加します)
b[1] = 3 // `a` は変化しません
println(a) // `[2, 2, 2, 13, 2, 3, 4]`
println(b) // `[2, 3, 13]`

mut a := [0, 1, 2, 3, 4, 5]
mut b := a[2..4].clone()
b[0] = 7 // 注意: `b[0]` は `a[2]` を参照していません。.clone() しなければ参照するようになります
println(a) // [0, 1, 2, 3, 4, 5]
println(b) // [7, 3]

a := [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
println(a#[-3..]) // [7, 8, 9]
println(a#[-20..]) // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
println(a#[-20..-8]) // [0, 1]
println(a#[..-3]) // [0, 1, 2, 3, 4, 5, 6]

// 空の配列
println(a#[-20..-10]) // []
println(a#[20..10]) // []
println(a#[20..30]) // []

// filter、map、負の配列スライスの利用
files := ['pippo.jpg', '01.bmp', '_v.txt', 'img_02.jpg', 'img_01.JPG']
filtered := files.filter(it#[-4..].to_lower() == '.jpg').map(it.to_upper())
// ['PIPPO.JPG', 'IMG_02.JPG', 'IMG_01.JPG']

mut fnums := [3]int{} // fnums は 3 要素の固定長配列です。
fnums[0] = 1
fnums[1] = 10
fnums[2] = 100
println(fnums) // => [1, 10, 100]
println(typeof(fnums).name) // => [3]int

fnums2 := [1, 10, 100]! // 同じことをする短縮初期化構文 (構文は変わる可能性あり)

anums := fnums[0..fnums.len]
println(anums) // => [1, 10, 100]
println(typeof(anums).name) // => []int

mut m := map[string]int // `string` をキーに `int` を格納する辞書配列
m['one'] = 1
m['two'] = 2
println(m['one']) // "1"
println(m['bad_key']) // "0"
println('bad_key' in m) // `in` を使ってそのようなキーが存在するかどうか検出する
m.delete('two')

numbers := {
	1: 'one'
	2: 'two'
}
println(numbers)

sm := {
	'abc': 'xyz'
}
val := sm['bad_key']
println(val) // ''

intm := {
	1: 1234
	2: 5678
}
s := intm[3]
println(s) // 0

mm := map[string]int{}
val := mm['bad_key'] or { panic('key not found') }

m := {
	'abc': 'def'
}
if v := m['abc'] {
	println('the map value for that key is: ${v}')
}

arr := [1, 2, 3]
large_index := 999
val := arr[large_index] or { panic('out of bounds') }
println(val)
// エラーを伝搬したい場合、以下のようにすることもできます。
val2 := arr[333]!
println(val2)

mut m := map[string]map[string]int{}
m['greet'] = {
	'Hello': 1
}
m['place'] = {
	'world': 2
}
m['code']['orange'] = 123
print(m)

import os

fn main() {
    // stdin からテキストを読み取る
    name := os.input('Enter your name: ')
    println('Hello, ${name}!')
}

import os { input }

fn main() {
	// 標準入力からテキストを読む
	name := input('Enter your name: ')
	println('Hello, $name!')
}

import os { input, user_os }

name := input('Enter your name: ')
println('Name: ${name}')
current_os := user_os()
println('Your OS is ${current_os}.')

import crypto.sha256
import mymod.sha256 as mysha256

fn main() {
    v_hash := sha256.sum('hi'.bytes()).hex()
    my_hash := mysha256.sum('hi'.bytes()).hex()
    assert my_hash == v_hash
}

import time

type MyTime = time.Time

fn (mut t MyTime) century() int {
    return 1 + t.year % 100
}

fn main() {
    my_time := MyTime{
        year: 2020,
        month: 12,
        day: 25
    }
    println(time.new_time(my_time).utc_string())
    println('Century: ${my_time.century()}')
}

a := 10
b := 20
if a < b {
    println('${a} < ${b}')
} else if a > b {
    println('${a} > ${b}')
} else {
    println('${a} == ${b}')
}

num := 777
s := if num % 2 == 0 { 'even' } else { 'odd' }
println(s)
// "odd"

m := {
	'foo': 'bar'
}
// handle missing keys
if v := m['foo'] {
	println(v) // bar
} else {
	println('not found')
}

fn res() !int {
	return 42
}
// functions that return a result type
if v := res() {
	println(v)
}

struct User {
	name string
}
arr := [User{'John'}]
// if unwrapping with assignment of a variable
u_name := if v := arr[0] {
	v.name
} else {
	'Unnamed'
}
println(u_name) // John

struct Abc {
    val string
}
struct Xyz {
    foo string
}

type Alphabet = Abc | Xyz

x := Alphabet(Abc{'test'}) // 直和型
if x is Abc {
    // x は自動で Abc にキャストをされここで使える
    println(x)
}
if x !is Abc {
    println('Not Abc')
}

match x {
	Abc {
		// x は自動で Abc へキャストされてここで使える
		println(x)
	}
	Xyz {
		// x は自動で Xyz へキャストされてここで使える
		println(x)
	}
}

struct MyStruct {
	x int
}

struct MyStruct2 {
	y string
}

type MySumType = MyStruct | MyStruct2

struct Abc {
	bar MySumType
}

x := Abc{
	bar: MyStruct{123} // MyStruct は自動的に MySumType 型へ変換される
}
if x.bar is MyStruct {
	// x.bar は自動でキャストされる
	println(x.bar)
} else if x.bar is MyStruct2 {
	new_var := x.bar as MyStruct2
	// もしくは `as` を用いて手動でキャストすることもできます。
	println(new_var)
}
match x.bar {
	MyStruct {
		// x.bar は自動でキャストされる
		println(x.bar)
	}
	else {}
}

mut x := MySumType(MyStruct{123})
if mut x is MyStruct {
	// x が可変であっても MyStruct へキャストされる
	// mut キーワードがなければ動作しない
	println(x)
}
// match も同様
match mut x {
	MyStruct {
		// x が可変であっても MyStruct へキャストされる
		// mut キーワードがなければ動作しない
		println(x)
	}
}

nums := [1, 2, 3]
println(1 in nums) // true
println(4 !in nums) // true
m := {
	'one': 1
	'two': 2
}
println('one' in m) // true
println('three' !in m) // true

m := {
	'one': 1
	'two': 2
}

println('one' in m) // true
println('three' !in m) // true

enum Token {
	plus
	minus
	div
	mult
}

struct Parser {
	token Token
}

parser := Parser{}
if parser.token == .plus || parser.token == .minus || parser.token == .div || parser.token == .mult {
    ...
}
if parser.token in [.plus, .minus, .div, .mult] {
    ...
}

os := 'windows'
print('V is running on ')
match os {
    'darwin' { println('macOS.') }
    'linux'  { println('Linux.') }
    else     { println(os) }
}

number := 2
s := match number {
    1 { 'one' }
    2 { 'two' }
    else { 'many' }
}

enum Color {
    red
    blue
    green
}

fn is_red_or_blue(c Color) bool {
    return match c {
        .red, .blue { true } // カンマで分けて複数の値を検知できる
        .green  { false }
    }
}

c := `v`
typ := match c {
    `0`...`9` { 'digit' }
    `A`...`Z` { 'uppercase' }
    `a`...`z` { 'lowercase' }
    else      { 'other' }
}
println(typ)
// 'lowercase'

numbers := [1, 2, 3, 4, 5]
for num in numbers {
	println(num)
}
names := ['Sam', 'Peter']
for i, name in names {
	println('${i}) ${name}')
	// Output: 0) Sam
	//         1) Peter
}

mut numbers := [0, 1, 2]
for mut num in numbers {
    num++
}
println(numbers) // [1, 2, 3]

struct SquareIterator {
	arr []int
mut:
	idx int
}

fn (mut iter SquareIterator) next() ?int {
	if iter.idx >= iter.arr.len {
		return none
	}
	defer {
		iter.idx++
	}
	return iter.arr[iter.idx] * iter.arr[iter.idx]
}

nums := [1, 2, 3, 4, 5]
iter := SquareIterator{
	arr: nums
}
for squared in iter {
	println(squared)
}

1
4
9
16
25

m := {'one':1, 'two':2}
for key, value in m {
    println("${key} -> ${value}")  // 出力: one -> 1
}                              //      two -> 2

m := {
	'one': 1
	'two': 2
}
// キーで繰り返し
for key, _ in m {
	println(key)
	// Output: one
	//         two
}
// 値で繰り返し
for _, value in m {
	println(value)
	// Output: 1
	//         2
}

// '01234' と出力する
for i in 0..5 {
    print(i)
}

mut sum := 0
mut i := 0
for i <= 100 {
    sum += i
    i++
}
println(sum) // "5050"

mut sum := 0
for {
    num++
    if num >= 10 {
        break
    }
}
println(num) // "10"

for i := 0; i < 10; i++ {
    // 6 は出力しない
    if i == 6 {
        continue
    }
    println(i)
}

outer: for i := 4; true; i++ {
	println(i)
	for {
		if i < 7 {
			continue outer
		} else {
			break outer
		}
	}
}

4
5
6
7

fn read_log() {
    mut ok := false
    mut f := os.open('log.txt') or { panic(err) }
    defer { f.close() }
    // ...
    if !ok {
        // defer 文がここで呼び出され、ファイルが閉じられる
        return
    }
    // ...
    // defer 文がここで呼び出され、ファイルが閉じられる
}

import os

enum State {
	normal
	write_log
	return_error
}

// ログファイルを書き込んで、書き込んだバイト数を返す
fn write_log(s State) !int {
	mut f := os.create('log.txt')!
	defer {
		f.close()
	}
	if s == .write_log {
		// `f.close()` は、`f.write()` が実行された後、
		// `write_log()` が最終的に書き込まれたバイト数を
		// `main()` へ返す前に呼び出されます
		return f.writeln('This is a log file')
	} else if s == .return_error {
		// ファイルは `error()` 関数が返された後に
		// クローズされるので、エラーメッセージにはオープン
		// と表示されます
		return error('nothing written; file open: ${f.is_opened}')
	}
	// ここでもファイルは閉じられます
	return 0
}

fn main() {
	n := write_log(.return_error) or {
		println('Error: ${err}')
		0
	}
	println('${n} bytes written')
}

fn (mut app App) auth_middleware() bool {
	defer {
		if !$res() {
			app.response.status_code = 401
			app.response.body = 'Unauthorized'
		}
	}
	header := app.get_header('Authorization')
	if header == '' {
		return false
	}
	return true
}
fn (mut app App) auth_with_user_middleware() (bool, string) {
	defer {
		if !$res(0) {
			app.response.status_code = 401
			app.response.body = 'Unauthorized'
		} else {
			app.user = $res(1)
		}
	}
	header := app.get_header('Authorization')
	if header == '' {
		return false, ''
	}
	return true, 'TestUser'
}

if x {
	// ...
	if y {
        unsafe {
    		goto my_label
        }
	}
	// ...
}
my_label:

struct Point {
    x int
    y int
}

p := Point{
    x: 10
    y: 20
}
println(p.x) // 構造体のフィールドはドットでアクセスできます
// もう一つのリテラル構文
p = Point{10, 20}
assert p.x == 10

struct Point {
    x int
    y int
}
p := &Point{10, 10}
// 参照にもフィールドにアクセスする構文がある
println(p.x)

struct Foo {
mut:
	x int
}

fa := Foo{1}
mut a := fa
a.x = 2
assert fa.x == 1
assert a.x == 2

// fb := Foo{ 1 }
// mut b := &fb  // error: `fb` is immutable, cannot have a mutable reference to it
// b.x = 2

mut fc := Foo{1}
mut c := &fc
c.x = 2
assert fc.x == 2
assert c.x == 2
println(fc) // Foo{ x: 2 }
println(c) // &Foo{ x: 2 } // `&` の接頭辞に注意。

struct Foo {
    n   int      // n は 0 がデフォルト値
    s   string   // s は '' がデフォルト値
    a   []int    // a は `[]int{}` がデフォルト値
    pos int = -1 // カスタムデフォルト値
}

struct Foo {
	n int [required]
}

_ = Foo{}

struct Point{
    x int
    y int
}
mut p := Point{
	x: 10
	y: 20
}
// 構造体名が分かっているので省略できます
p = Point{
	x: 30
	y: 4
}
assert p.y == 4
//
// 配列: 最初の要素が配列の型を決定する
points := [Point{10, 20}, Point{20, 30}, Point{40, 50}]
println(points) // [Point{x: 10, y: 20}, Point{x: 20, y: 30}, Point{x: 40,y: 50}]

struct User {
	name          string
	age           int
	is_registered bool
}

fn register(u User) User {
	return User{
		...u
		is_registered: true
	}
}

mut user := User{
	name: 'abc'
	age: 23
}
user = register(user)
println(user)

[params]
struct ButtonConfig {
    text        string
    is_disabled bool
    width       int = 70
    height      int = 20
}

fn new_button(c ButtonConfig) &Button {
    return &Button{
        width: c.width
        height: c.height
        text: c.text
    }
}

button := new_button(text:'Click me', width:100)
// height を指定していないので、デフォルト値になります
assert button.height == 20

new_button(ButtonConfig{text:'Click me', width:100})

struct Foo {
    a int     // 非公開 イミュータブル (デフォルト)
mut:
    b int     // 非公開 ミュータブル
    c int     // (同じアクセス指定で複数のフィールドを並べられる)
pub:
    d int     // 公開 イミュータブル (読み取り専用)
pub mut:
    e int     // 公開 親モジュールでのみミュータブル
__global:
    f int     // 公開かつ親モジュールの内側でも外側でもミュータブル
}             // (利用を推奨していないので、'global' キーワードは __ で始まります)

struct Book {
	author struct {
		name string
		age  int
	}

	title string
}

book := Book{
	author: struct {
		name: 'Samantha Black'
		age: 24
	}
}
assert book.author.name == 'Samantha Black'
assert book.author.age == 24

struct User {}

fn User.new() User {
	return User{}
}

user := User.new()

module sample

[noinit]
pub struct Information {
pub:
	data string
}

pub fn new_information(data string) !Information {
	if data.len == 0 || data.len > 100 {
		return error('data must be between 1 and 100 characters')
	}
	return Information{
		data: data
	}
}

import sample

fn main() {
	// こちらは [noinit] 属性があるため使えません。
	// info := sample.Information{
	// 	data: 'Sample information.'
	// }

	// こちらを使用します。
	info := sample.new_information('Sample information.')!

	println(info)
}

struct User {
    age int
}

fn (u User) can_register() bool {
    return u.age > 16
}

user := User{
	age: 10
}
println(user.can_register()) // "false"
user2 := User{
	age: 20
}
println(user2.can_register()) // "true"

struct Size {
mut:
	width  int
	height int
}

fn (s &Size) area() int {
	return s.width * s.height
}

struct Button {
	Size
	title string
}

mut button := Button{
	title: 'Click me'
	height: 2
}

button.width = 3
assert button.area() == 6
assert button.Size.area() == 6
print(button)

Button{
    Size: Size{
        width: 3
        height: 2
    }
    title: 'Click me'
}

mut button := Button{
	Size: Size{
		width: 3
		height: 2
	}
}

button.Size = Size{
	width: 4
	height: 5
}

struct Rgba32_Component {
	r u8
	g u8
	b u8
	a u8
}

union Rgba32 {
	Rgba32_Component
	value u32
}

clr1 := Rgba32{
	value: 0x008811FF
}

clr2 := Rgba32{
	Rgba32_Component: Rgba32_Component{
		a: 128
	}
}

sz := sizeof(Rgba32)
unsafe {
	println('Size: ${sz}B,clr1.b: ${clr1.b},clr2.b: ${clr2.b}')
}

struct User {
	name string
mut:
    is_registered bool
}

fn (mut u User) register() {
    u.is_registered = true
}

mut user := User{}
println(user.is_registered) // "false"
user.register()
println(user.is_registered) // "true"

fn multiply_by_2(mut arr []int) {
    for i in 0..arr.len {
        arr[i] *= 2
    }
}

mut nums := [1, 2, 3]
multiply_by_2(mut nums)
println(nums) // "[2, 4, 6]"

fn sum(a ...int) int {
    mut total := 0
    for x in a {
        total += x
    }
    return total
}
println(sum())     // 出力: 0
println(sum(1))    //      1
println(sum(2, 3)) //      5
// 配列展開を使用
a := [2, 3, 4]
println(sum(...a)) // <-- ... 接頭子をここで使います。出力: 9
b := [5, 6, 7]
println(sum(...b)) // 出力: 18

fn sqr(n int) int {
	return n * n
}

fn cube(n int) int {
	return n * n * n
}

fn run(value int, op fn (int) int) int {
	return op(value)
}

fn main() {
	// 関数は他の関数に渡せる
	println(run(5, sqr)) // "25"
	// 関数の中で無名の関数を宣言できる
	double_fn := fn (n int) int {
		return n + n
	}
	println(run(5, double_fn)) // "10"
	// 変数に代入しなくても、関数を渡したりできる
	res := run(5, fn (n int) int {
		return n + n
	})
	println(res) // "10"
	// 関数の配列/辞書配列もできる
	fns := [sqr, cube]
	println(fns[0](10)) // "100"
	fns_map := {
		'sqr':  sqr
		'cube': cube
	}
	println(fns_map['cube'](2)) // "8"
}

my_int := 1
my_closure := fn [my_int] () {
	println(my_int)
}
my_closure() // 1 を出力する

mut i := 1
func := fn [i] () int {
	return i
}
println(func() == 1) // true
i = 123
println(func() == 1) // true のまま

fn new_counter() fn () int {
	mut i := 0
	return fn [mut i] () int {
		i++
		return i
	}
}

c := new_counter()
println(c()) // 1
println(c()) // 2
println(c()) // 3

mut i := 0
mut ref := &i
print_counter := fn [ref] () {
	println(*ref)
}

print_counter() // 0
i = 10
print_counter() // 10

fn f(a1 int, a2 int, a3 int) {
	dump(a1 + a2 + a3)
}

fn main() {
	f(dump(100), dump(200), dump(300))
}

struct Foo{}

fn (foo Foo) bar_method() {
	// ...
}

fn bar_function(foo Foo) {
	// ...
}

struct Foo {
	abc int
}

fn (foo &Foo) bar() {
	println(foo.abc)
}

struct Node[T] {
	val   T
	left  &Node[T]
	right &Node[T]
}

const (
    pi    = 3.14
    world = '世界'
)

println(pi)
println(world)

const e = 2.71828

struct Color {
	r int
	g int
	b int
}

fn rgb(r int, g int, b int) Color {
	return Color{
		r: r
		g: g
		b: b
	}
}

const (
	numbers = [1, 2, 3]
	red     = Color{
		r: 255
		g: 0
		b: 0
	}
	// 関数呼び出しはコンパイル時に評価される
	blue    = rgb(0, 0, 255)
)

println(numbers)
println(red)
println(blue)

module mymodule

pub const golden_ratio = 1.61803

fn calc() {
	println(mymodule.golden_ratio)
}

fn print(s string) // 標準出力に出力します
fn println(s string) // 標準出力に出力して改行します

fn eprint(s string) // print() と同じですが、標準エラー出力を使います
fn eprintln(s string) // println() と同じですが、標準エラー出力を使います

fn exit(code int) // 指定のエラーコードでプログラムを終了します
fn panic(s string) // メッセージとバックトレースを標準エラー出力に出力して、エラーコード 1 でプログラムを終了します
fn print_backtrace() // バックトレースを標準エラー出力に出力します

struct User {
	name string
	age  int
}

println(1) // "1"
println('hi') // "hi"
println([1, 2, 3]) // "[1, 2, 3]"
println(User{ name: 'Bob', age: 20 }) // "User{name:'Bob', age:20}"

struct Color {
    r int
    g int
    b int
}

pub fn (c Color) str() string {
	return '{${c.r}, ${c.g}, ${c.b}}'
}

red := Color{
	r: 255
	g: 0
	b: 0
}
println(red)

fn factorial(n u32) u32 {
	if dump(n <= 1) {
		return dump(1)
	}
	return dump(n * factorial(n - 1))
}

fn main() {
	println(factorial(5))
}

[factorial.v:2] n <= 1: false
[factorial.v:2] n <= 1: false
[factorial.v:2] n <= 1: false
[factorial.v:2] n <= 1: false
[factorial.v:2] n <= 1: true
[factorial.v:3] 1: 1
[factorial.v:5] n * factorial(n - 1): 2
[factorial.v:5] n * factorial(n - 1): 6
[factorial.v:5] n * factorial(n - 1): 24
[factorial.v:5] n * factorial(n - 1): 120
120

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

module mymodule

// 関数をエクスポートするには `pub` を使用します
pub fn say_hi() {
    println('hello from mymodule!')
}

// myfile2.v
module mymodule

pub fn say_hi_and_bye() {
	say_hi() // myfile.v から
	println('goodbye from mymodule')
}

import mymodule

fn main() {
    mymodule.say_hi()
    mymodule.say_hi_and_bye()
}

fn init() {
    // ここにセットアップコード ...
}

enum Color as u8 {
    red green blue
}

mut color := Color.red
// V は `color` が `Color` 型だとわかっています。ここで `color = Color.green` とする必要はありません。
color = .green
println(color) // "green"
match color {
	.red { println('the color was red') }
	.green { println('the color was green') }
	.blue { println('the color was blue') }
}

enum Color {
	@none
	red
	green
	blue
}

color := Color.@none
println(color)

enum Grocery {
	apple
	orange = 5
	pear
}

g1 := int(Grocery.apple)
g2 := int(Grocery.orange)
g3 := int(Grocery.pear)
println('Grocery IDs: ${g1}, ${g2}, ${g3}')

enum Cycle {
	one
	two
	three
}

fn (c Cycle) next() Cycle {
	match c {
		.one {
			return .two
		}
		.two {
			return .three
		}
		.three {
			return .one
		}
	}
}

mut c := Cycle.one
for _ in 0 .. 10 {
	println(c)
	c = c.next()
}

one
two
three
one
two
three
one
two
three
one

type Filter = fn (string) string

type Filter = fn (string) string

fn filter(s string, f Filter) string {
	return f(s)
}

fn uppercase(s string) string {
	return s.to_upper()
}

// これで `uppercase` は Filter を必要とするあらゆる場所で使用できる

my_filter := Filter(uppercase)

my_filter := uppercase

println(filter('Hello world', my_filter)) // `HELLO WORLD` と出力する

println(filter('Hello world', uppercase))

println(filter('Hello world', fn (s string) string {
	return s.to_upper()
}))

struct Dog {
	breed string
}

struct Cat {
	breed string
}

fn (d Dog) speak() string {
	return 'woof'
}

fn (c Cat) speak() string {
	return 'meow'
}

// Go とは異なり、TypeScript と同様に V のインターフェイスはメソッドだけでなくフィールドも定義できます。
interface Speaker {
	breed string
	speak() string
}

dog := Dog{'Leonberger'}
cat := Cat{'Siamese'}

mut arr := []Speaker{}
arr << dog
arr << cat
for item in arr {
	println('a $item.breed says: $item.speak()')
}

module main

interface Foo {
	write(string) string
}

// => この型のメソッドシグネチャでは、Foo を実装するときはこのようになります。
// `fn (s Type) write(a string) string`

interface Bar {
mut:
	write(string) string
}

// => この型のメソッドシグネチャでは、Bar を実装するときはこのようになります。
// `fn (mut s Type) write(a string) string`

struct MyStruct {}

// MyStruct はインターフェイス Foo を実装していますが、インターフェイス Bar は実装 *していません*
fn (s MyStruct) write(a string) string {
	return a
}

fn main() {
	s1 := MyStruct{}
	fn1(s1)
	// fn2(s1) -> コンパイルエラー、MyStruct は Bar を実装していません
}

fn fn1(s Foo) {
	println(s.write('Foo'))
}

// fn fn2(s Bar) { // 適合しない
//      println(s.write('Foo'))
// }

interface Something {}

fn announce(s Something) {
	if s is Dog {
		println('a ${s.breed} dog') // `s` は自動的に `Dog` へとキャストされます (スマートキャスト」
	} else if s is Cat {
		println('a cat speaks ${s.speak()}')
	} else {
		println('something else')
	}
}

fn main() {
	dog := Dog{'Leonberger'}
	cat := Cat{'Siamese'}
	announce(dog)
	announce(cat)
}

interface IFoo {
	foo()
}

interface IBar {
	bar()
}

// implements only IFoo
struct SFoo {}

fn (sf SFoo) foo() {}

// implements both IFoo and IBar
struct SFooBar {}

fn (sfb SFooBar) foo() {}

fn (sfb SFooBar) bar() {
	dump('This implements IBar')
}

fn main() {
	mut arr := []IFoo{}
	arr << SFoo{}
	arr << SFooBar{}

	for a in arr {
		dump(a)
		// In order to execute instances that implements IBar.
		if a is IBar {
			// a.bar() // Error.
			b := a as IBar
			dump(b)
			a.bar()
		}
	}
}

interface Adoptable {}

fn (a Adoptable) speak() string {
	return 'adopt me!'
}

struct Cat {}

fn (c Cat) speak() string {
	return 'meow!'
}

struct Dog {}

fn main() {
	cat := Cat{}
	assert dump(cat.speak()) == 'meow!'
	//
	a := Adoptable(cat)
	assert dump(a.speak()) == 'adopt me!' // Adoptable の `speak` を呼び出します
	if a is Cat {
		// この `if` の中では、V にとって `a` がただの Adoptable の一種ではなく
		// 実際には Cat であることが分かるので、Adoptable の `speak`
        // ではなく Cat の `speak` が使用されます。
		dump(a.speak()) // meow!
	}
	//
	b := Adoptable(Dog{})
	assert dump(b.speak()) == 'adopt me!' // Adoptable の `speak` を呼び出します。
	// if b is Dog {
	// 	dump(b.speak()) // error: unknown method or field: Dog.speak
	// }
}

pub interface Reader {
mut:
	read(mut buf []u8) ?int
}

pub interface Writer {
mut:
	write(buf []u8) ?int
}

// ReaderWriter は Reader と Writer の両方を埋め込んでいます。
// これは Reader と Writer のメソッド/フィールドをすべて ReaderWriter
// へコピー/ペーストするのと同じ効果です。
pub interface ReaderWriter {
	Reader
	Writer
}

struct Moon {}

struct Mars {}

struct Venus {}

type World = Moon | Mars | Venus

sum := World(Moon{})
assert sum.type_name() == 'Moon'
println(sum)

// V の二分木
struct Empty {}

struct Node {
	value f64
	left  Tree
	right Tree
}

type Tree = Empty | Node

// 全ノードの値を合計

fn sum(tree Tree) f64 {
	return match tree {
		Empty { f64(0) } // TODO: match を賢くして f64() を取り除く
		Node { tree.value + sum(tree.left) + sum(tree.right) }
	}
}

fn main() {
	left := Node{0.2, Empty{}, Empty{}}
	right := Node{0.3, Empty{}, Node{0.4, Empty{}, Empty{}}}
	tree := Node{0.5, left, right}
	println(sum(tree)) // 0.2 + 0.3 + 0.4 + 0.5 = 1.4
}

struct Moon {}

struct Mars {}

struct Venus {}

type World = Mars | Moon | Venus

fn (m Mars) dust_storm() bool {
	return true
}

fn main() {
    mut w := World(Moon{})
    assert w is Moon

    w = Mars{}
    // `as` を使用して Mars インスタンスにアクセスします
    mars := w as Mars
    if mars.dust_storm() {
        println('bad weather!')
    }
}

if w is Mars {
    assert typeof(w).name == 'Mars'
    if w.dust_storm() {
        println('bad weather!')
    }
}

if w is Mars as mars {
    assert typeof(w).name == 'Mars'
    if mars.dust_storm() {
        println('bad weather!')
    }
}

struct Moon {}

struct Mars {}

struct Venus {}

type World = Mars | Moon | Venus

fn open_parachutes(n int) {
	println(n)
}

fn land(w World) {
    match w {
        Moon {} // 大気なし
        Mars {
            // 薄い大気
            open_parachutes(3)
        }
        Venus {
            // 濃い大気
            open_parachutes(1)
        }
    }
}

struct Moon {}
struct Mars {}
struct Venus {}

type World = Moon | Mars | Venus

fn (m Moon) moon_walk() {}
fn (m Mars) shiver() {}
fn (v Venus) sweat() {}

fn pass_time(w World) {
    match w {
        // シャドーイングされたマッチ変数の使用例。この場合は `w` (スマートキャスト)
        Moon { w.moon_walk() }
        Mars { w.shiver() }
        else {}
    }
}

struct User {
    id   int
    name string
}

struct Repo {
    users []User
}

fn (r Repo) find_user_by_id(id int) !User {
    for user in r.users {
        if user.id == id {
            // V は自動的にこれを Result 型にラップする
            return user
        }
    }
    return error('User ${id} not found')
}

// Option 型を用いたバージョン
fn (r Repo) find_user_by_id(id int) ?User {
    for user in r.users {
        if user.id == id {
            return user
        }
    }
    return none
}

fn main() {
    repo := Repo{
		users: [User{1, 'Andrew'}, User{2, 'Bob'},
			User{10, 'Charles'},
		]
    }
    user := repo.find_user_by_id(10) or { // Option/Result 型は `or` ブロックでハンドリングする必要がある
		return
    }
    println(user.id) // "10"
    println(user.name) // "Charles"

    user2 := repo.find_user_by_id2(10) or { return }
}

user := repo.find_user_by_id(7) or {
    println(err) // "User 7 not found"
    return
}

import net.http

fn f(url string) !string {
    resp := http.get(url)!
    return resp.body
}

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

user := repo.find_user_by_id(7) or { return }

fn do_something(s string) !string {
    if s == 'foo' {
        return 'foo'
    }
    return error('invalid string') // `return none` のようにもできる
}

a := do_something('foo') or { 'default' } // a will be 'foo'
b := do_something('bar') or { 'default' } // b will be 'default'
println(a)
println(b)

if resp := http.get('https://google.com') {
    println(resp.body) // resp は http.Response であり、Option ではありません
} else {
    println(err)
}

struct PathError {
	Error
	path string
}

fn (err PathError) msg() string {
	return 'Failed to open path: ${err.path}'
}

fn try_open(path string) ! {
    // 自動的に IError 型にキャストされます
	return PathError{
		path: path
	}
}

fn main() {
	try_open('/tmp') or { panic(err) }
}

struct Repo[T] {
    db DB
}

struct User {
	id   int
	name string
}

struct Post {
	id   int
	user_id int
	title string
	body string
}

fn new_repo[T](db DB) Repo[T] {
    return Repo[T]{db: db}
}

// これはジェネリック関数です。V は使用される型ごとに関数を生成します。
fn (r Repo[T]) find_by_id(id int) ?T {
    table_name := T.name // この例では型の名前をテーブル名にしています
    return r.db.query_one[T]('select * from $table_name where id = ?', id)
}

db := new_db()
users_repo := new_repo[User](db) // 戻り値 Repo[User]
posts_repo := new_repo[Post](db) // 戻り値 Repo[Post]
user := users_repo.find_by_id(1)? // find_by_id[User]
post := posts_repo.find_by_id(1)? // find_by_id[Post]

fn compare[T](a, b T) int {
    if a < b {
        return -1
    }
    if a > b {
        return 1
    }
    return 0
}

// compare[int]
println(compare(1,0)) // 出力: 1
println(compare(1,1)) //      0
println(compare(1,2)) //     -1
// compare[string]
println(compare('1','0')) // 出力: 1
println(compare('1','1')) //      0
println(compare('1','2')) //     -1
// compare[f64]
println(compare(1.1, 1.0)) // 出力: 1
println(compare(1.1, 1.1)) //      0
println(compare(1.1, 1.2)) //     -1

import math

fn p(a f64, b f64) { // 戻り値がない普通の関数
	c := math.sqrt(a * a + b * b)
	println(c)
}

fn main() {
	spawn p(3, 4)
	// p は並列スレッドでじっこうされます
	// これは以下のように書くこともできます
	// spawn fn (a f64, b f64) {
	// 	c := math.sqrt(a * a + b * b)
	// 	println(c)
	// }(3, 4)
}

import math

fn p(a f64, b f64) { // 戻り値がない普通の関数
	c := math.sqrt(a * a + b * b)
	println(c) // `5` が出力されます
}

fn main() {
	h := spawn p(3, 4)
	// p() を並列スレッドで実行します
	h.wait()
	// p() は確実に終了します
}

import math { sqrt }

fn get_hypot(a f64, b f64) f64 { // 戻り値がある普通の関数
	c := sqrt(a * a + b * b)
	return c
}

fn main() {
	g := go get_hypot(54.06, 2.08) // スレッドを生成してそのハンドルを得ます
	h1 := get_hypot(2.32, 16.74) //   ここで他の計算もします
	h2 := g.wait() //                 生成したスレッドから結果を取得します
	println('Results: ${h1}, ${h2}') //   `Results: 16.9, 54.1` と出力されます
}

import time

fn task(id int, duration int) {
	println('task ${id} begin')
	time.sleep(duration * time.millisecond)
	println('task ${id} end')
}

fn main() {
	mut threads := []thread{}
	threads << spawn task(1, 500)
	threads << spawn task(2, 900)
	threads << spawn task(3, 100)
	threads.wait()
	println('done')
}

// 出力:
// task 1 begin
// task 2 begin
// task 3 begin
// task 3 end
// task 1 end
// task 2 end
// done

fn expensive_computing(i int) int {
	return i * i
}

fn main() {
	mut threads := []thread int{}
	for i in 1 .. 10 {
		threads << spawn expensive_computing(i)
	}
	// Join all tasks
	r := threads.wait()
	println('All jobs finished: ${r}')
}

// 出力: All jobs finished: [1, 4, 9, 16, 25, 36, 49, 64, 81]

ch := chan int{} // バッファされない - "同期的"
ch2 := chan f64{cap: 100} // バッファ長 100

fn f(ch chan int) {
	// ...
}

fn main() {
	ch := chan int{}
	spawn f(ch)
	// ...
}

// バッファリングされたチャンネルを作り、(バッファに余裕がある場合) push がブロックされないようにする
ch := chan int{cap: 1}
ch2 := chan f64{cap: 1}
n := 5
// push
ch <- n
ch2 <- 7.3
mut y := f64(0.0)
m := <-ch // 新しい変数を作って取り出す
y = <-ch2 // 既存の変数に取り出す

ch := chan int{}
ch2 := chan f64{}
// ...
ch.close()
// ...
m := <-ch or {
    println('channel has been closed')
}

// エラーの伝播
y := <-ch2 ?

import time

fn main() {
	mut c := chan f64{}
	mut ch := chan f64{}
	mut ch2 := chan f64{}
	mut ch3 := chan f64{}
	mut b := 0.0
	c := 1.0
	// ... ch/ch2 に送信する go スレッドのセットアップ
	spawn fn (the_channel chan f64) {
		time.sleep(5 * time.millisecond)
		the_channel <- 1.0
	}(ch)
	spawn fn (the_channel chan f64) {
		time.sleep(1 * time.millisecond)
		the_channel <- 1.0
	}(ch2)
	spawn fn (the_channel chan f64) {
		_ := <-the_channel
	}(ch3)
	//
	select {
		a := <-ch {
			// `a` でなにかする
			eprintln('> a: ${a}')
		}
		b = <-ch2 {
			// 事前に宣言した `b` でなにかする
			eprintln('> b: ${b}')
		}
		ch3 <- c {
			// `c` が送られた場合になにかする
			time.sleep(5 * time.millisecond)
			eprintln('> c: ${c} was send on channel ch3')
		}
		500 * time.millisecond {
			// どのチャンネルも準備状態にならずに 0.5 秒経過したらなにかする
			eprintln('> more than 0.5s passed without a channel being ready')
		}
	}
}

if select {
    ch <- a {
        ...
    }
} {
    // チャンネルが開いていた
} else {
    // チャンネルが閉じられた
}

struct Abc {
	x int
}

a := 2.13
ch := chan f64{}
res := ch.try_push(a) // `ch <- a` を試みる
println(res)
l := ch.len // キューの最大要素数
c := ch.cap // キューの最大長
is_closed := ch.closed // bool のフラグ - `ch` が閉じているかどうか
println(l)
println(c)
mut b := Abc{}
ch2 := chan Abc{}
res2 := ch2.try_pop(b) // `b = <-ch2` を試みる

struct St {
mut:
	x int // 共有するデータ
}

fn (shared b St) g() {
	lock b {
		// b.x の読み込み/変更/書き込み
	}
}

fn main() {
	shared a := St{
		x: 10
	}
	spawn a.g()
	// ...
	rlock a {
		// a.x の読み込み
	}
}

import json

struct Foo {
	x int
}

struct User {
	// [required] 属性を追加すると、入力にそのフィールドが
	// 存在しなければデコードに失敗します。
	// [required] でないフィールドが存在しない場合では、数値では 0、
	// 文字列では '' などのデフォルト値としてみなされ、
	// デコードは失敗しません。
	name string [required]
    age  int
    // `skip` 属性を使用することで指定のフィールドをスキップできます
    foo Foo [skip]
    // フィールド名が JSON と異なる場合は、名前を指定できます
    last_name string [json:lastName]
}

data := '{ "name": "Frodo", "lastName": "Baggins", "age": 25 }'
user := json.decode(User, data) or {
    eprintln('Failed to decode json, error: ${err}')
    return
}
println(user.name)
println(user.last_name)
println(user.age)
// JSON 配列もデコードできます
sfoos := '[{"x":123},{"x":456}]'
foos := json.decode([]Foo, sfoos)!
println(foos[0].x)
println(foos[1].x)

import json

struct User {
	name  string
	score i64
}

mut data := map[string]int{}
user := &User{
	name: 'Pierre'
	score: 1024
}

data['x'] = 42
data['y'] = 360

println(json.encode(data)) // {"x":42,"y":360}
println(json.encode(user)) // {"name":"Pierre","score":1024}

mut v := 2
foo(mut v)
assert v < 4

fn test_assertion_with_extra_message_failure() {
	for i in 0 .. 100 {
        assert i * 2 - 45 < 75 + 10, 'assertion failed for i: ${i}'
    }
}

[assert_continues]
fn abc(ii int) {
	assert ii == 2
}

for i in 0 .. 4 {
	abc(i)
}

assert_continues_example.v:3: FAIL: fn main.abc: assert ii == 2
   left value: ii = 0
   right value: 2
assert_continues_example.v:3: FAIL: fn main.abc: assert ii == 2
   left value: ii = 1
  right value: 2
assert_continues_example.v:3: FAIL: fn main.abc: assert ii == 2
   left value: ii = 3
  right value: 2

module main
fn hello() string {
    return 'Hello world'
}
fn main() {
    println(hello())
}

module main
fn test_hello() {
    assert hello() == 'Hello world'
}

import strconv

fn test_atoi() ! {
	assert strconv.atoi('1')! == 1
	assert strconv.atoi('one')! == 1 // test will fail
}

import os

fn test_subtest() {
	res := os.execute('${@VEXE} other_test.v')
	assert res.exit_code == 1
	assert res.output.contains('other_test.v does not exist')
}

struct MyType {}

[unsafe]
fn (data &MyType) free() {
	// ...
}

import strings

fn draw_text(s string, x int, y int) {
	// ...
}

fn draw_scene() {
	// ...
	name1 := 'abc'
	name2 := 'def ghi'
	draw_text('hello ${name1}', 10, 10)
	draw_text('hello ${name2}', 100, 10)
	draw_text(strings.repeat(`X`, 10000), 10, 50)
	// ...
}

struct User {
	name string
}

fn test() []int {
    number := 7 // スタック変数
    user := User{} // スタック上に確保された構造体
    numbers := [1, 2, 3] // ヒープ上に確保された配列、関数を抜けるときに解放される
    println(number)
    println(user)
    println(numbers)
    numbers2 := [4, 5, 6] // 配列は返されるので、ここでは解放されない
    return numbers2
}

struct MyStruct {
	n int
}

struct RefStruct {
	r &MyStruct
}

fn main() {
	q, w := f()
	println('q: ${q.r.n}, w: ${w.n}')
}

fn f() (RefStruct, &MyStruct) {
	a := MyStruct{
		n: 1
	}
	b := MyStruct{
		n: 2
	}
	c := MyStruct{
		n: 3
	}
	e := RefStruct{
		r: &b
	}
	x := a.n + c.n
	println('x: ${x}')
	return e, &c
}

struct MyStruct {
mut:
	n int
}

fn main() {
	mut q := MyStruct{
		n: 7
	}
	w := MyStruct{
		n: 13
	}
	x := q.f(&w) // `q` と `w` の参照が渡される
	println('q: ${q}\nx: ${x}')
}

fn (mut a MyStruct) f(b &MyStruct) int {
	a.n += b.n
	x := a.n * b.n
	return x
}

struct RefStruct {
mut:
	r &MyStruct
}

// 下記の議論を参照
[heap]
struct MyStruct {
	n int
}

fn main() {
	m := MyStruct{}
	mut r := RefStruct{
		r: &m
	}
	r.g()
	println('r: ${r}')
}

fn (mut r RefStruct) g() {
	s := MyStruct{
		n: 7
	}
	r.f(&s) // `r` 内で `s` への参照を `main()` へ戻して渡す
}

fn (mut r RefStruct) f(s &MyStruct) {
	r.r = s // `[heap]` なしだとエラーを起こす
}

fn (mut a MyStruct) f() &MyStruct {
	// a でなにかする
	return &a // 借用したオブジェクトのアドレスを返す
}

struct MyStruct {
mut:
	n int
}

fn (mut a MyStruct) f() {
	// `a` でなにかをする
}

fn (mut a MyStruct) g() {
	// `a` で他のなにかをする
}

fn main() {
	x := MyStruct{} // スタックに確保
	mut y := x
	y.f()
	y.g()
	// `mut y := x.f().g() の代わり
}

struct MyStruct {
	n int
}

struct RefStruct {
mut:
	r &MyStruct
}

// シンプルな関数 - g() が使うスタックセグメントの上書き
fn use_stack() {
	x := 7.5
	y := 3.25
	z := x + y
	println('${x} ${y} ${z}')
}

fn main() {
	m := MyStruct{}
	mut r := RefStruct{
		r: &m
	}
	r.g()
	use_stack() // 無効なスタックの中身を消去する
	println('r: ${r}')
}

fn (mut r RefStruct) g() {
	s := &MyStruct{ // `s` がヒープのオブジェクトを参照すると明示
		n: 7
	}
	// 上書きされるスタックセグメント内のデータを見には
	// 上を `&MyStruct` -> `MyStruct`、下を `r.f(s)` -> `r.f(&s)` に変更
	r.f(s)
}

fn (mut r RefStruct) f(s &MyStruct) {
	r.r = unsafe { s } // コンパイラのチェックを回避
}

import db.sqlite

// カスタムのテーブル名を設定します。デフォルトは構造体の名前 (大文字小文字はそのまま) です。
[table: 'customers']
struct Customer {
	id        int    [primary; sql: serial] // `id` という名前の整数型のフィールドが最初に存在しなければなりません
	name      string [nonull]
	nr_orders int
	country   string [nonull]
}

db := sqlite.connect('customers.db')!

// 構造体宣言からテーブルを作成します。例えば次のクエリはこれと同様の SQL を発行します。
// CREATE TABLE IF NOT EXISTS `Customer` (
//      `id` INTEGER PRIMARY KEY,
//      `name` TEXT NOT NULL,
//      `nr_orders` INTEGER,
//      `country` TEXT NOT NULL
// )
sql db {
	create table Customer
}!

// 新しい顧客情報を挿入します:
new_customer := Customer{
	name: 'Bob'
	country: 'uk'
	nr_orders: 10
}
sql db {
	insert new_customer into Customer
}!
us_customer := Customer{
	name: 'Martin'
	country: 'us'
	nr_orders: 5
}
sql db {
	insert us_customer into Customer
}!
// 顧客情報を更新します:
sql db {
	update Customer set nr_orders = nr_orders + 1 where name == 'Bob'
}!

// select count(*) from customers
nr_customers := sql db {
	select count from Customer
}!
println('number of all customers: ${nr_customers}')
// V の構文はクエリの構築にも利用できます
uk_customers := sql db {
	select from Customer where country == 'uk' && nr_orders > 0
}!
println('We found a total of ${uk_customers.len} customers, that match the query.')
for customer in uk_customers {
	println('${customer.id} - ${customer.name}')
	println('customer: ${customer.id}, ${customer.name}, ${customer.country}, ${customer.nr_orders}')
}

// 顧客情報を削除します
sql db {
	delete from Customer where name == 'Bob'
}!

// clearall は配列の全ビットを消去します
fn clearall() {
}

// copy_all は再帰的に配列内の値をすべてコピーし、
// `dupes` が false ならば重複した値は処理中に除去します。
fn copy_all(dupes bool) {
	// ...
}

v fmt file.v

// vfmt の影響を受けなくなります
// vfmt off
... your code here ...
// vfmt on
// vfmt の影響を受けるようになります
... your code here ...

v shader /path/to/project/dir/or/file.v

import time

fn main() {
    sw := time.new_stopwatch({})
    println('Hello world')
    println('Greeting the world took: ${sw.elapsed().nanoseconds()}ns')
}

v [モジュールのオプション] [引数]

   install           VPM からモジュールをインストールする。
   remove            VPM からインストールしたモジュールを取り除く。
   search            VPM からモジュールを検索する。
   update            VPM からインストールしたモジュールを更新する。
   upgrade           すべての outdated なモジュールを更新する。
   list              すべてのインストールしたモジュールを列挙する。
   outdated          インストールしたモジュールのうち更新が必要なものを表示する。

v install [module]

v install ui

v install [--once] [--git|--hg] [url]

v install --git https://github.com/vlang/markdown

v install --once [module]

v remove [module]

v remove ui

v update [module]

v update ui

v update

v list
``

#### 例

```sh
> v list
Installed modules:
  markdown
  ui

v outdated

> v outdated
Modules are up to date.

// [flag] は列挙型をビットフィールドとして使えるようにします

[flag]
enum BitField {
	read
	write
	other
}

fn main() {
	assert 1 == int(BitField.read)
	assert 2 == int(BitField.write)
	mut bf := BitField.read
	assert bf.has(.read | .other) // フラグのうち *少なくとも 1 つ* がセットされているかテスト
	assert !bf.all(.read | .other) // フラグのうち *全て* がセットされているかテスト
	bf.set(.write | .other)
	assert bf.has(.read | .write | .other)
	assert bf.all(.read | .write | .other)
	bf.toggle(.other)
	assert bf == BitField.read | .write
	assert bf.all(.read | .write)
	assert !bf.has(.other)
}

module abc

// 注意として *他のモジュール* で Xyz.d に *直接* アクセスするときのみ、非推奨の通知/警告を生成します。
pub struct Xyz {
pub mut:
	a int
	d int [deprecated: 'use Xyz.a instead'; deprecated_after: '2999-03-01'] // 注意と, かなり先の非推奨の日付を生成します
}

// この関数を呼び出すと非推奨の警告が出ます
[deprecated]
fn old_function() {
}

// カスタムの非推奨メッセージも表示できます
[deprecated: 'use new_function() instead']
fn legacy_function() {}

// また、日付を指定することもでき、その日付以降、
// その関数は廃止されたとみなされます。その日より前での
// その関数の呼び出しは、コンパイラ通知として表示されますが、
// コンパイルには影響しません。その日以降は呼び出しが警告に
// なるため、通常のコンパイルは動作しますが、-prod での
// コンパイルは動作しません (-prod ではすべての警告が
// エラーとして扱われます)。非推奨日から 6 ヶ月後には、
// 呼び出しはハードコンパイラエラーになります。
[deprecated: 'use new_function2() instead']
[deprecated_after: '2021-05-27']
fn legacy_function2() {}

// この関数の呼び出しはインライン化されます。
[inline]
fn inlined_function() {
}

// この関数の呼び出しはインライン化されません。
[noinline]
fn function() {
}

// この関数は呼び出し元に戻りません。
// このような関数は、exit/1 や panic/1 のように、or ブロックの最後に使用することができます。 このような関数は戻り値を持つことができず、for{} で終わるか、他の `[noteturn]` 関数を呼び出して終了しなければなりません。
[noreturn]
fn forever() {
	for {}
}

// 次の構造体はヒープ上に割り当てられなければなりません。そのため、参照 (`&Window`) として、または別の参照 (`&OuterStruct{ Window{...} }`) の内部でのみ使用できます。
// 「スタックとヒープ」の章もご覧ください。
[heap]
struct Window {
}

// フラグが false になっていると、この関数とその呼び出しのコードを生成しなくなります。
// フラグを使うには、`v -d flag` のようにします
[if debug]
fn foo() { }

fn bar() {
   foo() // `-d debug` が渡されていないと呼び出されない
}

// この関数のポインタ引数が指すメモリは、この関数が戻る前にガベージコレクタによって
// 解放されません (使用されている場合)。
[keep_args_alive]
fn C.my_external_function(voidptr, int, voidptr) int

// 以下の関数は unsafe{} ブロック内で呼び出さなければなりません。
// なお、`risky_business()` 本体のコードは、`unsafe {}` ブロックで
// 包まない限りチェックされます。
// これは、ある安全ではない操作の前後にチェックを行う `[unsafe]` 関数を
// 作りたいときに便利で、V の安全機能の恩恵も受けられます。
[unsafe]
fn risky_business() {
	// チェックコード、おそらく事前条件のチェック
	unsafe {
		// ポインタ演算、ユニオンフィールドへのアクセス、他の `[unsafe]` 関数の呼び出し
		// などがチェック *されない* コードです。
		// 通常は、unsafe{} で囲まれたコードをできるだけ少なくするようにするのがよいでしょう。
		// [メモリ安全でないコード](#メモリ安全でないコード) もご覧ください
	}
	// チェックコード、おそらく事後条件のチェックや不変性の保持
}

// V の autofree エンジンはこの関数でメモリ管理を行いません。
// あなたは、その中でメモリの解放を手動で行う責任があります。
[manualfree]
fn custom_allocations() {
}

// C との相互運用向けのみですが，この構造体が C 内で `typedef struct` によって定義されていると V に伝えます。
[typedef]
struct C.Foo {
}

// 関数へのカスタム呼び出し規約を追加するために用いられ、stdcall、fastcall、cdecl の呼び出し規約が利用できます。
// このリストは型エイリアス (下記) においても同様です。
[callconv: "stdcall"]
fn C.DefWindowProc(hwnd int, msg int, lparam int, wparam int)

// 関数の型エイリアスに呼び出し規約を追加するために用いられます。
[callconv: "fastcall"]
type FastFn = fn (int) bool

// Windows 専用:
// デフォルトのグラフィックライブラリ (gg、ui など) がインポートされている場合、グラフィカルウィンドウ
// が優先され、コンソールウインドウは作成されず、println() ステートメントが効果的に無効になります。
// コンソールウインドウを明示的に作成する際にこれを使用します。main() の前でのみ有効です。
[console]
fn main() {
}

eprintln( 'file: ' + @FILE + ' | line: ' + @LINE + ' | fn: ' + @MOD + '.' + @FN)

import v.vmod
vm := vmod.decode( @VMOD_FILE ) or { panic(err) }
eprintln('${vm.name} ${vm.version}\n ${vm.description}')

struct User {
	name string
	age  int
}

fn main() {
	$for field in User.fields {
		$if field.typ is string {
			println('$field.name is of type string')
		}
	}
}

// 出力:
// name is of type string

// 一つの節で複数の条件をサポート
$if ios || android {
    println('Running on a mobile device!')
}
$if linux && x64 {
    println('64-bit Linux.')
}
// 式として利用
os := $if windows { 'Windows' } $else { 'UNIX' }
println('Using $os')
// $else-$if 節
$if tinyc {
    println('tinyc')
} $else $if clang {
    println('clang')
} $else $if gcc {
    println('gcc')
} $else {
    println('different compiler')
}
$if test {
    println('testing')
}
// v -cg ...
$if debug {
    println('debugging')
}
// v -d option ...
$if option ? {
    println('custom option')
}

import os
fn main() {
	embedded_file := $embed_file('v.png')
	os.write_file('exported.png', embedded_file.to_string())!
}

import os
fn main() {
	embedded_file := $embed_file('x.css', .zlib) // compressed using zlib
	os.write_file('exported.css', embedded_file.to_string())!
}

fn build() string {
	name := 'Peter'
	age := 25
	numbers := [1, 2, 3]
	return $tmpl('1.txt')
}

fn main() {
	println(build())
}

name: @name

age: @age

numbers: @numbers

@for number in numbers
  @number
@end

name: Peter

age: 25

numbers: [1, 2, 3]

1
2
3

module main

fn main() {
	compile_time_env := $env('ENV_VAR')
	println(compile_time_env)
}

module main

$if linux {
    $compile_error('Linux is not supported')
}

fn main() {
}

$ v run x.v
x.v:4:5: error: Linux is not supported
    2 |
    3 | $if linux {
    4 |     $compile_error('Linux is not supported')
      |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    5 | }
    6 |

module main
fn main() { println(message) }

module main
const ( message = 'Hello world' )

module main
const ( message = 'Hello linux' )

module main
const ( message = 'Hello windows' )

// 未初期化バイトを 2 つ確保 & その参照を返す
mut p := unsafe { malloc(2) }
p[0] = `h` // エラー: ポインタの配列扱いは `unsafe` ブロック内でのみ可能
unsafe {
    p[0] = `h` // OK
    p[1] = `i`
}
p++ // エラー: ポインタ演算は `unsafe` ブロック内でのみ可能
unsafe {
    p++ // OK
}
assert *p == `i`

struct Node {
	a &Node
	b &Node = unsafe { nil } // 自動で nil に初期化されます、使用の際はご注意ください!
}

// 初期値が宣言されていない場合、参照フィールドは初期化が必要です。
// ゼロ (0) は OK ですが気をつけてください。これは nil ポインタです。
foo := Node{
	a: 0
}
bar := Node{
	a: &foo
}
baz := Node{
	a: 0
	b: 0
}
qux := Node{
	a: &foo
	b: &bar
}
println(baz)
println(qux)

struct Foo {
	a int
	b int
}

assert sizeof(Foo) == 8
assert __offsetof(Foo, a) == 0
assert __offsetof(Foo, b) == 4

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}"
}

$if windows {
	#include "@VEXEROOT/thirdparty/stdatomic/win/atomic.h"
} $else {
	#include "@VEXEROOT/thirdparty/stdatomic/nix/atomic.h"
}

// 使いたい関数の宣言 - V は C ヘッダを解析しません
fn C.atomic_store_u32(&u32, u32)
fn C.atomic_load_u32(&u32) u32
fn C.atomic_compare_exchange_weak_u32(&u32, &u32, u32) bool
fn C.atomic_compare_exchange_strong_u32(&u32, &u32, u32) bool

const num_iterations = 10000000

// 下記の「グローバル変数」の章を参照
__global (
	atom u32 // アトミックとして使用する普通の変数
)

fn change() int {
	mut races_won_by_change := 0
	for {
		mut cmp := u32(17) // 比較対象となるアドレス値と、発見された値を格納する
		// `if atom == 17 { atom = 23 races_won_by_change++ } else { cmp = atom }` のアトミック版
		if C.atomic_compare_exchange_strong_u32(&atom, &cmp, 23) {
			races_won_by_change++
		} else {
			if cmp == 31 {
				break
			}
			cmp = 17 // atom の値が上書きされたので再代入する
		}
	}
	return races_won_by_change
}

fn main() {
	C.atomic_store_u32(&atom, 17)
	t := go change()
	mut races_won_by_main := 0
	mut cmp17 := u32(17)
	mut cmp23 := u32(23)
	for i in 0 .. num_iterations {
		//`if atom == 17 { atom = 23 races_won_by_main++ }` のアトミック版
		if C.atomic_compare_exchange_strong_u32(&atom, &cmp17, 23) {
			races_won_by_main++
		} else {
			cmp17 = 17
		}
		desir := if i == num_iterations - 1 { u32(31) } else { u32(17) }
		// `for atom != 23 {} atom = desir` のアトミック版
		for !C.atomic_compare_exchange_weak_u32(&atom, &cmp23, desir) {
			cmp23 = 23
		}
	}
	races_won_by_change := t.wait()
	atom_new := C.atomic_load_u32(&atom)
	println('atom: $atom_new, #exchanges: ${races_won_by_main + races_won_by_change}')
	// `atom: 31, #exchanges: 10000000`) と出力する
	println('races won by\n- `main()`: $races_won_by_main\n- `change()`: $races_won_by_change')
}

import sync

__global (
	sem   sync.Semaphore // `init()` 内で初期化が必要
	mtx   sync.RwMutex // `init()` 内で初期化が必要
	f1    = f64(34.0625) // 明示的に初期化
	shmap shared map[string]f64 // 空の `shared` 辞書配列として初期化
	f2    f64 // `0.0` に初期化
)

fn init() {
	sem.init(0)
	mtx.init()
}

#flag -lsqlite3
#include "sqlite3.h"
// さらなるサンプルは https://www.sqlite.org/quickstart.html を参照
struct C.sqlite3 {
}

struct C.sqlite3_stmt {
}

type FnSqlite3Callback = fn (voidptr, int, &&char, &&char) int

fn C.sqlite3_open(charptr, &&C.sqlite3) int

fn C.sqlite3_close(&C.sqlite3) int

fn C.sqlite3_column_int(stmt &C.sqlite3_stmt, n int) int

// ... さらに引数型を定義して C. 接頭詞の省略もできる
fn C.sqlite3_prepare_v2(&C.sqlite3, &char, int, &&C.sqlite3_stmt, &&char) int

fn C.sqlite3_step(&C.sqlite3_stmt)

fn C.sqlite3_finalize(&C.sqlite3_stmt)

fn C.sqlite3_exec(db &C.sqlite3, sql &char, cb FnSqlite3Callback, cb_arg voidptr, emsg &&char) int

fn C.sqlite3_free(voidptr)

fn my_callback(arg voidptr, howmany int, cvalues &&char, cnames &&char) int {
	unsafe {
		for i in 0 .. howmany {
			print('| ${cstring_to_vstring(cnames[i])}: ${cstring_to_vstring(cvalues[i]):20} ')
		}
	}
	println('|')
	return 0
}

fn main() {
	db := &C.sqlite3(unsafe { nil }) // `sqlite3* db = 0` と同義
	// C 関数の呼び出しに文字列リテラルを渡すと、V 文字列ではなく C 文字列になります。
	C.sqlite3_open('users.db', &db)
	// C.sqlite3_open(db_path.str, &db)
	query := 'select count(*) from users'
	stmt := &C.sqlite3_stmt(unsafe { nil })
	// 注意: V 文字列の `.str` フィールドを使用して、
	// C 方式のゼロ終端表現の取得もできます。
	C.sqlite3_prepare_v2(db, query.str, -1, &stmt, 0)
	C.sqlite3_step(stmt)
	nr_users := C.sqlite3_column_int(stmt, 0)
	C.sqlite3_finalize(stmt)
	println('There are $nr_users users in the database.')
	//
	error_msg := charptr(0)
	query_all_users := 'select * from users'
	rc := C.sqlite3_exec(db, query_all_users.str, my_callback, 7, &error_msg)
	if rc != C.SQLITE_OK {
		eprintln(cstring_to_vstring(error_msg))
		C.sqlite3_free(error_msg)
	}
	C.sqlite3_close(db)
}

[export: 'my_custom_c_name']
fn foo() {
}

#flag linux -lsdl2
#flag linux -Ivig
#flag linux -DCIMGUI_DEFINE_ENUMS_AND_STRUCTS=1
#flag linux -DIMGUI_DISABLE_OBSOLETE_FUNCTIONS=1
#flag linux -DIMGUI_IMPL_API=

#pkgconfig r_core
#pkgconfig --cflags --libs r_core

$if $pkgconfig('mysqlclient') {
	#pkgconfig mysqlclient
} $else $if $pkgconfig('mariadb') {
	#pkgconfig mariadb
}

Module {
    name: 'mymodule',
    description: 'My nice module wraps a simple C library.',
    version: '0.0.1'
    dependencies: []
}

#flag -I @VROOT/c
#flag @VROOT/c/implementation.o
#include "header.h"

struct SomeCStruct {
	uint8_t implTraits;
	uint16_t memPoolData;
	union {
		struct {
			void* data;
			size_t size;
		};

		DataView view;
	};
};

struct C.SomeCStruct {
	implTraits  u8
	memPoolData u16
	// これらのメンバーは、現在Vでは表現できないサブデータ構造の一部です。
	// このように直接宣言すれば、アクセスするには十分です。
	// union {
	// struct {
	data voidptr
	size size_t
	// }
	view C.DataView
	// }
}

#include "stdio.h"

int main() {
	for (int i = 0; i < 10; i++) {
		printf("hello world\n");
	}
	return 0;
}

fn main() {
	for i := 0; i < 10; i++ {
		println('hello world')
	}
}

v wrapper c_code/libsodium/src/libsodium

// ビルトインライブラリが使われる前にインクルードされる
#preinclude "pre_include.h"
// ビルトインライブラリが使われた後でインクルードされる.
#include "include.h"

fn main() {
    a := 10
    asm x64 {
        mov eax, [a]
        add eax, 10
        mov [a], eax
    }
}

module main

import time
import os

[live]
fn print_message() {
    println('Hello! Modify this message while the program is running.')
}

fn main() {
    for {
        print_message()
        time.sleep_ms(500)
    }
}

#!/usr/bin/env -S v run
// 上のシバンは、Unix 系システムでファイルを V に関連付け、
// `chmod +x` で実行可能にしてからファイルパスを指定すれば
// 実行できるようにしています。

// コマンドを出力してから実行します
fn sh(cmd string){
  println("❯ $cmd")
  print(execute_or_exit(cmd).output)
}

// build/ が有れば削除し、無い場合はそのエラーを無視します
rmdir_all('build') or { }

// build/ を作成し、build/ が無いことで失敗しないようにします
mkdir('build')!

// *.v ファイルを build/ へ移動します
result := execute('mv *.v build/')
if result.exit_code != 0 {
	println(result.output)
}

sh('ls')

// 以下と同じ:
// files := ls('.')!
// mut count := 0
// if files.len > 0 {
//     for file in files {
//         if file.ends_with('.v') {
//              mv(file, 'build/') or {
//                  println('err: $err')
//                  return
//              }
//         }
//         count++
//     }
// }
// if count == 0 {
//     println('No files')
// }

v deploy.vsh && ./deploy

v run deploy.vsh

as
asm
assert
atomic
break
const
continue
defer
else
enum
false
fn
for
go
goto
if
import
in
interface
is
isreftype
lock
match
module
mut
none
or
pub
return
rlock
select
shared
sizeof
spawn
static
struct
true
type
typeof
union
unsafe
volatile
__global
__offsetof

+=   -=   *=   /=   %=
&=   |=   ^=
>>=  <<=