Building a hybrid native application with Gleam and Tauri(wezm.net)

    type Variant = { kind: "value", value: string  } | { kind: "error", error: string } | { kind: "unexpected" };

    class Unreachable extends Error {
        constructor(unexpected: never) {
            super(`${unexpected}`);
        }
    }

    function useVariant(variant: Variant) {
        switch (variant.kind) {
            case "value":
                return variant.value;
            case "error":
                return variant.error;
            default:
                throw new Unreachable(variant);
        }
    }

    type A = { kind: "kindA", a: "dataA" }
    type B = { kind: "kindB", b: "dataB" }
    type Sum = A | B

    const match = <
        const V extends { kind: string },
        const C extends { [ kind in V[ "kind" ] ]: ( value: V & { kind: kind } ) => unknown }
    >( value: V, cases: C ) => cases[ value.kind as V[ "kind" ] ]( value ) as ReturnType<C[ V[ "kind" ] ]>

    // You check the type of result, change the type of value to A or B, make the cases non-exhaustive...
    const howToUse = ( value: Sum ) => {
        const result = match( value, {
            kindA: _ => _.a,
            kindB: _ => _.b
        } )
    }