Question: I have an interface in F#

```
type IStongList =
    abstract member ToStringList: float * float list

```

And I'm having trouble making a a list of float,float tuples.

```
type MyTypw = struct 
    val L1: float
    val L2: float
    val M1: float
    val M2: float
    // . . .
    interface  IStrongList with
        member this.ToStrongList = 
            let one: float * float  = (this.L1,this.M1) 
            let two: float * float  = (this.L2,this.M2) 
            [
                one
                two
            ]
end

```

The error I get is:

```
This expression was expected to have type
    float * float list    
but here has type
    'a list 

```

What am I doing wrong?

Answer: 
A `float * float list` is a tuple consisting of a `float` and a `float list`, *not* a list of tuples consisting of two `float`s. For that you should use `(float * float) list`:

```
type IStrongList =
    abstract member ToStrongList: (float * float) list

```

If you change your interface like this, the rest of your code will work fine.

There are also a few typos in your code (`IStongList` → `IStrongList` and `ToStringList` → `ToStrongList`) but I'll chalk these up to transcription errors.
Problem is not with your implementation, but with the interface declaration itself.

`float * float list` means a tuple of `float` and `float list`. To get a list of tuples of `float` and `float` you need `(float * float) list`:

```
type IStongList =
    abstract member ToStringList: (float * float) list

```