F# in 20 Minutes – Part II

re: F# in 20 Minutes – Part II

Paczesiowa — Sat, 10 May 2008 17:31:50 GMT

let result = 512 |> square |> toStr |> ref

should be rev

re: F# in 20 Minutes – Part II

ChrSmith — Sat, 10 May 2008 19:18:06 GMT

Doh. Fixed it, thanks.

re: F# in 20 Minutes – Part II

Keith — Thu, 15 May 2008 23:00:44 GMT

512^2 = 262144

32^2 = 1024

Great series, btw!

F# 20分钟快速上手（二）

Anders Cui — Sun, 10 Aug 2008 12:09:41 GMT

在上篇文章里，我们写出了F#的第一个程序，本文我们来看一些F#语言的核心部分，包括值的不变性，模块，Tuple，柯里化，Union类型，模式匹配，Record类型，序列和集合等内容，读完此文后，希望能让您对F#有个整体的认识。

re: F# in 20 Minutes – Part II

Kurt — Mon, 15 Sep 2008 23:43:01 GMT

Thanks for the articles. Is part III available? I can't seem to find the advanced topics article.

re: F# in 20 Minutes – Part II

Sam Stokes — Mon, 29 Sep 2008 22:03:05 GMT

Wow, this is a great way to learn Data Structures! I have ordered the F# for Scienctists, thanks for the review. I am working to figure out how to demo F# to non-CS faculty for simulations, etc.

F# 20分钟快速上手（二）

心界使者 — Thu, 16 Oct 2008 17:36:56 GMT

原文链接：http://www.cnblogs.com/anderslly/archive/2008/08/10/fs-in-20-minutes-core.html

re: F# in 20 Minutes – Part II

Rick Love — Sun, 26 Oct 2008 01:03:40 GMT

I was comparing F# features to C# 3.5, to see how they compare.

