Question

我想获得F＃代码，导致与C＃代码相同的行为：

public abstract class ModelBase<TIn, TOut>
{
  internal abstract Func<TIn, TOut> GetFuncInternal();
}

public class Model1 : ModelBase<Tuple<int, int>, int>
{
  private int _val;
  public Model1(int val)
  {
    _val = val;
  }

  internal override Func<Tuple<int, int>, int> GetFuncInternal()
  {
    return _ => _val; 
  }
}

public class Model2 : ModelBase<Tuple<int, double>, double>
{
  private double _val;
  public Model2(double val)
  {
    _val = val;
  }

  internal override Func<Tuple<int, double>, double> GetFuncInternal()
  {
    return _ => _val;
  }
}

public class Model3 : ModelBase<int, bool>
{
  internal override Func<int, bool> GetFuncInternal()
  {
    return _ => true;
  }
}

public static class Helpers
{
  public static Func<TIn, TOut> GetFunc<TIn, TOut>(ModelBase<TIn, TOut> model)
  {
    return model.GetFuncInternal();
  }
}

因此，上述代码可以通过以下方式使用：

var func1 = Helpers.GetFunc(new Model1(1));
var func2 = Helpers.GetFunc(new Model2(1.0));
var func3 = Helpers.GetFunc(new Model3());

正如您所看到的，GetFunc结果的类型取决于其参数的类型。

在定义为歧视联盟的F＃模型中：

type Model = 
  | Model1 of int
  | Model2 of double
  | Model3

问题是：如何在F＃中定义GetFunc？我需要这样的东西（当然由于模式匹配中的类型不匹配，后续样本没有编译）：

let GetFunc (m: Model) = 
  match  m with
  | Model1 i -> fun (x: int, y: int) -> i
  | Model2 d -> fun (x: int, y: double) -> d
  | Model3 ->   fun (x: int) -> true

Answer 1

不要那样定义Model。实际上，很难说你在做什么，但这就像一个你不需要定义任何类型的域。只需使用lambdas，您就不需要任何这些模型类型。你究竟想做什么？

如何定义一个函数，该函数返回一个具有依赖于参数的签名的函数

1 个答案: