In one of my previous posts, I described an implementation of miniKanren in Haskell. I have since been improving the implementation.

I am currently working on the third iteration of my logic library. The first one was described by my previous post. The second is in a GitHub repository. I have yet to settle on a design that I really like, but I thought I’d post something about what I’ve been working on.

Improvements

The key improvements in the second iteration were the ability to easily add custom data types and the addition of a match function. The custom data type addition was pretty straightforward.

The match function was an attempt to replicated the functionality of the match function in William Byrd’s thesis. I think what I have does the same thing; if not, it still gave me the idea.

The type of my match function is as follows:

match :: ( MonadKanren m, Matchable a, Unifiable b ) => ( a -> m ( LVar b ) ) -> m ( LVar a ) -> m ( LVar b ) match :: (MonadKanren m, Matchable a, Unifiable b) => (a -> m (LVar b)) -> m (LVar a) -> m (LVar b)

Think of the type m (LVar a) as a relational monadic computation that returns a logic variable.

match turns code that looks like this:

logic_append a b ab = do conde [ do ( h, t, res ) <- fresh Cons h t === a Cons h res === ab ab === logic_append t b res , do Nil === a b === ab ] logic_append a b ab = do conde [ do (h, t, res) <- fresh Cons h t === a Cons h res === ab ab === logic_append t b res , do Nil === a b === ab ]

into this:

logic_append a b = match ( logic_append_match b ) a where -- Note that the order of the arguments was swapped logic_append_match b Nil = b logic_append_match b ( Cons x xs ) = conso x ( logic_append xs b ) logic_append a b = match (logic_append_match b) a where -- Note that the order of the arguments was swapped logic_append_match b Nil = b logic_append_match b (Cons x xs) = conso x (logic_append xs b)

It lets me take some advatage of Haskell’s built-in pattern matching and cleans things up quite a bit.

Hey look! I found a Monad!

One of the really interesting things about match that I didn’t notice at first is that it, has a very similar type signature to the monad bind operator: =<<

match :: ( a -> m ( LVar b ) ) -> m ( LVar a ) -> m ( LVar b ) =<< :: ( a -> m b ) -> m a -> m b match :: (a -> m (LVar b)) -> m (LVar a) -> m (LVar b) =<< :: (a -> m b) -> m a -> m b

Is it possible to build a monad around match? It turns out: yes! This is the core idea behind my third iteration, which is starting to look a lot less like miniKanren.

In this implementation, match is implicit in monadic bind >>= . The main interesting consequence of this is that logic variable are abstracted away. A given piece of code in the resulting monad cannot tell the difference between a logic variable and a plain old regular value. And in fact, if it could, that would mess up everything.

I’m still working on fleshing out the implications of this. I honestly don’t know if this is a really cool idea or a really dumb idea. Perhaps both?

The most obvious implication is that it saves a lot of wrapping and unwrapping to convert between logic variables and computations that produce logic variable. Though at first glance it doesn’t look like it grants much more than just some extra syntactic sugar for the ‘match’ function. But…

Laziness

One thing that appears to be a more significant implication is laziness.

In my previous iterations, when I defined customs datatypes to be used by the logic library, I put the logic variables right in the datatype like so:

data List a = Cons ( LVar a ) ( LVar ( List a ) ) | Nil data List a = Cons (LVar a) (LVar (List a)) | Nil

Which worked fine, but it meant that I had to run all the computations that would produce those logic variables before I constructed an instance of my datatype.

In the new system, the list type looks like this:

data List f m = Cons ( m ( f m ) ) ( m ( List f m ) ) | Nil data List f m = Cons (m (f m)) (m (List f m)) | Nil

Which, first of all looks terrible (and I’ll talk more about that later), but secondly it lets me construct my list with just the computation that will produce the logic variable (or maybe just a value) rather than the logic variable itself. The computation is only run when the value is needed.

Going Forward

I’m still not sure if all this is a really cool idea or just a really dumb idea, but I’m learning a ton about relational/logic programming in the process.

My goal for my next iteration is to clean up the super ugly datastructures. Currently a custom datatype in the new system must be a higher-kinded type with higher-kinded parameters, which is not just ugly, but also a real pain. Defining your own datastructures and converting back a forth between the logic and regular variants of a datastructure is currently the biggest pain point in the new system. Fortunately, I think I can fix it.