4

Currently reading a series of blogposts on F#, targeted at the C# programmer. Right now I've finished reading part 3 ( http://www.jelovic.com/weblog/?p=220 ) and am left puzzled.

The difference between

let readLine = Console.ReadLine ()

and

let readLine () = Console.ReadLine ()

is clear enough but why is there the need to specify the two braces - () - in the following line:

let print (text : string) () = Console.WriteLine text

Shouldn't the compiler be able to figure out you're declaring a delegate print by omitting the braces, so it would look as follows:

let print (text : string) = Console.WriteLine text

Also, the following line made little sense to me

Usually when you have a function that takes parameters of a different type the compiler can differentiate between a function call and a delegate reference, but for unit you have to force it.

Does this mean that when the parameters are different it is safe for the compiler to assume it's a function call?

thank you all for the answers, it's clear to me now. As for the quote, we'll let it rest.

Improve this question
3
  • If you are coming to F# from C#, you may find these useful: lorgonblog.wordpress.com/2008/04/03/… and lorgonblog.wordpress.com/2008/11/28/… Commented Nov 13, 2010 at 17:50
  • 1
    The most confusing aspect of the blog is the use of print as the name of the function, when a better name is makePrinter, since it takes a string and returns a function that will print that string. Commented Nov 13, 2010 at 17:58
  • Regarding the quote, I'm not really sure what is the author trying to say, so I cannot help (it doesn't make much sense to me either). Possibly, he just tries to highlight the fact that there is a difference between value and function declarations in F#. Commented Nov 13, 2010 at 17:58

3 Answers 3

Reset to default
5

Introduction. I think it's useful to first discuss the difference in the simple example as it helps to understand what "unit" value is. The first declaration creates a string value (and immediately calls ReadLine to obtain the input from the user):

> let readLine = Console.ReadLine ();;
val readLine : string

The second declaration creates a function that takes unit value as an argument. The function doesn't need to take any input, but we want to define it as a function, so that it can be executed repeatedly (we need that, because the function has side-effect - it reads input from the user).

The "unit" parameter is just a way of creating a function that takes something as argument. "Unit" has only a single value written as (), so it doesn't represent any information - just the fact that there is some parameter:

> let readLine () = Console.ReadLine ();;
val readLine : unit -> string

Your question. To look at your example with additional braces. This creates a function that takes a string as the first parameter and takes additional "unit" value as the second parameter. You can see that from the type signature:

> let print (text : string) () = Console.WriteLine text 
val print : string -> unit -> unit

This is valid F# declaration, but it is not very useful. It means that the function will be only called when you give it some string to print and also additional "unit" value. You can call it like this:

print "Hello" ()

Even without the additional "unit" parameter, it would be a function (as opposed to a value), so adding the additional parameter doesn't help (you're always creating a function that can be called to print different strings).

There are still cases where this declaration can be interesting. For example, you can call the function just with the string as a parameter. In this case, you'll get a function as the result. The returned function will take unit and will print the string:

let f = print "Hello" // doesn't print anything
f ()                  // prints "Hello"
f ()                  // prints "Hello" again!

So, the compiler allows you to use "unit" values as any other values in the language. This includes uses that may look a bit unfamiliar (and not very useful) at first, but can make a good sense in some scenario.

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

3

This:

let print (text : string) = Console.WriteLine text

creates a method to print like:

print "hi" // prints "hi" in the console

where:

let print (text : string) () = Console.WriteLine text

produces a method to print a specific string like:

let printHi = print "hi" // Does NOT print a string to the console

printHi () // But now this does print "hi" :)
printHi () // And this...

So essentially, it is a "print specific string X to console function" factory which the result (ex printHi) can be reused many times.

Improve this answer

Comments

2

Using currying,

let makePrinter (text : string) () = Console.WriteLine text

let's you create a function that always prints a certain string, for instance

let helloPrinter = makePrinter "hello"

gives "hello" by simply calling

helloPrinter ()

On the other hand,

let print (text : string) = Console.WriteLine text

immediatly outputs "text" if called

print "hello"

and returns (), not a function of type unit -> unit as in the first, curried case.

Improve this answer

1 Comment

No prob (sorry for doing more editing than I initially intended)

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.