Widen Series method signatures to eliminate as-never casts in tests

Widen arithmetic methods to accept number | Series<Scalar> instead of
T | Series<T>, comparison methods to accept Scalar | Series<Scalar>,
and isin to accept readonly Scalar[]. This avoids literal type narrowing
issues that previously required as-never casts in tests.

Agent-Logs-Url: https://github.com/githubnext/tsessebe/sessions/8871403f-f41c-4311-a8fd-19f148d98d2d

Co-authored-by: mrjf <180956+mrjf@users.noreply.github.com>

Author: Copilot

src/core/series.ts

@@ -214,7 +214,10 @@ export class Series<T extends Scalar = Scalar> {
 
   // ─── arithmetic ───────────────────────────────────────────────────────────
 
-  private _scalarOp(other: T | Series<T>, fn: (a: number, b: number) => number): Series<number> {
+  private _scalarOp(
+    other: number | Series<Scalar>,
+    fn: (a: number, b: number) => number,
+  ): Series<number> {
     const isScalar = !(other instanceof Series);
     if (isScalar) {
       const b = other as number;
@@ -229,7 +232,7 @@ export class Series<T extends Scalar = Scalar> {
         name: this.name,
       });
     }
-    const o = other as Series<T>;
+    const o = other as Series<Scalar>;
     if (o.size !== this.size) {
       throw new RangeError(
         `Cannot operate on Series of different sizes: ${this.size} vs ${o.size}`,
@@ -249,46 +252,49 @@ export class Series<T extends Scalar = Scalar> {
   }
 
   /** Element-wise addition. */
-  add(other: T | Series<T>): Series<number> {
+  add(other: number | Series<Scalar>): Series<number> {
     return this._scalarOp(other, (a, b) => a + b);
   }
 
   /** Element-wise subtraction. */
-  sub(other: T | Series<T>): Series<number> {
+  sub(other: number | Series<Scalar>): Series<number> {
     return this._scalarOp(other, (a, b) => a - b);
   }
 
   /** Element-wise multiplication. */
-  mul(other: T | Series<T>): Series<number> {
+  mul(other: number | Series<Scalar>): Series<number> {
     return this._scalarOp(other, (a, b) => a * b);
   }
 
   /** Element-wise division (true division, returns float). */
-  div(other: T | Series<T>): Series<number> {
+  div(other: number | Series<Scalar>): Series<number> {
     return this._scalarOp(other, (a, b) => a / b);
   }
 
   /** Element-wise floor division. */
-  floordiv(other: T | Series<T>): Series<number> {
+  floordiv(other: number | Series<Scalar>): Series<number> {
     return this._scalarOp(other, (a, b) => Math.floor(a / b));
   }
 
   /** Element-wise modulo. */
-  mod(other: T | Series<T>): Series<number> {
+  mod(other: number | Series<Scalar>): Series<number> {
     return this._scalarOp(other, (a, b) => a % b);
   }
 
   /** Element-wise exponentiation. */
-  pow(other: T | Series<T>): Series<number> {
+  pow(other: number | Series<Scalar>): Series<number> {
     return this._scalarOp(other, (a, b) => a ** b);
   }
 
   // ─── comparison ───────────────────────────────────────────────────────────
 
-  private _cmpOp(other: T | Series<T>, fn: (a: T, b: T) => boolean): Series<boolean> {
+  private _cmpOp(
+    other: Scalar | Series<Scalar>,
+    fn: (a: Scalar, b: Scalar) => boolean,
+  ): Series<boolean> {
     const isScalar = !(other instanceof Series);
     if (isScalar) {
-      const b = other as T;
+      const b = other as Scalar;
       const newData = this._values.map((a) => fn(a, b));
       return new Series<boolean>({
         data: newData,
@@ -297,11 +303,11 @@ export class Series<T extends Scalar = Scalar> {
         name: this.name,
       });
     }
-    const o = other as Series<T>;
+    const o = other as Series<Scalar>;
     if (o.size !== this.size) {
       throw new RangeError(`Cannot compare Series of different sizes: ${this.size} vs ${o.size}`);
     }
-    const newData = this._values.map((a, i) => fn(a, o._values[i] as T));
+    const newData = this._values.map((a, i) => fn(a, o._values[i] as Scalar));
     return new Series<boolean>({
       data: newData,
       index: this.index,
@@ -310,15 +316,15 @@ export class Series<T extends Scalar = Scalar> {
     });
   }
 
-  eq(other: T | Series<T>): Series<boolean> {
+  eq(other: Scalar | Series<Scalar>): Series<boolean> {
     return this._cmpOp(other, (a, b) => a === b);
   }
 
-  ne(other: T | Series<T>): Series<boolean> {
+  ne(other: Scalar | Series<Scalar>): Series<boolean> {
     return this._cmpOp(other, (a, b) => a !== b);
   }
 
-  lt(other: T | Series<T>): Series<boolean> {
+  lt(other: Scalar | Series<Scalar>): Series<boolean> {
     return this._cmpOp(other, (a, b) => {
       if (a === null || b === null) {
         return false;
@@ -327,7 +333,7 @@ export class Series<T extends Scalar = Scalar> {
     });
   }
 
-  le(other: T | Series<T>): Series<boolean> {
+  le(other: Scalar | Series<Scalar>): Series<boolean> {
     return this._cmpOp(other, (a, b) => {
       if (a === null || b === null) {
         return false;
@@ -336,7 +342,7 @@ export class Series<T extends Scalar = Scalar> {
     });
   }
 
-  gt(other: T | Series<T>): Series<boolean> {
+  gt(other: Scalar | Series<Scalar>): Series<boolean> {
     return this._cmpOp(other, (a, b) => {
       if (a === null || b === null) {
         return false;
@@ -345,7 +351,7 @@ export class Series<T extends Scalar = Scalar> {
     });
   }
 
-  ge(other: T | Series<T>): Series<boolean> {
+  ge(other: Scalar | Series<Scalar>): Series<boolean> {
     return this._cmpOp(other, (a, b) => {
       if (a === null || b === null) {
         return false;
@@ -648,8 +654,8 @@ export class Series<T extends Scalar = Scalar> {
   // ─── set operations ───────────────────────────────────────────────────────
 
   /** True when `value` exists in this Series. */
-  isin(values: readonly T[]): Series<boolean> {
-    const set = new Set<T>(values);
+  isin(values: readonly Scalar[]): Series<boolean> {
+    const set = new Set<Scalar>(values);
     return new Series<boolean>({
       data: this._values.map((v) => set.has(v)),
       index: this.index,

tests/core/series.test.ts

@@ -99,30 +99,30 @@ describe("Series", () => {
     const a = new Series({ data: [1, 2, 3] });
     const b = new Series({ data: [4, 5, 6] });
 
-    it("add scalar", () => expect(a.add(10 as never).values).toEqual([11, 12, 13]));
-    it("add series", () => expect(a.add(b as never).values).toEqual([5, 7, 9]));
-    it("sub series", () => expect(b.sub(a as never).values).toEqual([3, 3, 3]));
-    it("mul scalar", () => expect(a.mul(2 as never).values).toEqual([2, 4, 6]));
-    it("div series", () => expect(b.div(a as never).values).toEqual([4, 2.5, 2]));
-    it("mod", () => expect(b.mod(a as never).values).toEqual([0, 1, 0]));
-    it("pow", () => expect(a.pow(2 as never).values).toEqual([1, 4, 9]));
-    it("floordiv", () => expect(b.floordiv(a as never).values).toEqual([4, 2, 2]));
+    it("add scalar", () => expect(a.add(10).values).toEqual([11, 12, 13]));
+    it("add series", () => expect(a.add(b).values).toEqual([5, 7, 9]));
+    it("sub series", () => expect(b.sub(a).values).toEqual([3, 3, 3]));
+    it("mul scalar", () => expect(a.mul(2).values).toEqual([2, 4, 6]));
+    it("div series", () => expect(b.div(a).values).toEqual([4, 2.5, 2]));
+    it("mod", () => expect(b.mod(a).values).toEqual([0, 1, 0]));
+    it("pow", () => expect(a.pow(2).values).toEqual([1, 4, 9]));
+    it("floordiv", () => expect(b.floordiv(a).values).toEqual([4, 2, 2]));
 
     it("throws when sizes differ", () => {
       const c = new Series({ data: [1, 2] });
-      expect(() => a.add(c as never)).toThrow(RangeError);
+      expect(() => a.add(c)).toThrow(RangeError);
     });
   });
 
   describe("comparison", () => {
     const s = new Series({ data: [1, 2, 3] });
 
-    it("eq", () => expect(s.eq(2 as never).values).toEqual([false, true, false]));
-    it("ne", () => expect(s.ne(2 as never).values).toEqual([true, false, true]));
-    it("lt", () => expect(s.lt(2 as never).values).toEqual([true, false, false]));
-    it("le", () => expect(s.le(2 as never).values).toEqual([true, true, false]));
-    it("gt", () => expect(s.gt(2 as never).values).toEqual([false, false, true]));
-    it("ge", () => expect(s.ge(2 as never).values).toEqual([false, true, true]));
+    it("eq", () => expect(s.eq(2).values).toEqual([false, true, false]));
+    it("ne", () => expect(s.ne(2).values).toEqual([true, false, true]));
+    it("lt", () => expect(s.lt(2).values).toEqual([true, false, false]));
+    it("le", () => expect(s.le(2).values).toEqual([true, true, false]));
+    it("gt", () => expect(s.gt(2).values).toEqual([false, false, true]));
+    it("ge", () => expect(s.ge(2).values).toEqual([false, true, true]));
   });
 
   describe("filter", () => {
@@ -134,7 +134,7 @@ describe("Series", () => {
     });
 
     it("filters by boolean Series", () => {
-      const mask = s.gt(2 as never);
+      const mask = s.gt(2);
       const result = s.filter(mask);
       expect(result.values).toEqual([3, 4, 5]);
     });
@@ -173,7 +173,7 @@ describe("Series", () => {
     it("nunique", () => expect(s.nunique()).toBe(5));
 
     it("sum with nulls skips them", () => {
-      const s2 = new Series({ data: [1, null, 2, null, 3] as never[] });
+      const s2 = new Series({ data: [1, null, 2, null, 3] });
       expect(s2.sum()).toBe(6);
     });
 
@@ -245,7 +245,7 @@ describe("Series", () => {
   describe("isin", () => {
     it("returns boolean mask", () => {
       const s = new Series({ data: [1, 2, 3, 4] });
-      expect(s.isin([2, 4] as never[]).values).toEqual([false, true, false, true]);
+      expect(s.isin([2, 4]).values).toEqual([false, true, false, true]);
     });
   });