Datum Parsing

src/MiniZinc.Client/MiniZincProcess.cs

@@ -378,8 +378,8 @@ public void Dispose()
     public override string ToString() => CommandString;
 
     private MiniZincResult Result(
-        in DataNode? objectiveValue = null,
-        in DataNode? objectiveBoundValue = null,
+        in Datum? objectiveValue = null,
+        in Datum? objectiveBoundValue = null,
         string? error = null
     )
     {

src/MiniZinc.Client/MiniZincResult.cs

@@ -74,18 +74,18 @@ public sealed record MiniZincResult
     /// <summary>
     /// Text content of the message
     /// </summary>
-    public required DataNode? Objective { get; init; }
+    public required Datum? Objective { get; init; }
 
     /// <summary>
     /// Upper or lower bound (solver-dependent)
     /// </summary>
-    public required DataNode? ObjectiveBound { get; init; }
+    public required Datum? ObjectiveBound { get; init; }
 
     /// <summary>
     /// Absolute Gap to optimality
     /// `abs(objective - bound)`
     /// </summary>
-    public required DataNode? AbsoluteGapToOptimality { get; init; }
+    public required Datum? AbsoluteGapToOptimality { get; init; }
 
     /// <summary>
     /// Relative Gap to optimality
@@ -98,7 +98,7 @@ public sealed record MiniZincResult
     /// the previous iteration
     /// `objective[i] - objective[i-1]`
     /// </summary>
-    public required DataNode? AbsoluteIterationGap { get; init; }
+    public required Datum? AbsoluteIterationGap { get; init; }
 
     /// <summary>
     /// Relative difference between this iteration and

src/MiniZinc.Parser/Data/BoolDatum.cs

@@ -0,0 +1,19 @@
+namespace MiniZinc.Parser;
+
+public sealed class BoolDatum(bool value) : MiniZincDatum
+{
+    public bool Value => value;
+
+    public static implicit operator bool(BoolDatum expr) => expr.Value;
+
+    public override bool Equals(object? obj)
+    {
+        if (obj is not bool other)
+            return false;
+        if (!value.Equals(other))
+            return false;
+        return true;
+    }
+
+    public override string ToString() => Value.ToString();
+}

src/MiniZinc.Parser/Data/BoolSet.cs

@@ -0,0 +1,3 @@
+namespace MiniZinc.Parser;
+
+public sealed class BoolSet(List<bool> values) : SetDatum<bool>(values) { }

src/MiniZinc.Parser/Data/Datum.cs

@@ -0,0 +1,83 @@
+namespace MiniZinc.Parser;
+
+using System.Text.Json;
+using System.Text.Json.Nodes;
+
+/// <summary>
+/// The values that that appear in MiniZinc data files or
+/// syntax.
+/// </summary>
+public abstract class MiniZincDatum
+{
+    public string Write(WriteOptions? options = null)
+    {
+        var writer = new Writer(options);
+        writer.WriteValue(this);
+        var mzn = writer.ToString();
+        return mzn;
+    }
+
+    public static readonly MiniZincDatum Empty = new EmptyDatum();
+
+    public static readonly MiniZincDatum True = new BoolDatum(true);
+
+    public static readonly MiniZincDatum False = new BoolDatum(false);
+
+    public static MiniZincDatum Float(decimal f) => new FloatDatum(f);
+
+    public static MiniZincDatum Int(int i) => new IntDatum(i);
+
+    public static MiniZincDatum String(string s) => new StringDatum(s);
+
+    public static MiniZincDatum FromJson(JsonNode? node)
+    {
+        switch (node)
+        {
+            case JsonArray array:
+                return FromJson((JsonNode?)array);
+            case JsonObject obj:
+                return FromJson((JsonNode?)obj);
+            case JsonValue val:
+                return FromJson((JsonNode?)val);
+            default:
+                return Empty;
+        }
+    }
+
+    public static MiniZincDatum FromJson(JsonObject obj)
+    {
+        Dictionary<string, MiniZincDatum> dict = [];
+        foreach (var (key, node) in obj)
+        {
+            var value = FromJson(node);
+            dict[key] = value;
+        }
+
+        var data = new RecordDatum(dict);
+        return data;
+    }
+
+    public static MiniZincDatum FromJson(JsonArray array)
+    {
+        List<MiniZincDatum> items = [];
+        foreach (var node in array)
+        {
+            var item = FromJson(node);
+            items.Add(item);
+        }
+        var data = new DatumArray(items);
+        return data;
+    }
+
+    public static MiniZincDatum FromJson(JsonValue node) =>
+        node.GetValueKind() switch
+        {
+            JsonValueKind.Null => Empty,
+            JsonValueKind.True => True,
+            JsonValueKind.False => False,
+            JsonValueKind.Number when node.TryGetValue<decimal>(out var dec) => Float(dec),
+            JsonValueKind.Number when node.TryGetValue<int>(out var i) => Int(i),
+            JsonValueKind.String => String(node.GetValue<string>()),
+            _ => throw new ArgumentException($"Could not parse {node} as a datum")
+        };
+}

src/MiniZinc.Parser/Data/ArrayData.cs → src/MiniZinc.Parser/Data/DatumArray.cs

@@ -2,8 +2,10 @@
 
 using System.Collections;
 
-public abstract class ArrayData<T>(List<T> values) : DataNode, IReadOnlyList<T>
+public abstract class ArrayDatum<T>(List<T> values) : Datum, IReadOnlyList<T>
 {
+    public override DatumKind Kind => DatumKind.Array;
+
     public IEnumerator<T> GetEnumerator() => values.GetEnumerator();
 
     IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
@@ -12,7 +14,7 @@ public abstract class ArrayData<T>(List<T> values) : DataNode, IReadOnlyList<T>
 
     public T this[int index] => values[index];
 
-    public bool Equals(ArrayData<T>? other)
+    public bool Equals(ArrayDatum<T>? other)
     {
         if (other is null)
             return false;
@@ -34,17 +36,17 @@ public bool Equals(ArrayData<T>? other)
         return true;
     }
 
-    public override bool Equals(object? obj) => Equals(obj as ArrayData<T>);
+    public override bool Equals(object? obj) => Equals(obj as ArrayDatum<T>);
 }
 
-public sealed class IntArrayData(List<int> list) : ArrayData<int>(list) { }
+public sealed class IntArray(List<int> list) : ArrayDatum<int>(list) { }
 
-public sealed class FloatArrayData(List<decimal> list) : ArrayData<decimal>(list) { }
+public sealed class FloatArray(List<decimal> list) : ArrayDatum<decimal>(list) { }
 
-public sealed class BoolArrayData(List<bool> list) : ArrayData<bool>(list) { }
+public sealed class BoolArray(List<bool> list) : ArrayDatum<bool>(list) { }
 
-public sealed class StringArrayData(List<string> list) : ArrayData<string>(list) { }
+public sealed class StringArray(List<string> list) : ArrayDatum<string>(list) { }
 
-public sealed class ArrayData(List<DataNode> list) : ArrayData<DataNode>(list) { }
+public sealed class DatumArray(List<Datum> list) : ArrayDatum<Datum>(list) { }
 
-public sealed class TupleData(List<DataNode> list) : ArrayData<DataNode>(list) { }
+public sealed class DatumTuple(List<Datum> list) : ArrayDatum<Datum>(list) { }

src/MiniZinc.Parser/Data/EmptyDatum.cs

@@ -0,0 +1,6 @@
+namespace MiniZinc.Parser;
+
+public sealed class EmptyDatum : MiniZincDatum
+{
+    public override bool Equals(object? obj) => obj is EmptyDatum;
+}

src/MiniZinc.Parser/Data/FloatDatum.cs

@@ -0,0 +1,19 @@
+namespace MiniZinc.Parser;
+
+public sealed class FloatDatum(decimal value) : MiniZincDatum
+{
+    public decimal Value => value;
+
+    public static implicit operator decimal(FloatDatum expr) => expr.Value;
+
+    public override bool Equals(object? obj)
+    {
+        if (obj is not decimal other)
+            return false;
+        if (!value.Equals(other))
+            return false;
+        return true;
+    }
+
+    public override string ToString() => Value.ToString();
+}