### Data Structures

I recently presented a paper on infinite traversals at the Haskell Symposium: A totally predictable outcome: an investigation of traversals of infinite structures. The main result there is a characterization of when a call to `traverse` on an infinite Traversable functor (like an infinite lazy list) yields a non-bottom result. It turns out this is a condition on the Applicative one traverses with that loosely amounts to it having only a single data constructor. What I want to talk about here is how the technique introduced in that paper, which I call "internal guarded recursion" can be used not only in a lightweight formal way to prove characterization theorems or the like, but just in everyday programming as a "back of the envelope" or "streetfighting" hack to quickly figure out when recursive functional programs terminate and when they go into infinite loops.

Let's talk about the basic trick that makes the whole thing work. First, we introduce an abstract newtype for identity, which we will disallow pattern matching against, and instead only allow access to through the structure of an applicative functor.

```
newtype Later a = Later a deriving Functor
instance Applicative Later where
pure = Later
Later f < *> Later x = Later (f x)
```

Next, we introduce the only function allowed to perform recursion:

```
lfix :: (Later a -> a) -> a
lfix f = fix (f . pure)
```

This function has almost the same type signature as the typical fixpoint operator, but it "guards" the argument to the function it is taking the fixedpoint of by our abstract `Later` type constructor.

Now, if you write code that only has recursion via `lfix` and no other function can implicitly or explicitly invoke itself (which the paper refers to as "working in the guarded fragment), your code will never produce a bottom. You can have whatever sorts of recursive Haskell '98 data definitions you like, it doesn't matter! (However, if you have "impredicative" datatypes that pack polymorphic functions into them, I think it would matter... but let's leave that aside). Try, for example, using only this form of recursion, to write a function that produces an infinite list. You'll realize that each recursive step requires using up one `Later` constructor as "fuel". And since there's no way to get an infinite amount of `Later` constructors to begin with, you'll only be able to produce lists of finite depth.

However, we can create related data structures to our existing ones, which "guard" their own recurrence behind a `Later` type constructor as well -- and we can create, consume and manipulate those also, and also do so without risk of writing an expression that produces a bottom. For example, here is the type of possibly infinite lists:

```
data Stream a =
Nil
| Cons a (Later (Stream a)
```

And here is a function that interleaves two such lists:

```
sinterleave :: Stream a -> Stream a -> Stream a
sinterleave = lfix \$ \f s1 s2 -> case s1 of
(Cons x xs) -> Cons x (f < *> pure s2 < *> xs)
_ -> s2
```

Now, I'm going to diverge from the paper and pose a sort of general problem, based on some discussions I had at ICFP. Suppose you have some tricky recursion, possibly involving "tying the knot" and want to show that it terminates, or to figure out under which conditions it terminates -- how can you do that? It turns out that internal guarded recursion can help! Here's the recipe:

1. Write your function using only explicit recursion (via `fix`).
2. Change `fix` to `lfix`
3. Figure out what work you have to do adding applicative operations involving `Later` to fix the types.

The paper has in it a general theorem that says, loosely speaking, that if you have code involving `lfix` and `Later`, and change that back to `fix` and erase all the mucking around with `Later` you get "essentially the same" function, and you still have a guarantee it won't produce bottoms. So this just turns that around -- start with your normal code, and show you can write it even in the guarded fragment, and then that tells you the properties of your original code!

I'll present this approach to reasoning about two tricky but well known problems in functional programming. First, as suggested by Tom Schrijvers as a question at the talk, is the famous "repmin" function introduced by Bird in 1984. This is a program that makes essential use of laziness to traverse a tree only once, but replacing each element in the tree by the minimum element anywhere in the tree. Here's a quick one-liner version, making use of traversal in the writer monad -- it works over any finite traversable structure, including typical trees. But it is perhaps easiest to test it over lists. For now, we'll ignore the issue of what happens with traversals of infinite structures, as that will complicate the example.

```
repMin1 :: (Traversable t, Ord a) => t a -> t a
repMin1 xs =
let (ans,m) = fmap minimum . runWriter \$
traverse (\x -> tell [x] >> pure m) xs in ans
```

Note that this above definition makes use of a recursive definition -- the body of the definition of `(ans,m)` makes use of the `m` being defined. This works because the definition does not pattern match on the m to compute -- otherwise we would bottom out. Using internal guarded recursion, we can let the type system guide us into rewriting our code into a form where it is directly evident that this does not bottom, rather than relying on careful reasoning about semantics. The first step is to mechanically transform the initial definition into one that is exactly the same, but where the implicit recursion has been rendered explicit by use of fix:

```
repMin2 :: (Traversable t, Ord a) => t a -> t a
repMin2 xs =
let res = fix go in fst res
where
go res = fmap minimum . runWriter \$
traverse (\x -> tell [x] >> pure (snd res)) xs
```

The next step is to now replace `fix` by `lfix`. When we do so, the type of `go` will no longer be correct. In particular, its argument, `res` will now be guarded by a `Later`. So we can no longer apply `snd` directly to it, but instead have to `fmap`. The compiler will notice this and yell at us, at which point we make that small tweak as well. In turn, this forces a change to the type signature of the overall function. With that done, everything still checks!

```
repMin3 :: (Traversable t, Ord a) => t a -> t (Later a)
repMin3 xs =
let res = lfix go in fst res
where
go res = fmap minimum . runWriter \$
traverse (\x -> tell [x] >> pure (snd < \$> res)) xs
```

We have now verified that the original `repMin1` function does not bottom out on finite structures. Further, the "one layer" of `Later` in the type of `repMin3` tells us that there was exactly one recursive step invoked in computing the final result!

The astute reader may have noticed a further complication -- to genuinely be in the guarded recursive fragment, we need to make sure all functions in sight have not been written using standard recursion, but only with guarded recursion. But in fact, both `minimum` and `traverse` are going to be written recursively! We limited ourselves to considering finite trees to avoid worrying about this for our example. But let's now briefly consider what happens otherwise. By the results in the paper, we can still use a guarded recursive traverse in the writer monad, which will produce a potentially productive stream of results -- one where there may be arbitrarily many `Later` steps between each result. Further, a guarded recursive `minimum` on such a stream, or even on a necessarily productive `Stream` as given above, will necessarily produce a value that is potentially infinitely delayed. So without grinding out the detailed equational substitution, we can conclude that the type signature we would have to produce in the case of a potentially infinite tree would in fact be: `(Traversable t, Ord a) => t a -> t (Partial a)` -- where a partial value is one that may be delayed behind an arbitrary (including infinite) sequence of `Later`. This in turns tells us that `repMin` on a potentially infinite structure would still produce safely the skeleton of the structure we started with. However, at each individual leaf, the value would potentially be bottom. And, in fact, by standard reasoning (it takes an infinite amount of time to find the minimum of an infinite stream), we can conclude that when `repMin` is run on an infinite structure, then indeed each leaf would be bottom!

We'll now consider one further example, arising from work by Kenneth Foner on fixed points of comonads. In their paper, Foner provides an efficient fixed point operator for comonads with an "apply" operator, but also makes reference to an inefficient version which they believe has the same semantics, and was introduced by Dominic Orchard. This latter operator is extremely simple to define, and so an easy candidate for an example. We'll first recall the methods of comonads, and then introduce Orchard's fixed-point:

```
class Functor w => Comonad w where
extract :: w a -> a
duplicate :: w a -> w (w a)
extend :: (w a -> b) -> w a -> w b

cfix f :: Comonad w => (w a -> a) -> w a
cfix f = fix (extend f)
```

So the question is -- when does cfix not bottom out? To answer this, we again just change `fix` to `lfix` and let the typechecker tells us what goes wrong. We quickly discover that our code no longer typechecks, because `lfix` enforces we are given a `Later (w a)` but the argument to `extend f` needs to be a plain old `w a`. We ask ghc for the type of the intermediate conversion function necessary, and arrive at the following:

```
lcfix :: Comonad w => (Later (w b) -> w a) -> (w a -> b) -> w b
lcfix conv f = lfix (extend f . conv)
```

So we discover that comonad fix will not bottom when we can provide some `conv` function that is "like the identity" (so it erases away when we strip out the mucking about with `Later`) but can send `Later (w a) -> w b`. If we choose to unify `a` and `b`, then this property (of some type to be equipped with an "almost identity" between it and it delayed by a `Later`) is examined in the paper at some length under the name "stability" -- and our conclusion is that cfix will terminate when the type `w a` is stable (which is to say that it in one way or another represents a potentially partial value). Also from the paper, we know that one easy way to get stability is when the type `w` is `Predictable` -- i.e. when it has an "almost identity" map `Later (w a) -> w (Later a)` and when `a` itself is stable. This handles most uses of comonad fix -- since functors of "fixed shape" (otherwise known as representable, or iso to `r -> a` for a fixed `r`) are all stable. And the stability condition on the underlying `a` tells us that even though we'll get out a perfectly good spine, whether or not there will be a bottom value at any given location in the resultant `w a` depends on the precise function being passed in.

In fact, if we simply start with the idea of predictability in hand, we can specialize the above code in a different way, by taking `predict` itself to be our conversion function, and unifying `b` with `Later a`, which yields the following:

```
lcfix2 :: (Comonad w, Predict w) => (w (Later a) -> a) -> w a
lcfix2 f = lfix (extend f . predict)
```

This signature is nice because it does not require stability -- i.e. there is no possibility of partial results. Further, it is particularly suggestive -- it looks almost like that of `lfix` but lifts both the input to the argument and the output of the fixed-point up under a `w`. This warns us how hard it is to get useful values out of fixing a comonad -- in particular, just as with our `lfix` itself, we can't directly pattern match on the values we are taking fixed points of, but instead only use them in constructing larger structures.

These examples illustrate both the power of the internal guarded recursion approach, and also some of its limits. It can tell us a lot of high level information about what does and doesn't produce bottoms, and it can produce conditions under which bottoms will never occur. However, there are also cases where we have code that sometimes bottoms, depending on specific functions it is passed -- the fact that it potentially bottoms is represented in the type, but the exact conditions under which bottoms will or will not occur aren't able to be directly "read off". In fact, in the references to the paper, there are much richer variants of guarded recursion that allow more precision in typing various sorts of recursive functions, and of course there is are general metamathematical barriers to going sufficiently far -- a typing system rich enough to say if any integer function terminates is also rich enough to say if e.g. the collatz conjecture is true or not! But with all those caveats in mind, I think this is still a useful tool that doesn't only have theoretical properties, but also practical use. The next time you have a tricky recursive function that you're pretty sure terminates, try these simple steps: 1) rewrite to use explicit fixed points; 2) change those to guarded recursive fixed points; 3) let ghc guide you in fixing the types; 4) see what you learn!

