I am seeking a method to define generic computation on a data set and have the compiler alert me if there are any errors.
Having experience with TypeScript, I have seen that you can achieve something like this:
/**
* Type inferred as:
* Array<{
* a: number;
* b: string;
* c: { d: number; e: string };
* }>
*/
const data = [
{ a: 1, b: "b", c: { d: 4, e: "e" } },
{ a: 2, b: "b", c: { d: 4, e: "e" } },
{ a: 3, b: "b", c: { d: 4, e: "e" } },
];
const result = data
// change the type of c to string
.map(o => ({...o, c: JSON.stringify(o.c)}))
// adding a new field
.map(o => ({...o, d: "new"}))
;
/**
* `result` type is automatically inferred as:
* Array<{
* d: string;
* c: string;
* a: number;
* b: string;
* }>
*/
After applying these transformations, the type of result will be accurately inferred along with each type within map.
The advantage here is that the compiler aids in identifying potential bugs.
Is it possible to achieve similar functionality in Java?
My attempt involved using a generic Map object with a spanning generic type across various lower-level types resembling a JS dictionary. Yet, the compiler lacks understanding that key X is actually of type Y, rendering it ineffective in bug detection.
It seems that replicating the same level of static analysis in Java as we have in TypeScript is not feasible. The Java compiler does not excel at updating unnamed types along the way and capturing such bugs.