lawspec 0.9.0 → 0.10.0

package/examples/native-payments/go/example/payments/domain.go

@@ -0,0 +1,38 @@
+package payments
+
+import "math/big"
+
+// Application-owned domain types, separate from generated canonical types.
+type CurrencyCode int
+
+const (
+	Dollars CurrencyCode = iota
+	Euros
+	Pounds
+)
+
+type Price struct {
+	Major LawSpecDecimal
+	Unit  CurrencyCode
+}
+
+type PaymentStatus interface{ payment() }
+type Settled struct{ Price Price }
+type Rejected struct{ Explanation string }
+
+func (Settled) payment()  {}
+func (Rejected) payment() {}
+
+// AddFee uses independent exact integer arithmetic, without ambient rounding.
+func AddFee(price Price) Price {
+	exponent := min(price.Major.exponent, -1)
+	power := func(n int) *big.Int {
+		return new(big.Int).Exp(big.NewInt(10), big.NewInt(int64(n)), nil)
+	}
+	amount := new(big.Int).Mul(price.Major.coefficient, power(price.Major.exponent-exponent))
+	fee := new(big.Int).Mul(big.NewInt(2), power(-1-exponent))
+	return Price{LawSpecDecimal{new(big.Int).Add(amount, fee), exponent}, price.Unit}
+}
+
+func Restore(value PaymentStatus) PaymentStatus                                { return value }
+func Store(values []LawSpecMaybe[PaymentStatus]) []LawSpecMaybe[PaymentStatus] { return values }

package/examples/native-payments/go/example/payments/native_generators_test.go

@@ -0,0 +1,13 @@
+package payments
+
+import (
+	"math/big"
+
+	"pgregory.net/rapid"
+)
+
+func NativePrices() *rapid.Generator[Price] {
+	return rapid.Map(rapid.IntRange(100, 200), func(cents int) Price {
+		return Price{LawSpecDecimal{big.NewInt(int64(cents)), -2}, Euros}
+	})
+}

package/examples/native-payments/go/lawspec.json

@@ -0,0 +1,136 @@
+{
+  "version": 1,
+  "sources": [
+    "laws"
+  ],
+  "machineBits": 64,
+  "targets": [
+    {
+      "language": "go",
+      "root": ".",
+      "nativeBindings": {
+        "types": [
+          {
+            "type": "example.payments::type::Currency",
+            "native": [
+              "CurrencyCode"
+            ],
+            "constructors": [
+              {
+                "constructor": "USD",
+                "native": [
+                  "Dollars"
+                ],
+                "style": "unit",
+                "fields": []
+              },
+              {
+                "constructor": "EUR",
+                "native": [
+                  "Euros"
+                ],
+                "style": "unit",
+                "fields": []
+              },
+              {
+                "constructor": "GBP",
+                "native": [
+                  "Pounds"
+                ],
+                "style": "unit",
+                "fields": []
+              }
+            ]
+          },
+          {
+            "type": "example.payments::type::Money",
+            "native": [
+              "Price"
+            ],
+            "constructors": [
+              {
+                "constructor": "Money",
+                "native": [
+                  "Price"
+                ],
+                "style": "record",
+                "fields": [
+                  {
+                    "field": "amount",
+                    "native": "Major"
+                  },
+                  {
+                    "field": "currency",
+                    "native": "Unit"
+                  }
+                ]
+              }
+            ]
+          },
+          {
+            "type": "example.payments::type::Payment",
+            "native": [
+              "PaymentStatus"
+            ],
+            "constructors": [
+              {
+                "constructor": "Paid",
+                "native": [
+                  "Settled"
+                ],
+                "style": "variant",
+                "fields": [
+                  {
+                    "field": "value",
+                    "native": "Price"
+                  }
+                ]
+              },
+              {
+                "constructor": "Declined",
+                "native": [
+                  "Rejected"
+                ],
+                "style": "variant",
+                "fields": [
+                  {
+                    "field": "reason",
+                    "native": "Explanation"
+                  }
+                ]
+              }
+            ]
+          }
+        ],
+        "functions": [
+          {
+            "declaration": "example.payments::addFee",
+            "native": [
+              "AddFee"
+            ]
+          },
+          {
+            "declaration": "example.payments::roundTrip",
+            "native": [
+              "Restore"
+            ]
+          },
+          {
+            "declaration": "example.payments::archive",
+            "native": [
+              "Store"
+            ]
+          }
+        ],
+        "generators": [
+          {
+            "type": "example.payments::type::Money",
+            "factory": [
+              "NativePrices"
+            ]
+          }
+        ]
+      }
+    }
+  ]
+}

package/examples/native-payments/haskell/lawspec.json