In the last couple posts I've used some 'free' constructions, and not remarked too much on how they arise. In this post, I'd like to explore them more. This is going to be something of a departure from the previous posts, though, since I'm not going to worry about thinking precisely about bottom/domains. This is more an exercise in applying some category theory to Haskell, "fast and loose".

(Advance note: for some continuous code to look at see this file.)

First, it'll help to talk about how some categories can work in Haskell. For any kind `k` made of `*` and `(->)`,  we can define a category of type constructors. Objects of the category will be first-class  types of that kind, and arrows will be defined by the following type family:

```
newtype Transformer f g = Transform { (\$\$) :: forall i. f i ~> g i }

type family (~>) :: k -> k -> * where
(~>) = (->)
(~>) = Transformer

type a < -> b = (a -> b, b -> a)
type a < ~> b = (a ~> b, b ~> a)
```

So, for a base case, * has monomorphic functions as arrows, and categories for higher kinds have polymorphic functions that saturate the constructor:

```
Int ~> Char = Int -> Char
Maybe ~> [] = forall a. Maybe a -> [a]
Either ~> (,) = forall a b. Either a b -> (a, b)
StateT ~> ReaderT = forall s m a. StateT s m a -> ReaderT s m a
```

We can of course define identity and composition for these, and it will be handy to do so:

```
class Morph (p :: k -> k -> *) where
id :: p a a
(.) :: p b c -> p a b -> p a c

instance Morph (->) where
id x = x
(g . f) x = g (f x)

instance Morph ((~>) :: k -> k -> *)
=> Morph (Transformer :: (i -> k) -> (i -> k) -> *) where
id = Transform id
Transform f . Transform g = Transform \$ f . g
```

These categories can be looked upon as the most basic substrates in Haskell. For instance, every type of kind `* -> *` is an object of the relevant category, even if it's a GADT or has other structure that prevents it from being nicely functorial.

The category for * is of course just the normal category of types and functions we usually call Hask, and it is fairly analogous to the category of sets. One common activity in category theory is to study categories of sets equipped with extra structure, and it turns out we can do this in Haskell, as well. And it even makes some sense to study categories of structures over any of these type categories.

When we equip our types with structure, we often use type classes, so that's how I'll do things here. Classes have a special status socially in that we expect people to only define instances that adhere to certain equational rules. This will take the place of equations that we are not able to state in the Haskell type system, because it doesn't have dependent types. So using classes will allow us to define more structures that we normally would, if only by convention.

So, if we have a kind `k`, then a corresponding structure will be `σ :: k -> Constraint`. We can then define the category `(k,σ)` as having objects `t :: k` such that there is an instance `σ t`. Arrows are then taken to be `f :: t ~> u` such that `f` "respects" the operations of `σ`.

As a simple example, we have:

```
k = *
σ = Monoid :: * -> Constraint

Sum Integer, Product Integer, [Integer] :: (*, Monoid)

f :: (Monoid m, Monoid n) => m -> n
if f mempty = mempty
f (m <> n) = f m <> f n
```

This is just the category of monoids in Haskell.

As a side note, we will sometimes be wanting to quantify over these "categories of structures". There isn't really a good way to package together a kind and a structure such that they work as a unit, but we can just add a constraint to the quantification. So, to quantify over all `Monoid`s, we'll use '`forall m. Monoid m => ...`'.

Now, once we have these categories of structures, there is an obvious forgetful functor back into the unadorned category. We can then look for free and cofree functors as adjoints to this. More symbolically:

```
Forget σ :: (k,σ) -> k
Free   σ :: k -> (k,σ)
Cofree σ :: k -> (k,σ)

Free σ ⊣ Forget σ ⊣ Cofree σ
```

