CODEWITHSUNDEEP
inheritancef#optional-arguments
Daniel
Daniel

Reputation: 47904

Propagating optional arguments

The following code does not compile.

type A(?arg) =
  member __.Arg : string option = arg

type B(?arg) =
  inherit A(arg) //ERROR expected type string but has type 'a option

I assume this is because an instance of the underlying type of the option must be provided, and the compiler handles passing Some/None based on syntax.

Assuming my assumption has been correctly assumed, is there a workaround for this? Is it possible to propagate optional arguments?

Upvotes: 13

Views: 1741

Answers (3)

JEE - Sharp and Soft
JEE - Sharp and Soft

Reputation: 19

F# will translate ?-marked arguments to optional values. Providing an argument gives a Some-value while not providing it gives a None-value. The combination of optional and named arguments lets you have huge flexibility.

See also my answer here https://stackoverflow.com/a/66043023/15143713 /JEE, Sharp#Soft

Upvotes: -1

desco
desco

Reputation: 16782

F# spec 8.13.5 Optional arguments to method members

Callers may specify values for optional arguments by using the following techniques:

  • By name, such as arg2 = 1.
  • By propagating an existing optional value by name, such as ?arg2=None or ?arg2=Some(3) or ?arg2=arg2. This can be useful when building one method that passes optional arguments on to another.

  • By using normal, unnamed arguments matched by position.

    type A(?arg) =
    member __.Arg : string option = arg

type B(?arg) =
    inherit A(?arg = arg) 

printfn "1. %A" (B()).Arg // None
printfn "2. %A" (B("1")).Arg // Some "1"

printfn "3. %A" (A()).Arg // None
printfn "4. %A" (A("1")).Arg // Some "1"

Upvotes: 26

Random Dev
Random Dev

Reputation: 52280

Sorry had to test it first: it seems you are right - you have to do the "?" for A yourself:

type A(arg : string option) =
  new (a) = new A(Some a)
  new () = new A(None)
  member __.Arg : string option = arg

type B(?arg) =
  inherit A(arg)

Upvotes: 0

Related Questions