错误 DART：名称“x”不是类型，因此不能用作类型参数

Question

Error in the Input part in one class and in Output in another class

1. This would be the main class referenced

abstract class HttpFunction<Input, Output>
{
  Output apply(Input paramInput);
}

2. This would be the class in which the previous one is called

class ComposerFunction with HttpFunction<Input, Request>
{
    RequestComposer<Input> inputConverter;

    ComposerFunction(RequestComposer inputConverter);

    ComposerFunction_(RequestComposer<Input> inputConverter)
    {
        this.inputConverter = inputConverter;
    }

    Request apply(Input input)
    {
        return this.inputConverter.compose(input);
    }
}

class InterpreterFunction with HttpFunction<Response, Output> 
{
    ResponseInterpreter<Output> responseInterpreter;

    InterpreterFunction(ResponseInterpreter outputConverter);

    InterpreterFunction_(ResponseInterpreter<Output> responseInterpreter)
    {
        this.responseInterpreter = responseInterpreter;
    }

    Output apply(Response response)
    {
        return this.responseInterpreter.interpret(response);
    }
}

3. These are the Errors

The name 'Input' isn't a type so it can't be used as a type argument.
Try correcting the name to an existing type, or defining a type named 'Input'.dart(non_type_as_type_argument)

And

The name 'Output' isn't a type so it can't be used as a type argument.
Try correcting the name to an existing type, or defining a type named 'Output'.dart(non_type_as_type_argument)

UPDATE

class ComposerFunction<Input> implements HttpFunction<Input, Request>
{
    ...
}

class InterpreterFunction<Output> implements HttpFunction<Response, Output>
{
   ...
}

Thank you for your answers:)

Answer 1

If generically passing types is what you're after, could you try changing your abstract class as below

abstract class HttpFunction<T, U>
{
  U apply<T, U>(T paramInput);
}

And the classes as follows:

class ComposerFunction with HttpFunction<Input, Request>
{
    RequestComposer<Input> inputConverter;

    ComposerFunction(RequestComposer inputConverter);

    ComposerFunction_(RequestComposer<Input> inputConverter)
    {
        this.inputConverter = inputConverter;
    }

    Request apply<Input, Request>(Input input)
    {
        return this.inputConverter.compose(input);
    }
}
class InterpreterFunction with HttpFunction<Response, Output>
{
    ResponseInterpreter<Output> responseInterpreter;

    InterpreterFunction(ResponseInterpreter outputConverter);

    InterpreterFunction_(ResponseInterpreter<Output> responseInterpreter)
    {
        this.responseInterpreter = responseInterpreter;
    }

    Output apply<Response, Output>(Response response)
    {
        return this.responseInterpreter.interpret(response);
    }
}

This is assuming you have classes created/referenced of the expected types

Answer 2

You have:

class ComposerFunction with HttpFunction<Input, Request>
{
   ...
}

Assuming that you want ComposerFunction to be a generic class that can be parameterized on caller-specified Input and Request types, you have not declared ComposerFunction to be a generic class. Although HttpFunction is a generic class, ComposerFunction as written is a non -generic class that uses HttpFunction specialized with types literally named Input and Request . If you don't have classes named Input and Request , this therefore fails with:

The name 'Input' isn't a type so it can't be used as a type argument.

to make ComposerFunction a generic class, you need to add type parameters to it :

class ComposerFunction<Input, Request> with HttpFunction<Input, Request>
{
   ...
}

Same thing applies to InterpreterFunction .

Additionally, with is normally intended for use with mixin s . It's also allowed with abstract class for backward compatibility with Dart 2.0 and earlier, but since HttpFunction does not provide any code that can be reused, this doesn't seem useful. If you want ComposerFunction (and InterpreterFunction ) to conform to an interface, then you usually would use implements instead.