A place for developers to talk about building on Farcaster.

/dev

Any TypeScript gurus in the house who can help me troubleshoot this? What am I fundamentally misunderstanding about type parameters / conditionals here?

maybe it's easier to find out with a link from here https://www.typescriptlang.org/play/

but as far as i can read from the images is because is not able to cast the type, possibly because the optionals

/frontend dev・founder/decentralized data wrangler /blockhead・UI/UX abstractionist・DeFi/web3 builder・dropout・24・prev /dydx, ritual.net・x.com/darryl__yeo

```ts
enum Type {
	A = 'A',
	B = 'B',
}

type FromThing<T extends Type = Type> = (
	& {
		type: Type,
	}

	& (
		T extends Type.A ?
			{
				A: number
			}
		
		: T extends Type.B ?
			{
				B: string
			}

		:
			Record<string, never>
	)
)

type ToThing<T extends Type = Type> = (
	& {
		type: Type,
	}

	& (
		T extends Type.A ?
			{
				a: number
			}
		
		: T extends Type.B ?
			{
				b: string
			}

		:
			Record<string, never>
	)
)

const transform = <
	T extends Type = Type
>(
	fromThing: FromThing<T>
): (
	ToThing<T>
) => ({
	type: fromThing.type,

	...(
		fromThing.type === Type.A && 'A' in fromThing && fromThing.A && {
			a: fromThing.A,
		}
	),

	...(
		fromThing.type === Type.B && 'B' in fromThing && fromThing.B && {
			b: fromThing.B,
		}
	),
})
```

Playground link is too long for Warpcast...

Barcelona based developer. I enjoy comics gaming and sci-fi

Playground link is too long for Warpcast...

https://warpcast.com/darrylyeo/0x34016cc1

Maybe you need some primitives like predicates.

```
const isTypeA = (x: Type): x is Type.A => x === Type.A
...
```
with that you can do `isTypeA` and will infer the right type

will try to see what's with the current snippet and get back to you

Neovim enjoyer, "a gift to the culture" | Building at /thirdweb

Nope, tried that

https://warpcast.com/darrylyeo/0x0dfee310

https://codesandbox.io/p/devbox/fp9ryk

seems to be that it's the optionals...

wrote a file called transform and added a variation and some comments

Thanks! This does work, but now I'm wondering if I'd be able to group multiple unique parameters under the same umbrella conditional instead of defining a conditional for each parameter.

```ts
type Type = 'A' | 'B'

type From<
	T extends Type = Type,
> = {
	type: Type
	A: T extends 'A' ? number : never
	B: T extends 'B' ? string : never
}

type To<
	T extends Type = Type,
> = {
	type: Type
	a?: T extends 'A' ? number : never
	b?: T extends 'B' ? string : never
}

const transform = <
	T extends Type = Type
>(
	{ type, A, B }: From<T>,
): To<T> => ({
	type,
	...type === 'A' && {
		a: A,
	},
	...type === 'B' && {
		b: B,
	},
})
```

Would be a dream if all of web dev Bluesky joined this app haha

yeah, time to put those brains to work haha. Will try to think in a way, but  AFAIK you can't "iterate" in types