为什么 C# 中的诚实函数示例仍然不诚实？

Question

来自此参考：http://functionalprogrammingcsharp.com/honest-functions

在 C# 中定义方法/函数时，我学会了更加诚实。 它表示更喜欢纯函数，以便函数始终给出签名中给出的确切返回类型。

但是当我尝试应用它时：

int Divide(int x, int y)
{
    return x / y;
}

来自网站：

签名声明该函数接受两个整数并返回另一个整数。但并非在所有情况下都如此。如果我们调用像 Divide(1, 0) 这样的函数会发生什么？函数实现不遵守其签名，抛出 DivideByZero 异常。这意味着这个函数也是“不诚实的”。我们如何才能使这个函数成为一个诚实的函数？我们可以更改 y 参数的类型（NonZeroInteger 是自定义类型，可以包含除零以外的任何整数）：

int Divide(int x, NonZeroInteger y)
{
    return x / y.Value;
}

我不确定 NonZeroInteger 的实现是什么，他们似乎没有在网站中提供 NonZeroInteger 的任何实现，是否应该在该类中检查 0？和 我很确定如果我调用 Divide(1, null) 它仍然会显示错误，从而使函数不诚实。

为什么C#中的诚实函数示例仍然不诚实？

Answer 1

我只想提一下，NonZeroInteger 绝对可以使用Peano numbers 的变体诚实地实现：

class NonZeroInteger
{
    /// <summary>
    /// Creates a non-zero integer with the given value.
    /// (This is private, so you don't have to worry about
    /// anyone passing in 0.)
    /// </summary>
    private NonZeroInteger(int value)
    {
        _value = value;
    }

    /// <summary>
    /// Value of this instance as plain integer.
    /// </summary>
    public int Value
    {
        get { return _value; }
    }
    private readonly int _value;

    public static NonZeroInteger PositiveOne = new NonZeroInteger(1);
    public static NonZeroInteger NegativeOne = new NonZeroInteger(-1);

    /// <summary>
    /// Answers a new non-zero integer with a magnitude that is
    /// one greater than this instance.
    /// </summary>
    public NonZeroInteger Increment()
    {
        var newValue = _value > 0
            ? _value + 1    // positive number gets more positive
            : _value - 1;   // negative number gets more negative
        return new NonZeroInteger(newValue);   // can never be 0
    }
}

唯一棘手的部分是我定义了Increment，以便它可以同时处理正整数和负整数。您可以创建除零之外的任何整数值，并且不会抛出任何异常，所以这个类是完全诚实的。 （我暂时忽略溢出，但我不认为这会是个问题。）

是的，它需要你重复加一来构建大整数，这是非常低效的，但是对于像这样的玩具类来说这没问题。可能还有其他更有效的诚实实现（例如，使用 uint 作为 +1 或 -1 的偏移量），但我将把它作为练习留给读者。

你可以这样测试：

class Test
{
    static int Divide(int x, NonZeroInteger y)
    {
        return x / y.Value;
    }

    static void Main()
    {
        var posThree = NonZeroInteger.PositiveOne
            .Increment()
            .Increment();
        Console.WriteLine(Divide(7, posThree));

        var negThree = NonZeroInteger.NegativeOne
            .Increment()
            .Increment();
        Console.WriteLine(Divide(7, negThree));
    }
}

输出是：

2
-2

Answer 2

读了很多遍..

我发现他在网站上的第二个选项是诚实的，而第一个是错误的。

int? Divide(int x, int y)
    {
        if (y == 0)
        return null;
        return x / y;
    }

编辑：从另一篇文章中得到想法，基本上模仿了 F# 路径，如下所示：

Option<int> Divide(int x, int y)
    {
        if (y == 0)
            return Option<int>.CreateEmpty();
        return Option<int>.Create(x / y);
    }

public class Option<T> : IEnumerable<T>
{
    private readonly T[] _data;

    private Option(T[] data)
    {
        _data = data;
    }

    public static Option<T> Create(T element)
    {
        return new Option<T>(new T[] { element });
    }

    public static Option<T> CreateEmpty()
    {
        return new Option<T>(new T[0]);
    }

