Is there default parameter in F#? - f#

Question

I wrote a program to convert file size from bytes to a human readable format in F#:
let rec sizeFmt num i =
let suffix="B"
let unit = ["";"Ki";"Mi";"Gi";"Ti";"Pi";"Ei";"Zi"]
match abs num with
| x when x < 1024.0 -> printfn "%3.1f %s%s" num unit.[i] suffix
| _ -> sizeFmt (num / 1024.0) (i+1)
let humanReadable n =
sizeFmt (float n) 0
Run example:
> humanReadable 33;;
33.0 B
val it : unit = ()
> humanReadable 323379443;;
308.4 MiB
val it : unit = ()
>
Question:
It would be nice if I can set i=0 as the default value in the
sizeFmt funciton. I checked the F# documentation, only found that
there's no default parameter. So I have to write a wrapper function
humanReadable. Is there a better way?
In order to handle both int and float type input like humanReadable 123;; and humanReadable 123433.33;;, I have to add a float n in the wrapper function. The obvious problem is: it is very easy to exceed the max int size which is 2,147,483,647. I guess there might be a better way, are there?

Answer 1

If sizeFmt is only used by humanReadable, it makes sense to make it an inner function. That avoids the 'parameter default' issue.
Also, marking the outer function inline causes it to accept any type of n that supports explicit conversion to float.
let inline humanReadable n =
let rec sizeFmt num i =
let suffix="B"
let unit = ["";"Ki";"Mi";"Gi";"Ti";"Pi";"Ei";"Zi"]
match abs num with
| x when x < 1024.0 -> printfn "%3.1f %s%s" num unit.[i] suffix
| _ -> sizeFmt (num / 1024.0) (i+1)
sizeFmt (float n) 0
humanReadable 123 //works
humanReadable 123433.33 //also works

Answer 2

One F# convention that may help is to put primary parameters at the end of the parameter list and secondary parameters first - the opposite of the convention in OO languages. This lets you pipe your primary argument to your function, e.g.
let rec sizeFmt i num =
...
123.0 |> sizeFmt 0
It also lets you easily create partial functions with optional parameters filled in:
let humanReadable = sizeFmt 0
In answer to 2, no there is no better way, unless you make sizeFmt generic and pass in the typed value of 1024.0 but this probably won't make it any simpler.

Answer 3

The only way to have an optional parameter in F# is to use a method instead of a function. To specify that a parameter is optional, put a ? before it. From the documentation here:
type DuplexType =
| Full
| Half
type Connection(?rate0 : int, ?duplex0 : DuplexType, ?parity0 : bool) =
let duplex = defaultArg duplex0 Full
let parity = defaultArg parity0 false
let mutable rate = match rate0 with
| Some rate1 -> rate1
| None -> match duplex with
| Full -> 9600
| Half -> 4800
do printfn "Baud Rate: %d Duplex: %A Parity: %b" rate duplex parity
let conn1 = Connection(duplex0 = Full)
let conn2 = Connection(duplex0 = Half)
let conn3 = Connection(300, Half, true)

Answer 4

Although I know that's not what is being asked about, did you know about F#'s Units of Measure feature?
[<Measure>] type B
[<Measure>] type kB
let bPerKB = 1024.M<B/kB>
let bytesToKiloBytes (bytes : decimal<B>) = bytes / bPerKB
let kiloBytesToBytes (kiloBytes : decimal<kB>) = kiloBytes * bPerKB
This gives you a type-safe way to distinguish bytes from kilobytes, and prevents you from accidentally assigning a kilobyte value to a function that expects bytes.
Here are some example conversions:
> 1024.M<B> |> bytesToKiloBytes;;
val it : decimal<kB> = 1M
> 1145.M<B> |> bytesToKiloBytes;;
val it : decimal<kB> = 1.1181640625M
> 1.M<kB> |> kiloBytesToBytes;;
val it : decimal<B> = 1024M
If you just need the function like above as a quick way to make a large byte value human-readable, this is surely overkill, but if you need to manage byte values on many scales, this may be appropriate.

Answer 5

The existing answers already explain that keeping a wrapper function is a good idea, since this lets the code be as much modular as possible. This would not be very obvious in a simple example, but in real-life projects it would be a great advantage to be able to extend sizeFmt at some moment by exposing more parameters — consider that you may occasionally need "Hertz" instead of "Bytes" (and division by 1000 instead of 1024), or a sting format pattern (five decimal digits), or a localizable list of multipliers, and so on.
As for the second question, converting to float, the solution is very simple: make value a statically-resolved type:
let inline humanReadable (value:^T) =
sizeFmt (float value) 0
This will make humanReadable to have the following type constraint:
val inline humanReadable :
value: ^T -> unit when ^T : (static member op_Explicit : ^T -> float)
Usage:
humanReadable 42424242.42 // float
humanReadable 4242 // int
humanReadable 42424242424242424242I // Numerics.BigInteger
humanReadable (424242424242424242422424N / 5N) // BigRational
Using float in the inner function seems to be fine: any round-off errors will be eliminated by a series of divisions.