public static IEnumerable<T> Map<F,T>(Func<F,T> func, IEnumerable<F> source)
{
    return
        from it in source
        select func(it);
}

Actually, it’s trivial to implement without the new syntax (although I’ve left in Func because it’s nicer than defining a separate delegate):

public static IEnumerable<T> Map<F,T>(Func<F,T> func, IEnumerable<F> from)
{
    foreach (F it in from)
        yield return func(it);
}

But why stop at map? We can also define a fold:

public static T FoldL<F, T>(Func<T, F, T> func, IEnumerable<F> source, T init)
{
    T last = init;
    foreach (F it in source)
        last = func(last, it);
    return last;
}

Or the non-empty-list variant. This is made easier through the query operator Skip:

public static T FoldL1<T>(Func<T, T, T> func, IEnumerable<T> source)
{
    T last = source.First();
    foreach (T it in source.Skip(1))
        last = func(last, it);
    return last;
}

Finally, a simple compose operator for sticking two functions together, again using the nicer syntax to make this simple:

public static Func<X,Z> Compose<X,Y,Z>(this Func<Y,Z> second, Func<X,Y> first) {
    return x => second(first(x));
}

Example

A simple example including functionality from each part above (I put everything into an FFC utility class):

int[] numbers = { 1, 2, 3, 4, 5 };
Func<int, int> addOne = n => n + 1;
 
foreach (var k in FFC.Map(addOne, numbers))
    Console.Write(k + " ");
Console.ReadLine();
 
Func<int,int> addTwo = addOne.Compose(addOne);
 
foreach (var k in FFC.Map(addTwo, numbers))
    Console.Write(k + " ");
Console.ReadLine();
 
var sum = FFC.FoldL((x, y) => x + y, numbers, 0);
Console.Write(sum + " ");
Console.ReadLine();

A first attempt

The first thing I thought of was to implement them using an IEnumerable with yield statements, so I began with a construction borrowed from Haskell: the iterate function.

static class FakeLazyList
{
    public static IEnumerable<T> Iterate<T>(Func<T, T> f, T x)
    {
        while (true)
        {
            yield return x;
            x = f(x);
        }
    }
}

While this works (try FakeLazyList.Iterate(i => i + 1, 0)), it is obviously a poor solution; it is not flexible as it requires a seperate function to be written for every incarnation.

Lazy data in general

My next approach was to begin with creating a generic type for lazy data. All it has to do is act as a wrapper for a piece of data. However, since in C# arguments must be evaluated before they are used, the data must in turn be wrapped inside a delegate so that the delegate’s execution can be postponed. This resulted in:

public class Lazy<T> 
{
    public Lazy(Func<T> del)
    {
        Del = del;
    }
    private Func<T> Del;
    private T PValue;
    private bool HasValue = false;
    public static implicit operator T(Lazy<T> f)
    {
        if (!f.HasValue)
        {
            f.PValue = f.Del.Invoke();
            f.HasValue = true;
        }
        return f.PValue;
    }
}

As you can see, execution of the data-bearing delegate is delayed until the lazy data is forced to become normal data.

Implementing the list

For the list implementation itself, I chose to go with the traditional cons list structure, so that each list item has an object of data, and a pointer to the next item in the list. In order to make the list lazy, the next item of the list should be generated only on-access, so it is wrapped in the above Lazy<T> class.

public class LazyList<T> : IEnumerable<T>, IEnumerable
{
    private T _First;
    private Lazy<LazyList<T>> _Rest;
 
    public T First { get { return _First; } }
    public LazyList<T> Rest { get { return _Rest; } }
 
    public LazyList(T first, Lazy<LazyList<T>> rest)
    {
        _First = first; _Rest = rest;
    }

Next comes some boilerplate so that the class can be used as an enumerable structure:

    public IEnumerator<T> GetEnumerator() {
        return new Enumerator(this);
    }
    IEnumerator IEnumerable.GetEnumerator()
    {
        return new Enumerator(this);
    }
 
