Overview

msgpack wraps MessagePack — a binary serialization format compatible with Python, Go, Rust, JavaScript, and 50+ other languages. It is typically 20–50% smaller than equivalent JSON and 2–10x faster to encode/decode.

Quick Start

uses msgpack;

// Build a value tree
var m := MsgMap;
MapSet(m, 'name',  MsgString('Alice'));
MapSet(m, 'age',   MsgInt(30));
MapSet(m, 'score', MsgFloat(98.5));
MapSet(m, 'active', MsgBool(True));

var tags := MsgArray;
ArrayAdd(tags, MsgString('admin'));
ArrayAdd(tags, MsgString('user'));
MapSet(m, 'tags', tags);

// Serialize to binary
var bytes := Pack(m);
WriteLn('Size: ', Length(bytes), ' bytes');

// Deserialize
var v := Unpack(bytes);
WriteLn('Name: ', AsString(MapGet(v, 'name')));
WriteLn('Age:  ', AsInt(MapGet(v, 'age')));

FreeValue(m);
FreeValue(v);

Type Inspection

var v := Unpack(data);
case ValueKind(v) of
  mkString: WriteLn('String: ', AsString(v));
  mkInt:    WriteLn('Int:    ', AsInt(v));
  mkFloat:  WriteLn('Float:  ', AsFloat(v):0:4);
  mkBool:   WriteLn('Bool:   ', AsBoolean(v));
  mkNil:    WriteLn('Nil');
  mkArray:  WriteLn('Array[', ArrayLen(v), ']');
  mkMap:    begin
    var keys := MapKeys(v);
    for I := 0 to Length(keys)-1 do
      WriteLn(keys[I], ': ', AsString(MapGet(v, keys[I])));
  end;
end;

Float Arrays — Vector Embeddings

// Efficient packing of float vectors (e.g. ML embeddings)
var embedding: array of Double;
// ... fill 1536-dim embedding ...

var packed := PackFloatArray(embedding);
WriteLn('Vector packed: ', Length(packed), ' bytes');

// Restore
var restored := UnpackFloatArray(packed);
WriteLn('Dims: ', Length(restored));

JSON Bridge

// Convert JSON → msgpack (no intermediate parsing)
var json   := '{"user":"bob","score":42}';
var packed := JSONToMsgPack(json);

// Convert msgpack → JSON
var back   := MsgPackToJSON(packed);
WriteLn(back);  // {"user":"bob","score":42}

Single-value shortcuts

var bi := PackInt(12345);
var bf := PackFloat(3.14159);
var bs := PackString('hello world');

var i  := AsInt(Unpack(bi));
var f  := AsFloat(Unpack(bf));
var s  := AsString(Unpack(bs));

With ZMQ (send binary messages)

uses msgpack, zmq;

var ctx  := NewContext;
var sock := NewSocket(ctx, ZMQ_REQ);
Connect(sock, TCPEndpoint('localhost', 5555));

// Pack and send
var msg := MsgMap;
MapSet(msg, 'cmd', MsgString('compute'));
MapSet(msg, 'n',   MsgInt(42));
Send(sock, Pack(msg));

// Receive and unpack
var reply := Unpack(Receive(sock));
WriteLn(AsString(MapGet(reply, 'result')));

FreeValue(msg); FreeValue(reply);
CloseSocket(sock); FreeContext(ctx);