How to create a specific alias based on a generic typescript interface

Question

Consider the following interfaces:

export interface FooInterface<T, O extends FooOptions<T>> {
  items: T[];
  options: O;
}

interface FooOptions<T> {
  doSomething: (e: T) => void;
}

Now whenever i need to do something with this I need to repeat T. For example:

const t: FooInterface<string, FooOptions<string>> = {
  items: ["a","b","c"],
  options: {doSomething: (e) => {
      console.log(e);
  }}
}

Now, repeating is boring, is it possible to create a type or interface where T should be string for both types, or redefine the interfaces somehow, so that I write something like this instead:

const t: FooInterfaceString
//or
const t: FooInterfaceOfType<string>

jcalz · Accepted Answer · 2019-05-02 12:18:40Z

The other answers here are correct, but I want to add that you might consider using generic parameter defaults if you are usually (but not always) going to just pass in FooOptions<T> as the type of O:

interface FooOptions<T> {
    doSomething: (e: T) => void;
}

// note how O has a default value now
export interface FooInterface<T, O extends FooOptions<T> = FooOptions<T>> {
    items: T[];
    options: O;
}

That lets you just leave out the O parameter when you intend it to just be FooOptions<T>:

const t: FooInterface<string> = {
    items: ["a", "b", "c"],
    options: {
        doSomething: (e) => {
            console.log(e);
        }
    }
}

And in the event that you actually want O to be more specific than FooOptions<T> (that's why you have it as a separate parameter, right?), you can still do it:

interface MoreOptions {
    doSomething: (e: string) => void;
    doNothing: () => void;
}

const u: FooInterface<string, MoreOptions> = {
    items: ["d", "e", "f"],
    options: {
        doSomething(e) { console.log(e); },
        doNothing() { console.log("lol nvm"); }
    }
}

Oh, and if T will usually be string then you can add a default for it too and then FooInterface without parameters will be interpreted as FooInterface<string, FooOptions<string>>:

export interface FooInterface<T = string, O extends FooOptions<T> = FooOptions<T>> {
    items: T[];
    options: O;
}

const t: FooInterface = {
    items: ["a", "b", "c"],
    options: {
        doSomething: (e) => {
            console.log(e);
        }
    }
}

Okay, hope that helps. Good luck!

Thanks a bunch, this was really exactly what I was looking for.

Romain · Accepted Answer · 2019-05-02 11:46:42Z

2

how about :

type FooInterfaceString = FooInterface<string, FooOptions<string>>;

also, maybe consider this if it fits your design:

export interface FooInterface<T> {
  items: T[];
  options: FooOptions<T>;
}
type FooInterfaceString = FooInterface<string>;

answered May 2, 2019 at 11:46

Romain

8106 silver badges8 bronze badges

Comments

Emaro · Accepted Answer · 2019-05-02 11:49:57Z

1

You could use a TypeScript alias:

// Declaration
type FooInterfaceOfType<T> = FooInterface<T, FooOptions<T>>;

// Usage
const t: FooInterfaceOfType<string>;

answered May 2, 2019 at 11:49

Emaro

1,5171 gold badge13 silver badges23 bronze badges

Collectives™ on Stack Overflow

How to create a specific alias based on a generic typescript interface

3 Answers 3

1 Comment

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

1 Comment

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related