F# -- excessively lazy sequences and stateful visitors

Doing something a little bit complicated here: the functional equivalent of a visitor pattern, where I want to apply a few functions to a long and potentially expensive to traverse sequence of items (so ruling out a series of iterations over the visited nodes) --

	let ToSeq x =
	seq {yield x}
	let visitor (node:Node) =
	// pattern match on the node type to do visitor stuff
	// use mutable state to record context
	let internal apply (visitors : seq<Node -> unit>) (node : Node) =
	visitors |>
	Seq.iter (fun v -> v node)
	let internal Visit (visitors : seq<Node -> unit>) =
	BuildNodeSequence
	|> Seq.iter (apply visitors)
	...
	Visit (ToSeq visitor)
	...

view raw gistfile1.fs hosted with ❤ by GitHub

BuildNodeSequence itself returns a nested sequence expression of the data to visit, and state is well, expected to be handled by mutable out-of-band means.

This works nicely, but is impure -- so let's try to fix that by having the visitor function update itself with the transient state we need to carry between (there will still be side-effects for output). The code becomes

	type Fix<'T> = delegate of 'T -> Fix<'T>
	let internal invoke (node : Node) (visitor:Fix<Node>) =
	visitor.Invoke(node)
	let internal apply (visitors : seq<Fix<Node>>) (node : Node) =
	visitors |>
	Seq.map (invoke node)
	let internal Visit (visitors : seq<Fix<Node>>) =
	BuildNodeSequence
	|> Seq.fold apply visitors
	|> ignore
	...
	Visit (ToSeq visitor)
	...

view raw gistfile1.fs hosted with ❤ by GitHub

where the Fix delegate type is a way of reifying an otherwise infinite type Node ->'a where 'a is also Node ->'a through

	let StatefulVisitor state node =
	// pattern match on the node type to do visitor stuff
	// use input and returned values to record context
	newState
	let rec stateful state = new Fix<Node> (
	fun (node:Node) ->
	let next = StatefulVisitor state node
	stateful next)
	let visitor (node:Node) =
	stateful initialState

view raw gistfile1.fs hosted with ❤ by GitHub

and have it build

Well, I run this and...

Nothing happens -- or at least apply gets called for every node to visit, but invoke never did; until I forced the evaluation of the visitors sequence by

	let internal apply (visitors : seq<Fix<Node>>) (node : Node) =
	Console.WriteLine(Seq.count visitors) // putting Console.WriteLine(visitors.Count) just echoed the delegate name, which gave me the clue as to a fix...
	visitors |>
	Seq.map (invoke node)

view raw gistfile1.fs hosted with ❤ by GitHub

So, what I finally ended up with is

	let internal apply (visitors : list<Fix<Node>>) (node : Node) =
	visitors |>
	List.map (invoke node)
	let internal Visit (visitors : list<Fix<Node>>) =
	BuildNodeSequence
	|> Seq.fold apply visitors
	|> ignore
	...
	Visit [visitor]
	...

view raw gistfile1.fs hosted with ❤ by GitHub

where the inner iterable is evaluated eagerly, rather than being left to lazy IEnumerable expansion; and this then works.

Links for 18-May

ThinVNC -- HTML5+JSON browser based desktop remoting.

F#:

• F# Project Extender for separating file management in Solution Explorer from controlling compilation order.
• Consuming WPF dependency properties cleanly.

.net4/VS2010:

• The .net 4 StructuralComparisons Type.
• IronPython integration into VS2010.
• VS2010 extension to change colour scheme.

The Windows API code pack for Win7.

NGEN walkthrough series.

Introduction to using git.

An interesting bit of F# behaviour

In one assembly, define a public static class in C#:

	namespace ClassLibrary1
	{
	public static class Class1
	{
	public static string Hello()
	{
	return "Hello";
	}
	}
	}

view raw gistfile1.cs hosted with ❤ by GitHub

In another do something similar in F#:

	namespace ClassLibrary1
	module Module1 =
	let Hello () = "Hello"

view raw gistfile1.fs hosted with ❤ by GitHub

which Reflector tells us is equivalent to

	[CompilationMapping(SourceConstructFlags.Module)]
	public static class Module1
	{
	// Methods
	public static string Hello()
	{
	return "Hello";
	}
	}

view raw gistfile1.cs hosted with ❤ by GitHub

inside namespace ClassLibrary1. Now create another F# library referencing the previous two containing

	namespace ClassLibrary1
	module Module1 =
	let type1 = typeof<ClassLibrary1.Class1>
	let type2 = typeof<ClassLibrary1.Module1>

view raw gistfile1.fs hosted with ❤ by GitHub

The first line compiles; the second doesn't, failing with compile error error FS0039: The type 'Module1' is not defined.

Clearly the CompilationMapping is being sniffed by the typeof operation, because that is the only difference between the two.

No real change here then

Conservative 47.4; Liberal Democrat 34.1; Labour 10.2; Constituency Swing 2.5% From CON to LD since last time (continuing small erosion).

At least the only fascist party standing locally came last -- and the local character and UKIP ejectee standing as an independent came in 4th, narrowly beating UKIP into 5th place out of six.

Whoever emerges from the rest of the shambles will probably be calling in the IMF in a few months, so it makes little difference.