However, what would be nicer (for some purposes) than having to look for these is being able to construct them all systematically, without having to think much about the structure `σ`.

Category theory gives a hint at this, too, in the form of Kan extensions. In category terms they look like:

```  p : C -> C'
f : C -> D
Ran p f : C' -> D
Lan p f : C' -> D

Ran p f c' = end (c : C). Hom_C'(c', p c) ⇒ f c
Lan p f c' = coend (c : c). Hom_C'(p c, c') ⊗ f c
```

where `⇒` is a "power" and `⊗` is a copower, which are like being able to take exponentials and products by sets (or whatever the objects of the hom category are), instead of other objects within the category. Ends and coends are like universal and existential quantifiers (as are limits and colimits, but ends and coends involve mixed-variance).

Some handy theorems relate Kan extensions and adjoint functors:

```  if L ⊣ R
then L = Ran R Id and R = Lan L Id

if Ran R Id exists and is absolute
then Ran R Id ⊣ R

if Lan L Id exists and is absolute
then L ⊣ Lan L Id

Kan P F is absolute iff forall G. (G . Kan P F) ~= Kan P (G . F)
```

It turns out we can write down Kan extensions fairly generally in Haskell. Our restricted case is:

```
p = Forget σ :: (k,σ) -> k
f = Id :: (k,σ) -> (k,σ)

Free   σ = Ran (Forget σ) Id :: k -> (k,σ)
Cofree σ = Lan (Forget σ) Id :: k -> (k,σ)

g :: (k,σ) -> j
g . Free   σ = Ran (Forget σ) g
g . Cofree σ = Lan (Forget σ) g
```

As long as the final category is like one of our type constructor categories, ends are universal quantifiers, powers are function types, coends are existential quantifiers and copowers are product spaces. This only breaks down for our purposes when `g` is contravariant, in which case they are flipped. For higher kinds, these constructions occur point-wise. So, we can break things down into four general cases, each with cases for each arity:

```
newtype Ran0 σ p (f :: k -> *) a =
Ran0 { ran0 :: forall r. σ r => (a ~> p r) -> f r }

newtype Ran1 σ p (f :: k -> j -> *) a b =
Ran1 { ran1 :: forall r. σ r => (a ~> p r) -> f r b }

-- ...

data RanOp0 σ p (f :: k -> *) a =
forall e. σ e => RanOp0 (a ~> p e) (f e)

-- ...

data Lan0 σ p (f :: k -> *) a =
forall e. σ e => Lan0 (p e ~> a) (f e)

data Lan1 σ p (f :: k -> j -> *) a b =
forall e. σ e => Lan1 (p e ~> a) (f e b)

-- ...

data LanOp0 σ p (f :: k -> *) a =
LanOp0 { lan0 :: forall r. σ r => (p r -> a) -> f r }

-- ...
```

The more specific proposed (co)free definitions are:

```
type family Free   :: (k -> Constraint) -> k -> k
type family Cofree :: (k -> Constraint) -> k -> k

newtype Free0 σ a = Free0 { gratis0 :: forall r. σ r => (a ~> r) -> r }
type instance Free = Free0

newtype Free1 σ f a = Free1 { gratis1 :: forall g. σ g => (f ~> g) -> g a }
type instance Free = Free1

-- ...

data Cofree0 σ a = forall e. σ e => Cofree0 (e ~> a) e
type instance Cofree = Cofree0

data Cofree1 σ f a = forall g. σ g => Cofree1 (g ~> f) (g a)
type instance Cofree = Cofree1

-- ...
```

We can define some handly classes and instances for working with these types, several of which generalize existing Haskell concepts:

```
class Covariant (f :: i -> j) where
comap :: (a ~> b) -> (f a ~> f b)

class Contravariant f where
contramap :: (b ~> a) -> (f a ~> f b)

class Covariant m => Monad (m :: i -> i) where
pure :: a ~> m a
join :: m (m a) ~> m a

class Covariant w => Comonad (w :: i -> i) where
extract :: w a ~> a
split :: w a ~> w (w a)

class Couniversal σ f | f -> σ where
couniversal :: σ r => (a ~> r) -> (f a ~> r)

class Universal σ f | f -> σ where
universal :: σ e => (e ~> a) -> (e ~> f a)

instance Covariant (Free0 σ) where
comap f (Free0 e) = Free0 (e . (.f))

pure x = Free0 \$ \k -> k x
join (Free0 e) = Free0 \$ \k -> e \$ \(Free0 e) -> e k

instance Couniversal σ (Free0 σ) where
couniversal h (Free0 e) = e h

-- ...
```

The only unfamiliar classes here should be `(Co)Universal`. They are for witnessing the adjunctions that make `Free σ` the initial `σ` and `Cofree σ` the final `σ` in the relevant way. Only one direction is given, since the opposite is very easy to construct with the (co)monad structure.

`Free σ` is a monad and couniversal, `Cofree σ` is a comonad and universal.

We can now try to convince ourselves that `Free σ` and `Cofree σ` are absolute Here are some examples:

```
free0Absolute0 :: forall g σ a. (Covariant g, σ (Free σ a))
=> g (Free0 σ a) < -> Ran σ Forget g a
free0Absolute0 = (l, r)
where
l :: g (Free σ a) -> Ran σ Forget g a
l g = Ran0 \$ \k -> comap (couniversal \$ remember0 . k) g

r :: Ran σ Forget g a -> g (Free σ a)
r (Ran0 e) = e \$ Forget0 . pure

free0Absolute1 :: forall (g :: * -> * -> *) σ a x. (Covariant g, σ (Free σ a))
=> g (Free0 σ a) x < -> Ran σ Forget g a x
free0Absolute1 = (l, r)
where
l :: g (Free σ a) x -> Ran σ Forget g a x
l g = Ran1 \$ \k -> comap (couniversal \$ remember0 . k) \$\$ g

r :: Ran σ Forget g a x -> g (Free σ a) x
r (Ran1 e) = e \$ Forget0 . pure

free0Absolute0Op :: forall g σ a. (Contravariant g, σ (Free σ a))
=> g (Free0 σ a) < -> RanOp σ Forget g a
free0Absolute0Op = (l, r)
where
l :: g (Free σ a) -> RanOp σ Forget g a
l = RanOp0 \$ Forget0 . pure

r :: RanOp σ Forget g a -> g (Free σ a)
r (RanOp0 h g) = contramap (couniversal \$ remember0 . h) g

-- ...
```

As can be seen, the definitions share a lot of structure. I'm quite confident that with the right building blocks these could be defined once for each of the four types of Kan extensions, with types like:

```
freeAbsolute
:: forall g σ a. (Covariant g, σ (Free σ a))
=> g (Free σ a) < ~> Ran σ Forget g a

cofreeAbsolute
:: forall g σ a. (Covariant g, σ (Cofree σ a))
=> g (Cofree σ a) < ~> Lan σ Forget g a

freeAbsoluteOp
:: forall g σ a. (Contravariant g, σ (Free σ a))
=> g (Free σ a) < ~> RanOp σ Forget g a

cofreeAbsoluteOp
:: forall g σ a. (Contravariant g, σ (Cofree σ a))
=> g (Cofree σ a) < ~> LanOp σ Forget g a
```

