Why use generics when you are not using the type parameter?

const hoc = (child: (arg: {a: string}) => void): void => {
  child({ a: 'apple' });
};

@AnyhowStep The code sample was a reduced example. If you click through to the playground, it shows a more meaningful example where the type parameter is being used.

Update: I updated the code sample to include use of the type parameter.

I've got a workaround but it isn't the prettiest,
Playground

Your solution probably sits somewhere between #14520 and #12936

Re: #14520

{} is a super type of { a : string }. So, <T super Addition> wouldn't work for this case.

Re: #12936

Most people think of "exact types" as having exact properties, but not exact types for values.

So, { a : "hi" } would still be assignable to Exact<{ a : string }>

{} is a super type of { a : string }. So, wouldn't work for this case

You can have upper and lower bound constraints on a parameter

Alternative solution, still requires a cast unfortunately. Playground

// child() requires data including `a` and `b`.
function child(data: { a: string, b: string }): void {
    console.log(data.a, data.b)
};

// Merge two objects, taking types from U if possible, and falling back to T
type Merge<T, U> = {
    [K in keyof T | keyof U]: K extends keyof U ? U[K] : K extends keyof T ? T[K] : never
}

// Remove props in T that are also in U
type RemoveCommonProps<T, U> = Pick<T, Exclude<keyof T, keyof U>>

// hoc() supplies `a`, and returns a function that only requires `b`.
type Addition = { a: string };

function hoc<T extends Addition>(child: (data: Merge<T, Addition>) => void) {
    function wrapped(data: RemoveCommonProps<T, Addition>) {
        // Still requires a cast unfortunately
        child({ ...data, a: 'apple' } as Merge<T, Addition>);
    }

    return wrapped;
}

const wrapped = hoc(child);

wrapped({ b: 'boy' });
wrapped({ b: 'boy', a: 'a' }) // Error, provided by hoc (freshness check)

const data = { a: 'a', b: 'b' }
wrapped(data) // No error because object literal is not fresh

I think @Gerrit0's solution is reasonable. If I understand correctly the errors (or lack-of) at the call to wrapped are less important because the spread overrides correctly.

Expecting an error for a call like hoc((arg: {}) => {}); might not be right because a function of that type can be safely used at types with more specific arguments like (arg: {a: string}) => {}.

Tagging this Discussion since I think there are a variety of good approaches on the table already, plus various other proposals linked to would cover this if implemented

I ran into this same issue, posted on SO, and was very surprised that the response was there's no way to require an exact match. +1 for this feature.

I have similar but slightly more complex issue: #41930

I think I might have solved your problem while working on it. Take a look at my example and I must say it works as "extending" middleware. So that you can make it so:

middleware(foo(), bar(), handler);

foo and bar may add something to payload while bar and handler may require some types. There are only 3 files there middleware.ts, middleware.spec.ts utils.ts so it should be easy for you to copy and test it for yourself. For now I implemented types for only up to 3 functions but it can be extended.