    private class Enumerator : IEnumerator<T>, IEnumerator
    {
        private LazyList<T> curr = null;
        private LazyList<T> next;
        public Enumerator(LazyList<T> parent)
        {
            next = parent;
        }
        /* must implement both interfaces */
        object IEnumerator.Current { get { return this.Current; } }
        public T Current {
                get {
                    if (curr == null)
                        throw new InvalidOperationException();
                    else
                        return curr._First;
                }
        }
 
        public bool MoveNext() { curr = next; next = next._Rest; return curr != null; }
        public void Reset() { throw new NotSupportedException(); }
        public void Dispose() { return; }
    }

Last of all comes a couple of utility functions for constructing lists, both of which I took from Haskell. The first, iterate, generates a list of items by taking a function f and a datum x and generating the list like this [x,f(x),f(f(x)),f(f(f(x))),...].

    public static LazyList<X> Iterate<X>(Func<X, X> f, X x)
    {
        return new LazyList<X>(x, new Lazy<LazyList<X>>(delegate { return Iterate(f, f(x)); }));
    }

The next takes a datum and generates the infinite list of just that datum:

    public static LazyList<X> Repeat<X>(X x)
    {
        return new LazyList<X>(x, new Lazy<LazyList<X>>(delegate { return Repeat(x); }));
    }
}

As you can see, the usage of the LazyList constructor isn’t the most elegant. I had hoped that I would be able to use an implicit operator on the Lazy class, such as:

public static implicit operator Lazy<T>(Func<T> f)
{
    return new Lazy<T>(f);
}

… and then use it like this …

new LazyList<X>(x, () => Repeat(x));

Unfortunately, this doesn’t work, giving error CS1660. Apparently the C# compiler cannot use the fact that an implicit cast has been defined. Still, this implementation works well.

Usage

The usage of the LazyList in normal code is very simple, and as shown in this example, you can also use the new C# 3.0-defined list operators Take, Drop, Where etc:

IEnumerable<int> ys;
 
// Lazy list of all positive integers
ys = LazyList<int>.Iterate(i => i + 1, 0).Take(20);
foreach (var y in ys) Console.WriteLine(y);
 
//Lazy list of [89, 89, 89, 89, ...]
ys = LazyList<int>.Repeat(89).Take(20);
foreach (var y in ys) Console.WriteLine(y);
 
Console.ReadLine();

First of all we have to have an idea of what the numbers look like. We want to simulate this in XSL:

data Nat = Zero | Succ Nat

Using XSD we can have something like this:

<complexType name="Nat">
    <choice>
        <element name="Zero"/>
        <element name="Succ" type="Nat"/>
    </choice>
</complexType>

(Note that this is not tested, and probably wrong!)

However, since I don’t have an XSLT processor on hand that can deal with XSD types, I had to drop this course of action (although I still used the introduced type for the data). The type gives data like this:

<Succ><Succ><Zero/></Succ></Succ>

…in this case standing for the number two. Now the idea of addition on these numbers is given by a function:

add Zero y = y
add (Succ x) y = Succ (add x y)

Since this function involves pattern-matching it is an ideal candidate for implementation in XSLT, and it looks something like this:

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="2.0" 
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
 
	<!-- apply the add function to two numbers -->
	<xsl:template name="add" match="add">
		<xsl:apply-templates mode="adder" select="*[1]">
			<xsl:with-param name="rest" select="*[2]"/>
		</xsl:apply-templates>
	</xsl:template>
 
	<!-- add Succ(x) y = Succ(add x y) -->
	<xsl:template name="addSucc" mode="adder" match="Succ">
		<xsl:param name="rest"/>
		<Succ>
			<xsl:apply-templates mode="adder">
				<xsl:with-param name="rest" select="$rest"/>
			</xsl:apply-templates>
		</Succ>
	</xsl:template>
 
	<!-- add Zero y = y -->
	<xsl:template name="addZero" mode="adder" match="Zero">
		<xsl:param name="rest"/>
		<xsl:copy-of select="$rest"/>
	</xsl:template>
 
