13

我已经实现了一个斐波那契数列生成器，如下所示

let getNext upperLimit current= 
        let (e1, e2) = current
        let next = e1 + e2
        if next > upperLimit then None
        else Some (next, (e2,next))

let fib upperLimit = (0,1) |> Seq.unfold (getNext upperLimit) |> Seq.append [0;1]

我的测试代码是

[<Test>]
member Spec.``fib not exeeding 20 should be 0,1,1,2,3,5,8,13``()=
    let expected = seq [0;1;1;2;3;5;8;13] 
    let result = fib 20
    let expectedSameAsResult = (expected = result)
    printfn "Expected: %A  Result: %A result length: %d" expected result (Seq.length result) 
    Assert.That expectedSameAsResult

测试失败，打印结果为

预期：[0; 1个；1个；2；3；5个；8个；13] 结果：seq [0; 1个；1个；2；...] 结果长度：8

当我使用 for 循环打印结果中的每个元素时，我得到了预期序列中完全相同的元素。

那么，期望序列和结果序列有什么区别呢？

编辑：我的实现可以在https://github.com/weima/EulerProblems/tree/master/EulerProblems

编辑：为了回答 John Palmer 的回答 ，我刚刚在 F# 交互窗口中写了一个测试

 let a = seq[1;2;3]
 let b = seq[1;2;3]
 let c = a = b;;

我得到的结果是 val a : seq = [1; 2；3] val b : seq = [1; 2；3] val c : bool = true

所以 F# 也可以对序列进行结构比较。

编辑以反映 Gene Belitski 的回答 我已将测试更改为

[<Test>]
member Spec.``fib not exeeding 20 should be 0,1,1,2,3,5,8,13``()=
    let expected = seq [0;1;1;2;3;5;8;13] 
    let result = Problem2.fib 20
    let comparedResult =  Seq.compareWith (fun a b -> a - b) expected result  
    let expectedSameAsResult = (comparedResult = 0)
    Assert.That expectedSameAsResult

它现在起作用了。谢谢！但我仍然不明白为什么简单的 seq[1;2;3]=seq[1;2;3] 有效，但我的测试用例却没有。

4

5 回答 5

17

虽然您可能期望它a=b会比较序列的元素，但它实际上会a=b计算引用相等性。

你可以用类似的东西看到这个

seq {1..3} = seq {1..3}

返回false。

但是，在某些情况下，当您使用常量时，您会得到令人困惑的结果，尤其是

seq [1;2;3] = seq [1;2;3]

返回 true，这令人困惑。

为避免此问题，您需要执行类似的操作

 let test a b = Seq.fold (&&) true (Seq.zip a b |> Seq.map (fun (aa,bb) -> aa=bb))

明智地比较元素。

或者，您可以Seq.compareWith按照 Gene 的回答中所述使用。但是，这要求元素还实现比较运算符以及相等性，这对于某些事情可能并非如此，例如实现=但不比较的可区分联合。

于 2013-06-14T05:10:45.243 回答
16

添加到约翰的答案：可以使用Seq.compareWith库函数确定序列相等性：

let compareSequences = Seq.compareWith Operators.compare

那么序列相等将是表达式的值

let expectedSameAsResult = (compareSequences expected result = 0)
于 2013-06-14T05:34:44.753 回答
5

MSDN for Operators.seq<'T>函数说：使用序列表达式语法构建序列。如果您查看它的实现，您会发现它基本上只是标识函数，仅在与序列表达式语法一起使用时对编译器具有特殊意义。如果您使用 list 调用 - 您将得到相同的列表（向上转换为 seq<_>）。

根据 F# 规范，重新构造平等：

默认情况下，记录、联合和结构类型定义（称为结构类型）隐式包含编译器生成的结构相等、散列和比较的声明。这些隐式声明包括以下结构相等和散列：

override x.GetHashCode() = ...
override x.Equals(y:obj) = ...
interface System.Collections.IStructuralEquatable with 
    member x.Equals(yobj: obj, comparer: System.Collections.IEqualityComparer) = ...
    member x.GetHashCode(comparer: System.IEqualityComparer) = ...

以下声明启用结构比较：

interface System.IComparable with 
    member x.CompareTo(y:obj) = ...
interface System.Collections.IStructuralComparable with 
    member x.CompareTo(yobj: obj, comparer: System.Collections.IComparer) = ...

对于异常类型，会生成结构相等和散列的隐式声明，但不会生成结构比较的声明。永远不会为接口、委托、类或枚举类型生成隐式声明。枚举类型通过它们作为整数的底层表示隐式地获得对相等、散列和比较的支持

所以列表（基本上是联合） - 支持结构平等和序列 - 不。要成对检查元素，您还可以使用 Seq.forall2

let isEqual = (s1, s2) ||> Seq.forall2 (=)
于 2013-06-15T05:18:52.103 回答
4

对于任何找到这个答案的人来说，他们只想用一种简单的方法来比较两个序列，可以使用 Seq.compareWith 的替代方法：

有一个 .NET 方法Enumerable.SequenceEqual。我在测试时一直使用它。

示例用法：

let sequenceA = seq { 1..5 }
let sequenceB = seq { 1..5 }

Enumerable.SequenceEqual (sequenceA, sequenceB) // True
于 2017-02-09T13:21:16.650 回答
1

原因：

序列不支持结构相等。

如果您将 aseq视为 .NET，IEnumerable<T>也许这更有意义？这seq [1;2;3] = seq [1;2;3]是一个不幸的巧合。考虑一个非纯的seq：

let rnd = System.Random()
let x = seq { yield rnd.Next() }
printfn "x is %A" x
printfn "x is %A" x

结果：

x is seq [372511654]
x is seq [1026368248]

val rnd : System.Random
val x : seq<int>

显而易见的答案：

使用list而不是在seq这里。

[<Test>]
member Spec.``fib not exeeding 20 should be 0,1,1,2,3,5,8,13``()=
    let expected = [0;1;1;2;3;5;8;13] 
    let result = fib 20 |> Seq.toList
    let expectedSameAsResult = (expected = result)

细节：

查看其他答案。

于 2013-12-05T15:45:17.517 回答