However, it seems quite difficult to structure things in a way such that GHC will accept the definitions. I've successfully written `freeAbsolute` using some axioms, but turning those axioms into class definitions and the like seems impossible.

Anyhow, the punchline is that we can prove absoluteness using only the premise that there is a valid `σ` instance for `Free σ` and `Cofree σ`. This tends to be quite easy; we just borrow the structure of the type we are quantifying over. This means that in all these cases, we are justified in saying that `Free σ ⊣ Forget σ ⊣ Cofree σ`, and we have a very generic presentations of (co)free structures in Haskell. So let's look at some.

We've already seen `Free Monoid`, and last time we talked about `Free Applicative`, and its relation to traversals. But, `Applicative` is to traversal as `Functor` is to lens, so it may be interesting to consider constructions on that. Both `Free Functor` and `Cofree Functor` make `Functor`s:

```
instance Functor (Free1 Functor f) where
fmap f (Free1 e) = Free1 \$ fmap f . e

instance Functor (Cofree1 Functor f) where
fmap f (Cofree1 h e) = Cofree1 h (fmap f e)
```

And of course, they are (co)monads, covariant functors and (co)universal among `Functor`s. But, it happens that I know some other types with these properties:

```
data CoYo f a = forall e. CoYo (e -> a) (f e)

instance Covariant CoYo where
comap f = Transform \$ \(CoYo h e) -> CoYo h (f \$\$ e)

pure = Transform \$ CoYo id
join = Transform \$ \(CoYo h (CoYo h' e)) -> CoYo (h . h') e

instance Functor (CoYo f) where
fmap f (CoYo h e) = CoYo (f . h) e

instance Couniversal Functor CoYo where
couniversal tr = Transform \$ \(CoYo h e) -> fmap h (tr \$\$ e)

newtype Yo f a = Yo { oy :: forall r. (a -> r) -> f r }

instance Covariant Yo where
comap f = Transform \$ \(Yo e) -> Yo \$ (f \$\$) . e

extract = Transform \$ \(Yo e) -> e id
split = Transform \$ \(Yo e) -> Yo \$ \k -> Yo \$ \k' -> e \$ k' . k

instance Functor (Yo f) where
fmap f (Yo e) = Yo \$ \k -> e (k . f)

instance Universal Functor Yo where
universal tr = Transform \$ \e -> Yo \$ \k -> tr \$\$ fmap k e
```

These are the types involved in the (co-)Yoneda lemma. `CoYo` is a monad, couniversal among functors, and `CoYo f` is a `Functor`. `Yo` is a comonad, universal among functors, and is always a `Functor`. So, are these equivalent types?

```
coyoIso :: CoYo < ~> Free Functor
coyoIso = (Transform \$ couniversal pure, Transform \$ couniversal pure)

yoIso :: Yo < ~> Cofree Functor
yoIso = (Transform \$ universal extract, Transform \$ universal extract)
```

Indeed they are. And similar identities hold for the contravariant versions of these constructions.

I don't have much of a use for this last example. I suppose to be perfectly precise, I should point out that these uses of `(Co)Yo` are not actually part of the (co-)Yoneda lemma. They are two different constructions. The (co-)Yoneda lemma can be given in terms of Kan extensions as:

```
yoneda :: Ran Id f < ~> f

coyoneda :: Lan Id f < ~> f
```

But, the use of `(Co)Yo` to make `Functor`s out of things that aren't necessarily is properly thought of in other terms. In short, we have some kind of category of Haskell types with only identity arrows---it is discrete. Then any type constructor, even non-functorial ones, is certainly a functor from said category (call it Haskrete) into the normal one (Hask). And there is an inclusion functor from Haskrete into Hask:

```             F
|        /|
|       /
|      /
Incl  |     /
|    /  Ran/Lan Incl F
|   /
|  /
v /
```

So, `(Co)Free Functor` can also be thought of in terms of these Kan extensions involving the discrete category.

To see more fleshed out, loadable versions of the code in this post, see this file. I may also try a similar Agda development at a later date, as it may admit the more general absoluteness constructions easier.

: The reason for restricting ourselves to kinds involving only `*` and `(->)` is that they work much more simply than data kinds. Haskell values can't depend on type-level entities without using type classes. For *, this is natural, but for something like `Bool -> *`, it is more natural for transformations to be able to inspect the booleans, and so should be something more like `forall b. InspectBool b => f b -> g b`.

: First-class types are what you get by removing type families and synonyms from consideration. The reason for doing so is that these can't be used properly as parameters and the like, except in cases where they reduce to some other type that is first-class. For example, if we define:

```
type I a = a
```

even though GHC will report `I :: * -> *`, it is not legal to write `Transform I I`.

Last time I looked at free monoids, and noticed that in Haskell lists don't really cut it. This is a consequence of laziness and general recursion. To model a language with those properties, one needs to use domains and monotone, continuous maps, rather than sets and total functions (a call-by-value language with general recursion would use domains and strict maps instead).

This time I'd like to talk about some other examples of this, and point out how doing so can (perhaps) resolve some disagreements that people have about the specific cases.

The first example is not one that I came up with: induction. It's sometimes said that Haskell does not have inductive types at all, or that we cannot reason about functions on its data types by induction. However, I think this is (techincally) inaccurate. What's true is that we cannot simply pretend that that our types are sets and use the induction principles for sets to reason about Haskell programs. Instead, one has to figure out what inductive domains would be, and what their proof principles are.

