then how would T and U be known when accessor is used? do you have to specify accessor<number, string> or you imagine some sort of inference taking place? if so how?

just in the exact same way as it is for functions:

1. yes, one way it to explicitly set them accessor<string, number>.get(xxx)
2. yes, another way is to let the inference guess: takeAccessor(accessor)

does that happen on every use? or the first, then it is fixed? functions and classes guarantee that each invocation is isolated from the other, but that is not the same as a variable, assuming there is a state involved.. e.g. can i

var x: number;
accessor.set({ value: "string" } );
x = accessor.get();

just like with the functions where type arguments are required on each call, the arguments for values need to be provided or inferred at each reading (dereferencing)

so yes it needs to happen on every use

in fact at the moment i use functions to do exactly that:

function alwaysAccesorOf<T, U>(): Accessor<T, U> {
   return {
      get: data => data.value,
      set: (data, value) => ({ ...data, value })
   };
}

alwaysAccessorOf<string, number>().get(xxx) // <-- i wish i could avoid a function call just
                                            // for the sake of providing type arguments
                                            // and simply do:

accessor<string, number>.get(xxx);

👍
I run into this fairly often.

Related issues:
#19728
#17574

also related to #15877

Tracking at #17574