v: fix generic lambda type binding and resolution

vlib/v/ast/ast.v

@@ -1872,6 +1872,7 @@ pub mut:
 	func       &AnonFn = unsafe { nil }
 	is_checked bool
 	typ        Type
+	call_ctx   &CallExpr = unsafe { nil }
 }
 
 pub struct Likely {

vlib/v/checker/fn.v

@@ -1585,6 +1585,19 @@ fn (mut c Checker) fn_call(mut node ast.CallExpr, mut continue_check &bool) ast.
 						if c.comptime.type_map.len > 0 {
 							continue
 						}
+						if mut call_arg.expr is ast.LambdaExpr {
+							// Calling fn is generic and lambda arg also is generic
+							if node.concrete_types.len > 0
+								&& call_arg.expr.func.decl.generic_names.len > 0 {
+								call_arg.expr.call_ctx = unsafe { node }
+								if c.table.register_fn_concrete_types(call_arg.expr.func.decl.fkey(),
+									node.concrete_types)
+								{
+									call_arg.expr.func.decl.ninstances++
+								}
+							}
+							continue
+						}
 						c.error('${err.msg()} in argument ${i + 1} to `${fn_name}`', call_arg.pos)
 					}
 				}

vlib/v/gen/c/cgen.v

@@ -3565,8 +3565,14 @@ fn (mut g Gen) expr(node_ ast.Expr) {
 			g.write('/*IsRefType*/ ${is_ref_type}')
 		}
 		ast.LambdaExpr {
-			g.gen_anon_fn(mut node.func)
-			// g.write('/* lambda expr: ${node_.str()} */')
+			if node.call_ctx != unsafe { nil } {
+				save_cur_concrete_types := g.cur_concrete_types
+				g.cur_concrete_types = node.call_ctx.concrete_types
+				g.gen_anon_fn(mut node.func)
+				g.cur_concrete_types = save_cur_concrete_types
+			} else {
+				g.gen_anon_fn(mut node.func)
+			}
 		}
 		ast.Likely {
 			if node.is_likely {

vlib/v/gen/c/fn.v

@@ -575,6 +575,7 @@ fn (mut g Gen) closure_ctx(node ast.FnDecl) string {
 fn (mut g Gen) gen_anon_fn(mut node ast.AnonFn) {
 	g.gen_anon_fn_decl(mut node)
 	mut fn_name := node.decl.name
+
 	if node.decl.generic_names.len > 0 {
 		fn_name = g.generic_fn_name(g.cur_concrete_types, fn_name)
 	}

vlib/v/tests/lambda_generic_test.v

@@ -0,0 +1,12 @@
+import arrays
+
+fn abc[T](arg T, call fn (a T) string) string {
+	return call(arg)
+}
+
+fn test_main() {
+	a := [1, 2, 3, 4]
+	b := arrays.join_to_string(a, '-', |x| x.str())
+	assert b == '1-2-3-4'
+	assert abc(123, |x| x.str()) == '123'
+}