fthomas/refined

This system is the Refined library, a Scala type-level refinement framework that enforces value constraints at compile time to ensure data validity. It provides a core API for defining and validating predicates across numeric, string, and collection types, with specific support for Scala 3 opaque types and native inference. The library extends its capabilities through integrated modules for popular functional libraries like Cats and Scalaz, as well as utilities for configuration parsing, command-line arguments, and testing.

15 changes.

The project underwent a major architectural overhaul to support Scala 3 and cross-compilation across JVM, JavaScript, and Native platforms, replacing the legacy build system with modern sbt tooling. This period focused on rebuilding the core validation API, removing deprecated infrastructure, and introducing new integration modules for Scalaz and scodec alongside comprehensive test coverage.

15 changes.

This period focused on expanding the library's ecosystem by adding integration modules for Cats, Shapeless, scopt, Pureconfig, and JSON path validation. Significant effort was also dedicated to enhancing test coverage across core types, scalacheck, and the new integrations, alongside introducing runtime expression evaluation and performance benchmarks.

14 changes.

The project undertook a comprehensive migration to support Scala 3, replacing the shapeless-based implementation with native features such as opaque types, inline implicits, and infix syntax. This effort expanded the library's capabilities by introducing new refined types for networking, strings, time, and digests, while restructuring the core API for better compatibility and usability. Extensive test suites were added to ensure correctness across both Scala 2 and Scala 3 environments.

A new benchmark module has been added to the project, introducing JMH-based performance tests for key Refined operations. This includes benchmarks for macro inference (autoInfer), type refinement (autoRefineV), unsafe value creation (PosInt.unsafeFrom), and validated refinement (refineV) for both numeric and string types. The benchmarks are configured to measure average execution time in nanoseconds, providing a baseline for tracking performance improvements in macro expansion and runtime validation.

modules/benchmark · high confidence

This change introduces support for the Pureconfig library in Scala 3 by moving the integration code to a shared module and providing version-specific implementations. For Scala 3, it uses Scala 3 macros to describe types, while Scala 2 continues to use reflection-based type tags. This enables users to read and write refined types from configuration files in Scala 3 projects.

modules/pureconfig/shared/src/main · high confidence

This change introduces a new \scodec\ module that integrates the refined library with the scodec codec framework. It provides a \RefTypeCodec\ instance, allowing users to encode and decode refined types (such as \PosInt\) directly, where decoding automatically validates the predicate and fails if the value does not satisfy the constraint. Additionally, it adds specific validation support for \ByteVector\ size predicates, enabling refined checks on the length of byte vectors during validation.

modules/scodec · high confidence

A new \scopt\ module has been added to provide seamless integration between the refined library and the scopt command-line parser. This module supplies an implicit \Read\ instance for refined types, allowing users to define scopt options that automatically validate input against refined predicates. If a parsed value fails validation, the parser will reject it, ensuring that configuration objects only contain valid data.

modules/scopt · high confidence

A new \string\ utility module has been added to \eu.timepit.refined.util\, providing factory methods to construct \Regex\, \URI\, \URL\, \UUID\, and \XPathExpression\ instances from strings validated by refined types. This allows users to safely instantiate these standard library types using statically checked string constraints.

modules/core/shared/src/main/scala/eu/timepit/refined/util · high confidence

Users can now validate that a String contains a syntactically correct JSON path using the new \JSONPath\ refinement type in the \eu.timepit.refined.jsonpath\ package. This feature leverages the \com.jayway.jsonpath\ library to compile and verify path expressions, ensuring that strings conform to valid JSON path syntax before being used in refined contexts.

modules/jsonpath · high confidence

This change introduces a new Scalaz module providing seamless integration between Refined and Scalaz. It adds a \RefType\ implementation for Scalaz's \@@\ tag type, enabling automatic refinement via the \auto\ object. The module includes a \derivation\ object that automatically generates typeclass instances (such as \Equal\ and \Show\) for refined types by leveraging Scalaz's \Contravariant\ and \MonadError\ capabilities. Additionally, it provides syntax helpers for validating refined types against Scalaz's \ValidationNel\ error handling, while deprecating the previous generic derivation methods in favor of this new organized structure.

modules/scalaz/shared/src/main · high confidence

The Scala 3.0- macro implementation now supports compile-time validation for \BigInt\ and \BigDecimal\ literal values. By introducing \BigIntMatcher\ and \BigDecimalMatcher\ utilities and caching validation instances for these types, the library can now refine these numeric types at compile time, preventing runtime errors for invalid constants just as it does for standard numeric types like \Int\ and \Double\.

