manifold

Very good summary of why static types are so useful, and when they're not so much... BTW, Java has a framework called Manifold that provides type-safe SQL just like the author wants, with IDE support and everything: https://github.com/manifold-systems/manifold/blob/master/man...

Quite similar to manifold-sql[1], which is arguably better integrated into Java than SQLx is into Rust. Inline native SQL in Java is *inherently type-safe*, no mapping -- query types, query results, query parameters all projected types at compile-time. int year = 2019; . . . for(Film film: "[.sql/] select * from film where release_year > :rel_year".fetch(year)) { out.println(film.title); } 1. https://github.com/manifold-systems/manifold/blob/master/man...

What if these were real, type-safe expressions in Java: 2025 July 19 // → LocalDate 299.8M m/s // → Velocity 1 to 10 // → Range<Integer> Schedule meeting with Alice on Tuesday at 3pm // → CalendarEvent That's the idea behind binding expressions — a compiler plugin I built to explore what it would mean if adjacency had operator semantics. It lets adjacent expressions bind based on their static types, forming new expressions through type-directed resolution. Details here: [https://github.com/manifold-systems/manifold/blob/master/doc...](https://github.com/manifold-systems/manifold/blob/master/doc...)

The manifold project[1] for Java provides that feature as "Structural Interfaces" which supports polymorphic variants. The project also supports tuples that behave similarly. var person = (name: "Joe", age: 35); . . . Person p = person; // tuple's name, age properties satisfy Person record 1. https://github.com/manifold-systems/manifold

I hadn't come across the "Row" polymorphism term before, but it sounds more like structural typing -- for example TypeScript, and to a lesser degree Go, have structural interfaces that provide "row polymorphic" programming. You could go further with variant structural typing, basically this is a broader form of type checking based on call compatibility, which answers the question -- is B#foo() callable as an A#foo()? For instance, your `area` example requires `double` result types, otherwise a row type having `width` and `length` defined as `integer` columns doesn't satisfy `area`. But, result types are naturally covariant -- `integer` is a subset of `double` -- which permits us to accept `integer` in the implementation of `area`. Similarly, parameter types are naturally contravariant -- `Shape` is contravariant to `Triangle`, thus `B#foo

Yep. Using DuckDB against conventional data sources such as JSON and CSV or even Parquet has amazing potential. Paired with manifold[1]--a Java library that makes it all type safe--and it's a game changer. 1. https://github.com/manifold-systems/manifold/blob/master/doc...

Hey HN! Oracle refuses to add optional parameters (and named args) to Java. So I did via a javac plugin and a smidge of hacking to modify the AST. The result is a pretty comprehensive implementation of the feature, without breaking binary compatibility. Here's a short summary. --- The manifold-params compiler plugin adds support for optional parameters and named arguments in Java methods, constructors, and records -- offering a simpler, more expressive alternative to method overloading and builder patterns. public String valueOf(char[] data, int offset = 0, int count = data.length - offset) {...} valueOf(array) // use defaults for offset and count valueOf(array, 2) // use default for count valueOf(array, count:20) // use default for offset by naming count This plugin

Languages should strive to type safely inline SQL and other structured data. With Java the manifold project achieves this via compiler plugin. The manifold-sql[1] module provides inline, type safe, native SQL. 1.https://github.com/manifold-systems/manifold/blob/master/man...

Cool tool, even cooler when paired with the manifold project for SQL[1], which has fantastic support for type-safe, native DuckDB syntax. 1. https://github.com/manifold-systems/manifold/blob/master/man...

Agree 1000% There’s a Java compiler plugin[1] that muscles in operator overloading pretty comprehensively, and works with all LTS JDKs. 1. https://github.com/manifold-systems/manifold/tree/master/man...

Agreed. Type providers bring metaprogramming to F# in a way that’s both powerful and innovative. The concept is amazing, enabling a new frontier for dynamically extending type safety. My only surprise is how little fanfare it has received since its introduction. For a more pragmatic take on static metaprogramming, the manifold project[1] for Java is worth a look. Unlike F#, which leans toward expansive schemas, Manifold focuses on contained, compile-time integrations—handling JSON, XML, SQL, GraphQL, and even other languages in a seamless, type-safe way. 1. https://github.com/manifold-systems/manifold

CSV is everywhere. I use manifold-csv[1] it’s amazing. 1. https://github.com/manifold-systems/manifold/tree/master/man...

I use Java with manifold-units[1] for this. Some examples: ‎ > // commonly used unit abbreviations e.g., m, ft, hr, mph, etc. import static manifold.science.util.UnitConstants.*; ... Length l = 5m; // 5 meters Length height = 5 ft + 9.5 in; Length distance = 80 mph * 2.3 hr; Force force = 5kg * 9.807 m/s/s; // 49.035 Newtons Force f = 49.035 kg m/s/s; force == f // true force == 49.035 N // true 1. https://github.com/manifold-systems/manifold/tree/master/man...*

I’ve been using IntelliJ’s JDBC-based UI, this will add a lot more capability. I’m using the manifold-sql[1] project with duckdb for analytics, amazing. 1. https://github.com/manifold-systems/manifold/blob/master/doc...