F# – Page 5 – adilakhter λ

Hi, I’m back. I’ve finally sorted out the guidelines for blogging in Credit Suisse.

Here is something I have been playing around with in the spare time between one meeting and the next one. It is a Scheme interpreter that includes a REPL window. The full code is here.

All the smarts for it come from this Wiki Book. I just ported the code to F# (and modified it a bit). I thought the comparison might be interesting, so here we go. Thanks to Tobias and Jose for reviewing the code, find one bug and suggest improvements.

Before we start looking at the real code, here is what we are trying to accomplish in form of test cases. If you are a bit rusty on LISP syntax, you might want to try and see if you understand what it does.

Our goal is to make all this XUnit…

View original post 501 more words

x += x++

This is part of my ‘things that I do in the empty spaces between one meeting and the next one, which might end up being vaguely interesting’. It is a lambda expression parser.

The full source code is here.

I actually have two versions of it: one written longhand and the other one written with FParsec. Just to be clear: I’m no expert of either.

And just to be more clear: I think writing most parsers longhand in the way I am about to show is crazy. You either use FParsec or fslex / fsyacc.

I have a strong distaste for additional compilation steps. I think it lingers on from MFC project types of 15/20 years ago. I was one of these crazy folks that would generate the project, wrap the generated code (with some generalizations) in my own library and use that one from then on.

View original post 408 more words

The Code Decanter

After much experimentation and digging around on google groups (special thanks to Ibrahim Hadad) I have finally managed to get Monodevelop 3 and F# working together nicely on Ubuntu. These were the steps I took. Your mileage may vary. :)

(Update: Knocte has suggested a couple of modifications to simplify the process. These are now reflected below.)

1) sudo apt-get install mono-complete libgdiplus git autoconf libtool

2) Install monodevelop using the script from John Ruiz’ blog:
http://blog.johnruiz.com/2012/05/installing-monodevelop-3-on-ubuntu.html

3) Get F# source and compile:
git clone git://github.com/fsharp/fsharp cd fsharp/ ./autogen.sh --prefix=/usr make sudo make install

4) Run monodevelop. Go to tools, add-in manager, gallery. Install F# language binding.

5) Enjoy!

View original post

Define symbolic operators with F#

This post describes how we can define a custom operator with F#. Defining a new operator in F# is very straightforward. For instance, by using the following code, we can define “!” as an operator to compute factorial of an integer.

	let rec (!) n =
	match n with
	\| 1 -> (1)
	\| n -> n*(n-1)

view raw sym_op.fs hosted with ❤ by GitHub

Running the following command in the interactive F# console computes the factorial for 10.

> !10;; 
val it : int = 3628800 
>

A symbolic operator can use any sequence of the following characters: ! % & * + - . / ? @ ^ |~. Note that, “:” can also be used in the character sequence of symbolic operation if and only if, it is not the first character in the operator.

Following is an example of modulo operator defined using F#:

	let rec (\|%\|) a n =
	match a, n with
	\|_ when a < n -> a
	\|_ when a>=n -> (\|%\|) (a-n) n

	//Resulting signature: val ( \|%\| ) : int -> int -> int

view raw modulo.fs hosted with ❤ by GitHub

Following outputs shows how to use it from F# interactive shell.

> 23 |%| 3;;
val it : int = 2
> 3 |%| 3;;
val it : int = 0
>

F# | Length of a List

The code snippets listed below defines a function to compute the length of a give list using F#. Note that these functions are also called polymorphic function, as they work with any type of list (as shown in the output).

	// naive implementation
	let rec length list =
	match list with
	\| [] -> 0
	\| _::tail -> 1 + computeLength tail

view raw gistfile1.fs hosted with ❤ by GitHub

A tail recursive implementation is outlined next.

	// Tail recursive computation of List's length
	let length list =
	// Auxiliary function to compute length
	// It store intermediate result in acc.
	let rec lengthAux acc list =
	match list with
	\| [] -> acc
	\| _::tail -> lengthAux (acc+1) tail
	lengthAux 0 list // invoking lengthAux with acc = 0

view raw gistfile1.fs hosted with ❤ by GitHub

Following is a more succinct implementation using List.Fold.

	let length list =
	List.fold
	(fun acc _ -> acc+1)
	0
	list

view raw length.fs hosted with ❤ by GitHub

Output:

> length [];;
val it : int = 0
> length [1;2;3;4];;
val it : int = 4
> length ['a';'b'];;
val it : int = 2

	let rec (\|%\|) a n =
	match a, n with
	\|_ when a < n -> a
	\|_ when a>=n -> (\|%\|) (a-n) n

	//Resulting signature: val ( \|%\| ) : int -> int -> int