fix: Fixed a compilation issue with send_const_string.

`send` now automatically uses `send_const_string` when appropriate.

examples/const_echo/main.odin

@@ -0,0 +1,64 @@
+package main
+
+import zmq "../../"
+import "core:fmt"
+import "core:log"
+
+main :: proc() {
+	context.logger = log.create_console_logger(.Debug, {})
+
+	major, minor, patch := zmq.version()
+	log.infof(
+		"zmq echo (libzmq %d.%d.%d) over inproc; type lines, Ctrl-D to quit",
+		major,
+		minor,
+		patch,
+	)
+
+	ctx := zmq.ctx_new()
+	defer zmq.ctx_term(ctx)
+
+	srv, serr := zmq.socket(ctx, .REP)
+	if serr != nil {
+		log.panic(zmq.strerror(serr))
+	}
+	defer zmq.close(srv)
+	if err := zmq.bind(srv, "inproc://echo"); err != nil {
+		log.panic(zmq.strerror(err))
+	}
+
+	cli, cerr := zmq.socket(ctx, .REQ)
+	if cerr != nil {
+		log.panicf("err: %v (%d) %s", cerr, cerr, zmq.strerror(cerr))
+	}
+	defer zmq.close(cli)
+	if err := zmq.connect(cli, "inproc://echo"); err != nil {
+		log.panic(zmq.strerror(err))
+	}
+
+	buf: [255]u8
+	msg :: "Hello, World"
+
+	fmt.printfln("> %s", msg)
+
+	if _, err := zmq.send_const(cli, msg); err != nil {
+		fmt.eprintfln("send: %s", zmq.strerror(err))
+		return
+	}
+	n, rerr := zmq.recv(srv, buf[:])
+	if rerr != nil {
+		fmt.eprintfln("rep recv: %s", zmq.strerror(rerr))
+		return
+	}
+	if _, werr := zmq.send(srv, buf[:n]); werr != nil {
+		fmt.eprintfln("rep send: %v %s", werr, zmq.strerror(werr))
+		return
+	}
+	m, qerr := zmq.recv(cli, buf[:])
+	if qerr != nil {
+		fmt.eprintfln("req recv: %s", zmq.strerror(qerr))
+		return
+	}
+	fmt.printfln("< %s", string(buf[:m]))
+}
+

zmq.odin

@@ -115,6 +115,7 @@ connect :: proc(s: Socket, addr: string, allocator := context.temp_allocator) ->
 
 send :: proc {
 	send_bytes,
+	send_const_string,
 	send_string,
 }
 
@@ -136,17 +137,12 @@ send_const :: proc {
 }
 
 send_const_string :: proc(s: Socket, $str: string, flags: Flags = {}) -> (int, Error) {
-	n := _send_const(s, rawptr($str), len($str), flags)
-	if n < 0 {
-		return -1, last_error()
-	}
-
-	return int(n), nil
+	return send_const_bytes(s, transmute([]byte)str, flags)
 }
 
 // buf must have @(rodata) or global lifetime.
 send_const_bytes :: proc(s: Socket, buf: []byte, flags: Flags = {}) -> (int, Error) {
-	n := _send_const(s, rawptr(&buf[0]), len(buf), flags)
+	n := _send_const(s, rawptr(&buf[0]), c.size_t(len(buf)), flags)
 	if n < 0 {
 		return -1, last_error()
 	}