Re.Mark

My Life As A Blog

TF#I Friday #7 Part 2 : In which it still isn’t Friday

leave a comment »

Looking at how to call F# from C#, I thought I should share this link.  I have 2 projects in one solution (one in F# and one in C#.)  The C# project (a console application) references the F# project (a library) and that works.  Doesn’t do anything useful yet, but one step at a time…

Written by remark

June 29, 2011 at 3:09 pm

Posted in .NET, c#, Development, F#

TF#I Friday #7 : In which it isn’t really Friday but there is some F#

leave a comment »

After my simple start to an anagram solver in C#, I have a simple equivalent in F#:

let generateKey (chars : char[]) = new string(chars)
let lookup =  words |> Seq.groupBy(fun x -> generateKey(x.ToCharArray() |> Array.sort))
 

The lookup function expects a list of strings.  It works – although I’ve only tried it with fairly short lists of words.  Next exercise is to try calling this (or something like it) from C#.

Written by remark

June 29, 2011 at 11:45 am

Posted in .NET, Development, F#, Languages

TF#I Friday #6 : In which I write no F# at all

leave a comment »

I’ve been spending a little time recently writing a simple Windows Phone 7 app and I’ve been impressed with how easy it has been.  I’ve been thinking of writing an anagram solver as an exercise in F# – and it might make for another simple phone app – so I thought I’d start with a few simple steps.

The first step is to try (part of) a potential solution – given a list of words, group the words by the constituent letters (so that, for instance, horse and shore would be grouped together.)  That way, I won’t have to try every single combination of letters and compare against a list of words.  My intention this week was to write a simple program in C# to do this.  Here’s the method that does the work:


private Dictionary<string, List<string>> ProcessWordList(string[] words)
{
    Dictionary<string, List<string>> result = new Dictionary<string, List<string>>();

    foreach (string word in words)
    {
        IOrderedEnumerable<char> ordered = from char a in word.ToCharArray()
                                           orderby a
                                           select a;
        string orderedString = new string(ordered.ToArray());
        if (result.ContainsKey(orderedString))
        {
           result[orderedString].Add(word);
        }
        else
        {
            List<string> list = new List<string>();
            list.Add(word);
            result.Add(orderedString, list);
        }
    }

    return result;
}

Next exercise is either to extend the program towards solving anagrams or to write the method above in F#.

Written by remark

May 27, 2011 at 5:31 pm

Posted in .NET, c#, Development, F#, Languages

TF#I Friday #5 : In which I return to C# for a bit

leave a comment »

In my last post I counted some words using F#, which turned out to require a single, simple line of F#.  When I’d done the same thing before in C# i had iterated over the words and kept a count as I went, which is a typically imperative approach.  So, I wondered if you could apply the functional approach to C# – perhaps using LINQ.  Turns out you can.

Firstly, it’s helpful to have some words to count.  Here’s a simple approach:


string test = "The cat sat on the mat.";
string[] words = test.Split(' ');

