\def \newpi{{\pi\mskip -7.8 mu \pi}}

This, when rendered by pdfLaTeX, gives:

Zoomed in, we can see the problems with the symbol. I propose instead that the symbol defined as this should be used:

\newcommand{\cak}{\mathring\pi}

This symbol (rendered here in Zapf’s Euler) displays nicely the idea of pi as a full circle—and it has a nice tie-in with ancient mathematics: Diophantus used M̊ (an M with a ring above it) to represent the unit term in polynomial equations… we can think of pi as the ‘unit’ of angle.

Oh, and the name ‘cak’ is due to apotheon on Reddit, because:

As pi is to pie, so cak is to cake. Cakes are usually somewhere around twice as big as pies (in terms of height/volume), too.

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

Now, a functor is—according to higher sources—something which takes any type to a type . Let’s see how we can accomplish that with our functor, using Haskell code:

data MyFunctor a = Construct a

This is quite simply a type constructor for our functor for any type . For example, we can use it on the Integer type as Construct Integer, which will give us the type MyFunctor Integer.

That’s half the definition of a functor. The other half is that it also converts any function to a function . This means for any function, it converts that function to work on stuff “inside” the functor.

In terms of our Haskell code, this means that we have a function that acts on another function to modify it. This function is usually called “fmap” (for “functor map” or something similar). This function has the type:

fmap :: (a -> b) -> (MyFunctor a -> MyFunctor b)

It takes any function to . Now we can define the function itself. This is the part which will be the most unique for our functor, and we can define it how we like. For our functor, this isn’t going to be very interesting:

fmap f (MyFunctor a) = MyFunctor (f a)

We unwrap the object from our MyFunctor, apply the function , then wrap it back up.

Now there are two laws that must satisfy in order for this to be a “real” functor. In Haskell these are:

(fmap f) . (fmap g) == fmap (f . g)
id . fmap == fmap . id == fmap

These can’t be enforced from “within” Haskell, but you must keep them in mind when writing your functor. If you’d like, you can check that these laws hold for our MyFunctor defined above.

Now we have our entire functor:

data MyFunctor a = Construct a
fmap f (MyFunctor a) = MyFunctor (f a)

…and in fact, Haskell has a built-in class for functors:

class Functor f where
  fmap :: (a -> b) -> (f a -> f b)

We can declare our MyFunctor to be a Functor like this:

instance Functor MyFunctor where
  fmap f (MyFunctor a) = MyFunctor (f a)

…which still doesn’t seem very interesting.

An interesting functor is . This is defined as:

data List a = Empty | Cons a (List a)
 
instance Functor List where
  fmap f (Cons first rest) = Cons (f first) (fmap f rest)
  fmap f Empty = Empty

…wherein the functor takes a type to a list of , and is the familiar map list function, only expressed in a functor context.

data Surreal = Zero | Plus Surreal | Minus Surreal

… which also seems very similar to the usual construction for natural numbers:

data Nat = Zero | Succ Nat

(I noted this in a comment on the original post.)

This got me thinking about how this construction (the sign-expanded version) mapped onto the original construction of the surreal numbers, which uses a left and a right set:

data Surreal = Surreal [Surr] [Surr]

These types translate to the following (in order of appearance):

This last type is suggestive for the natural numbers as well, and of course there is a analogous construction for the naturals:

…which is a set-based construction for the naturals. (Note that in the above formulas multisets are used instead of true sets, but I don’t think this makes a difference in this context.)

Of course this raises the question of what is possible with three sets (or a 3-enum (3-num?)). More on this in another post.