Fortunately, there are some papers about doing this. The most recent (that I'm aware of) is Generic Fibrational Induction. I won't get too into the details, but it shows how one can talk about induction in a general setting, where one has a category that roughly corresponds to the type theory/programming language, and a second category of proofs that is 'indexed' by the first category's objects. Importantly, it is not required that the second category is somehow 'part of' the type theory being reasoned about, as is often the case with dependent types, although that is also a special case of their construction.

One of the results of the paper is that this framework can be used to talk about induction principles for types that don't make sense as sets. Specifically:

```
newtype Hyp = Hyp ((Hyp -> Int) -> Int)
```

the type of "hyperfunctions". Instead of interpreting this type as a set, where it would effectively require a set that is isomorphic to the power set of its power set, they interpret it in the category of domains and strict functions mentioned earlier. They then construct the proof category in a similar way as one would for sets, except instead of talking about predicates as subsets, we talk about sub-domains instead. Once this is done, their framework gives a notion of induction for this type.

This example is suitable for ML (and suchlike), due to the strict functions, and sort of breaks the idea that we can really get away with only thinking about sets, even there. Sets are good enough for some simple examples (like flat domains where we don't care about ⊥), but in general we have to generalize induction itself to apply to all types in the 'good' language.

While I haven't worked out how the generic induction would work out for Haskell, I have little doubt that it would, because ML actually contains all of Haskell's data types (and vice versa). So the fact that the framework gives meaning to induction for ML implies that it does so for Haskell. If one wants to know what induction for Haskell's 'lazy naturals' looks like, they can study the ML analogue of:

```
data LNat = Zero | Succ (() -> LNat)
```

because function spaces lift their codomain, and make things 'lazy'.

----

The other example I'd like to talk about hearkens back to the previous article. I explained how `foldMap` is the proper fundamental method of the `Foldable` class, because it can be massaged to look like:

```
foldMap :: Foldable f => f a -> FreeMonoid a
```

and lists are not the free monoid, because they do not work properly for various infinite cases.

I also mentioned that `foldMap` looks a lot like `traverse`:

```
foldMap  :: (Foldable t   , Monoid m)      => (a -> m)   -> t a -> m
traverse :: (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b)
```

And of course, we have `Monoid m => Applicative (Const m)`, and the functions are expected to agree in this way when applicable.

Now, people like to get in arguments about whether traversals are allowed to be infinite. I know Ed Kmett likes to argue that they can be, because he has lots of examples. But, not everyone agrees, and especially people who have papers proving things about traversals tend to side with the finite-only side. I've heard this includes one of the inventors of `Traversable`, Conor McBride.

In my opinion, the above disagreement is just another example of a situation where we have a generic notion instantiated in two different ways, and intuition about one does not quite transfer to the other. If you are working in a language like Agda or Coq (for proving), you will be thinking about traversals in the context of sets and total functions. And there, traversals are finite. But in Haskell, there are infinitary cases to consider, and they should work out all right when thinking about domains instead of sets. But I should probably put forward some argument for this position (and even if I don't need to, it leads somewhere else interesting).

One example that people like to give about finitary traversals is that they can be done via lists. Given a finite traversal, we can traverse to get the elements (using `Const [a]`), traverse the list, then put them back where we got them by traversing again (using `State [a]`). Usually when you see this, though, there's some subtle cheating in relying on the list to be exactly the right length for the second traversal. It will be, because we got it from a traversal of the same structure, but I would expect that proving the function is actually total to be a lot of work. Thus, I'll use this as an excuse to do my own cheating later.

Now, the above uses lists, but why are we using lists when we're in Haskell? We know they're deficient in certain ways. It turns out that we can give a lot of the same relevant structure to the better free monoid type:

```
newtype FM a = FM (forall m. Monoid m => (a -> m) -> m) deriving (Functor)

instance Applicative FM where
pure x = FM (\$ x)
FM ef < *> FM ex = FM \$ \k -> ef \$ \f -> ex \$ \x -> k (f x)

instance Monoid (FM a) where
mempty = FM \$ \_ -> mempty
mappend (FM l) (FM r) = FM \$ \k -> l k <> r k

instance Foldable FM where
foldMap f (FM e) = e f

newtype Ap f b = Ap { unAp :: f b }

instance (Applicative f, Monoid b) => Monoid (Ap f b) where
mempty = Ap \$ pure mempty
mappend (Ap l) (Ap r) = Ap \$ (<>) < \$> l < *> r

instance Traversable FM where
traverse f (FM e) = unAp . e \$ Ap . fmap pure . f
```

So, free monoids are `Monoids` (of course), `Foldable`, and even `Traversable`. At least, we can define something with the right type that wouldn't bother anyone if it were written in a total language with the right features, but in Haskell it happens to allow various infinite things that people don't like.

Now it's time to cheat. First, let's define a function that can take any `Traversable` to our free monoid:

```
toFreeMonoid :: Traversable t => t a -> FM a
toFreeMonoid f = FM \$ \k -> getConst \$ traverse (Const . k) f
```

Now let's define a `Monoid` that's not a monoid:

```
data Cheat a = Empty | Single a | Append (Cheat a) (Cheat a)

instance Monoid (Cheat a) where
mempty = Empty
mappend = Append
```

You may recognize this as the data version of the free monoid from the previous article, where we get the real free monoid by taking a quotient. using this, we can define an `Applicative` that's not valid:

```
newtype Cheating b a =
Cheating { prosper :: Cheat b -> a } deriving (Functor)

instance Applicative (Cheating b) where
pure x = Cheating \$ \_ -> x

Cheating f < *> Cheating x = Cheating \$ \c -> case c of
Append l r -> f l (x r)
```

Given these building blocks, we can define a function to relabel a traversable using a free monoid:

```
relabel :: Traversable t => t a -> FM b -> t b
relabel t (FM m) = propser (traverse (const hope) t) (m Single)
where
hope = Cheating \$ \c -> case c of
Single x -> x
```

And we can implement any traversal by taking a trip through the free monoid:

```
slowTraverse
:: (Applicative f, Traversable t) => (a -> f b) -> t a -> f (t b)
slowTraverse f t = fmap (relabel t) . traverse f . toFreeMonoid \$ t
```

And since we got our free monoid via traversing, all the partiality I hid in the above won't blow up in practice, rather like the case with lists and finite traversals.

Arguably, this is worse cheating. It relies on the exact association structure to work out, rather than just number of elements. The reason is that for infinitary cases, you cannot flatten things out, and there's really no way to detect when you have something infinitary. The finitary traversals have the luxury of being able to reassociate everything to a canonical form, while the infinite cases force us to not do any reassociating at all. So this might be somewhat unsatisfying.

But, what if we didn't have to cheat at all? We can get the free monoid by tweaking `foldMap`, and it looks like `traverse`, so what happens if we do the same manipulation to the latter?

It turns out that lens has a type for this purpose, a slight specialization of which is:

```
newtype Bazaar a b t =
Bazaar { runBazaar :: forall f. Applicative f => (a -> f b) -> f t }
```

Using this type, we can reorder `traverse` to get:

```
howBizarre :: Traversable t => t a -> Bazaar a b (t b)
howBizarre t = Bazaar \$ \k -> traverse k t
```

But now, what do we do with this? And what even is it? 

If we continue drawing on intuition from `Foldable`, we know that `foldMap` is related to the free monoid. `Traversable` has more indexing, and instead of `Monoid` uses `Applicative`. But the latter are actually related to the former; `Applicative`s are monoidal (closed) functors. And it turns out, `Bazaar` has to do with free `Applicative`s.

If we want to construct free `Applicative`s, we can use our universal property encoding trick:

```
newtype Free p f a =
Free { gratis :: forall g. p g => (forall x. f x -> g x) -> g a }
```

This is a higher-order version of the free `p`, where we parameterize over the constraint we want to use to represent structures. So `Free Applicative f` is the free `Applicative` over a type constructor `f`. I'll leave the instances as an exercise.

Since free monoid is a monad, we'd expect `Free p` to be a monad, too. In this case, it is a McBride style indexed monad, as seen in The Kleisli Arrows of Outrageous Fortune.

```
type f ~> g = forall x. f x -> g x

embed :: f ~> Free p f
embed fx = Free \$ \k -> k fx

translate :: (f ~> g) -> Free p f ~> Free p g
translate tr (Free e) = Free \$ \k -> e (k . tr)

collapse :: Free p (Free p f) ~> Free p f
collapse (Free e) = Free \$ \k -> e \$ \(Free e') -> e' k
```

That paper explains how these are related to Atkey style indexed monads:

```
data At key i j where
At :: key -> At key i i

type Atkey m i j a = m (At a j) i

ireturn :: IMonad m => a -> Atkey m i i a
ireturn = ...

ibind :: IMonad m => Atkey m i j a -> (a -> Atkey m j k b) -> Atkey m i k b
ibind = ...
```

It turns out, `Bazaar` is exactly the Atkey indexed monad derived from the `Free Applicative` indexed monad (with some arguments shuffled) :

```
hence :: Bazaar a b t -> Atkey (Free Applicative) t b a
hence bz = Free \$ \tr -> runBazaar bz \$ tr . At

forth :: Atkey (Free Applicative) t b a -> Bazaar a b t
forth fa = Bazaar \$ \g -> gratis fa \$ \(At a) -> g a

imap :: (a -> b) -> Bazaar a i j -> Bazaar b i j
imap f (Bazaar e) = Bazaar \$ \k -> e (k . f)

ipure :: a -> Bazaar a i i
ipure x = Bazaar (\$ x)

(>>>=) :: Bazaar a j i -> (a -> Bazaar b k j) -> Bazaar b k i
Bazaar e >>>= f = Bazaar \$ \k -> e \$ \x -> runBazaar (f x) k

(>==>) :: (s -> Bazaar i o t) -> (i -> Bazaar a b o) -> s -> Bazaar a b t
(f >==> g) x = f x >>>= g
```

As an aside, `Bazaar` is also an (Atkey) indexed comonad, and the one that characterizes traversals, similar to how indexed store characterizes lenses. A `Lens s t a b` is equivalent to a coalgebra `s -> Store a b t`. A traversal is a similar `Bazaar` coalgebra:

```
s -> Bazaar a b t
~
s -> forall f. Applicative f => (a -> f b) -> f t
~
forall f. Applicative f => (a -> f b) -> s -> f t
```

It so happens that Kleisli composition of the Atkey indexed monad above `(>==>)` is traversal composition.

Anyhow, `Bazaar` also inherits `Applicative` structure from `Free Applicative`:

```
instance Functor (Bazaar a b) where
fmap f (Bazaar e) = Bazaar \$ \k -> fmap f (e k)

instance Applicative (Bazaar a b) where
pure x = Bazaar \$ \_ -> pure x
Bazaar ef < *> Bazaar ex = Bazaar \$ \k -> ef k < *> ex k
```

This is actually analogous to the `Monoid` instance for the free monoid; we just delegate to the underlying structure.

The more exciting thing is that we can fold and traverse over the first argument of `Bazaar`, just like we can with the free monoid:

```
bfoldMap :: Monoid m => (a -> m) -> Bazaar a b t -> m
bfoldMap f (Bazaar e) = getConst \$ e (Const . f)

newtype Comp g f a = Comp { getComp :: g (f a) } deriving (Functor)

instance (Applicative f, Applicative g) => Applicative (Comp g f) where
pure = Comp . pure . pure
Comp f < *> Comp x = Comp \$ liftA2 (< *>) f x

btraverse
:: (Applicative f) => (a -> f a') -> Bazaar a b t -> Bazaar a' b t
btraverse f (Bazaar e) = getComp \$ e (c . fmap ipure . f)
```

This is again analogous to the free monoid code. `Comp` is the analogue of `Ap`, and we use `ipure` in `traverse`. I mentioned that `Bazaar` is a comonad:

```
extract :: Bazaar b b t -> t
extract (Bazaar e) = runIdentity \$ e Identity
```

And now we are finally prepared to not cheat:

```
honestTraverse
:: (Applicative f, Traversable t) => (a -> f b) -> t a -> f (t b)
honestTraverse f = fmap extract . btraverse f . howBizarre
```

So, we can traverse by first turning out `Traversable` into some structure that's kind of like the free monoid, except having to do with `Applicative`, traverse that, and then pull a result back out. `Bazaar` retains the information that we're eventually building back the same type of structure, so we don't need any cheating.

To pull this back around to domains, there's nothing about this code to object to if done in a total language. But, if we think about our free `Applicative`-ish structure, in Haskell, it will naturally allow infinitary expressions composed of the `Applicative` operations, just like the free monoid will allow infinitary monoid expressions. And this is okay, because some `Applicative`s can make sense of those, so throwing them away would make the type not free, in the same way that even finite lists are not the free monoid in Haskell. And this, I think, is compelling enough to say that infinite traversals are right for Haskell, just as they are wrong for Agda.

For those who wish to see executable code for all this, I've put a files here and here. The latter also contains some extra goodies at the end that I may talk about in further installments.

 Truth be told, I'm not exactly sure.

 It turns out, you can generalize `Bazaar` to have a correspondence for every choice of `p`

```
newtype Bizarre p a b t =
Bizarre { bizarre :: forall f. p f => (a -> f b) -> f t }
```

`hence` and `forth` above go through with the more general types. This can be seen here.

Consider the humble Applicative. More than a functor, less than a monad. It gives us such lovely syntax. Who among us still prefers to write `liftM2 foo a b` when we could instead write `foo <\$> a <*> b`? But we seldom use the Applicative as such — when Functor is too little, Monad is too much, but a lax monoidal functor is just right. I noticed lately a spate of proper uses of Applicative —Formlets (and their later incarnation in the reform library), OptParse-Applicative (and its competitor library CmdTheLine), and a post by Gergo Erdi on applicatives for declaring dependencies of computations. I also ran into a very similar genuine use for applicatives in working on the Panels library (part of jmacro-rpc), where I wanted to determine dependencies of a dynamically generated dataflow computation. And then, again, I stumbled into an applicative while cooking up a form validation library, which turned out to be a reinvention of the same ideas as formlets.

Given all this, It seems post on thinking with applicatives is in order, showing how to build them up and reason about them. One nice thing about the approach we'll be taking is that it uses a "final" encoding of applicatives, rather than building up and then later interpreting a structure. This is in fact how we typically write monads (pace operational, free, etc.), but since we more often only determine our data structures are applicative after the fact, we often get some extra junk lying around (OptParse-Applicative, for example, has a GADT that I think is entirely extraneous).

So the usual throat clearing:

```{-# LANGUAGE TypeOperators, MultiParamTypeClasses, FlexibleInstances,
StandaloneDeriving, FlexibleContexts, UndecidableInstances,

module Main where
import Control.Applicative hiding (Const)
import Data.Monoid hiding (Sum, Product)
instance Show a => Show (Identity a) where
show (Identity x) = "(Identity " ++ show x ++ ")"```

And now, let's start with a classic applicative, going back to the Applicative Programming With Effects paper:

```data Const mo a = Const mo deriving Show

instance Functor (Const mo) where
fmap _ (Const mo) = Const mo

instance Monoid mo => Applicative (Const mo) where
pure _ = Const mempty
(Const f) < *> (Const x) = Const (f <> x)```

(`Const` lives in transformers as the `Constant` functor, or in base as `Const`)

Note that `Const` is not a monad. We've defined it so that its structure is independent of the `a` type. Hence if we try to write `(>>=) `of type `Const mo a -> (a -> Const mo b) -> Const mo b`, we'll have no way to "get out" the first `a` and feed it to our second argument.

One great thing about Applicatives is that there is no distinction between applicative transformers and applicatives themselves. This is to say that the composition of two applicatives is cleanly and naturally always also an applicative. We can capture this like so:

```
newtype Compose f g a = Compose (f (g a)) deriving Show

instance (Functor f, Functor g) => Functor (Compose f g) where
fmap f (Compose x) = Compose \$ (fmap . fmap) f x

instance (Applicative f, Applicative g) => Applicative (Compose f g) where
pure = Compose . pure . pure
(Compose f) < *> (Compose x) = Compose \$ (< *>) < \$> f < *> x```

(`Compose` also lives in transformers)

Note that Applicatives compose two ways. We can also write:

```data Product f g a = Product (f a) (g a) deriving Show

instance (Functor f, Functor g) => Functor (Product f g) where
fmap f (Product  x y) = Product (fmap f x) (fmap f y)

instance (Applicative f, Applicative g) => Applicative (Product f g) where
pure x = Product (pure x) (pure x)
(Product f g) < *> (Product  x y) = Product (f < *> x) (g < *> y)```

(`Product` lives in transformers as well)

This lets us now construct an extremely rich set of applicative structures from humble beginnings. For example, we can reconstruct the Writer Applicative.

```type Writer mo = Product (Const mo) Identity

tell :: mo -> Writer mo ()
tell x = Product (Const x) (pure ())```
```-- tell  *> tell 
-- > Product (Const [1,2]) (Identity ())```

Note that if we strip away the newtype noise, Writer turns into `(mo,a)` which is isomorphic to the Writer monad. However, we've learned something along the way, which is that the monoidal component of Writer (as long as we stay within the rules of applicative) is entirely independent from the "identity" component. However, if we went on to write the Monad instance for our writer (by defining `>>=`), we'd have to "reach in" to the identity component to grab a value to hand back to the function yielding our monoidal component. Which is to say we would destroy this nice seperation of "trace" and "computational content" afforded by simply taking the product of two Applicatives.

Now let's make things more interesting. It turns out that just as the composition of two applicatives may be a monad, so too the composition of two monads may be no stronger than an applicative!

We'll see this by introducing Maybe into the picture, for possibly failing computations.

```type FailingWriter mo = Compose (Writer mo) Maybe

tellFW :: Monoid mo => mo -> FailingWriter mo ()
tellFW x = Compose (tell x *> pure (Just ()))

failFW :: Monoid mo => FailingWriter mo a
failFW = Compose (pure Nothing)```
```-- tellFW  *> tellFW 
-- > Compose (Product (Const [1,2]) (Identity Just ()))

-- tellFW  *> failFW *> tellFW 
-- > Compose (Product (Const [1,2]) (Identity Nothing))```

Maybe over Writer gives us the same effects we'd get in a Monad — either the entire computation fails, or we get the result and the trace. But Writer over Maybe gives us new behavior. We get the entire trace, even if some computations have failed! This structure, just like Const, cannot be given a proper Monad instance. (In fact if we take Writer over Maybe as a Monad, we get only the trace until the first point of failure).

This seperation of a monoidal trace from computational effects (either entirely independent of a computation [via a product] or independent between parts of a computation [via Compose]) is the key to lots of neat tricks with applicative functors.

Next, let's look at Gergo Erdi's "Static Analysis with Applicatives" that is built using free applicatives. We can get essentially the same behavior directly from the product of a constant monad with an arbitrary effectful monad representing our ambient environment of information. As long as we constrain ourselves to only querying it with the takeEnv function, then we can either read the left side of our product to statically read dependencies, or the right side to actually utilize them.

```type HasEnv k m = Product (Const [k]) m
takeEnv :: (k -> m a) -> k -> HasEnv k m a
takeEnv f x = Product (Const [x]) (f x)```

If we prefer, we can capture queries of a static environment directly with the standard Reader applicative, which is just a newtype over the function arrow. There are other varients of this that perhaps come closer to exactly how Erdi's post does things, but I think this is enough to demonstrate the general idea.

```data Reader r a = Reader (r -> a)
pure x = Reader \$ pure x

takeEnvNew :: (env -> k -> a) -> k -> HasEnv k (Reader env) a
takeEnvNew f x = Product (Const [x]) (Reader \$ flip f x)```

So, what then is a full formlet? It's something that can be executed in one context as a monoid that builds a form, and in another as a parser. so the top level must be a product.

`type FormletOne mo a = Product (Const mo) Identity a`

Below the product, we read from an environment and perhaps get an answer. So that's reader with a maybe.

```type FormletTwo mo env a =
Product (Const mo) (Compose (Reader env) Maybe) a```

Now if we fail, we want to have a trace of errors. So we expand out the Maybe into a product as well to get the following, which adds monoidal errors:

```type FormletThree mo err env a =
Product (Const mo)
(Compose (Reader env) (Product (Const err) Maybe)) a```

But now we get errors whether or not the parse succeeds. We want to say either the parse succeeds or we get errors. For this, we can turn to the typical Sum functor, which currently lives as Coproduct in comonad-transformers, but will hopefully be moving as Sum to the transformers library in short order.

```data Sum f g a = InL (f a) | InR (g a) deriving Show

instance (Functor f, Functor g) => Functor (Sum f g) where
fmap f (InL x) = InL (fmap f x)
fmap f (InR y) = InR (fmap f y)```

The Functor instance is straightforward for Sum, but the applicative instance is puzzling. What should "pure" do? It needs to inject into either the left or the right, so clearly we need some form of "bias" in the instance. What we really need is the capacity to "work in" one side of the sum until compelled to switch over to the other, at which point we're stuck there. If two functors, F and G are in a relationship such that we can always send `f x -> g x` in a way that "respects" fmap (that is to say, such that (`fmap f . fToG == ftoG . fmap f`) then we call this a natural transformation. The action that sends f to g is typically called "eta". (We actually want something slightly stronger called a "monoidal natural transformation" that respects not only the functorial action `fmap` but the applicative action `<*>`, but we can ignore that for now).

Now we can assert that as long as there is a natural transformation between g and f, then Sum f g can be made an Applicative, like so:

```class Natural f g where
eta :: f a -> g a

instance (Applicative f, Applicative g, Natural g f) =>
Applicative (Sum f g) where
pure x = InR \$ pure x
(InL f) < *> (InL x) = InL (f < *> x)
(InR g) < *> (InR y) = InR (g < *> y)
(InL f) < *> (InR x) = InL (f < *> eta x)
(InR g) < *> (InL x) = InL (eta g < *> x)```

The natural transformation we'll tend to use simply sends any functor to Const.

```instance Monoid mo => Natural f (Const mo) where
eta = const (Const mempty)```

However, there are plenty of other natural transformations that we could potentially make use of, like so:

```instance Applicative f =>
Natural g (Compose f g) where
eta = Compose . pure

instance (Applicative g, Functor f) => Natural f (Compose f g) where
eta = Compose . fmap pure

instance (Natural f g) => Natural f (Product f g) where
eta x = Product x (eta x)

instance (Natural g f) => Natural g (Product f g) where
eta x = Product (eta x) x

instance Natural (Product f g) f where
eta (Product x _ ) = x

instance Natural (Product f g) g where
eta (Product _ x) = x

instance Natural g f => Natural (Sum f g) f where
eta (InL x) = x
eta (InR y) = eta y

instance Natural Identity (Reader r) where
eta (Identity x) = pure x```

In theory, there should also be a natural transformation that can be built magically from the product of any other two natural transformations, but that will just confuse the Haskell typechecker hopelessly. This is because we know that often different "paths" of typeclass choices will often be isomorphic, but the compiler has to actually pick one "canonical" composition of natural transformations to compute with, although multiple paths will typically be possible.

For similar reasons of avoiding overlap, we can't both have the terminal homomorphism that sends everything to "Const" and the initial homomorphism that sends "Identity" to anything like so:

```-- instance Applicative g => Natural Identity g where
--     eta (Identity x) = pure x
```

We choose to keep the terminal transformation around because it is more generally useful for our purposes. As the comments below point out, it turns out that a version of "Sum" with the initial transformation baked in now lives in transformers as `Lift`.

In any case we can now write a proper Validation applicative:

```type Validation mo = Sum (Const mo) Identity

validationError :: Monoid mo => mo -> Validation mo a
validationError x = InL (Const x)```

This applicative will yield either a single result, or an accumulation of monoidal errors. It exists on hackage in the Validation package.

Now, based on the same principles, we can produce a full Formlet.

```type Formlet mo err env a =
Product (Const mo)
(Sum (Const err) Identity))
a```

All the type and newtype noise looks a bit ugly, I'll grant. But the idea is to think with structures built with applicatives, which gives guarantees that we're building applicative structures, and furthermore, structures with certain guarantees in terms of which components can be interpreted independently of which others. So, for example, we can strip away the newtype noise and find the following:

`type FormletClean mo err env a = (mo, env -> Either err a)`

Because we built this up from our basic library of applicatives, we also know how to write its applicative instance directly.

Now that we've gotten a basic algebraic vocabulary of applicatives, and especially now that we've produced this nifty Sum applicative (which I haven't seen presented before), we've gotten to where I intended to stop.

But lots of other questions arise, on two axes. First, what other typeclasses beyond applicative do our constructions satisfy? Second, what basic pieces of vocabulary are missing from our constructions — what do we need to add to flesh out our universe of discourse? (Fixpoints come to mind).

Also, what statements can we make about "completeness" — what portion of the space of all applicatives can we enumerate and construct in this way? Finally, why is it that monoids seem to crop up so much in the course of working with Applicatives? I plan to tackle at least some of these questions in future blog posts.

Lenses are a great way to deal with functional references, but there are two common issues that arise from their use.

1. There is a long-standing folklore position that lenses do not support polymorphic updates. This has actually caused a fair bit of embarrassment for the folks who'd like to incorporate lenses in any Haskell record system improvement.
2. Access control. It'd be nice to have read-only or write-only properties -- "one-way" or "mirrored" lenses, as it were. Moreover, lenses are commonly viewed as an all or nothing proposition, in that it is hard to mix them with arbitrary user functions.
3. Finally there is a bit of a cult around trying to generalize lenses by smashing a monad in the middle of them somewhere, it would be nice to be able to get into a list and work with each individual element in it without worrying about someone mucking up our lens laws, and perhaps avoid the whole generalized lens issue entirely.

We'll take a whack at each of these concerns in turn today.
(more...)

Last time, I showed that we can build a small parsec clone with packrat support.

This time I intend to implement packrat directly on top of Parsec 3.

One of the main topics of discussion when it comes to packrat parsing since Bryan Ford's initial release of Pappy has been the fact that in general you shouldn't use packrat to memoize every rule, and that instead you should apply Amdahl's law to look for the cases where the lookup time is paid back in terms of repetitive evaluation, computation time and the hit rate. This is great news for us, since, we only want to memoize a handful of expensive combinators.

You never heard of the Millenium Falcon? It's the ship that made the Kessel Run in 12 parsecs.

I've been working on a parser combinator library called trifecta, and so I decided I'd share some thoughts on parsing.

Packrat parsing (as provided by frisby, pappy, rats! and the Scala parsing combinators) and more traditional recursive descent parsers (like Parsec) are often held up as somehow different.

Today I'll show that you can add monadic parsing to a packrat parser, sacrificing asymptotic guarantees in exchange for the convenient context sensitivity, and conversely how you can easily add packrat parsing to a traditional monadic parser combinator library.

Today I hope to start a new series of posts exploring constructive abstract algebra in Haskell.

In particular, I want to talk about a novel encoding of linear functionals, polynomials and linear maps in Haskell, but first we're going to have to build up some common terminology.

Having obtained the blessing of Wolfgang Jeltsch, I replaced the algebra package on hackage with something... bigger, although still very much a work in progress.

Today, I'll show that we can go one step further and derive a monad transformer from any comonad!

Last time, I said that I was going to put our cheap new free monad to work, so let's give it a shot.

Last time, I started exploring whether or not Codensity was necessary to improve the asymptotic performance of free monads.

This time I'll show that the answer is no; we can get by with something smaller.

A couple of years back Janis Voigtländer wrote a nice paper on how one can use the codensity monad to improve the asymptotic complexity of algorithms using the free monads. He didn't use the name Codensity in the paper, but this is essentially the meaning of his type `C`.

I just returned from running a workshop on domain-specific languages at McMaster University with the more than able assistance of Wren Ng Thornton. Among the many topics covered, I spent a lot of time talking about how to use free monads to build up term languages for various DSLs with simple evaluators, and then made them efficient by using `Codensity`.

This has been shown to be a sufficient tool for this task, but is it necessary?

I've uploaded a package named heaps to Hackage that provides Brodal-Okasaki bootstrapped skew-binomial heaps in Haskell.
(more...)

I gave a talk last night at Boston Haskell on finger trees.

In particular I spent a lot of time focusing on how to derive the construction of Hinze and Paterson's 2-3 finger trees via an extended detour into a whole menagerie of tree types, and less on particular applications of the final resulting structure.

I was asked to give two talks at the Boston Area Haskell User Group for this past Tuesday. The first was pitched at a more introductory level and the second was to go deeper into what I have been using monoids for lately.

The first talk covers an introduction to the mathematical notion of a monoid, introduces some of the features of my Haskell monoids library on hackage, and starts to motivate the use of monoidal parallel/incremental parsing, and the modification use of compression algorithms to recycle monoidal results.

The second talk covers a way to generate a locally-context sensitive parallel/incremental parser by modifying Iteratees to enable them to drive a Parsec 3 lexer, and then wrapping that in a monoid based on error productions in the grammar before recycling these techniques at a higher level to deal with parsing seemingly stateful structures, such as Haskell layout.

Due to a late start, I was unable to give the second talk. However, I did give a quick run through to a few die-hards who stayed late and came to the Cambridge Brewing Company afterwards. As I promised some people that I would post the slides after the talk, here they are.

The current plan is to possibly give the second talk in full at either the September or October Boston Haskell User Group sessions, depending on scheduling and availability.

This post is a bit of a departure from my recent norm. It contains no category theory whatsoever. None. I promise.

Now that I've bored away the math folks, I'll point out that this also isn't a guide to better horticulture. Great, there goes the rest of you.

Instead, I want to talk about Bloom filters, Bloom joins for distributed databases and some novel extensions to them that let you trade in resources that we have in abundance for ones that are scarce, which I've been using for the last few months and which I have never before seen before in print. Primarily because I guess they have little to do with the strengths of Bloom filters.