Back to Questions
1.8k
views1
comment
Trying to pass a struct parameters byref when using static member operator overloading
f#

When trying to pass struct parameters byref when using operator overloading it will only work when
defining the the opertor outside the class as in curried form like this.
But this unfortunately redefines the global ( + ) operator.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

[<Struct>]


type Vector (x : float, y : float) =


    member v.x = x


    member v.y = y

//Curried


let inline ( + ) (l : Vector byref) (r : Vector byref) =


    new Vector (l.x + r.x, l.y + r.y)


let mutable a = new Vector (1.0, 2.0)


let mutable b = new Vector (2.0, 1.0)


let c = &a + &b

Note that in the following snippets inline causes:
System.TypeLoadException was unhandled
Message: The generic type 'Microsoft.FSharp.Core.Tuple`2' was used

with an invalid instantiation in assembly 'FSharp.Core,

Version=1.9.4.19, Culture=neutral

It doesn't work as a tupled static member 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

[<Struct>]


type Vector (x : float, y : float) =


    member v.x = x


    member v.y = y


    // Tupled


    static member (*inline*) ( + ) (l : Vector byref, r : Vector byref) =


        new Vector (l.x + r.x, l.y + r.y)

let mutable a = new Vector (1.0, 2.0)


let mutable b = new Vector (2.0, 1.0)

// This works
let c = Vector.( + ) (&a, &b)


// But this doesn't compile
let d = &a + &b  
// Error    2    Invalid mutation of a constant expression. Consider copying the expression to a mutable local, e.g. 'let mutable x = ...'.
// Error    1    The type 'Vector byref' does not support any operators named '+'
// Error    3    The type 'Vector byref' does not support any operators named '+'

It doesn't work when augmenting byref

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

[<Struct>]


type Vector (x : float, y : float) =
    member v.x = x
    member v.y = y


// Augmenting byref


type 'a Microsoft.FSharp.Core.byref with
    static member (*inline*) ( + ) (l : Vector byref, r : Vector byref) =
        new Vector (l.x + r.x, l.y + r.y)


let mutable a = new Vector (1.0, 2.0)


let mutable b = new Vector (2.0, 1.0)

// This works
let c = byref<Vector>.( + ) (&a, &b) 


          


// But this doesn't compile
let d = &a + &b 
// Error    2    Invalid mutation of a constant expression. Consider copying the expression to a mutable local, e.g. 'let mutable x = ...'.
// Error    1    The type 'Vector byref' does not support any operators named '+'
// Error    3    The type 'Vector byref' does not support any operators named '+'

So my question is what is the correct way of doing this?
It would also be nice to have something like transparent const reference passing for structs like in C++

.

Looking at the code I can't think of anything that's wrong with it (i.e., I would expect that to all 'just work'). I've logged a bug in our internal database.

By on 8/21/2008 10:03 AM ()

    Topic tags

    IntelliFactory Offices Copyright (c) 2011-2012 IntelliFactory. All rights reserved.
    Home | Products | Consulting | Trainings | Blogs | Jobs | Contact Us | Terms of Use | Privacy Policy | Cookie Policy     		Built with WebSharper