    public IEnumerator<T> GetEnumerator()
    {
        return ((IEnumerable<T>) _data).GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    public void Match(Action<T> onSuccess, Action onError) {
        if(_data.Length == 0) {
            onError();
        } else {
            onSuccess(_data[0]);
        }
    }
}

参考：https://www.matheus.ro/2017/09/26/design-patterns-and-practices-in-net-option-functional-type-in-csharp/

打电话：

public void Main() {
    Option<int> result = Divide(1,0);
    result.Match(
        x => Console.Log(x),
        () => Console.Log("divided by zero")
    )
}

Answer 3

“诚实功能”的概念仍有解释的余地​​，我不想在这里争论，这将是更多的意见而不是实际有用的答案。

要具体回答您的示例，您可以将 NonZeroInteger 声明为 ValueType，使用 struct 而不是 class。

值类型是不可为空的（除非您使用? 明确指定可空版本）。在这种情况下没有空问题。顺便说一句，int 是值类型的一个示例（准确地说，它是System.Int32 的别名）。

因为有些有pointed out，它可能会导致其他困难（结构总是有一个默认构造函数将所有字段初始化为默认值，int 的默认值是 0...）

对于一个中等经验的程序员来说，这种例子不需要在文章中明确实现即可理解。

但是，如果您不确定，这绝对是一个很好的编程学习练习，我强烈建议您自己实现它！ （顺便说一下，创建单元测试来证明你的函数没有“错误”）

Answer 4

老实说，国际海事组织，这是矫枉过正，但如果我要采用“诚实”的方法。我会做这样的事情。而不是创建一个全新的类。这不是关于做什么的建议，以后很容易导致代码出现问题。 IMO 处理此问题的最佳方法是使用该函数并在方法之外捕获异常。这是一个“诚实”的方法，因为它总是返回一个整数，但它可能返回错误值。

    int Divide(int x, int y)
    {
        try
        {
            return x / y;
        }
        catch (DivideByZeroException)
        {
            return 0;
        }
    }

Answer 5

这个NonZeroInteger只是一个“符号”，只是代表想法，不代表具体实现。

当然，作者可以提供这种结构的实现，但它的名称服务器正好适合一篇文章。

可能的实现可能是：

public class NonZeroInteger
{
  public int Value { get; set; }
  public NonZeroInteger(int value)
  {
    if( value == 0 ) throw new ArgumentException("Argument passed is zero!");
    Value = value;
  }
}

但这只是将不诚实推到其他地方（就文章而言），因为构造函数应该返回一个对象，而不是抛出异常。

IMO，诚实是无法实现的，因为它只是将不诚实转移到其他地方，如本例所示。

Answer 6

老实说，定义一个新的数据结构并检查状态。

enum Status { OK, NAN }
class Data
{
    public int Value { get; set; }
    public Status Status { get; set; }

    public static Data operator /(Data l, Data r)
    {
        if (r.Value == 0)
        {
            // Value  can be set to any number, here I choose 0. 
            return new Data { Value = 0, Status = Status.NAN };
        }
        return new Data { Value = l.Value / r.Value, Status = Status.OK };
    }

    public override string ToString()
    {
        return $"Value: {Value}, Status: {Enum.GetName(Status.GetType(), Status)}";
    }
}

class Test
{
    static Data Divide(Data left, Data right)
    {
        return left / right;
    }
    static void Main()
    {
        Data left = new Data { Value = 1 };
        Data right = new Data { Value = 0 };
        Data output = Divide(left, right);

        Console.WriteLine(output);
    }
}

Answer 7

以您发布的示例为例，并阅读链接后，如果您想让函数“诚实”，那么您实际上不需要创建新类型，您可以实现 Try 模式：

bool TryDivide(int x, int y, out int result)
{
  if(y != 0)
  {
    result = x / y;
    return true;
  }

  result = 0;
  return false;
}

这个功能基本上符合“诚实”的原则。名字说它会尝试做除法，结果 'bool' 说它会表明它是成功的。

您可以创建一个struct NonZeroInteger，但您将不得不围绕它编写大量代码以使其表现得像一个常规的数字类型，而且您可能会回到原点。例如，如果将0 传递给NonZeroInteger 构造函数会怎样？它应该失败吗？那是诚实的吗？

另外，struct 类型总是有一个默认构造函数，所以如果你要包装一个 int，避免它被设置为 0 会很尴尬。