modules/core/shared/src/main/scala-3.0-/eu/timepit/refined/macros · high confidence

The Cats module now provides comprehensive support for Cats typeclasses and syntax. It introduces generic derivation instances (via \Contravariant\ and \MonadError\) for encoding/decoding refined types, and adds \Eq\, \Order\, and \Show\ instances for refined types. New syntax extensions allow validating refined types into \ValidatedNel\/\ValidatedNec\ and provide \take\ operations for \NonEmptyList\ and \NonEmptyVector\. Additionally, commutative semigroup and monoid instances are added for positive/negative numeric refined types, handling overflow by shifting values, and an \UnorderedFoldable\ instance is provided to validate collection sizes.

modules/cats/shared/src/main · high confidence

Users can now define validation predicates using string-based Scala expressions that are evaluated at runtime via the Scala ToolBox. This change adds an \Eval\ type and corresponding \Validate\ instance in the \modules/eval\ module, allowing predicates like \Eval\[W.\"(x: Int) =\> x % 2 == 0"\.T\]\ to be used with refined types. The implementation caches the ToolBox instance for performance and includes tests verifying correct evaluation of expressions, proper handling of parameter types, and appropriate error throwing for out-of-scope variables.

modules/eval · high confidence

The library now includes a new \char\ module providing validation predicates for \Char\ values, specifically \Digit\, \Letter\, \LowerCase\, \UpperCase\, and \Whitespace\, along with a combined \LetterOrDigit\ type alias. Users can now refine \Char\ types using these built-in validators to enforce character classification constraints.

modules/core/shared/src/main/scala/eu/timepit/refined · high confidence

The \eu.timepit.refined.types\ package now provides a comprehensive set of predefined refined types, organized into specific modules. Users can now import \Char\ types like \LowerCaseChar\ and \UpperCaseChar\, as well as a wide range of numeric types including \PosInt\, \NonNegLong\, \NegDouble\, and \NonNaNFloat\/\NonNaNDouble\. These types are also aggregated in the \all\ module for convenient bulk imports, simplifying the use of common refined constraints without needing to define them manually.

modules/core/shared/src/main/scala/eu/timepit/refined/types · high confidence

The \eu.timepit.refined.types\ package now exposes new type aliases and companion objects for message digests (MD5, SHA1, SHA224, SHA256, SHA384, SHA512), network identifiers (port numbers, RFC1918/RFC5737/RFC3927 private and test networks), string constraints (finite, non-empty, trimmed, hex), and time units (month, day, hour, minute, second, millisecond). These types are available in the \scala-3.0-\ source directory and provide compile-time validation for these common data categories.

modules/core/shared/src/main/scala-3.0-/eu/timepit/refined/types · high confidence

The Scala 3 source directory now includes dedicated modules for network, string, time, and digest types. Users can validate port numbers (including system, user, and dynamic ranges) and IPv4 addresses against RFC1918, RFC5737, and RFC3927 standards. String validation now supports finite lengths with optional truncation, non-empty checks, trimming, and hexadecimal formatting. Time components (month, day, hour, minute, second, millisecond) are enforced via numeric intervals, and message digests (MD5, SHA1, SHA224, SHA256, SHA384, SHA512) are validated by length and hexadecimal format.

modules/core/shared/src/main/scala-3.0+/eu/timepit/refined/types · high confidence

The repository has been initialized with the refined library (version 0.11.4), including the core source code, comprehensive documentation in README.md, and the MIT license. Build and development tooling has been configured via .scalafmt.conf (version 3.11.5), .jvmopts, and .scala-steward.conf. CI/CD infrastructure has been set up using GitHub Actions (replacing the previous Travis CI configuration) and Mergify for automated pull request handling, while code coverage is enabled via .codecov.yml.

(repo-wide) · high confidence

The refined library's core API now explicitly defines the foundational type classes and structures used for refinement. This includes the \Validate\ type class for checking predicates, the \Result\ sealed trait (with \Passed\ and \Failed\ cases) for validation outcomes, and the \Inference\ type class for handling refinement subtyping. Additionally, new \Min\ and \Max\ type classes are introduced to determine the minimum and maximum valid values for refined types, supporting various numeric bounds and logical combinations. The \RefinedType\ trait is also defined to combine \RefType\ and \Validate\ instances, providing methods like \refine\ and \unsafeRefine\ for creating refined values.

modules/core/shared/src/main/scala/eu/timepit/refined/api · high confidence

This change introduces the core refined library implementation for Scala 2 (via the \scala-3.0-\ source directory), providing compile-time validation and automatic refinement capabilities. It defines predicates for boolean logic (And, Or, Not), numeric comparisons (Greater, Less, Interval), collection properties (Size, Forall, NonEmpty), and string formats (IPv4, IPv6, Regex, Uri). It also includes \auto.scala\, which enables implicit compile-time refinements and type conversions, allowing values to be automatically wrapped in refined types or converted between compatible refined types when valid.

modules/core/shared/src/main/scala-3.0-/eu/timepit/refined · high confidence

The shapeless module now provides an implicit Typeable instance for refined types, allowing refined values to be cast and described via Shapeless's Typeable interface. This enables runtime type checking and casting for refined types (e.g., PosInt, String with regex constraints) by validating the underlying value against the refinement predicate during the cast operation. A corresponding test suite verifies successful casts, failed casts when refinements are violated, and the descriptive string output for these types.

modules/shapeless · high confidence

The \refined\ package's foundational validation infrastructure has been removed, including the \Predicate\ trait, the \refine\ and \refineL\ entry-point functions, and all built-in predicate implementations for boolean logic (\Not\, \And\, \Or\), numeric comparisons (\Less\, \Greater\, \Positive\, \Negative\), and string constraints (\NonEmpty\, \LowerCase\, \UpperCase\). Users can no longer use these types to validate or refine values within this module.

src/main · high confidence

The \data/downloads\ directory now contains monthly CSV files covering download counts and proportions for Scala versions 2.10, 2.11, and 2.12 from June 2016 through June 2018. Each file lists version-specific download volumes, providing a detailed historical record of library adoption over this period.

data · high confidence

The internal implementation of refined has been reorganized to improve code structure and maintainability. New internal files have been introduced: \Adjacent.scala\ provides a type class for finding the next greater or smaller value for numeric types, extending \Ordering\; \ApplyRefPartiallyApplied.scala\ and \RefinePartiallyApplied.scala\ contain helper classes to support Scala's type inference for refinement operations; and \Resources.scala\ centralizes string constants and formatting logic for validation error messages. These changes affect the internal mechanics of how refinements are applied and how errors are reported, but do not alter the public API surface.

modules/core/shared/src/main/scala/eu/timepit/refined/internal · high confidence

The library introduces a new \eu.timepit.refined.predicates\ package that consolidates all predicate types (boolean, char, collection, generic, numeric, and string) into a single \all\ object for easier importing. This change reorganizes existing predicates into specific sub-packages (e.g., \boolean\, \numeric\) while maintaining binary compatibility through separate traits (\AllPredicatesBinCompat1\, \NumericPredicatesBinCompat1\). Notably, the \NonNaN\ numeric predicate and \HexStringSpec\ string predicate are now explicitly included in these compatibility layers to ensure existing code continues to work without recompilation.

modules/core/shared/src/main/scala/eu/timepit/refined/predicates · high confidence

The project now uses a custom shell script (scripts/release.sh) to manage releases, replacing the previous sbt-release plugin. This script automates the process of updating version numbers in the README and build configuration, creating signed git tags, and pushing changes, while also allowing the old version to be passed as a parameter.

scripts · high confidence

The core refinement API in the \scala-3.0-\ source directory has been restructured to support Scala 3 (Dotty) while maintaining Scala 2 compatibility. \RefType\ now provides a cleaner trait-based interface for wrapping and unwrapping refined types, removing the use of existential types in \unwrap\ to resolve compiler errors. \Refined\ is defined as a simple value class, and \RefinedTypeOps\ offers a simplified way to create companion objects for refined types with methods like \from\, \unsafeFrom\, and \unapply\. Deprecated macro-based methods (\unsafeWrapM\, \unsafeRewrapM\, \refineMF\) are retained but marked for removal, encouraging migration to the new non-macro variants.

modules/core/shared/src/main/scala-3.0-/eu/timepit/refined/api · high confidence

The scalacheck module has been restructured to provide ScalaCheck Arbitrary instances for refined types, with separate source files for Scala 2 and Scala 3 to handle type-class differences (e.g., using \ValueOf\ in Scala 3 vs \Witness\ in Scala 2). This update introduces comprehensive generators for string predicates (such as \NonEmpty\, \Size\, and numeric string validations), collection predicates (including \NonEmpty\ and \Size\ for Lists and Vectors), and logical predicates (like \Or\). Numeric generation has been modernized to use the \Min\ and \Max\ API instead of the deprecated \Bounded\ type class, and the internal \Adjacent\ utility has been deprecated in favor of the core module's implementation. A generic \Arbitrary\ instance for any refined type is also provided, though it may discard invalid values during generation.

modules/scalacheck/shared/src/main · high confidence

