haskell_match 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb352d5517fab56493d4c3ad9e8bae04d579659d2e7e75d501738ff4ff9ca4fc
-  data.tar.gz: 30f8f63b4c194ffffb8fd972a47e21cbd9a8c61755add53ff2ea700c1ee0ef24
+  metadata.gz: 4910f364d7296c14a45bb08c20b0129b74616d690d56f6cd19c598602946f535
+  data.tar.gz: 7a9f2c74794f08f3b2e2436e971ee5dd564819006220942e8adf8f302e26d48d
 SHA512:
-  metadata.gz: 343fe3a4d9d4c67db7bd1d406055fd828db5a569bf2d3da71c2e929cd6e937815bb161476b43dda9cd52de69ee1ce8f870b891ff02d4721e5b2f21294caddf9a
-  data.tar.gz: '09ae56f141727dc5ad9bdb4d1b77cd0c86abbaa3ad7fc1cb6f0571dc7547447b0c47f95c92bf087f5d1da23cb9fd62b9dcda283c946c215c9c806e2eab416bd3'
+  metadata.gz: c55aebeb2dd4a51181112d05a958e41c6e76a7318289557979946cb23a9e93131d780cb463e09249e291a58b95c83a790b175e187fa8a6e443ac84a0aa23d25e
+  data.tar.gz: 8eb6749c25422f70c7e8178061f22ad55a8f83aa53fdc5453389671ad90e0750012ba733dc084dc807fbe3f520443419c6d6820f2f1a7a6872429eb7bc7ba422

data/CHANGELOG.md

@@ -6,6 +6,12 @@ All notable changes to haskell_match are recorded here. The format follows
 
 ## [Unreleased]
 
+## [0.2.0] - 2026-10-20
+
+Installing still builds the Rust extension from source, so a Rust toolchain
+(`cargo`) is required; `fiddle`, which loads the built library, is now a
+declared dependency ahead of Ruby 3.5 dropping it from the default gems.
+
 ### Added
 
 - **Haskell tier 1.** User-defined operators with `infixl`/`infixr`/`infix`
@@ -77,14 +83,32 @@ All notable changes to haskell_match are recorded here. The format follows
   show the offending source line with a caret.
 - `Native.parse_data` returns field types and the `deriving` list;
   `Constructor.field_types`.
+- `HaskellMatch::Native.rbs`: the RBS declaration of the module functions,
+  generated by Rutie.
 
 ### Changed
 
 - `Native::Matcher.new` takes a fifth argument, the type scope;
   `Native.register_type`, `render_pattern`, `constructors` and
   `constructor_info` take an optional scope.
+- **Rutie 0.13.3 with the `derive` feature.** The native layer now uses
+  Rutie's attributes: the `HaskellMatch::Native` module functions are
+  declared with `#[rubymodule]` on plain Rust functions that take Rust types
+  and return `Result`s, and the `HaskellMatch` exceptions the extension
+  raises are declared with `#[rubyerror]`, so an error is raised after the
+  method's Rust values have been dropped instead of `longjmp`ing past them.
+  `Native::Matcher`'s construction and accessor methods return `Result`s
+  through `methods!` the same way; its hot-path methods (`call`, `prepare`,
+  `select`, `select_with`, `run`) and its typed-data definition, which sets
+  `RUBY_TYPED_FROZEN_SHAREABLE` for `Ractor.make_shareable`, are unchanged.
+  The crate no longer depends on `lazy_static`.
+- At the internal `Native` boundary an argument of the wrong type now raises
+  `TypeError` (Ruby's convention, and what the attributes generate) rather
+  than `ArgumentError`, and an Integer out of range raises `RangeError`;
+  well-typed arguments with bad values still raise `ArgumentError`, as does
+  `HaskellMatch.max_depth = -1`. The public API is unaffected.
 
-## [0.1.0] - unreleased
+## [0.1.0] - 2026-10-07
 
 ### Added
 

data/README.md

@@ -248,7 +248,7 @@ end                                  # => "just 3"
 
 # a pattern on its own, usable in case/when
 head = HaskellMatch.pattern { Just([x, *_]) }
-head.match(Just[[9, 8]])             # => {:x=>9}
+head.match(Just[[9, 8]])             # => {x: 9}
 head === Just[[]]                    # => false
 
 # methods defined by clauses, with access to self
@@ -282,7 +282,7 @@ end
 f.([1, 2, 3])                        # => [2, 3]
 
 g = HaskellMatch.fn(:g) { on([x, *xs]) { |x:, xs:| { x: x, xs: xs } }; on([]) { {} } }
-g.([1, 2])                           # => {:x=>1, :xs=>[2]}
+g.([1, 2])                           # => {x: 1, xs: [2]}
 ```
 
 ## Recursion without limits, and laziness
@@ -1458,8 +1458,11 @@ Array per `(x:xs)` tail that is bound.
   of {0, 1}`).
 * `core::tree` — compilation to a decision tree over numbered value slots.
 * `ruby::runtime` — evaluation over Ruby values, including Strings and lazy