(In F# I populated a list of words directly, so there’s an extra line of C# here – largely because I started with my previous C# code.)  Right, now to the counting in one line:


var result = from word in words
             let strippedWord = StripPunctuation(word).ToLower()
             where strippedWord.Length > 0
             group word by strippedWord into grouped
             select new { Word = grouped.Key, Count = grouped.Count() };

You  may have noticed a call to StripPunctuation – a utility function I had in my previous C# code.  Here it is (declared static as I was running it in a console application:


private static string StripPunctuation(string word)
{
    string result = word;
    if (result.Length > 0)
    {
        if (char.IsPunctuation(result[0]))
        {
            result = result.TrimStart(result[0]);
        }
        if (result.Length > 0)
        {
            if (char.IsPunctuation(result[result.Length - 1]))
            {
                result = result.TrimEnd(result[result.Length - 1]);
            }
        }
    }
    return result;
}

And now, with a little sprinkling of dynamic capability, outputting the results to the console:


foreach (dynamic entry in result)
{
    Console.WriteLine("{0}\t{1}", entry.Word, entry.Count);
}

So it is possible to apply the more functional approach courtesy of LINQ, although there’s still more code than I had in F#.  The C# is doing a couple of extra things (it strips out punctuation and is case insensitive) - but the point isn’t really the comparison between the two examples so much as the fact that by grasping some functional concepts can result in a change to your C# – which is a good reason to learn some F#.

Written by remark

March 25, 2011 at 5:43 pm

Posted in .NET, c#, Development, F#, Languages

TF#I Friday #4 : In which I count some words

leave a comment »

For a recent MSDN Flash article I wrote some simple code to calculate word frequency in C#.  As I get to grips with F#, I’m learning that the most rewarding but also the most difficult aspect is to think in a more functional way.  To count words in an imperative style (as I did in my C# example) I would iterate through a collection of words and keep a running count.  And, of course, you could write code in F# to do that.  But what would be the point?  How about approaching it in a different fashion?  So, with those questions in mind, I fired up Visual Studio and went about trying to bend my brain into a more F# like shape.  One of the things I like about F# is F# Interactive – a REPL which makes trying out and learning F# (as well as prototyping) easy – so that was where I started.  First thing I needed to do was to create a list of words (since at this stage I’m concerned simply with calculating frequency and not reading files or strings.)  It’s fairly simple to do that in F#:

let words = ["the"; "cat"; "sat"; "on"; "the"; "mat"];;

(the double semicolons are signal to F# Interactive the completion of a statement.)  After reading a bit about processing sequences in F#, I spotted that there is a function to count elements in a list – it can easily be used against the whole list like this:

let count = words |> Seq.countBy(fun x -> x);;

The countBy function takes a function to generate a key – in this case we can use each individual word.  To see if that has worked, we can print out the contents of the result:

printfn "%A" count;;

And in this case, I got the following result:

seq [("the", 2); ("cat", 1); ("sat", 1); ("on", 1); ...]
val it : unit = ()

Which means it worked as intended.  There’s work to be done to make it the equivalent of the C# code, but the core counting is implemented in one line of code.

Written by remark

March 4, 2011 at 5:09 pm

Posted in .NET, c#, Development, F#, Languages

TF#I Friday #3 : Still getting started

leave a comment »

After mentioning in my last post that my initial exposure to F# was negative, I’ve just had a similar reaction looking around the web.  I think that’s because there’s two things to learn – the functional paradigm and a new syntax – and many of he posts out there assume that you’re familiar with at least one of the two.  Which is why of the two books I mentioned before, I prefer Functional Programming – it gives examples in both C# and F#, which means you can separate the paradigm from the syntax and still learn about both.

Written by remark

February 11, 2011 at 6:57 pm

Posted in .NET, Development, F#, Languages

TF#I Friday #2 : Getting started

with one comment

My initial introduction to F# was effective.  Unfortunately, the effect it had was to convince me that I should never learn F#.  And so I stayed away from the language for a couple of years until its inclusion in Visual Studio 2010 reawakened my interest.   I’m glad I’ve gone back to learning about F#, but it does make you realise that the first few minutes with a new language or technology are crucial.

So, this time around, I decided to go back to my tried and trusted method which consists simply of reading and experimenting.  In support of which I bought a couple of books: Programming F# and Functional Programming.  Other books are available.  As for online resources, I tend to read articles that are suggested via the maelstrom of near real time social online noise-makers or search for relevant stuff.  However, there’s a few links worth noting as good starting places:

F# Developer Centre

Don Syme’s blog

Tomas Petricek’s blog

hubFS forums

Of course, you’ll find your own places and resources as I’m sure I will as the journey continues.

Written by remark

January 7, 2011 at 6:50 pm

Posted in .NET, Development, F#, Languages

Follow

Get every new post delivered to your Inbox.