</xsl:stylesheet>

The first template matches any occurances of <add/>, and calls the real ‘add’ function on them. It passes the second number as a parameter, while the first is what the function actually recurses on—exactly as in the Haskell example. The rest proceeds similarly.

You can test it yourself by using the W3C online XSLT processor, which uses my processor and some sample input data. It should work for any similar data that you can throw at it as well. In this case it is adding 2 + 2 and coming up with 4, as we expect

I particularly recommend the (currently ‘in beta’) “stream search results” feature. When you would normally reach the bottom of a page in Google, the extension appends the next page onto the bottom, so you’ll never have to click “next” again!

T[X] = Forall(n : N) Xn / Autn

This is a little much for me, since I don’t understand the symbolism and terminology used in the other 99% of the paper, either! However, as they note that it closely matches the Taylor-series expansion of e^x. I think that using the simple concepts I linked to in the previous post, I can approach a similar definition.

First of all, start with a simple (identity?) type:

F[X] = X

Now, since what we want is a type that when differentiated, gives itself, we should start by integrating:

F[X]  = X2 ÷ 2

As shown in the previous post, we can interpret the division operator as ‘missing information’. In this case, the missing information is a 2-enum stating where the new type element was to be inserted… thus we have a type consisting of two elements, only we don’t know in what order they should appear. If we repeat this process several times, we obtain:

F[X] = X3 ÷ (2×3)
F[X] = X4 ÷ (2×3×4)
F[X] = X5 ÷ (2×3×4×5)

Now we can begin to see a pattern emerging. Each time we integrate the function, we are adding an element to the type, without saying where it should be inserted—in other words, we are creating an unordered set of objects (note that these aren’t true sets, but merely bags: sets which can contain duplicates). Now if we take the literal Taylor expansion of e^x, we can see what it really is as a type:

E[X] = Σ (Xn ÷ n!)

It is either a bag with one element, or a bag with two elements, or a bag with three elements… it is in fact the union of all bag types! That is, the exponential function interpreted as a type, is the type of bags.

