diff options
Diffstat (limited to 'v.html.markdown')
| -rw-r--r-- | v.html.markdown | 229 |
1 files changed, 229 insertions, 0 deletions
diff --git a/v.html.markdown b/v.html.markdown new file mode 100644 index 00000000..4f698184 --- /dev/null +++ b/v.html.markdown @@ -0,0 +1,229 @@ +--- +language: v +filename: vlang.v +contributors: + - ["Maou Shimazu", "https://github.com/Maou-Shimazu"] +--- + +V is a statically typed compiled programming language +designed for building maintainable software. + +It's similar to Go and its design has also been influenced by +Oberon, Rust, Swift, Kotlin, and Python. + +The language promotes writing +simple and clear code with minimal abstraction. + +Despite being simple, V gives the developer a lot of power. +Anything you can do in other languages, you can do in V. + +```v +// Single Line Comment. +/* + Multi Line Comment +*/ + +struct User { // Cannot be defined in main, explained later. + age int + name string + pos int = -1 // custom default value +} +// struct method +fn (u User) can_register() bool { + return u.age > 16 +} + +struct Parser { + token Token +} + +// c like enums +enum Token { + plus + minus + div + mult +} + +// 1. functions +// language does not use semi colons +fn add(x int, y int) int { + return x + y +} +// can return multiple values +fn foo() (int, int) { + return 2, 3 +} + +// function visibility +pub fn public_function() { // pub can only be used from a named module. +} + +fn private_function() { +} + + + +// Main function +fn main() { + // Anonymous functions can be declared inside other functions: + double_fn := fn (n int) int { + return n + n + } + // 2. Variables: they are immutable by default + // implicitly typed + x := 1 + // x = 2 // error + mut y := 2 + y = 4 + name := "John" + large_number := i64(9999999999999) + println("$x, $y, $name, $large_number") // 1, 4, John, 9999999999999 + + // unpacking values from functions. + a, b := foo() + println("$a, $b") // 2, 3 + c, _ := foo() // ignore values using `_` + println("$c") // 2 + + // Numbers + u := u16(12) + v := 13 + u // v is of type `u16` + r := f32(45.6) + q := r + 3.14 // x is of type `f32` + s := 75 // a is of type `int` + l := 14.7 // b is of type `f64` + e := u + s // c is of type `int` + d := l + r // d is of type `f64` + + // Strings + mut bob := 'Bob' + assert bob[0] == u8(66) // indexing gives a byte, u8(66) == `B` + assert bob[1..3] == 'ob' // slicing gives a string 'ob' + bobby := bob + 'by' // + is used to concatenate strings + println(bobby) // "Bobby" + bob += "by2" // += is used to append to strings + println(bob) // "Bobby2" + + //String values are immutable. You cannot mutate elements: + //mut s := 'hello 🌎' + //s[0] = `H` // not allowed + + //For raw strings, prepend r. Escape handling is not done for raw strings: + rstring := r'hello\nworld' // the `\n` will be preserved as two characters + println(rstring) // "hello\nworld" + + // string interpolation + println('Hello, $bob!') // Hello, Bob! + println('Bob length + 10: ${bob.len + 10}!') // Bob length + 10: 13! + + // 3. Arrays + mut numbers := [1, 2, 3] + println(numbers) // `[1, 2, 3]` + numbers << 4 // append elements with << + println(numbers[3]) // `4` + numbers[1] = 5 + println(numbers) // `[1, 5, 3]` + // numbers << "John" // error: `numbers` is an array of numbers + numbers = [] // array is now empty + arr := []int{len: 5, init: -1} + // `arr == [-1, -1, -1, -1, -1]`, arr.cap == 5 + + number_slices := [0, 10, 20, 30, 40] + println(number_slices[1..4]) // [10, 20, 30] + println(number_slices[..4]) // [0, 10, 20, 30] + println(number_slices[1..]) // [10, 20, 30, 40] + + // 4. structs and enums + // struct User { + // age int + // name string + // pos int = -1 // custom default value + // } + mut users := User{21, 'Bob', 0} + println(users.age) // 21 + + // 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 { + // ... + } + + + // 5. Maps + number_map := { + 'one': 1 + 'two': 2 + } + println(number_map) // {'one': 1, 'two': 2} + println(number_map["one"]) // 1 + mut m := map[string]int{} // a map with `string` keys and `int` values + m['one'] = 1 + m['two'] = 2 + println(m['one']) // "1" + println(m['bad_key']) // "0" + m.delete('two') + + // 6. Conditionals + a_number := 10 + b_number := 20 + if a_number < b { + println('$a_number < $b_number') + } else if a_number > b { + println('$a_number > $b_number') + } else { + println('$a_number == $b_number') + } + num := 777 + even_odd := if num % 2 == 0 { 'even' } else { 'odd' } + println(even_odd) + + match even_odd { + 'even' { println('even') } + 'odd' { println('odd') } + else { println('unknown') } + } + + // 7. Loops + loops := [1, 2, 3, 4, 5] + for lp in loops { + println(lp) + } + loop_names := ['Sam', 'Peter'] + for i, lname in loop_names { + println('$i) $lname') + // Output: 0) Sam + // 1) Peter + } + // You can also use break and continue followed by a + // label name to refer to an outer for loop: + outer: for i := 4; true; i++ { + println(i) + for { + if i < 7 { + continue outer + } else { + break outer + } + } + } +} + +``` +## Further reading + +There are more complex concepts to be learnt in V which are available at the +official [V documentation](https://github.com/vlang/v/blob/master/doc/docs.md). + +You can also find more information about the V language at the [official website](https://vlang.io/) +or check it out at the [v playground](https://v-wasm.vercel.app/).
\ No newline at end of file |