The "unit" type
Deferring execution of code
We can use the
unit type as a function argument to define functions that we don't want executed until later. This is often useful in asynchronous background tasks, when the main thread may want trigger some predefined functionality of the background thread, like maybe moving it to a new file, or if a a let-binding should not be run immediately:
In the following code, we define code to start a "worker" which simply prints out the value it is working on every 2 seconds. The worker then returns two functions which may be used to control it - one which moves it to the next value to work on, and one which stops it from working. These must be functions, because we do not want their bodies to be executed until we choose to, otherwise the worker would immediately move to the second value and shutdown without having done anything.
We can then start a worker by doing
and the work will begin - if we are in F# interactive, we will see the messages printed out in the console every two seconds. We can then run
and we will see the messages indicating that value being worked on has moved to the next one.
When it is time to finish working, we can run the
function, which will print out the closing message, then exit.
unit type is important here to signify "no input" - the functions already have all the information they need to work built into them, and the caller is not allowed to change that.
What good is a 0-tuple?
A 2-tuple or a 3-tuple represent a group of related items. (Points in 2D space, RGB values of a color, etc.) A 1-tuple is not very useful since it could easily be replaced with a single
A 0-tuple seems even more useless since it contains absolutely nothing. Yet it has properties that make it very useful in functional languages like F#. For example, the 0-tuple type has exactly one value, usually represented as
(). All 0-tuples have this value so it's essentially a singleton type. In most functional programming languages, including F#, this is called the
Functions that return
void in C# will return the
unit type in F#:
Run that in the F# interactive interpreter, and you'll see:
This means that the value
printResult is of type
unit, and has the value
() (the empty tuple, the one and only value of the
Functions can take the
unit type as a parameter, too. In F#, functions may look like they're taking no parameters. But in fact, they're taking a single parameter of type
unit. This function:
is actually equivalent to:
That is, a function that takes one parameter of type
unit and returns the
int value 6. If you look at the type signature that the F# interactive interpreter prints when you define this function, you'll see:
The fact that all functions will take at least one parameter and return a value, even if that value is sometimes a "useless" value like
(), means that function composition is a lot easier in F# than in languages that don't have the
unit type. But that's a more advanced subject which we'll get to later on. For now, just remember that when you see
unit in a function signature, or
() in a function's parameters, that's the 0-tuple type that serves as the way to say "This function takes, or returns, no meaningful values."