add index argument to many functions in ReadonlyArray

[matheuspuel]

No description provided.

[changeset-bot]

🦋 Changeset detected

Latest commit: cb09879

The changes in this PR will be included in the next version bump.

This PR includes changesets to release 17 packages

Name	Type
effect	Patch
@effect/cli	Patch
@effect/experimental	Patch
@effect/opentelemetry	Patch
@effect/platform-browser	Patch
@effect/platform-bun	Patch
@effect/platform-node	Patch
@effect/platform	Patch
@effect/printer-ansi	Patch
@effect/printer	Patch
@effect/rpc-http-node	Patch
@effect/rpc-http	Patch
@effect/rpc-nextjs	Patch
@effect/rpc-workers	Patch
@effect/rpc	Patch
@effect/schema	Patch
@effect/typeclass	Patch

Not sure what this means? Click here to learn what changesets are.

Click here if you're a maintainer who wants to add another changeset to this PR

[gcanti]

@matheuspuel I would add some dtslint tests, based on my experiments these tests fail:

// file: /packages/effect/dtslint/ReadonlyArray.ts

// -------------------------------------------------------------------------------------
// takeWhile
// -------------------------------------------------------------------------------------

ReadonlyArray.takeWhile(numbersOrStrings, (
  _item // $ExpectType string | number
) => true)

// fails: Parameter '_item' implicitly has an 'any' type.ts(7006)
ReadonlyArray.takeWhile(numbersOrStrings, (
  _item, // $ExpectType string | number
  _i // $ExpectType number
) => true)

pipe(
  numbersOrStrings,
  ReadonlyArray.takeWhile((
    _item // $ExpectType string | number
  ) => true)
)

// fails: Parameter '_item' implicitly has an 'any' type.ts(7006)
pipe(
  numbersOrStrings,
  ReadonlyArray.takeWhile((
    _item, // $ExpectType string | number
    _i // $ExpectType number
  ) => true)
)

unless you add a i: number parameter to refinements too:

export const takeWhile: {
  <A, B extends A>(refinement: (a: A, i: number) => a is B): (self: Iterable<A>) => Array<B>
  <B extends A, A = B>(predicate: (a: A, i: number) => boolean): (self: Iterable<B>) => Array<B>
  <A, B extends A>(self: Iterable<A>, refinement: (a: A, i: number) => a is B): Array<B>
  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Array<A>
} = dual(2, <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Array<A> => {
  let i = 0
  const out: Array<A> = []
  for (const a of self) {
    if (!predicate(a, i)) {
      break
    }
    out.push(a)
    i++
  }
  return out
})