The library now supports Scala 3 by introducing a new \RefType\ type class that abstracts refinement operations (wrap, unwrap, refine) and providing a Scala 3-specific implementation of \Refined\ as an opaque type. This change replaces the previous Scala 2 implementation (which relied on shapeless) with native Scala 3 features, including an infix syntax for the \Refined\ type alias and extension methods for value access. Additionally, \RefinedTypeOps\ is provided to simplify the creation of companion objects for refined types, offering \from\ and \unsafeFrom\ methods.

modules/core/shared/src/main/scala-3.0+/eu/timepit/refined/api · high confidence

The refined library now provides a dedicated source set for Scala 3 (scala-3.0+) that replaces the previous shapeless-based implementation with native Scala 3 features. This change introduces automatic refinement unwrapping via the \auto\ module, allowing refined types to be used as subtypes of their base types without explicit conversion. It also adds compile-time type inference for predicates (e.g., inferring \Greater\[5\]\ implies \GreaterEqual\[5\]\) and enables infix syntax for boolean operators (\And\, \Or\, \Xor\) and numeric comparisons, improving code readability. Additionally, it allows Int and Double literals to be used directly as arguments in predicates, simplifying the definition of numeric constraints.

modules/core/shared/src/main/scala-3.0+/eu/timepit/refined · high confidence

For users on Scala versions prior to 3.0, the library now allows Int and Double literals to be used directly as universal arguments in numeric predicates (e.g., \Greater\[W.\2.718\.T\]\ or \Less\[W.\1\.T\]\). This is achieved by introducing the \WitnessAs\ type class in the \scala-3.0-\ source directory, which provides implicit conversions from literal types to various numeric base types (Byte, Short, Int, Long, Float, Double, BigDecimal, BigInt). This change enables more concise and intuitive predicate definitions without requiring explicit type annotations or wrapper conversions for common numeric literals.

modules/core/shared/src/main/scala-3.0-/eu/timepit/refined/internal · high confidence

The library now allows Int and Double literals to be used directly as arguments in numeric predicates (such as Greater or Less) when running on Scala 3. This is achieved by introducing a new ToInt type class and replacing the deprecated generic intWitnessAs with specialized inline given instances (e.g., intWitnessAsByte, intWitnessAsDouble) that convert integer literals to the target numeric type at compile time. This change removes the dependency on shapeless for Scala 3 and enables seamless usage like refineV\[Greater\[2.718\]\](BigDecimal(3.141)).

modules/core/shared/src/main/scala-3.0+/eu/timepit/refined/internal · high confidence

Added JVM-specific validation tests for String types; Added Scala 3 test suite for core refined predicates and inference; Added ScalaCheck property tests for refined types; Added comprehensive test coverage for Cats integration; Added comprehensive test coverage for refined types; Added test coverage for auto-unwrap and character validation; Added tests for Cogen instances and NonEmptyString generation; Added tests for RefinedTypeOps; Added tests for Scalaz integration; Added tests for numeric validation refinements in Scala 3; Added tests for refined type configuration conversion; Added tests for scalaz imports and NonEmptyString.show; Added tests for string type refinements and hash validations.

The build configuration has been significantly modernized, introducing centralized version management for key libraries including Cats (2.13.0), PureConfig (0.17.8), Shapeless (2.3.13), and ScalaCheck (1.20.0). The project now officially supports cross-compilation for Scala 2.12, 2.13, and Scala 3 across JVM, JavaScript, and Native platforms, with specific modules like \cats\, \core\, \scalacheck\, and \shapeless\ available on all three targets. Additionally, the build integrates GitHub Actions for CI/CD, Mergify for automated PR handling, and Codecov for coverage reporting, replacing previous CI setups.

(dependencies) · high confidence

The build system has been upgraded from sbt 0.13.8 to sbt 1.13.0. This change consolidates previously separate plugin configuration files (plugin-bintray.sbt, plugin-git.sbt, plugin-scalariform.sbt) into a single plugins.sbt file, removing the deprecated bintray and scalariform plugins in favor of sbt-ci-release, sbt-git, and sbt-scalafmt. A new LatestVersion.scala plugin is introduced to manage versioning metadata, and all core build plugins (Scala.js, Scala Native, scoverage, doctest, etc.) are updated to their latest compatible versions.

project · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 41 → 63 (+22.2)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 100 → 98 (-2.1)
• Architecture 100 (new)
• Maturity 50 → 63 (+13.2)
• Readiness 30 → 53 (+23.0)
• Security 38 → 65 (+27.7)

• Dimension evaluation failed
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• LLM evaluation failed
• No artifact signing
• No automated tests
• No exposed public API
• No tests found
• Test reliability not included

