Matt Manela's Blog : F#

A functional take on console program loop in F#

MattManela — Tue, 14 Apr 2009 07:51:19 GMT

Often when learning a new technology I start with a simple console application in which the program is run in a loop it continues to prompt you for more input until you give some command like quit or exit or whatever you choose:

Enter input: someInput
someOutput
Enter input: otherInput
someoutPut
Enter input: quit
Thanks! Come again!

The code for this is in an imperative language is usually something like:

       1: while(true)

       2: {

       3:     Console.Write("\nEnter input:");

       4:     var line = Console.ReadLine();

       5:     if(line == "quit") break;

       6:     

       7:     doSomething(line);

       8: }

       9:  

      10: Console.WriteLine("Thanks! Come Again");

While reading some F# samples, I saw some code doing essentially the same thing which looked something like:

       1: Console.Write "\nEnter input:"

       2: let mutable input = Console.ReadLine()

       3: while input <> "quit"

       4:     do

       5:     

       6:     if input <> "quit" 

       7:     then

       8:         doSomething input

       9:         Console.Write "\nEnter input:" 

      10:         input <- Console.ReadLine()

Now this just feels dirty! In a functional language explicit loop constructs like a while loop feel wrong. I different way of doing this which is more functional is to create an infinite list of actions. Where each action represents one iteration of any of the above loops. Then you just execute each action until some condition is met (like seeing the input “quit”).

       1: let action = fun _ ->

       2:     Console.Write "\nEnter input: "

       3:     Console.ReadLine()

       4:  

       5: let readlines = Seq.init_infinite (fun _ -> action())

       6:     

       7: let run item = if item = "quit" 

       8:                 then Some(item) 

       9:                 else

      10:                     parse item 

      11:                     None

      12:  

      13: Seq.first run readlines |> ignore

      14: Console.WriteLine "Thanks! Come Again"

This code makes use of the Seq.init_infinite which create a infinite sequence and Seq.first which enumerates the sequence until the passed in function returns Some.

Parameterized State Transformer Monad in F#?

MattManela — Wed, 05 Nov 2008 08:30:29 GMT

I have have been playing around with F# and I decided to create a state monad. This worked out really well since I was able to leverage the F# computation expressions. I then decided to try to extend this and make it more general by creating a parameterized state transformer monad. This is a state monad which encapsulates another monad. What this allow you to do is turn any computation into a statefull one.

This concept exists in Haskell which you can see here. However, my attempts at replicating this in F# failed. Unlike in Haskell, the computation expressions in F# don't share a common interface (or type class). This prevents a computation from being able to generically take another computation as a parameter. The reason is that an operation on the parameterized state transformer monad such as bind will result in a bind called on its encapsulated monad. But since there is no interface for computations there is no bind method to call.

I attempted to fix this by creating my own monad interface but this didn't work:

   1: type Monad =   2:     abstract Bind : 'm * ('a -> 'm) -> 'm   3:     abstract Delay : (unit ->'m) -> 'm   4:     abstract Let : 'a * ('a -> 'm) -> 'm   5:     abstract Return : 'a -> 'm   6:     abstract Zero : unit -> 'm   7:     abstract Combine : 'm -> 'm2 -> 'm3   8:     abstract Run : (unit ->'m) -> 'm

After playing with that and failing I ended up with a less than ideal solution. Given a Maybe monad like below:

   1: // Maybe Monad       2: type MaybeBuilder() =   3:     member b.Return(x) = Some x   4:     member b.Run(f) = f()   5:     member b.Delay(f) = f   6:     member b.Let(p,rest) = rest p   7:     member b.Zero () = None   8:     member b.Combine(m1,dm2) = match m1 with   9:                                  | None -> dm2()  10:                                  | x -> x  11:    12:     member b.Bind(p,rest) = match p with   13:                             | None -> None  14:                             | Some r -> rest r

I created a state transformer monad which take an argument of type m:MaybeBuilder

   1: type StateMBuilder(m:MaybeBuilder) =    2:     member b.Return(x) = fun s -> m.Return (x,s)   3:     member b.Run(f) = fun inp -> (f inp)()   4:     member b.Delay(f) = fun inp -> fun () -> f() inp   5:     member b.Let(p,rest) = rest p   6:     member b.Zero () = fun s -> m.Zero()   7:     member b.Bind(p,rest) = fun s -> m.Bind(p s,fun (v,s2) -> rest v s2)   8:     member b.Combine(p1,dp2) = fun s -> m.Combine(p1 s, dp2 s)   9:    10:     // State specific functions  11:     member b.Update f = fun s -> try m.Return (s, f s) with e -> m.Zero()  12:     member b.Read () = b.Update id  13:     member b.Set t = b.Update (fun _ -> t)

Now although this type is technically parameterized ;) it isn't really the idea since its not generic, it has to be a MaybeBuilder. To use this with a different monad I would need to change m:MaybeBuild to m:SomeOtherMonad.

I am still going to play with this but this is as far as I have gotten.

After all of that here is how you create a state transformer monad parameterized over the maybe monad:

   1: let maybe = MaybeBuilder()   2: let state = StateMBuilder(maybe)

If anyone has an idea how I can make this work I would love to hear it.

I started playing with F#...

MattManela — Fri, 22 Aug 2008 19:23:29 GMT

I decided to do some Project Euler problems using F#.

So here is my first one, Problem # 31. Nothing in this solution really shows off anything special about F# but you have to start somewhere ;)

        1: #light

       2:  

       3: let rec combos amt (denoms:int list) = 

       4:     if amt = 0 then 1

       5:     elif denoms.IsEmpty || amt < 0 then 0

       6:     else 

       7:         combos (amt - denoms.Head) denoms + 

       8:         combos amt denoms.Tail

       9:     

      10:     

      11: printf "\n\nThe Anwer is: %i \n" (combos 200 [200;100;50;20;10;5;2;1])

      12: