Merge branch 'master' of https://github.com/get200/v

Author: get200

.github/workflows/v_apps_and_modules_compile_ci.yml

@@ -46,6 +46,13 @@ jobs:
             v retry brew install sassc libgit2
           fi
 
+      - name: Build docs generator
+        run: |
+          v retry -- v install markdown
+          v retry -- git clone https://github.com/vlang/docs --branch generator --depth 1
+          cd docs
+          v .
+
       - name: Test vtcc
         if: runner.os == 'Linux'
         run: .github/workflows/compile_v_with_vtcc.sh

cmd/tools/gg_split_memdump_to_frames.vsh

@@ -0,0 +1,42 @@
+#!/usr/bin/env -S v -raw-vsh-tmp-prefix tmp
+
+module main
+
+import os
+import log
+
+fn write_chunk(n int, min_size int, original string, start int, end int) {
+	size := end - start
+	if size < min_size {
+		return
+	}
+	frame_file := 'frame_${n:06}.bin'
+	log.warn('writing ${frame_file}, from start: ${start:9}, to end: ${end:9} | size: ${size:9} >= ${min_size:9}, memuse: ${gc_memory_use()}')
+	os.write_file(frame_file, original#[start..end]) or { log.error(err.str()) }
+}
+
+fn main() {
+	log.info('Start.')
+	fpath := os.args[2] or { 'memdump.bin' }
+	separator := os.args[3] or { '@@ gg_memory_trace_frame' }
+	min_size := os.args[1] or { '${separator.len}' }.int()
+	log.info('Splitting chunk min_size (arg 1): ${min_size}, file (arg 2): ${fpath}, by string separator (arg 3): `${separator}` ...')
+	log.info('Memory use before reading: ${gc_memory_use()}')
+	original := os.read_file(fpath)!
+	log.info('file size: ${original.len}')
+	log.info('Memory use after reading: ${gc_memory_use()}')
+	mut n := 0
+	for start := 0; start < original.len; {
+		gc_collect()
+		idx := original.index_after_(separator, start + separator.len) // ensure that we advance each time
+		if idx < 0 {
+			write_chunk(n, min_size, original, start, original.len)
+			break
+		}
+		write_chunk(n, min_size, original, start, idx)
+		start = idx
+		n++
+	}
+	log.info('Memory use after processing: ${gc_memory_use()}')
+	log.info('Done.')
+}

doc/docs.md

@@ -120,6 +120,7 @@ by using any of the following commands in a terminal:
     * [Mutable arguments](#mutable-arguments)
     * [Variable number of arguments](#variable-number-of-arguments)
     * [Anonymous & higher-order functions](#anonymous--higher-order-functions)
+    * [Lambda expressions](#lambda-expressions)
     * [Closures](#closures)
     * [Parameter evaluation order](#parameter-evaluation-order)
 * [References](#references)
@@ -3021,6 +3022,28 @@ fn main() {
 }
 ```
 
+### Lambda expressions
+
+Lambda expressions in V are small anonymous functions, defined using
+the `|variables| expression` syntax. Note: this syntax is valid only inside calls to higher
+order functions.
+
+Here are some examples:
+```v
+mut a := [1, 2, 3]
+a.sort(|x, y| x > y) // sorts the array, defining the comparator with a lambda expression
+println(a.map(|x| x * 10)) // prints [30, 20, 10]
+```
+
+```v
+// Lambda function can be used as callback
+fn f(cb fn (a int) int) int {
+	return cb(10)
+}
+
+println(f(|x| x + 4)) // prints 14
+```
+
 ### Closures
 
 V supports closures too.
@@ -8331,4 +8354,4 @@ This is the place to be, to discuss the V language, learn about latest
 developments, quickly get help with issues, witness/participate in
 ~~epic flame wars~~ constructive criticism exchanges and design decisions.
 Join it, and learn more about languages, games, editors, people, Klingons,
-Conway's law and the universe.
+Conway's law and the universe.

examples/database/mysql.v

@@ -13,5 +13,5 @@ fn main() {
 	for row in res.rows() {
 		println(row.vals.join(', '))
 	}
-	conn.close()
+	conn.close()!
 }

examples/database/mysql_pool.v

@@ -0,0 +1,159 @@
+// vtest build: !(macos || windows)
+import db.mysql
+import pool
+import time
+
+// Define your connection factory function
+fn create_conn() !&pool.ConnectionPoolable {
+	config := mysql.Config{
+		host:     '127.0.0.1'
+		port:     3306
+		username: 'root'
+		password: '12345678'
+		dbname:   'mysql'
+	}
+	db := mysql.connect(config)!
+	return &db
+}
+
+fn main() {
+	// Configure pool parameters
+	config := pool.ConnectionPoolConfig{
+		max_conns:      50
+		min_idle_conns: 5
+		max_lifetime:   2 * time.hour
+		idle_timeout:   30 * time.minute
+		get_timeout:    5 * time.second
+	}
+
+	// Create connection pool
+	mut my_pool := pool.new_connection_pool(create_conn, config)!
+	defer {
+		// When application exits
+		my_pool.close()
+	}
+
+	// Acquire connection
+	mut conn := my_pool.get()!
+	defer {
+		// Return connection to pool
+		my_pool.put(conn) or { println(err) }
+	}
+
+	// Convert `conn` to a `mysql.DB` object
+	mut db := conn as mysql.DB
+
+	assert db.validate()!
+
+	mut response := db.exec('drop table if exists users')!
+	assert response == []mysql.Row{}
+
+	response = db.exec('create table if not exists users (
+                        id INT PRIMARY KEY AUTO_INCREMENT,
+                        username TEXT,
+						last_name TEXT NULL DEFAULT NULL
+                      )')!
+	assert response == []mysql.Row{}
+
+	mut result_code := db.exec_none('insert into users (username) values ("jackson")')
+	assert result_code == 0
+	result_code = db.exec_none('insert into users (username) values ("shannon")')
+	assert result_code == 0
+	result_code = db.exec_none('insert into users (username) values ("bailey")')
+	assert result_code == 0
+	result_code = db.exec_none('insert into users (username) values ("blaze")')
+	assert result_code == 0
+	rows := db.exec_param('insert into users (username) values (?)', 'Hi')!
+	assert rows == []mysql.Row{}
+
+	// Regression testing to ensure the query and exec return the same values
+	res := db.query('select * from users')!
+	response = res.rows()
+	assert response[0].vals[1] == 'jackson'
+	response = db.exec('select * from users')!
+	assert response[0].vals[1] == 'jackson'
+
+	response = db.exec('select * from users where id = 400')!
+	assert response.len == 0
+
+	single_row := db.exec_one('select * from users')!
+	assert single_row.vals[1] == 'jackson'
+
+	response = db.exec_param_many('select * from users where username = ?', [
+		'jackson',
+	])!
+	assert response[0] == mysql.Row{
+		vals: ['1', 'jackson', '']
+	}
+
+	response = db.exec_param_many('select * from users where username = ? and id = ?',
+		['bailey', '3'])!
+	assert response[0] == mysql.Row{
+		vals: ['3', 'bailey', '']
+	}
+
+	response = db.exec_param_many('select * from users', [''])!
+	assert response == [
+		mysql.Row{
+			vals: ['1', 'jackson', '']
+		},
+		mysql.Row{
+			vals: ['2', 'shannon', '']
+		},
+		mysql.Row{
+			vals: ['3', 'bailey', '']
+		},
+		mysql.Row{
+			vals: ['4', 'blaze', '']
+		},
+		mysql.Row{
+			vals: ['5', 'Hi', '']
+		},
+	]
+
+	response = db.exec_param('select * from users where username = ?', 'blaze')!
+	assert response[0] == mysql.Row{
+		vals: ['4', 'blaze', '']
+	}
+
+	// transaction test
+	// turn off `autocommit` first
+	db.autocommit(false)!
+	// begin a new transaction
+	db.begin()!
+	result_code = db.exec_none('insert into users (username) values ("tom")')
+	assert result_code == 0
+	// make a savepoint
+	db.savepoint('savepoint1')!
+	result_code = db.exec_none('insert into users (username) values ("kitty")')
+	assert result_code == 0
+	// rollback to `savepoint1`
+	db.rollback_to('savepoint1')!
+	result_code = db.exec_none('insert into users (username) values ("mars")')
+	assert result_code == 0
+	db.commit()!
+	response = db.exec_param_many('select * from users', [''])!
+	assert response == [
+		mysql.Row{
+			vals: ['1', 'jackson', '']
+		},
+		mysql.Row{
+			vals: ['2', 'shannon', '']
+		},
+		mysql.Row{
+			vals: ['3', 'bailey', '']
+		},
+		mysql.Row{
+			vals: ['4', 'blaze', '']
+		},
+		mysql.Row{
+			vals: ['5', 'Hi', '']
+		},
+		mysql.Row{
+			vals: ['6', 'tom', '']
+		},
+		mysql.Row{
+			vals: ['8', 'mars', '']
+		},
+	]
+}

examples/database/orm.v

@@ -110,7 +110,7 @@ fn msql_array() ! {
 		sql db {
 			drop table Parent
 		} or {}
-		db.close()
+		db.close() or {}
 	}
 
 	db.query('drop table if exists Parent')!
@@ -144,7 +144,7 @@ fn psql_array() ! {
 	mut db := pg.connect(host: pg_host, user: pg_user, password: pg_pass, dbname: pg_db)!
 	defer {
 		db.exec_one('drop table if exists "Parent", "Child"') or { eprintln(err) }
-		db.close()
+		db.close() or {}
 	}
 	db.exec_one('drop table if exists "Parent", "Child"') or { eprintln(err) }
 
@@ -219,7 +219,7 @@ fn msql() ! {
 	defer {
 		conn.query('DROP TABLE IF EXISTS Module') or { eprintln(err) }
 		conn.query('DROP TABLE IF EXISTS User') or { eprintln(err) }
-		conn.close()
+		conn.close() or {}
 	}
 	conn.query('DROP TABLE IF EXISTS Module') or { eprintln(err) }
 	conn.query('DROP TABLE IF EXISTS User') or { eprintln(err) }
@@ -253,7 +253,7 @@ fn psql() ! {
 	mut db := pg.connect(host: pg_host, user: pg_user, password: pg_pass, dbname: pg_db)!
 	defer {
 		db.exec_one('drop table if exists "modules", "User"') or { eprintln(err) }
-		db.close()
+		db.close() or {}
 	}
 	db.exec_one('drop table if exists "modules", "User"') or { eprintln(err) }
 	sql db {

thirdparty/stdatomic/nix/atomic_cpp.h

@@ -120,6 +120,14 @@ using std::memory_order_consume;
 using std::memory_order_relaxed;
 using std::memory_order_release;
 using std::memory_order_seq_cst;
+
+#define memory_order_relaxed std::memory_order_relaxed
+#define memory_order_consume std::memory_order_consume
+#define memory_order_acquire std::memory_order_acquire
+#define memory_order_release std::memory_order_release
+#define memory_order_acq_rel std::memory_order_acq_rel
+#define memory_order_seq_cst std::memory_order_seq_cst
+
 #else /* <atomic> unavailable, possibly because this is C, not C++ */
 #include <sys/types.h>
 #include <stdbool.h>
@@ -266,6 +274,7 @@ typedef enum
     memory_order_acq_rel = __ATOMIC_ACQ_REL,
     memory_order_seq_cst = __ATOMIC_SEQ_CST
 } memory_order;
+
 /*
  * 7.17.4 Fences.
  */

vlib/builtin/reuse.v

@@ -0,0 +1,45 @@
+module builtin
+
+// reuse_data_as_string provides a way to treat the memory of a []u8 `buffer` as a string value.
+// It does not allocate or copy the memory block for the `buffer`, but instead creates a string descriptor,
+// that will point to the same memory as the input.
+// The intended use of that function, is to allow calling string search methods (defined on string),
+// on []u8 values too, without having to copy/allocate by calling .bytestr() (that can be too slow and unnecessary in loops).
+// Note: unlike normal V strings, the return value *is not* guaranteed to have a terminating `0` byte,
+// since this function does not allocate or modify the input in any way. This is not a problem usually,
+// since V methods and functions do not require it, but be careful, if you want to pass that string to call a C. function,
+// that expects 0 termination. If you have to do it, make a `tmp := s.clone()` beforehand, and free the cloned `tmp` string
+// after you have called the C. function with it.
+// The .len field of the result value, will be the same as the buffer.len.
+// Note: avoid storing or returning that resulting string,
+// and avoid calling the fn with a complex expression (prefer using a temporary variable as an argument).
+@[unsafe]
+pub fn reuse_data_as_string(buffer []u8) string {
+	return string{
+		str:    buffer.data
+		len:    buffer.len
+		is_lit: 1 // prevent freeing the string, since its memory is owned by the input buffer
+	}
+}
+
+// reuse_string_as_data provides a way to treat the memory of a string `s`, as a []u8 buffer.
+// It does not allocate or copy the memory block for the string `s`, but instead creates an array descriptor,
+// that will point to the same memory as the input.
+// The intended use of that function, is to allow calling array methods (defined on []u8),
+// on string values too, without having to copy/allocate by calling .bytes() (that can be too slow and unnecessary in loops).
+// Note: since there are no allocations, the buffer *will not* contain the terminating `0` byte, that V strings have usually.
+// The .len field of the result value, will be the same as s.len .
+// Note: avoid storing or returning that resulting byte buffer,
+// and avoid calling the fn with a complex expression (prefer using a temporary variable as an argument).
+@[unsafe]
+pub fn reuse_string_as_data(s string) []u8 {
+	mut res := unsafe {
+		array{
+			data:         s.str
+			len:          s.len
+			element_size: 1
+			flags:        .nogrow | .noshrink | .nofree // prevent freeing/resizing the array, since its memory is owned by the input string
+		}
+	}
+	return res
+}

vlib/builtin/reuse_test.v

@@ -0,0 +1,17 @@
+fn test_buf_to_str() {
+	s := 'abc'
+	aview := unsafe { reuse_string_as_data(s) }
+	dump(aview)
+	assert aview == [u8(97), 98, 99]
+	assert voidptr(aview.data) == voidptr(s.str)
+	assert aview.len == s.len
+}
+
+fn test_str_to_buf() {
+	a := [u8(88), 55, 77]
+	sview := unsafe { reuse_data_as_string(a) }
+	dump(sview)
+	assert sview == 'X7M'
+	assert voidptr(sview.str) == voidptr(a.data)
+	assert sview.len == a.len
+}