• Duplicated block (10 lines × 2) (modules/core/shared/src/main/scala-3.0+/eu/timepit/refined/api/RefinedTypeOps.scala)
• Duplicated block (11 lines × 2) (modules/core/shared/src/main/scala-3.0+/eu/timepit/refined/collection.scala)
• Duplicated block (11 lines × 2) (modules/core/shared/src/main/scala-3.0+/eu/timepit/refined/collection.scala)
• Duplicated block (11 lines × 2) (modules/core/shared/src/main/scala-3.0+/eu/timepit/refined/collection.scala)
• Duplicated block (14 lines × 2) (modules/core/shared/src/main/scala-3.0+/eu/timepit/refined/collection.scala)
• Duplicated block (14 lines × 2) (modules/core/shared/src/main/scala-3.0+/eu/timepit/refined/collection.scala)
• Duplicated block (14 lines × 4) (modules/core/shared/src/main/scala-3.0+/eu/timepit/refined/boolean.scala)
• Duplicated block (15 lines × 2) (modules/core/shared/src/main/scala-3.0+/eu/timepit/refined/collection.scala)
• Duplicated block (17 lines × 2) (modules/core/shared/src/main/scala-3.0+/eu/timepit/refined/collection.scala)
• Duplicated block (19 lines × 2) (modules/core/shared/src/main/scala-3.0+/eu/timepit/refined/boolean.scala)
• Duplicated block (20 lines × 2) (modules/core/shared/src/main/scala-3.0+/eu/timepit/refined/boolean.scala)
• Duplicated block (21 lines × 2) (modules/core/shared/src/main/scala-3.0+/eu/timepit/refined/collection.scala)
• Duplicated block (5 lines × 2) (modules/core/shared/src/main/scala-3.0+/eu/timepit/refined/collection.scala)
• Duplicated block (5 lines × 2) (modules/core/shared/src/main/scala-3.0+/eu/timepit/refined/string.scala)
• Duplicated block (6 lines × 2) (modules/core/shared/src/main/scala-3.0+/eu/timepit/refined/boolean.scala)
• Duplicated block (6 lines × 2) (modules/core/shared/src/main/scala-3.0+/eu/timepit/refined/boolean.scala)
• Duplicated block (6 lines × 2) (modules/core/shared/src/main/scala-3.0+/eu/timepit/refined/boolean.scala)
• Duplicated block (6 lines × 4) (modules/core/shared/src/main/scala-3.0+/eu/timepit/refined/boolean.scala)
• Duplicated block (66 lines × 2) (modules/core/shared/src/main/scala-3.0+/eu/timepit/refined/numeric.scala)
• Duplicated block (7 lines × 6) (modules/core/shared/src/main/scala-3.0+/eu/timepit/refined/boolean.scala)
• …and 20 more

• 23 commits — 23 feature/other, 0 fixes

• (repo) — 11 commits
• project/plugins.sbt — 8 commits
• project/build.properties — 2 commits
• (root) — 1 commit
• modules/core — 1 commit

• change: Also update sbt-doctest
• change: Merge pull request #1456 from scala-steward/update/sbt-scalafmt-2.6.2
• change: Merge pull request #1462 from scala-steward/update/sbt-1.12.15
• change: Merge pull request #1464 from scala-steward/update/sbt-scala-native-crossproject-1.4.0
• change: Merge pull request #1465 from scala-steward/update/sbt-ci-release-1.12.1
• change: Merge pull request #1466 from scala-steward/update/sbt-1.13.0
• change: Merge pull request #1467 from xuwei-k/wildcard-syntax
• change: Merge pull request #1470 from scala-steward/update/scalacheck-1.20.0
• change: Merge pull request #1473 from scala-steward/update/sbt-mima-plugin-1.2.0
• change: Merge pull request #1474 from scala-steward/update/sbt-git-2.2.0
• change: Merge pull request #1475 from scala-steward/update/sbt-buildinfo-0.13.2
• change: Merge pull request #1476 from scala-steward/update/sbt-mima-plugin-1.2.1
• change: Update sbt, scripted-plugin to 1.12.15
• change: Update sbt, scripted-plugin to 1.13.0
• change: Update sbt-buildinfo to 0.13.2
• change: Update sbt-ci-release to 1.12.1
• change: Update sbt-git to 2.2.0
• change: Update sbt-mima-plugin to 1.2.0
• change: Update sbt-mima-plugin to 1.2.1
• change: Update sbt-scala-native-crossproject, ... to 1.4.0
• …and 3 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

fthomas/refined was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.