If we take integration to be the logical inverse of differentiation (which is defined in the article as ‘removal of an element from a type’, then we have integration as the addition of an element to a type.

For example, take the type of an array of 3 elements of the same type:

F[T] = T3

If we are to add an element to this array, we want to integrate it. This gives us:

F[T] = T4 ÷ 4

Clearly this is not what we expected. If we want to add an element to a 3-element array, we are expecting a 4-element array. However, if we look again at the above result, we can reinterpret it as telling us something: the mere integration of the type is not supplying the expected result; and if we interpret division as ‘without’ (just as addition is ‘or’ and multiplication is ‘and’, then we can understand the result obtained.

What this is in fact telling us is that we need to provide another parameter (an enum in this case), which will give us the required result. In other words (if we do it backwards…:

F[T] = T4 -- wanted
F'[T] = 4.T3 -- needed

In order to obtain a 4-element array, we need a 3-element array and a 4-enum. This makes sense, because if we have a 3-element array:

x y z

…and we wish to add an element ‘w’ to it, we need to know where to insert it. The number of insertion points is:

(1) x (2) y (3) z (4)

…and thus we need to supply a 4-enum to specify exactly where we want the insertion to take place. Once we have done this, we obtain our 4-element array with no ‘missing’ parameters.

foldr getCounts (0,0,0) $ map classify $ concat [[20..30], [490..500], [8120..8130]]

In order to understand what is happening here, one needs to start from the RHS of the expression and then work backwards—much the same as in this snippet of APL:

(∼R∈R∘.×R)/R←1↓⍳R

(See the Wikipedia article on APL for what is happening here.)

In both cases, the code is operating upon a common parameter which is modified by each function in turn. Similarly, there seems to be a rather high-level isomorphism between these kinds of functional code and the concept of Unix pipes:

sort file | uniq -c | sort -n

…with the difference being that in this case, the common parameter is being passed from the left instead of from the right.

Now, in Haskell I can define a new “pipe” operator (| is already taken):

(~>) :: a -> (a->b) -> b
(~>) x f = f x

Which just has the reverse signature to the $ operator, and:

foldr getCounts (0,0,0) $ map classify $ concat [[20..30], [490..500], [8120..8130]]

…becomes…

[[20..30], [490..500], [8120..8130]] ~> concat ~> map classify ~> foldr getCounts (0,0,0)

…which makes it a bit easier to read, at least in my (used-to-Linux) eyes.

I was bored, and it didn’t seem to have been done before, so here’s some Future action in C#.

The Code

using System;
using System.IO;
using System.Reflection;
using System.Threading;
 
public class Future<T> {
        public delegate R FutureDelegate<R>();
        public Future (FutureDelegate<T> del) {
                Del = del;
                Result = del.BeginInvoke(null,null);
        }
        private FutureDelegate<T> Del;
        private IAsyncResult Result;
        private T PValue;
        private bool HasValue = false;
        private T Value {
                get {
                        if (!HasValue) {
                                if (!Result.IsCompleted)
                                        Result.AsyncWaitHandle.WaitOne();
                                PValue = Del.EndInvoke(Result);
                                HasValue = true;
                        }
                        return PValue;
                }
        }
        public static implicit operator T(Future<T> f) {
                return f.Value;
        }
}
 
public static class MainClass {
        //This is purposely wasteful!
        public static ulong Fib(ulong n) {
                if (n > 1) {
                        return Fib(n-1)+Fib(n-2);
                }
                else if (n == 1)
                        return 1;
                else //n == 0
                        return 0;
        }
        //Demo using futures.
        public static void Main(string[] args) {
                Console.WriteLine("First, call synchronously.");
                Console.WriteLine(Fib(40));
                Thread.Sleep(1000);
                Console.WriteLine("Next, call asynchronously.");
                Future<ulong> fib40 = new Future<ulong>(delegate{
                        return Fib(40);
                }); //Begins computing Fib(40) at this point...
                Thread.Sleep(1500);
                Console.WriteLine("Note that we can do other things in the mean time, and that the thread only blocks when we ask for the value.");
                Console.WriteLine(fib40); //Need it now!
                Thread.Sleep(2000);
                Console.WriteLine("We can then ask for the computed value as many times as we like.");
                Console.WriteLine(fib40); //Already computed.
        }
}

Caveats

Most notably, this doesn’t do promise pipelining (and I doubt I could without some compiler magicking), so instead of nesting futures, you’ll want to seperate them out. That is; instead of:

t3 = new Future(delegate{return new Future(delegate{return x.a()}).c(new Future(delegate{return y.b()}))});

…you’ll want to do:

t1 = new Future(delegate{return x.a()});
t2 = new Future(delegate{return y.b()});
t3 = new Future(delegate{return t1.c(t2)});

…although you’d probably want to do this anyway if you don’t want to wander into The LispZone.

Don’t use this method any more! I have a much easier way to do it in a more recent post.

But for posterity…

First install resolvconf and pdnsd: sudo apt-get install pdnsd resolvconf. Resolvconf handles the messy interaction between different programs fighting over the /etc/resolv.conf file, and pdnsd provides a persistent DNS daemon, which will cache the DNS lookups on your machine in order to make browsing faster.

Next, you just need to edit pdnsd’s configuration file, /etc/pdnsd.conf as root. Edit it to look like this:

global {
        perm_cache=512;
        cache_dir="/var/cache/pdnsd";
        max_ttl=604800;
        run_as="pdnsd";
        paranoid=on;
#       next setting allows ppp/ip-up update the name servers -- ABa / 20040213
        status_ctl=on;
        server_port=53;
        server_ip="127.0.0.1";
}

#Edit these to be your own servers if wished:
server {
        label = "OpenDNS";
        ip=208.67.222.222,208.67.220.220;
        proxy_only=on;
        timeout=10;
}

# if you installed resolvconf, and status_ctl=on
server {
    label="resolvconf";
}

source {
        ttl=86400;
        owner="localhost.";
#       serve_aliases=on;
        file="/etc/hosts";
}

And finally, restart pdnsd with sudo /etc/init.d/pdnsd restart to use the new settings. In the example above, I've used OpenDNS's servers, but you can change these to whatever you want. As far as actual results go:

~$ dig example.com

; <<>> DiG 9.3.2 <<>> example.com
;; global options: printcmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 17447
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 0

;; QUESTION SECTION:
;example.com. IN A

;; ANSWER SECTION:
example.com. 172800 IN A 192.0.34.166

;; Query time: 513 msec
;; SERVER: 127.0.0.1#53(127.0.0.1)
;; WHEN: Thu Oct 5 15:24:19 2006
;; MSG SIZE rcvd: 45

$ dig example.com

; <<>> DiG 9.3.2 <<>> example.com
;; global options: printcmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 19338
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 0

;; QUESTION SECTION:
;example.com. IN A

;; ANSWER SECTION:
example.com. 172799 IN A 192.0.34.166

;; Query time: 0 msec
;; SERVER: 127.0.0.1#53(127.0.0.1)
;; WHEN: Thu Oct 5 15:24:20 2006
;; MSG SIZE rcvd: 45


find . -type f -iname '*.mp3' -print0 | xargs -0 mp3gain -r -k

Unfortunately, this seems to have problems with very large collections (I suspect that the command line is being filled up), so here’s what I came up with:

find . -iname '*.mp3' -execdir mp3gain -r -k "{}" \; &

If you’d rather use album normalization (and you have your files separated by album such as “~/Music/David Bowie/Hunky Dory”/):

find . -iname '*.mp3' -execdir mp3gain -r -k -a "{}" + &

How to use it

Simply open a terminal, browse to your music directory (using cd), and type it in.

Break it down

What the command does:

1. find . -iname '*.mp3' finds all MP3 files in the current directory and all subdirectories.
2. -execdir mp3gain -r -k "{}" \; & executes “mp3gain -r -k” on each file (the filename goes where {} is found). The semi-colon indicates to execute the command once per file, but since ; is also a significant character for bash, you need to escape it with a backslash. The final ‘&’ tells bash to run the command in the background.

Attempting to fix this by forcing the install of the 32-bit version of uqm doesn’t work, because for some reason then apt won’t recognise that it is installed and complain that uqm-content has unmet dependencies. So here’s the official recommendation from me:

1. Install uqm normally with the package manager.
2. Download the i386 .debs, extract them and overwrite the binary files from uqm (there are two of them).
3. Install ia32-libs-sdl for the 32-bit versions of the libraries it depends on.

… and it should work perfectly. If you want voice-overs and music (yes!), head to the UQM download page, and download the second two files listed under “Content” (you already have the first). These are in fact just renamed zip files, so unzip them to /usr/share/games/uqm/content/ and you’re good to go.

And the game? Excellent. This is much better than the last game I bought—Civilization IV.

Install command-not-found then add this to your ~/.bashrc:

function command_not_found_handle {
        /usr/bin/command-not-found $1
        return $?
}

And you’re all done:

~$ ssed
The program 'ssed' is currently not installed, you can install it by typing:
sudo apt-get install ssed


This seen outside New World supermarket, Wellington, New Zealand. I’m not sure if the placement is some kind of metaphor.

The thing that’s nice about these Python applications is their extensibility, and not having to restart them for new plugins and suchlike. Now if only they’d automatically check for updates…