-  lists viewed as lists; `ruby` — the `Native` module, the trampoline that
-  handles `tail`/`defer` markers and the Fiber-segmented recursion.
+  lists viewed as lists; `ruby::native` — the `Native` module functions,
+  declared with Rutie's `#[rubymodule]`; `ruby::error` — the exceptions the
+  extension raises, declared with `#[rubyerror]`; `ruby` — the `Matcher`
+  class, the trampoline that handles `tail`/`defer` markers and the
+  Fiber-segmented recursion.
 * `lib/haskell_match/pattern_ast.rb` — the in-place pattern syntax, rendered
   to Haskell text; `lazy_list.rb` — memoised lazy lists.
 

data/ext/haskell_match/Cargo.lock

@@ -6,7 +6,6 @@ version = 4
 name = "haskell_match"
 version = "0.1.0"
 dependencies = [
- "lazy_static",
  "rutie",
 ]
 
@@ -22,12 +21,59 @@ version = "0.2.190"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ce5d3ddc6d3fa000eb1536d85e147bfe31aacaba692ed6a876f95cb7c855be78"
 
+[[package]]
+name = "proc-macro2"
+version = "1.0.107"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
+dependencies = [
+ "proc-macro2",
+]
+
 [[package]]
 name = "rutie"
-version = "0.13.1"
+version = "0.13.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30d1529470ad0b69b81a6d0224632d00c01b46ef671452e24407512165b7ed84"
+checksum = "6517f7cec549a68e81525252a4088420659c7e46109a5f1f9d3204b656e3ee65"
 dependencies = [
  "lazy_static",
  "libc",
+ "rutie-derive",
+]
+
+[[package]]
+name = "rutie-derive"
+version = "0.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2639fa56c00a98f1f4010bd779a12ee4c3c8348ce6ee2ab705c76009bb0f724"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.119"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
 ]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2c754d6c33795a1c324727428e5a7dedb5b06195f9890bdbcba760d3e246563"

data/ext/haskell_match/Cargo.toml

@@ -11,9 +11,9 @@ name = "haskell_match"
 crate-type = ["cdylib"]
 
 [dependencies]
-# Rutie 0.13 targets Ruby 3.x; Rutie 0.14 targets Ruby 4.0.
-rutie = "0.13"
-lazy_static = "1.4"
+# Rutie 0.13 targets Ruby 3.x; Rutie 0.14 targets Ruby 4.0.  The `derive`
+# feature gives the `#[rubymodule]`, `#[rubyerror]` and related attributes.
+rutie = { version = "0.13.3", features = ["derive"] }
 
 [profile.release]
 opt-level = 3

data/ext/haskell_match/src/lib.rs

@@ -6,8 +6,6 @@
 
 #[macro_use]
 extern crate rutie;
-#[macro_use]
-extern crate lazy_static;
 
 pub mod core;
 pub mod ruby;

data/ext/haskell_match/src/ruby/error.rs