@@ -0,0 +1,149 @@
+{
+  "version": 1,
+  "sources": [
+    "laws"
+  ],
+  "machineBits": 64,
+  "targets": [
+    {
+      "language": "haskell",
+      "root": ".",
+      "nativeBindings": {
+        "types": [
+          {
+            "type": "example.payments::type::Currency",
+            "native": [
+              "PaymentsDomain",
+              "CurrencyCode"
+            ],
+            "constructors": [
+              {
+                "constructor": "USD",
+                "native": [
+                  "PaymentsDomain",
+                  "Dollars"
+                ],
+                "style": "unit",
+                "fields": []
+              },
+              {
+                "constructor": "EUR",
+                "native": [
+                  "PaymentsDomain",
+                  "Euros"
+                ],
+                "style": "unit",
+                "fields": []
+              },
+              {
+                "constructor": "GBP",
+                "native": [
+                  "PaymentsDomain",
+                  "Pounds"
+                ],
+                "style": "unit",
+                "fields": []
+              }
+            ]
+          },
+          {
+            "type": "example.payments::type::Money",
+            "native": [
+              "PaymentsDomain",
+              "Price"
+            ],
+            "constructors": [
+              {
+                "constructor": "Money",
+                "native": [
+                  "PaymentsDomain",
+                  "Price"
+                ],
+                "style": "record",
+                "fields": [
+                  {
+                    "field": "amount",
+                    "native": "major"
+                  },
+                  {
+                    "field": "currency",
+                    "native": "unit"
+                  }
+                ]
+              }
+            ]
+          },
+          {
+            "type": "example.payments::type::Payment",
+            "native": [
+              "PaymentsDomain",
+              "PaymentStatus"
+            ],
+            "constructors": [
+              {
+                "constructor": "Paid",
+                "native": [
+                  "PaymentsDomain",
+                  "Settled"
+                ],
+                "style": "variant",
+                "fields": [
+                  {
+                    "field": "value",
+                    "native": "price"
+                  }
+                ]
+              },
+              {
+                "constructor": "Declined",
+                "native": [
+                  "PaymentsDomain",
+                  "Rejected"
+                ],
+                "style": "variant",
+                "fields": [
+                  {
+                    "field": "reason",
+                    "native": "explanation"
+                  }
+                ]
+              }
+            ]
+          }
+        ],
+        "functions": [
+          {
+            "declaration": "example.payments::addFee",
+            "native": [
+              "PaymentsDomain",
+              "addFee"
+            ]
+          },
+          {
+            "declaration": "example.payments::roundTrip",
+            "native": [
+              "PaymentsDomain",
+              "restore"
+            ]
+          },
+          {
+            "declaration": "example.payments::archive",
+            "native": [
+              "PaymentsDomain",
+              "store"
+            ]
+          }
+        ],
+        "generators": [
+          {
+            "type": "example.payments::type::Money",
+            "factory": [
+              "PaymentGenerators",
+              "prices"
+            ]
+          }
+        ]
+      }
+    }
+  ]
+}

package/examples/native-payments/haskell/src/PaymentsDomain.hs

@@ -0,0 +1,21 @@
+module PaymentsDomain where
+
+import Data.Ratio ((%))
+import Data.Text (Text)
+import LawSpecRuntime (Decimal(..))
+
+data CurrencyCode = Dollars | Euros | Pounds deriving (Eq, Show)
+-- Deliberately reverse the logical field order.
+data Price = Price { unit :: CurrencyCode, major :: Decimal } deriving (Eq, Show)
+data PaymentStatus = Settled { price :: Price } | Rejected { explanation :: Text }
+  deriving (Eq, Show)
+
+addFee :: Price -> Price
+addFee value = case major value of
+  Decimal amount -> value { major = Decimal (amount + 1 % 5) }
+
+restore :: PaymentStatus -> PaymentStatus
+restore value = value
+
+store :: [Maybe PaymentStatus] -> [Maybe PaymentStatus]
+store values = values

package/examples/native-payments/haskell/test/PaymentGenerators.hs

@@ -0,0 +1,12 @@
+module PaymentGenerators where
+
+import Data.Ratio ((%))
+import Hedgehog (Gen)
+import qualified Hedgehog.Gen as Gen
+import qualified Hedgehog.Range as Range
+import LawSpecRuntime (Decimal(..))
+import PaymentsDomain
+
+prices :: Gen Price
+prices = (\cents -> Price Euros (Decimal (cents % 100))) <$>
+  Gen.integral (Range.linear 100 200)

package/examples/native-payments/java/lawspec.json

