Add string.concat

It servers the same purposes as Lua's `table.concat`

docs/pages/clibraries.md

@@ -2858,15 +2858,15 @@ function C._Exit(status: cint): void
 ### C.atexit
 
 ```nelua
-function C.atexit(func: pointer): cint
+function C.atexit(func: function(): void): cint
 ```
 
 
 
 ### C.at_quick_exit
 
 ```nelua
-function C.at_quick_exit(func: pointer): cint
+function C.at_quick_exit(func: function(): void): cint
 ```
 
 

docs/pages/libraries.md

@@ -1821,6 +1821,14 @@ Converts a string to a span of bytes.
 
 Remarks: Similar to `subview` a reference of the current string data is returned.
 
+### string.concat
+
+```nelua
+function string.concat(list: span(string), sep: facultative(string)): string
+```
+
+Concatenates a span of a strings into a single string.
+
 ### string:__close
 
 ```nelua
@@ -2596,7 +2604,7 @@ The coroutine handle.
 ### coroutine.destroy
 
 ```nelua
-function coroutine.destroy(co: coroutine): void
+function coroutine.destroy(co: coroutine): (boolean, string)
 ```
 
 Destroy the coroutine `co`, freeing its stack memory and resources.
@@ -2616,7 +2624,7 @@ Effectively the same as `destroy`, called when a to-be-closed variable goes out
 ### coroutine.create
 
 ```nelua
-function coroutine.create(f: function_concept): coroutine
+function coroutine.create(f: function_concept): (coroutine, string)
 ```
 
 Returns a new coroutine with body function `f`.
@@ -2677,7 +2685,7 @@ Starts or continues the execution of the coroutine `co`.
 ### coroutine.spawn
 
 ```nelua
-function coroutine.spawn(f: function_concept, ...: varargs): coroutine
+function coroutine.spawn(f: function_concept, ...: varargs): (coroutine, string)
 ```
 
 Creates and immediately starts a new coroutine with body function `f`.
@@ -2688,7 +2696,7 @@ This is effectively the same as calling `coroutine.create` and then `coroutine.r
 ### coroutine.yield
 
 ```nelua
-function coroutine.yield(...: varargs): void
+function coroutine.yield(...: varargs): (boolean, string)
 ```
 
 Suspends the execution of the running coroutine.

lib/string.nelua

@@ -265,6 +265,35 @@ function string.span(s: string): span(byte) <inline>
   return (@span(byte)){data=s.data, size=s.size}
 end
 
+-- Concatenates a span of a strings into a single string.
+function string.concat(list: span(string), sep: facultative(string)): string
+  ## if sep.type.is_niltype then
+  local sep: string = ""
+  ## end
+  local size: usize
+  for i: usize=0,<list.size do
+    if i > 0 then size = size + sep.size end
+    size = size + list[i].size
+  end
+  if size == 0 then return (@string){} end
+  local s: string = string.create(size)
+  local pos: usize = 0
+  for i: usize=0,<list.size do
+    if sep.size > 0 and i > 0 then
+      for j=0,<sep.size do
+        s.data[pos] = sep.data[j]
+        pos = pos + 1
+      end
+    end
+    local part: string = list[i]
+    for j=0,<part.size do
+      s.data[pos] = part.data[j]
+      pos = pos + 1
+    end
+  end
+  return s
+end
+
 ----------------------------------------------------------------------------------------------------
 -- String metamethods
 

tests/string_test.nelua

@@ -437,7 +437,7 @@ do -- string.gsub
   sub:destroy()
 end
 
-do -- string format
+do -- string.format
   local s: string
   assert_string_eq(string.format(''), '')
   assert_string_eq(string.format('%s', (@string){}), '')
@@ -480,6 +480,16 @@ do -- string format
   assert_string_eq(string.format('|%4s|', ''), '|    |')
 end
 
+do -- string.concat
+  assert(string.concat({}) == "")
+  assert(string.concat({}, " ") == "")
+
+  local s: string <close> = string.concat({"hello", "world"}) assert(s == "helloworld")
+  local s: string <close> = string.concat({"hello", "world"}, " ") print(s) assert(s == "hello world")
+  local s: string <close> = string.concat({"hello", "huge", "world"}, ",") assert(s == "hello,huge,world")
+  local s: string <close> = string.concat({"a", "b", "c"}, ";:") assert(s == "a;:b;:c")
+end
+
 do -- print
   print('hello')
   local s: string = 'world'