Improve V code (#376)

ArtemkaKun · web-flow · commit 256d728ef03f · 2023-03-04T02:26:53.000Z
diff --git a/.gitattributes b/.gitattributes
@@ -0,0 +1 @@
+**/*.v linguist-language=V
diff --git a/bench/algorithm/binarytrees/1.v b/bench/algorithm/binarytrees/1.v
@@ -42,7 +42,7 @@ fn main() {
 
 	stretch_depth := max_depth + 1
 	stretch_tree := create(stretch_depth)
-	println('stretch tree of depth $stretch_depth\t check: ${check(stretch_tree)}')
+	println('stretch tree of depth ${stretch_depth}\t check: ${check(stretch_tree)}')
 
 	long_lived_tree := create(max_depth)
 
@@ -58,8 +58,8 @@ fn main() {
 			check_result += check(node)
 		}
 
-		println('$n\t trees of depth $depth\t check: $check_result')
+		println('${n}\t trees of depth ${depth}\t check: ${check_result}')
 	}
 
-	println('long lived tree of depth $max_depth\t check: ${check(long_lived_tree)}')
+	println('long lived tree of depth ${max_depth}\t check: ${check(long_lived_tree)}')
 }
diff --git a/bench/algorithm/coro-prime-sieve/1.v b/bench/algorithm/coro-prime-sieve/1.v
@@ -9,13 +9,13 @@ fn main() {
 		n = strconv.atoi(os.args[1]) or { n }
 	}
 
-	mut ch := chan int{cap:1}
-	go generate(ch)
+	mut ch := chan int{cap: 1}
+	spawn generate(ch)
 	for _ in 0 .. n {
 		prime := <-ch
 		println(prime)
-		ch_next := chan int{cap:1}
-		go filter(ch, ch_next, prime)
+		ch_next := chan int{cap: 1}
+		spawn filter(ch, ch_next, prime)
 		ch = ch_next
 	}
 }
diff --git a/bench/algorithm/edigits/1.v b/bench/algorithm/edigits/1.v
@@ -28,9 +28,9 @@ fn main() {
 		} else {
 			mut line := s[i..n]
 			for _ in 0 .. (10 - n % 10) {
-				line = '$line '
+				line = '${line} '
 			}
-			print('$line\t:$n')
+			print('${line}\t:${n}')
 		}
 	}
 }
diff --git a/bench/algorithm/fannkuch-redux/1.v b/bench/algorithm/fannkuch-redux/1.v
@@ -11,7 +11,7 @@ fn main() {
 
 	sum, flips := fannkuchredux(n)
 
-	println('$sum\nPfannkuchen($n) = $flips')
+	println('${sum}\nPfannkuchen(${n}) = ${flips}')
 }
 
 [direct_array_access]
diff --git a/bench/algorithm/fasta/1.v b/bench/algorithm/fasta/1.v
@@ -55,7 +55,7 @@ fn main() {
 }
 
 fn make_repeat_fasta(id string, desc string, src []byte, n int) {
-	println('>$id $desc')
+	println('>${id} ${desc}')
 	mut char_print_idx := 0
 	mut sb := strings.new_builder(line_width)
 	unsafe {
@@ -83,7 +83,7 @@ fn make_repeat_fasta(id string, desc string, src []byte, n int) {
 }
 
 fn make_random_fasta(mut rand_gen RandGen, id string, desc string, mut table map[byte]f64, n int) {
-	println('>$id $desc')
+	println('>${id} ${desc}')
 	mut prob := 0.0
 	for k, p in table {
 		prob += p
diff --git a/bench/algorithm/helloworld/1.v b/bench/algorithm/helloworld/1.v
@@ -2,5 +2,5 @@ import os
 
 fn main() {
 	name := if os.args.len > 1 { os.args[1] } else { '' }
-	println('Hello world $name!')
+	println('Hello world ${name}!')
 }
diff --git a/bench/algorithm/http-server/1.v b/bench/algorithm/http-server/1.v
@@ -13,11 +13,11 @@ fn main() {
 		n = strconv.atoi(os.args[1]) or { 10 }
 	}
 	port := int(rand.u32_in_range(20000, 50000) or { 23333 })
-	go vweb.run(&App{}, port)
-	url := 'http://localhost:$port/api'
+	spawn vweb.run(&App{}, port)
+	url := 'http://localhost:${port}/api'
 	mut ch := chan int{cap: n}
 	for i in 1 .. (n + 1) {
-		go send(url, i, ch)
+		spawn send(url, i, ch)
 	}
 	mut sum := 0
 	for _ in 0 .. n {
@@ -45,7 +45,7 @@ pub fn (mut app App) api() vweb.Result {
 			value: 0
 		}
 	}
-	return app.text('$data.value')
+	return app.text('${data.value}')
 }
 
 struct Payload {
diff --git a/bench/algorithm/json-serde/1.v b/bench/algorithm/json-serde/1.v
@@ -11,10 +11,10 @@ fn main() {
 	if os.args.len > 2 {
 		n = strconv.atoi(os.args[2]) or { 3 }
 	}
-	json_str := os.read_file('${file_name}.json') ?
-	data := json.decode(GeoData, json_str) ?
+	json_str := os.read_file('${file_name}.json')!
+	data := json.decode(GeoData, json_str)!
 	println(md5.hexhash(json.encode(data)))
-	array := []GeoData{len: n, cap: n, init: json.decode(GeoData, json_str) ?}
+	array := []GeoData{len: n, cap: n, init: json.decode(GeoData, json_str)!}
 	println(md5.hexhash(json.encode(array)))
 }
 
diff --git a/bench/algorithm/lru/1.v b/bench/algorithm/lru/1.v
@@ -80,5 +80,5 @@ fn main() {
 		}
 	}
 
-	println('$hit\n$missed')
+	println('${hit}\n${missed}')
 }
diff --git a/bench/algorithm/lru/2.v b/bench/algorithm/lru/2.v
@@ -19,28 +19,28 @@ fn (mut lcg LCG) next() u32 {
 	return lcg.seed
 }
 
-struct LinkedListNode<T> {
+struct LinkedListNode[T] {
 mut:
-	prev &LinkedListNode<T>
-	next &LinkedListNode<T>
+	prev &LinkedListNode[T]
+	next &LinkedListNode[T]
 	data T
 }
 
-struct LinkedList<T> {
+struct LinkedList[T] {
 mut:
 	len  int
-	head &LinkedListNode<T> = 0
-	tail &LinkedListNode<T> = 0
+	head &LinkedListNode[T] = 0
+	tail &LinkedListNode[T] = 0
 }
 
-fn (mut ll LinkedList<T>) add<T>(data T) &LinkedListNode<T> {
+fn (mut ll LinkedList[T]) add[T](data T) &LinkedListNode[T] {
 	node = &LinkedListNode{data}
 	ll.__add_node(node)
 	ll.len += 1
 	return node
 }
 
-fn (mut ll LinkedList<T>) __add_node<T>(node &LinkedListNode<T>) {
+fn (mut ll LinkedList[T]) __add_node[T](node &LinkedListNode[T]) {
 	if ll.head == 0 {
 		ll.head = node
 		node.prev = 0
@@ -52,7 +52,7 @@ fn (mut ll LinkedList<T>) __add_node<T>(node &LinkedListNode<T>) {
 	node.next = 0
 }
 
-fn (mut ll LinkedList<T>) __remove<T>(node &LinkedListNode<T>) {
+fn (mut ll LinkedList[T]) __remove[T](node &LinkedListNode[T]) {
 	if ll.head == node {
 		ll.head = node.next
 	}
@@ -67,12 +67,12 @@ fn (mut ll LinkedList<T>) __remove<T>(node &LinkedListNode<T>) {
 	}
 }
 
-fn (mut ll LinkedList<T>) move_to_end(node &LinkedListNode<T>) {
+fn (mut ll LinkedList[T]) move_to_end(node &LinkedListNode[T]) {
 	ll.__remove(node)
 	ll.__add_node(node)
 }
 
-fn (mut ll LinkedList<T>) pop_head() &LinkedListNode<T> {
+fn (mut ll LinkedList[T]) pop_head() &LinkedListNode[T] {
 	if self.head != 0 {
 		head := self.head
 		self.head = head.next
@@ -82,16 +82,16 @@ fn (mut ll LinkedList<T>) pop_head() &LinkedListNode<T> {
 	return 0
 }
 
-struct Pair<K, V> {
+struct Pair[K, V] {
 	key   K
 	value V
 }
 
-struct LRU<K, V> {
+struct LRU[K, V] {
 	size int
 mut:
-	_key_lookup map[K]&LinkedListNode<Pair<K, V>> = {}
-	_entries    LinkedList<Pair<K, V>> = {}
+	_key_lookup map[K]&LinkedListNode[Pair[K, V]] = {}
+	_entries    LinkedList[Pair[K, V]] = {}
 }
 
 fn (mut lru LRU) get(key u32) ?u32 {
@@ -130,7 +130,7 @@ fn main() {
 	mut rng1 := LCG{
 		seed: 1
 	}
-	mut lru := LRU<u32, u32>{
+	mut lru := LRU[u32, u32]{
 		size: size
 	}
 
@@ -148,5 +148,5 @@ fn main() {
 		}
 	}
 
-	println('$hit\n$missed')
+	println('${hit}\n${missed}')
 }
diff --git a/bench/algorithm/mandelbrot/1.v b/bench/algorithm/mandelbrot/1.v
@@ -17,7 +17,7 @@ fn main() {
 	for i in 0 .. n {
 		xloc[i / 8][i % 8] = f64(i) * inv - 1.5
 	}
-	println('P4\n$n $n')
+	println('P4\n${n} ${n}')
 
 	mut rows := []byte{len: n * chunk_size, cap: n * chunk_size, init: 0}
 	for chunk_id := 0; chunk_id < n; chunk_id++ {
diff --git a/bench/algorithm/pidigits/1.v b/bench/algorithm/pidigits/1.v
@@ -41,7 +41,7 @@ fn main() {
 			digits_printed++
 			digits_printed_mod_ten := digits_printed % 10
 			if digits_printed_mod_ten == 0 {
-				sb.write_string('\t:$digits_printed')
+				sb.write_string('\t:${digits_printed}')
 				println(sb.str())
 				sb.go_back_to(0)
 			}
@@ -51,7 +51,7 @@ fn main() {
 					for _ in 0 .. (10 - digits_printed_mod_ten) {
 						sb.write_byte(` `)
 					}
-					sb.write_string('\t:$digits_printed')
+					sb.write_string('\t:${digits_printed}')
 					println(sb.str())
 				}
 				return
diff --git a/bench/algorithm/pidigits/2.v b/bench/algorithm/pidigits/2.v
@@ -47,7 +47,7 @@ fn main() {
 			digits_printed++
 			digits_printed_mod_ten := digits_printed % 10
 			if digits_printed_mod_ten == 0 {
-				sb.write_string('\t:$digits_printed')
+				sb.write_string('\t:${digits_printed}')
 				println(sb.str())
 				sb.go_back_to(0)
 			}
@@ -57,7 +57,7 @@ fn main() {
 					for _ in 0 .. (10 - digits_printed_mod_ten) {
 						sb.write_byte(` `)
 					}
-					sb.write_string('\t:$digits_printed')
+					sb.write_string('\t:${digits_printed}')
 					println(sb.str())
 				}
 				return
diff --git a/bench/algorithm/regex-redux/1.v b/bench/algorithm/regex-redux/1.v
@@ -21,7 +21,7 @@ fn main() {
 		'agggta[cgt]a|t[acg]taccct',
 		'agggtaa[cgt]|[acg]ttaccct',
 	] {
-		println('$p ${var_find(content, p)?}')
+		println('${p} ${var_find(content, p)?}')
 	}
 	for p, r in {
 		'tHa[Nt]':                    '<4>'
@@ -33,7 +33,7 @@ fn main() {
 		mut re := regex.regex_opt(p)?
 		content = re.replace(content, r)
 	}
-	println('\n$ilen\n$clen\n$content.len')
+	println('\n${ilen}\n${clen}\n${content.len}')
 }
 
 fn var_find(content string, pattern string) ?int {
@@ -44,6 +44,6 @@ fn var_find(content string, pattern string) ?int {
 
 fn normalize_pattern(pattern string) string {
 	return pattern.split('|').map(fn (s string) string {
-		return '($s)'
+		return '(${s})'
 	}).join('|')
 }

Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ fn main() {`
`42`	`42`
`43`	`43`	`stretch_depth := max_depth + 1`
`44`	`44`	`stretch_tree := create(stretch_depth)`
`45`		`- println('stretch tree of depth $stretch_depth\t check: ${check(stretch_tree)}')`
	`45`	`+ println('stretch tree of depth ${stretch_depth}\t check: ${check(stretch_tree)}')`
`46`	`46`
`47`	`47`	`long_lived_tree := create(max_depth)`
`48`	`48`
`@@ -58,8 +58,8 @@ fn main() {`
`58`	`58`	`check_result += check(node)`
`59`	`59`	`}`
`60`	`60`
`61`		`- println('$n\t trees of depth $depth\t check: $check_result')`
	`61`	`+ println('${n}\t trees of depth ${depth}\t check: ${check_result}')`
`62`	`62`	`}`
`63`	`63`
`64`		`- println('long lived tree of depth $max_depth\t check: ${check(long_lived_tree)}')`
	`64`	`+ println('long lived tree of depth ${max_depth}\t check: ${check(long_lived_tree)}')`
`65`	`65`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,13 +9,13 @@ fn main() {`
`9`	`9`	`n = strconv.atoi(os.args[1]) or { n }`
`10`	`10`	`}`
`11`	`11`
`12`		`- mut ch := chan int{cap:1}`
`13`		`- go generate(ch)`
	`12`	`+ mut ch := chan int{cap: 1}`
	`13`	`+ spawn generate(ch)`
`14`	`14`	`for _ in 0 .. n {`
`15`	`15`	`prime := <-ch`
`16`	`16`	`println(prime)`
`17`		`- ch_next := chan int{cap:1}`
`18`		`- go filter(ch, ch_next, prime)`
	`17`	`+ ch_next := chan int{cap: 1}`
	`18`	`+ spawn filter(ch, ch_next, prime)`
`19`	`19`	`ch = ch_next`
`20`	`20`	`}`
`21`	`21`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,9 +28,9 @@ fn main() {`
`28`	`28`	`} else {`
`29`	`29`	`mut line := s[i..n]`
`30`	`30`	`for _ in 0 .. (10 - n % 10) {`
`31`		`- line = '$line '`
	`31`	`+ line = '${line} '`
`32`	`32`	`}`
`33`		`- print('$line\t:$n')`
	`33`	`+ print('${line}\t:${n}')`
`34`	`34`	`}`
`35`	`35`	`}`
`36`	`36`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ fn main() {`
`11`	`11`
`12`	`12`	`sum, flips := fannkuchredux(n)`
`13`	`13`
`14`		`- println('$sum\nPfannkuchen($n) = $flips')`
	`14`	`+ println('${sum}\nPfannkuchen(${n}) = ${flips}')`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`[direct_array_access]`
Original file line number	Diff line number	Diff line change
`@@ -2,5 +2,5 @@ import os`
`2`	`2`
`3`	`3`	`fn main() {`
`4`	`4`	`name := if os.args.len > 1 { os.args[1] } else { '' }`
`5`		`- println('Hello world $name!')`
	`5`	`+ println('Hello world ${name}!')`
`6`	`6`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,11 +13,11 @@ fn main() {`
`13`	`13`	`n = strconv.atoi(os.args[1]) or { 10 }`
`14`	`14`	`}`
`15`	`15`	`port := int(rand.u32_in_range(20000, 50000) or { 23333 })`
`16`		`- go vweb.run(&App{}, port)`
`17`		`- url := 'http://localhost:$port/api'`
	`16`	`+ spawn vweb.run(&App{}, port)`
	`17`	`+ url := 'http://localhost:${port}/api'`
`18`	`18`	`mut ch := chan int{cap: n}`
`19`	`19`	`for i in 1 .. (n + 1) {`
`20`		`- go send(url, i, ch)`
	`20`	`+ spawn send(url, i, ch)`
`21`	`21`	`}`
`22`	`22`	`mut sum := 0`
`23`	`23`	`for _ in 0 .. n {`
`@@ -45,7 +45,7 @@ pub fn (mut app App) api() vweb.Result {`
`45`	`45`	`value: 0`
`46`	`46`	`}`
`47`	`47`	`}`
`48`		`- return app.text('$data.value')`
	`48`	`+ return app.text('${data.value}')`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`struct Payload {`
Original file line number	Diff line number	Diff line change
`@@ -11,10 +11,10 @@ fn main() {`
`11`	`11`	`if os.args.len > 2 {`
`12`	`12`	`n = strconv.atoi(os.args[2]) or { 3 }`
`13`	`13`	`}`
`14`		`- json_str := os.read_file('${file_name}.json') ?`
`15`		`- data := json.decode(GeoData, json_str) ?`
	`14`	`+ json_str := os.read_file('${file_name}.json')!`
	`15`	`+ data := json.decode(GeoData, json_str)!`
`16`	`16`	`println(md5.hexhash(json.encode(data)))`
`17`		`- array := []GeoData{len: n, cap: n, init: json.decode(GeoData, json_str) ?}`
	`17`	`+ array := []GeoData{len: n, cap: n, init: json.decode(GeoData, json_str)!}`
`18`	`18`	`println(md5.hexhash(json.encode(array)))`
`19`	`19`	`}`
`20`	`20`
Original file line number	Diff line number	Diff line change
`@@ -80,5 +80,5 @@ fn main() {`
`80`	`80`	`}`
`81`	`81`	`}`
`82`	`82`
`83`		`- println('$hit\n$missed')`
	`83`	`+ println('${hit}\n${missed}')`
`84`	`84`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,28 +19,28 @@ fn (mut lcg LCG) next() u32 {`
`19`	`19`	`return lcg.seed`
`20`	`20`	`}`
`21`	`21`
`22`		`-struct LinkedListNode<T> {`
	`22`	`+struct LinkedListNode[T] {`
`23`	`23`	`mut:`
`24`		`- prev &LinkedListNode<T>`
`25`		`- next &LinkedListNode<T>`
	`24`	`+ prev &LinkedListNode[T]`
	`25`	`+ next &LinkedListNode[T]`
`26`	`26`	`data T`
`27`	`27`	`}`
`28`	`28`
`29`		`-struct LinkedList<T> {`
	`29`	`+struct LinkedList[T] {`
`30`	`30`	`mut:`
`31`	`31`	`len int`
`32`		`- head &LinkedListNode<T> = 0`
`33`		`- tail &LinkedListNode<T> = 0`
	`32`	`+ head &LinkedListNode[T] = 0`
	`33`	`+ tail &LinkedListNode[T] = 0`
`34`	`34`	`}`
`35`	`35`
`36`		`-fn (mut ll LinkedList<T>) add<T>(data T) &LinkedListNode<T> {`
	`36`	`+fn (mut ll LinkedList[T]) add[T](data T) &LinkedListNode[T] {`
`37`	`37`	`node = &LinkedListNode{data}`
`38`	`38`	`ll.__add_node(node)`
`39`	`39`	`ll.len += 1`
`40`	`40`	`return node`
`41`	`41`	`}`
`42`	`42`
`43`		`-fn (mut ll LinkedList<T>) __add_node<T>(node &LinkedListNode<T>) {`
	`43`	`+fn (mut ll LinkedList[T]) __add_node[T](node &LinkedListNode[T]) {`
`44`	`44`	`if ll.head == 0 {`
`45`	`45`	`ll.head = node`
`46`	`46`	`node.prev = 0`
`@@ -52,7 +52,7 @@ fn (mut ll LinkedList<T>) __add_node<T>(node &LinkedListNode<T>) {`
`52`	`52`	`node.next = 0`
`53`	`53`	`}`
`54`	`54`
`55`		`-fn (mut ll LinkedList<T>) __remove<T>(node &LinkedListNode<T>) {`
	`55`	`+fn (mut ll LinkedList[T]) __remove[T](node &LinkedListNode[T]) {`
`56`	`56`	`if ll.head == node {`
`57`	`57`	`ll.head = node.next`
`58`	`58`	`}`
`@@ -67,12 +67,12 @@ fn (mut ll LinkedList<T>) __remove<T>(node &LinkedListNode<T>) {`
`67`	`67`	`}`
`68`	`68`	`}`
`69`	`69`
`70`		`-fn (mut ll LinkedList<T>) move_to_end(node &LinkedListNode<T>) {`
	`70`	`+fn (mut ll LinkedList[T]) move_to_end(node &LinkedListNode[T]) {`
`71`	`71`	`ll.__remove(node)`
`72`	`72`	`ll.__add_node(node)`
`73`	`73`	`}`
`74`	`74`
`75`		`-fn (mut ll LinkedList<T>) pop_head() &LinkedListNode<T> {`
	`75`	`+fn (mut ll LinkedList[T]) pop_head() &LinkedListNode[T] {`
`76`	`76`	`if self.head != 0 {`
`77`	`77`	`head := self.head`
`78`	`78`	`self.head = head.next`
`@@ -82,16 +82,16 @@ fn (mut ll LinkedList<T>) pop_head() &LinkedListNode<T> {`
`82`	`82`	`return 0`
`83`	`83`	`}`
`84`	`84`
`85`		`-struct Pair<K, V> {`
	`85`	`+struct Pair[K, V] {`
`86`	`86`	`key K`
`87`	`87`	`value V`
`88`	`88`	`}`
`89`	`89`
`90`		`-struct LRU<K, V> {`
	`90`	`+struct LRU[K, V] {`
`91`	`91`	`size int`
`92`	`92`	`mut:`
`93`		`- _key_lookup map[K]&LinkedListNode<Pair<K, V>> = {}`
`94`		`- _entries LinkedList<Pair<K, V>> = {}`
	`93`	`+ _key_lookup map[K]&LinkedListNode[Pair[K, V]] = {}`
	`94`	`+ _entries LinkedList[Pair[K, V]] = {}`
`95`	`95`	`}`
`96`	`96`
`97`	`97`	`fn (mut lru LRU) get(key u32) ?u32 {`
`@@ -130,7 +130,7 @@ fn main() {`
`130`	`130`	`mut rng1 := LCG{`
`131`	`131`	`seed: 1`
`132`	`132`	`}`
`133`		`- mut lru := LRU<u32, u32>{`
	`133`	`+ mut lru := LRU[u32, u32]{`
`134`	`134`	`size: size`
`135`	`135`	`}`
`136`	`136`
`@@ -148,5 +148,5 @@ fn main() {`
`148`	`148`	`}`
`149`	`149`	`}`
`150`	`150`
`151`		`- println('$hit\n$missed')`
	`151`	`+ println('${hit}\n${missed}')`
`152`	`152`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ fn main() {`
`17`	`17`	`for i in 0 .. n {`
`18`	`18`	`xloc[i / 8][i % 8] = f64(i) * inv - 1.5`
`19`	`19`	`}`
`20`		`- println('P4\n$n $n')`
	`20`	`+ println('P4\n${n} ${n}')`
`21`	`21`
`22`	`22`	`mut rows := []byte{len: n * chunk_size, cap: n * chunk_size, init: 0}`
`23`	`23`	`for chunk_id := 0; chunk_id < n; chunk_id++ {`