@@ -0,0 +1,165 @@
+{
+  "version": 1,
+  "sources": [
+    "laws"
+  ],
+  "machineBits": 64,
+  "targets": [
+    {
+      "language": "java",
+      "root": ".",
+      "nativeBindings": {
+        "types": [
+          {
+            "type": "example.payments::type::Currency",
+            "native": [
+              "domain",
+              "PaymentsDomain",
+              "CurrencyCode"
+            ],
+            "constructors": [
+              {
+                "constructor": "USD",
+                "native": [
+                  "domain",
+                  "PaymentsDomain",
+                  "CurrencyCode",
+                  "Dollars"
+                ],
+                "style": "unit",
+                "fields": []
+              },
+              {
+                "constructor": "EUR",
+                "native": [
+                  "domain",
+                  "PaymentsDomain",
+                  "CurrencyCode",
+                  "Euros"
+                ],
+                "style": "unit",
+                "fields": []
+              },
+              {
+                "constructor": "GBP",
+                "native": [
+                  "domain",
+                  "PaymentsDomain",
+                  "CurrencyCode",
+                  "Pounds"
+                ],
+                "style": "unit",
+                "fields": []
+              }
+            ]
+          },
+          {
+            "type": "example.payments::type::Money",
+            "native": [
+              "domain",
+              "PaymentsDomain",
+              "Price"
+            ],
+            "constructors": [
+              {
+                "constructor": "Money",
+                "native": [
+                  "domain",
+                  "PaymentsDomain",
+                  "Price"
+                ],
+                "style": "record",
+                "fields": [
+                  {
+                    "field": "amount",
+                    "native": "major"
+                  },
+                  {
+                    "field": "currency",
+                    "native": "unit"
+                  }
+                ]
+              }
+            ]
+          },
+          {
+            "type": "example.payments::type::Payment",
+            "native": [
+              "domain",
+              "PaymentsDomain",
+              "PaymentStatus"
+            ],
+            "constructors": [
+              {
+                "constructor": "Paid",
+                "native": [
+                  "domain",
+                  "PaymentsDomain",
+                  "Settled"
+                ],
+                "style": "variant",
+                "fields": [
+                  {
+                    "field": "value",
+                    "native": "price"
+                  }
+                ]
+              },
+              {
+                "constructor": "Declined",
+                "native": [
+                  "domain",
+                  "PaymentsDomain",
+                  "Rejected"
+                ],
+                "style": "variant",
+                "fields": [
+                  {
+                    "field": "reason",
+                    "native": "explanation"
+                  }
+                ]
+              }
+            ]
+          }
+        ],
+        "functions": [
+          {
+            "declaration": "example.payments::addFee",
+            "native": [
+              "domain",
+              "PaymentsDomain",
+              "apply_fee"
+            ]
+          },
+          {
+            "declaration": "example.payments::roundTrip",
+            "native": [
+              "domain",
+              "PaymentsDomain",
+              "restore"
+            ]
+          },
+          {
+            "declaration": "example.payments::archive",
+            "native": [
+              "domain",
+              "PaymentsDomain",
+              "store"
+            ]
+          }
+        ],
+        "generators": [
+          {
+            "type": "example.payments::type::Money",
+            "factory": [
+              "domain",
+              "PaymentGenerators",
+              "prices"
+            ]
+          }
+        ]
+      }
+    }
+  ]
+}

package/examples/native-payments/java/src/main/java/domain/PaymentsDomain.java

@@ -0,0 +1,32 @@
+package domain;
+
+import java.math.BigDecimal;
+import java.util.List;
+import lawspec.runtime.LawSpecRuntime.Maybe;
+
+/** Application types, independent of generated LawSpec domain declarations. */
+public final class PaymentsDomain {
+  private PaymentsDomain() {}
+
+  public enum CurrencyCode { Dollars, Euros, Pounds }
+
+  public record Price(BigDecimal major, CurrencyCode unit) {}
+
+  public sealed interface PaymentStatus permits Settled, Rejected {}
+
+  public record Settled(Price price) implements PaymentStatus {}
+
+  public record Rejected(String explanation) implements PaymentStatus {}
+
+  public static Price apply_fee(Price price) {
+    return new Price(price.major().add(new BigDecimal("0.2")), price.unit());
+  }
+
+  public static PaymentStatus restore(PaymentStatus payment) {
+    return payment;
+  }
+
+  public static List<Maybe<PaymentStatus>> store(List<Maybe<PaymentStatus>> payments) {
+    return payments;
+  }
+}

package/examples/native-payments/java/src/test/java/domain/PaymentGenerators.java

@@ -0,0 +1,16 @@
+package domain;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import org.jetbrains.jetCheck.Generator;
+
+public final class PaymentGenerators {
+  private PaymentGenerators() {}
+
+  public static Generator<PaymentsDomain.Price> prices() {
+    return Generator.integers(100, 200)
+        .map(cents -> new PaymentsDomain.Price(
+            new BigDecimal(BigInteger.valueOf(cents), 2),
+            PaymentsDomain.CurrencyCode.Euros));
+  }
+}