One thing that interested me is the forward pipe operator (which would be nice for C# to implement next version).

However, it can be simulated with Extension Methods:

public static class FunctionalPipeExtensions

{

public static void Test()

{

var doSquare = new Func<int, int>(n => n * n);

var doReverse = new Func<string, string>(

s => s.ToCharArray()

.Pipe(Array.Reverse)

.Pipe(ca => new String(ca))

);

var strRev = (4)

.Pipe(doSquare)

.ToString()

.Pipe(doReverse);

var numberRev = strRev.Pipe(s => int.Parse(s));

// numberRev == 61

}

public static TResult Pipe<T, TResult>(this T input, Func<T, TResult> doFunc)

{

return doFunc(input);

}

public static T Pipe<T>(this T input, Action<T> doFunc)

{

doFunc(input);

return input;

}

I considered naming this method "_" or "_P_" instead of "Pipe" because it is a strange but useful little guy in C#.

Especially notice the 2nd Pipe method which allows one to use a void returning method (which changes the internal state of the mutable object), but continue the series of method calls.

Also, object methods and extension methods fit right into the pipeline.

Some limitations:

- Cannot assign lambda expression to an implicitly-typed local variable.

- The C# compiler will not automatically map a method to an equivalent delegate Func<T,TResult>, etc. The types on the generic method must be given, or a lambda expression must be used to wrap the method call.

re: F# in 20 Minutes – Part II

Jarlac — Fri, 28 Nov 2008 22:09:23 GMT

let result = 512 |> square |> toStr |> rev

It looks like RPN (Reverse Polish Notation) to me.

But from the definition: let (|>) x f = f x ,

I guess it only takes one parameter right? Is there a way to pass more parameters before the function call??

re: F# in 20 Minutes – Part II

ChrSmith — Sat, 29 Nov 2008 01:17:22 GMT

Using the pipe forward operator (|>) you can pipe a single value to a function that takes any number of parameters. But from the definition it looks as if 'f' only takes one.

The trick is to use function currying. Let's say you have a function that takes three parameters:

let f x y z = ...

If you curry f by providing two of its parameters:

let g = f x y

The result is a function that takes a single parameter (what would have been z).

So to use the pipe forward operator with a function that takes multiple args you end up with something like this:

z |> f x y

The only downside is that the pipe forward operator only works for curryable functions. If a function takes a tuple:

f (x, y, z)

Then you will not be able to pipe data into it.

re: F# in 20 Minutes – Part II

Dustin — Tue, 02 Dec 2008 23:04:48 GMT

The only downside is that the pipe forward operator only works for curryable functions. If a function takes a tuple:

f (x, y, z)

We can't? Perhaps I'm misunderstanding how a function is defined in F# (I'm using the longest of a few ways, I know):

let sum3 = function

| (x, y, z) -> x + y + z;;

let my_tuple = (1, 2, 3);;

let result = my_tuple |> sum3;;

printf "%A\n" result;;

That prints 6, right? Perhaps I misinterpreted your statement, Chris?

re: F# in 20 Minutes – Part II

Ryan — Sun, 07 Dec 2008 01:25:30 GMT

Curryable functions and tuple functions have different signatures. The key is to understand that functions are themselves values. Let's compare:

> let sum3tuple (x, y, z) = x + y + z;;

val sum3tuple : int * int * int -> int

> let sum3curry x y z = x + y + z;;

val sum3curry : int -> int -> int -> int

This shows that sum3tuple accepts a triple of integers and returns an integer. It's used like this:

> sum3tuple (1, 2, 3);;

val it : int = 6

The tuple is a single value that must be constructed with parentheses because syntactically that is the only way to construct a tuple.

Whereas sum3curry accepts an integer and returns a function with the signature (int -> int -> int). The returned function is itself a function that accepts an integer and returns a function that accepts and integer and returns an integer. Confused yet?

Here's how it works:

> sum3curry 1 2 3;;

val it : int = 6

I can add parenthetical nesting to emphasize how this works:

> ((sum3curry 1) 2) 3;;

val it : int = 6

In this example, (sum3curry 1) returns a function which is then passed the argument 2. This returns another function that is passed the argument 3. Finally, this function returns an integer.

The |> operator just lets us flip this around backward and put the inputs to the function first:

> 3 |> (2 |> (1 |> sum3curry));;

val it : int = 6

Note that the parenthetical grouping is required this time because the default precedence is left-to-right.

Incidentally, we can still use |> with the tuple version, we just can't split up the parameters:

> (1, 2, 3) |> sum3tuple;;

val it : int = 6

re: F# in 20 Minutes – Part II

Steve — Fri, 12 Dec 2008 12:30:19 GMT

And you can move between the curried world and the uncurried world using functions like:

> let curry2 f x y = f (x, y);;

val curry2 : ('a * 'b -> 'c) -> 'a -> 'b -> 'c

> let uncurry2 f (x, y) = f x y;;

val uncurry2 : ('a -> 'b -> 'c) -> 'a * 'b -> 'c

F#, Imperative Languages and Identifiers

Sam Stokes on Research in your life and studies — Tue, 30 Dec 2008 00:21:39 GMT

OMG! I got pulled off my usual job of doing a bunch of things and have been focused on getting students

re: Immutability

beginner-1104 — Tue, 03 Feb 2009 01:37:14 GMT

I still don't get the immutability. In F# Interactive console I typed

> let x = 3;;

which evaluated x as

val it : int = 3

Then I typed

> let x = 4;;

First of all, I expected some kind of error message that x cannot be re-assigned or something like that. But it was accepted OK.

Then, the evaluation of x was:

val it : int = 4

So, where is the immutablity? Do I miss something?

Many thanks!

re: re: Immutability

beginner-1104 — Wed, 11 Feb 2009 18:39:17 GMT

I found the answer to my above question at http://en.wikibooks.org/wiki/Haskell/Variables_and_functions