fn main() {
	areas := ['game', 'web', 'tools', 'science', 'systems',
	          'embedded', 'drivers', 'GUI', 'mobile'] 
	for area in areas {
		println('Hello, $area developers!')
	}
}	

import os

// Print file lines that starth with "DEBUG:"
fn main() {
	// `read_file` returns an optional (`?string`), it must be checked
	text := os.read_file('app.log') or {
		println('failed to read the file')
		return
	}
	lines := text.split_into_lines()
	for line in lines {
		if line.starts_with('DEBUG:') {
			println(line)
		}
	}
}

import time
import http

fn main() {
	resp := http.get('https://vlang.io/utc_now') or {
		println('failed to fetch data from the server')
		return
	}
	t := time.unix(resp.text.int())
	println(t.format()) // 2019-08-16 17:48
}

import json

struct User {
	name          string
	age           int
mut:
	is_registered bool
}

fn main() {
	s := '[{"name":"Frodo", "age":25}, {"name":"Bobby", "age":10}]'
	users := json.decode([]User, s) or {
		eprintln('Failed to parse json')
		return
	}
	for user in users {
		println('$user.name: $user.age')
	}
	println('')
	for i, user in users {
		println('$i) $user.name')
		if !user.can_register() {
			println('Cannot register $user.name, they are too young')
			continue
		}
		users[i].register() // `user` is immutable, we have to modify the array
	}
	// Let's encode users again just for fun
	println('')
	println(json.encode(users))
}

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

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

struct Customer {
	id int
	name string
	nr_orders int
	country string
}

db := pg.connect(db_name, db_user)

nr_customers := db.select count from Customer
println('number of all customers: $nr_customers')

// V syntax can be used to build queries
uk_customers = db.select from Customer where country == 'uk' && nr_orders > 0
for customer in uk_customers {
	println('$customer.id - $customer.name')
}

// by adding `limit 1` we tell V that there will be only one object
customer = db.select from Customer where id == 1 limit 1
println(customer.name)

// insert a new customer
new_customer := Customer{name: 'Bob', nr_orders: 10}
db.insert(new_customer)

struct Story {
    title string
}

// Fetches top HN stories in 8 coroutines 
fn main() {
    resp := http.get('https://hacker-news.firebaseio.com/v0/topstories.json')?
    ids := json.decode([]int, resp.body)?
    mut cursor := 0
    for _ in 0..8 {
        go fn() {
            for  {
                lock { // Without this lock the program will not compile 
                    if cursor >= ids.len {
                        break
                    }
                    id := ids[cursor]
                    cursor++
                }
                resp := http.get('https://hacker-news.firebaseio.com/v0/item/$id.json')? 
                story := json.decode(Story, resp.body)?
                println(story.title)
            }
        }()
    }
    runtime.wait() // Waits for all coroutines to finish 
} 

import ui  // Native cross-platform ui toolkit (uses Cocoa, win32, GTK+)  

// There are no globals, so we have to use a context struct 
struct Context {
    input ui.TextBox // this uses native conrols (NSTextView on macOS, edit HWND on Windows)  
    names []string   // let's log the names to demonstrate how arrays work  
}

fn main() {
    wnd := ui.new_window(ui.WindowCfg{  // V has no default arguments and overloading. 
        width:  600                     // All stdlib functions with many args use Cfg wrappers.
        height: 300 
        title:  'hello world' 
    }) 
    mut ctx := Context{
        input: ui.new_textbox(wnd) 
        // we don't need to initialize the names array, it's done automatically  
    }
    ctx.input.set_placeholder('Enter your name')
    btn := ui.new_button(wnd, 'Click me', ctx.btn_click)
    for {
        ui.wait_events()
    }
}

fn (ctx mut Context) btn_click() { 
    name := ctx.input.text()
    println('current list of names: $ctx.names')  // >> current list of names: [ "Bob", "Alex" ] 
    ui.alert('Hello, $name!')
    if ctx.names.contains(name) {
        ui.alert('I already greeted you ;)') 
    } 
    ctx.names << name 
} 

struct User { /* ... */ }
struct Post { /* ... */ }
struct DB   { /* ... */ }

struct Repo <T> {
    db DB
}

fn new_repo<T>(db DB) Repo {
    return Repo<T>{db: db}
}

fn (r Repo) find_by_id(id int) T? { // `?` means the function returns an optional
    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)
}

fn main() {
    db := new_db()
    users_repo := new_repo<User>(db)
    posts_repo := new_repo<Post>(db)
    user := users_repo.find_by_id(1) or {
        eprintln('User not found')
        return
    }
    post := posts_repo.find_by_id(1) or {
        eprintln('Post not found')
        return
    }
}