三小时学会V语言到放弃（第二小时）

root@SW-SERVER:~/v_test# cat hi.v
//结构体
struct point{
        x int
        y int
}
/*
struct Foo{
        a int    //私有 不可变

        mut:    //私有 可变
        b int
        c int

        pub:    //公开 不可变
        d int

        pub mut:     //公开 仅在父模块
        e int

        pub mut mut:    //公开 父模块内外都可以用
        f int
}
*/

//结构体-方法
struct User{
        age int
        mut:
                is_registered int
}
//(u User) u 相当于self or this
/*
V 没有 class概念，但是我们可以在结构体上定义方法。
方法是具有特殊行参的函数。特殊行参 放在 fn关键字 和方法名之间的参数列表中。

简单示例（can_register 方法具有 User 类型的 特殊行参 u）：

不和其他语言一样，使用 self 或 this ，而是使用短名称，当然最好一个字母长

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

/*
纯函数
V语言的函数默认是纯函数，也就是函数的输出结果只依赖输入的参数，并且没有其它的影响。
因为V语言没有全局变量，且所有的参数默认都是只读的，即使传入的引用也是默认只读的。
然后V语言并不纯的函数式语言。我们可以通过mut来修饰行参数，使得可以被修改：
*/
fn (u mut User) register(){
        u.is_registered = 10
}



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,2,3]
        Red = Color{r:255,g:0,b:0}
        Blue = rgb(0,0,255)
)

fn main()
{
        p := point{
                x: 10
                y: 20
        }
        println(p.x)
        println(p.y)

        p1 := &point{30,40}
        println(p1.x)
        println(p1.y)

        mut user := User{age:10}
        mut user1 := User{age:20}
        println(user.is_registered)
        println(user1.can_register())
        user.register()
        println(user.is_registered)
        println(Numbers)
        println(Red)
        println(Blue)
}

root@SW-SERVER:~/v_test# cat interface.v
//interface 接口
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())
}

//枚举
enum Color{
        red green blue
}

//可选类型 和 错误处理
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){
        for user in r.users{
                if user.id == id{
                        return user
                }
        }
        return error('User $id not found')
}

fn main(){
        dog := Dog{}
        cat := Cat{}
        perform(dog)
        perform(cat)

        mut color := Color.red
        println(color)
        color = .green
        println(color)

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

        println(user.id)
        println(user.name)
}