Implement at method for tuples

[mvares]

Closes #2975

[changeset-bot]

🦋 Changeset detected

Latest commit: 7d9686e

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

This PR includes changesets to release 25 packages

Name	Type
effect	Minor
@effect/cli	Major
@effect/experimental	Major
@effect/opentelemetry	Major
@effect/platform-browser	Major
@effect/platform-bun	Major
@effect/platform-node-shared	Major
@effect/platform-node	Major
@effect/platform	Major
@effect/printer-ansi	Major
@effect/printer	Major
@effect/rpc-http	Major
@effect/rpc	Major
@effect/schema	Major
@effect/sql-drizzle	Major
@effect/sql-mssql	Major
@effect/sql-mysql2	Major
@effect/sql-pg	Major
@effect/sql-sqlite-bun	Major
@effect/sql-sqlite-node	Major
@effect/sql-sqlite-react-native	Major
@effect/sql-sqlite-wasm	Major
@effect/sql	Major
@effect/typeclass	Major
@effect/vitest	Major

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

[mikearnaldi]

We could probably do better by using N extends number instead of number so that T[N] is the actual tuple type at N

[mvares]

We could probably do better by using N extends number instead of number so that T[N] is the actual tuple type at N

Ready!

[mikearnaldi]

export const at: {
  <A extends ReadonlyArray<unknown>, N extends number>(index: N): (self: A) => A[N]
  <A extends ReadonlyArray<unknown>, N extends number>(self: A, index: N): A[N]
}

wondering if N should instead extends keyof A, if instead we leave it as number then it would allow undefined access to properties not in the tuple (which may / may not be ok) but in that case a more correct signature would be:

export const at: {
  <N extends number>(index: N): <A extends ReadonlyArray<unknown>>(self: A) => A[N]
  <A extends ReadonlyArray<unknown>, N extends number>(self: A, index: N): A[N]
}

So that it allows at(n) to be used as a function even outside of a pipe.

cc @gcanti @tim-smart

[gcanti]

I would mirror what we did in Struct.ts:

src/Tuple.ts

export const get =
  <I extends number>(index: I) => <T extends ReadonlyArray<any>>(t: T): [] extends T ? T[I] | undefined : T[I] =>
    t[index]

dtslint/Tuple.ts

import { hole, pipe } from "effect/Function"

// -------------------------------------------------------------------------------------
// get
// -------------------------------------------------------------------------------------

// $ExpectType <T extends readonly any[]>(t: T) => [] extends T ? T[0] | undefined : T[0]
const get0 = get(0)

// $ExpectType undefined
pipe(hole<[]>(), get0)

// $ExpectType undefined
pipe(hole<readonly []>(), get0)

// $ExpectType string
pipe(hole<[string, number]>(), get0)

// $ExpectType string
pipe(hole<readonly [string, number]>(), get0)

// $ExpectType number
pipe(hole<[string, number]>(), get(1))

// $ExpectType number
pipe(hole<readonly [string, number]>(), get(1))

// $ExpectType undefined
pipe(hole<[string, number]>(), get(2))

// $ExpectType undefined
pipe(hole<readonly [string, number]>(), get(2))

// $ExpectType string | number
pipe(hole<[string, number]>(), get(-1))

// $ExpectType string | number
pipe(hole<readonly [string, number]>(), get(-1))

// $ExpectType number | undefined
pipe(hole<Array<number>>(), get(1))

// $ExpectType number | undefined
pipe(hole<Array<number>>(), get(-1))

[mvares]

thank you @gcanti! what do you think, @mikearnaldi?

[mvares]

It would be something as:

/**
 * Retrieves the element at a specified index from a tuple.
 *
 * @param self - A tuple from which to retrieve the element.
 * @param index - The index of the element to retrieve.
 *
 * @example
 * import { at } from "effect/Tuple"
 *
 * assert.deepStrictEqual(at([1, 'hello', true], 1), 'hello')
 *
 * @category getters
 * @since 3.4.0
 */
export const at: {
  <N extends number>(index: N): <A extends ReadonlyArray<unknown>>(self: A) => A[N]
  <A extends ReadonlyArray<unknown>, N extends number>(self: A, index: N): A[N]
} = dual(2, <A extends ReadonlyArray<unknown>, N extends number>(self: A, index: N): A[N] => self[index])

[mikearnaldi]

I think I am ok with it, it's in line with schema

[mvares]

I will send a PR to add it

[mvares]

cc @mikearnaldi 👍🏻

[tim-smart]

I would be good to add the dtslint tests @gcanti quoted above.