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?

/frontend dev (HTML/CSS)・founder/decentralized data wrangler /blockhead・contributor /ethglobal /walletbeat・hackathon bounty hunter・music maker・dropout・nomad・25

```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,
		}
	),
})
```

Does it work if you use an `is` predicate with a symbol for "type"?

```ts
type FromThing<T extends 'A' | 'B' = 'A' | 'B'> = (
	& {
		type: T,
	}

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

		:
			Record<string, never>
	)
)

type ToThing<T extends 'A' | 'B' = 'A' | 'B'> = (
	& {
		type: T,
	}

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

		:
			Record<string, never>
	)
)

const isTypeA = (thing: FromThing): thing is FromThing<'A'> => (
	thing.type === 'A'
)

const isTypeB = (thing: FromThing): thing is FromThing<'B'> => (
	thing.type === 'B'
)

const transform = <
	T extends 'A' | 'B' = 'A' | 'B'
>(
	thing: FromThing<T>
): ToThing<T> => {
	if (isTypeA(thing))
		return {
			type: 'A',
			a: thing.A,
		} as ToThing<'A'>

	if (isTypeB(thing))
		return {
			type: 'B',
			b: thing.B,
		}

	return {
		type: thing.type,
	}
}
```

Try a symbol for the type?
https://www.typescriptlang.org/docs/handbook/symbols.html