optional parameters in abstract class type signature

Question

The Class:

type NotAbstract () = 
    member this.WithOptionalParameters (x, ?y) = 
        let y = defaultArg y 10
        x + y

has the following type signature:

type NotAbstract =
  class
    new : unit -> NotAbstract
    member WithOptionalParameters : x:int * ?y:int -> int
  end

However, this does not work:

[<AbstractClass>]
type AbstractExample () = 
    abstract WithOptionalParameters: int * ?int -> int /// Ouch...

type NotAbstract () = 
    inherit AbstractExample ()
    override this.WithOptionalParameters (x, ?y) = 
        let y = defaultArg y 10
        x + y

How to write the proper type signature in the abstract definition of a function with optional parameters? I did not find any hint here.

PS: I am aware that (similar) result could be achieved with polymorphism

The F# way is to use Option types instead of the (more primitive) Nullable types. — Panagiotis Kanavos, Mar 06 '14 at 09:08
@PanagiotisKanavos It is but there are two important cases where you need optionals: Fable bindings and C# interop — sdgfsdh, Mar 26 '20 at 14:08

score 9 · Accepted Answer · answered Mar 06 '14 at 20:48

Declaring an argument as Option type doesn't really make the argument optional.

NotAbstract().WithOptionalParameters(2)
// This expression was expected to have type
//     int * Option<int>    
// but here has type
//     int

The spec §8.13.6 has it:

In a signature, optional arguments appear as follows: static member OneNormalTwoOptional : arg1:int * ?arg2:int * ?arg3:int -> int

Naming your optional argument in the abstract member signature thus

[<AbstractClass>]
type AbstractExample () = 
    abstract WithOptionalParameters: int * ?y:int -> int      

type NotAbstract () = 
    inherit AbstractExample ()
    override this.WithOptionalParameters (x, ?y) = 
        let y = defaultArg y 10
        x + y

NotAbstract().WithOptionalParameters(42)  // val it : int = 52

score 4 · Answer 2 · edited Mar 06 '14 at 09:09

4

Optional parameters are compiled to Option types, use Option<int> instead of ?int:

[<AbstractClass>]
type AbstractExample () = 
    abstract WithOptionalParameters: int * Option<int> -> int      

type NotAbstract () = 
    inherit AbstractExample ()
    override this.WithOptionalParameters (x, ?y) = 
        let y = defaultArg y 10
        x + y

edited Mar 06 '14 at 09:09

NoIdeaHowToFixThis

4,484
2
34
69

answered Mar 06 '14 at 09:05

polkduran

2,533
24
34

Thanks, yes, this is true. I edited your answer to fix my own error in the type signature of `WithOptionalParameters` which actually returns an `int`. – NoIdeaHowToFixThis Mar 06 '14 at 09:10
@NoIdeaHowToFixThis Ok thanks for the edit, I din't check the code before pasting it. – polkduran Mar 06 '14 at 09:16

score 2 · Answer 3 · edited May 23 '17 at 12:33

2

This should work:

[<AbstractClass>]
type AbstractExample () = 
    abstract WithOptionalParameters: int * Nullable<int> -> unit

In F#, there's no syntactical sugar for nullable types, so although you can declare a value nullable with the ?y syntax, you can't do that for a type. Instead, you'll have to use Nullable<T>.

edited May 23 '17 at 12:33

Community

1
1

answered Mar 06 '14 at 09:00

Mark Seemann

225,310
48
427
736

s/declare a *value* nullable/declare a value optional/ ? – Ruben Bartelink Mar 06 '14 at 10:59
Either I misread the original question, or made some other cognitive error along the way, but I ended up thinking this was the solution. Obviously, the right answer is the one provided by polkduran, but I thought I'd just leave my answer here, in the off chance it could ever help someone else... – Mark Seemann Mar 06 '14 at 11:40
1

@Mark The `?arg` syntax in F# does not "make a value nullable". It declares an element of a tupled method parameter as optional for F# clients. However, non-F# clients will see it as `FSharpOption<...>`. This is different from the `?Type` syntax in C#, which declares a value type as nullable, which appears to all CLI clients, including F#, as `Nullable<...>`. The two concepts have nothing to do with each other... – Marc Sigrist Mar 06 '14 at 16:48
@MarkSeemann Yes, makes sense - esp with the context. +1 as it [with the explanation] adds variety without misleading. – Ruben Bartelink Mar 06 '14 at 22:55

optional parameters in abstract class type signature

3 Answers3