Before answering some of your more in-depth questions, a note on the environment.

If you installed VS 2005, then F# 1.9.x, then do the following. Open up your F# project/file. Then, go to Tools -> Add-In Manager. Check the add-in that says "F# Interactive for Visual Studio" (check the box on the left, leave the others the way they are). Hit OK. This will bring up a box that is running an F# interpreter.

The way most functional languages work is that they give you a REPL (real-eval-print loop). What this interactive interface lets you do is dynamically test out pieces of code before integrating them into your larger project. Sort of like on-the-spot unit testing. Now, whenever you want to run some code, select the code in the editor and hit ALT+ENTER. This will send the code to the interpreter to be evaluated and the result will be printed right in front of you. The code is sent as a block, ie, send a function as a whole, don't send each line one at a time. Check out the following for more information:

[link:img99.imageshack.us] (this is a vertical panorama of VS 2008 screenshots. Note that you may have different boxes checked in VS 2005 (probably, command-line will be checked). Don't touch any of those settings, only check the box on the left).

My next piece of advice is to forget about Windows Forms (MessageBox, etc), as these elements add unnecessary complexity to learning F#.

Now, onto your questions:

(1) The assignment to 'q' failed, and rightly so. This syntax that I described is not for assigning values to variables (although it can be used as such).

The first thing I feel I need to clarify is that regular assignments using let (eg, let x = 5) are not variable assignments. The value of x cannot be changed in the sense that it can be changed in imperative languages (C++/Java/C#). As such, you can modify your code as follows to assign a value to a variable 'q':

1
2
3
4

let z = [3;12]
let q = z
        |> List.map Int32.to_string
        |> String.concat " "

Just keep in mind that since #light syntax is whitespace-dependent, it matters where the |> are aligned.

(2) If you use the interpreter I describe above, you don't even need to use printf/n. Instead, the REPL will simply output the answer in semi-human readable form.

The way I normally develop is I write a function encompassing an algorithm, then test it with fringle values and incorrect values, knowing what answer I should get. If I don't get what I want, I read through the code a few times till I find the problem. Then, once I'm satisfied, I insert the code into the main project. Then, I do some very preliminary integration testing, ie, checking to see that the functions that need to use the new code are using it correctly and that all pre/post conditions are okay.

(3) About the books, I have Foundations of F# but not Expert F#, and I don't have a problem with it. I don't think you can go wrong with either one, although since I don't have Expert F# I can't really say whether it is appropriate for a person just learning about functional programming. Foundations of F# is very good as an introductory text for functional programming in general and specifically F#.

(4) (from post 4643) List.iter vs. List.map. Think of List.map as transforming each element of a list separately, then combining all those results to make a new list. So, for example, List.map (fun x -> x + 5) [3; 12] will output a new list of the same length:

1
2

> List.map (fun x -> x + 5) [3; 12] ;;
val it : int list = [8; 17]

On the other hand, List.iter is more for imperative style programming. What it does is run the function you provide on each member of the list (similar to List.map). However, it differs in that the return value of the function must be unit, ie, () (unit is equivalent to void in other languages). What this means is that your function cannot return a meaningful value. So, one way I might use List.iter is List.iter (fun x -> printfn "The value is: %A" x) [3; 12]. The output for this line is as follows:

1
2
3
4

> List.iter (fun x -> printfn "The value is: %A" x) [3; 12];;
The value is: 3
The value is: 12
val it : unit = ()

Notice the difference in return values from the two functions. List.iter returns nothing meaningful, which means that all of its work is done through side-effects, ie, some kind of mutability, IO, etc. On the other hand, List.map is mainly for transforming values in a list (usually with no side effects).

Hope I didn't confuse you too much.

Regards,

z.