@@ -0,0 +1,123 @@
+//! The exceptions the native layer raises, declared with `#[rubyerror]`.
+//!
+//! The Ruby classes themselves, with their `CompileError`/`MatchError` tiers
+//! and `PatternSyntaxError.with_caret`, are defined in
+//! `lib/haskell_match/errors.rb` before the extension loads; `#[rubyerror]`
+//! finds each class by its path.  A method that returns `Err(HmError)` raises
+//! the matching exception once its Rust values have been dropped, instead of
+//! `longjmp`ing past them with `VM::raise_ex`.
+
+use std::fmt;
+
+use rutie::derive::IntoException;
+use rutie::{rubyerror, AnyException, Exception};
+
+use crate::core::error::{CoreError, ErrorKind};
+
+/// Every `HaskellMatch` exception the extension raises, one variant per
+/// Ruby class, each carrying its message.
+#[rubyerror(path = "HaskellMatch::Error", superclass = "StandardError")]
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum HmError {
+    /// Malformed pattern text.
+    #[ruby(path = "HaskellMatch::PatternSyntaxError")]
+    Syntax(String),
+    /// A constructor name that no registered data type declares.
+    #[ruby(path = "HaskellMatch::UnknownConstructorError")]
+    UnknownConstructor(String),
+    /// A constructor applied to the wrong number of arguments.
+    #[ruby(path = "HaskellMatch::ArityError")]
+    Arity(String),
+    /// Patterns of different types in the same position.
+    #[ruby(path = "HaskellMatch::PatternTypeError")]
+    Type(String),
+    /// The same variable bound twice in one clause.
+    #[ruby(path = "HaskellMatch::DuplicateVariableError")]
+    DuplicateVariable(String),
+    /// Record pattern problems (unknown field, positional constructor, ...).
+    #[ruby(path = "HaskellMatch::FieldError")]
+    Field(String),
+    /// Malformed `data` declaration.
+    #[ruby(path = "HaskellMatch::DataDeclarationError")]
+    DataDeclaration(String),
+    /// Clauses of one function with different numbers of arguments.
+    #[ruby(path = "HaskellMatch::ClauseArityError")]
+    ClauseArity(String),
+    /// No clause matched at call time.
+    #[ruby(path = "HaskellMatch::MatchError")]
+    NoMatch(String),
+    /// A value is not of the type the patterns expect.
+    #[ruby(path = "HaskellMatch::TypeMismatchError")]
+    TypeMismatch(String),
+    /// An irrefutable (`~`) pattern failed to destructure.
+    #[ruby(path = "HaskellMatch::IrrefutablePatternError")]
+    IrrefutablePattern(String),
+    /// Recursion through compiled functions exceeded `HaskellMatch.max_depth`.
+    #[ruby(path = "HaskellMatch::StackOverflowError")]
+    StackOverflow(String),
+}
+
+impl HmError {
+    /// The exception's message.
+    pub fn message(&self) -> &str {
+        match self {
+            HmError::Syntax(m)
+            | HmError::UnknownConstructor(m)
+            | HmError::Arity(m)
+            | HmError::Type(m)
+            | HmError::DuplicateVariable(m)
+            | HmError::Field(m)
+            | HmError::DataDeclaration(m)
+            | HmError::ClauseArity(m)
+            | HmError::NoMatch(m)
+            | HmError::TypeMismatch(m)
+            | HmError::IrrefutablePattern(m)
+            | HmError::StackOverflow(m) => m,
+        }
+    }
+}
+
+impl fmt::Display for HmError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(self.message())
+    }
+}
+
+impl std::error::Error for HmError {}
+
+/// A compile-time error of the pure core, by kind.
+impl From<CoreError> for HmError {
+    fn from(e: CoreError) -> Self {
+        let m = e.message;
+        match e.kind {
+            ErrorKind::Syntax => HmError::Syntax(m),
+            ErrorKind::UnknownConstructor => HmError::UnknownConstructor(m),
+            ErrorKind::Arity => HmError::Arity(m),
+            ErrorKind::Type => HmError::Type(m),
+            ErrorKind::DuplicateVariable => HmError::DuplicateVariable(m),
+            ErrorKind::Field => HmError::Field(m),
+            ErrorKind::DataDeclaration => HmError::DataDeclaration(m),
+            ErrorKind::ClauseArity => HmError::ClauseArity(m),
+        }
+    }
+}
+
+/// So `?` can mix `HmError`s and `ArgumentError`s in a method returning
+/// `Result<T, AnyException>`.
+impl From<HmError> for AnyException {
+    fn from(e: HmError) -> Self {
+        e.into_exception()
+    }
+}
+
+impl From<CoreError> for AnyException {
+    fn from(e: CoreError) -> Self {
+        HmError::from(e).into_exception()
+    }
+}
+
+/// An `ArgumentError`: a well-typed argument with a value that makes no
+/// sense (a wrong type is the `TypeError` the argument conversion raises).
+pub fn argument_error(message: &str) -> AnyException {
+    AnyException::new("ArgumentError", Some(message))
+}