import Control.Monad
import Data.Char
import Data.List

main = do
dict <- buildDictionary
mapM_ printSolution $ findAnagrams "documenting" dict


addOne c xs = xs : zipWith insert (inits xs) (tails xs) where
insert left right = left ++ [c] ++ right

anagrams = foldl (\r x -> concatMap (addOne x) r) [""]

quux(A, B, R) :- R is A + B.

and its use:

40 ?- quux(1, 2, R).
R = 3.

Note: ‘is’ is Prolog’s way of doing math. It’s like = in C.
In C# it might look like:

void quux(int a, int b, out r)
{
r = a + b;
}

For short programs it’s okay, but for larger, more complex ones it can be pretty hard to see what goes where (at least I find it hard since I’m not that experienced with Prolog). Enter Haskell’s do notation. Using do notation the previous example might look like:

R <- quux(1, 2)

What have we done here? We have extracted the out parameter of the quux predicate and put it in front of the call. But how can that be? Won’t quux complain that it’s missing an argument? Here comes the nice part: Prolog, like Lisp, is homoiconic. Also Prolog, like Lisp, has as its main data structure the list. If you squint a little

quux(1, 2, R)

becomes:

(quux, 1, 2, R)

Use space as a separator instead of commas and you have Lisp. So Prolog is homoiconic, whoopy, but what’s that have to do with anything? Well it does, and quite a lot. It means that the language can look at code as data (if you have the time this is a must). Our point of view now changes: quux(1, 2) is not a predicate call anymore, but a list: (quux 1 2). If we add it another element and try to call it Prolog will recognize it as a valid predicate call. But how can we do that? Prolog has a nice set of predefined predicates to support metaprogramming. call is one of them. It is a variadic (it can receive a variable number of arguments) predicate that expects a predicate to call (our (quux 1 2) list in this case) and extra parameters. So

44 ?- call(quux(1, 2), R).
R = 3.

behaves exactly as expected.
Prolog also lets us define new operators, so we can define <- as an operator so we won’t be forced to use call all the time:

:- op(710, xfx, '<-').
'<-'(X, Y) :- call(Y, X).

The snipet above defines <- as an infix operator with a 710 precedence level.
Looking in the neighbour’s back yard I also picked the bind operator (for details on monads read this). Essentially what bind does is thread state. To illustrate it let’s define a new predicate baz that simply writes its parameter:

baz(A) :- write(A).

Using bind (denoted by >>=) we can write:

53 ?- quux(1, 2) >>= baz.
3
true.

and see that it acts as expected. >>= uses a temporary variable to hold the result of quux and passes it to baz. That’s it. Here’s the code:

:- op(705, xfx, '>>=').
'>>='(X, Y) :- call(X, Z), call(Y, Z).
'>>='(X, Y, R) :- call(X, Z), call(Y, Z, R).

As you can see we treat the case where the lastt predicate can have an out parameter separately.
Using >= we can write thing like:

50 ?- R <- quux(1, 2) >>= qux.
R = 4.

assuming that qux looks like:

qux(A, R) :- R is A + 1.

Now, that was useless, but fun :^).

[x..] ; gives [x, x + 1, x + 2 ...]
[x1,x2..] ; gives [x, x + d, x + (2 * d)...], where d = x2 - x1
[x1..xn] ; gives [x, x + 1 ... xn]
[x1,x2..xn] ; gives t[x, x + d, x + (2 * d) ... xn], where d = x2 - x1

Now that we have lazy lists (from the last post) cases like the first and the third are no longer a problem. What about the Haskell-ish syntax I promised? Reader macros to the rescue. Reader macros are Lisp’s way to let the programmer mess with the reader (the reader is a Lisp’s system component that transforms textual representations of objects to actual objects; more on reader macros here). It’s not as hard as it sounds:

(set-macro-character #\[ #'(lambda (s c) (generator s c)))

This tells the Lisp reader to do something whenever it sees the '[' character (in Lisp characters are prefixed with #\ -- that's actually a reader macro, too :) ). In this case it calls (well, the anonymous function denoted by the lambda calls our function, but I won't get into details here) the generator function passing it two parameters: a stream and the matched character (here '['). The function can parse the stream in any way it likes, thus being able to define a completely new syntax.

First of all we need some utility functions:

(defun read-while (stream condition string-builder)
  "Reads characters from a stream pushing them into the string-builder while the condition evaluates to true."
  (setf (fill-pointer string-builder) 0)
  (loop (if (funcall condition (peek-char nil stream))
	    (vector-push-extend (read-char stream) string-builder)
	    (return (> (fill-pointer string-builder) 0)))))

(defun parse-int (stream string-builder)
  "Parses an integer from the stream."
  (peek-char t stream)
  (when (read-while stream #'(lambda (x) (or (digit-char-p x) (eq x #\-))) string-builder)
    (parse-integer string-builder)))

(defmacro when-char (stream char &rest body)
  "Evaluates the body when the next char in the stream is char and consumes it."
  `(when (eq (peek-char t ,stream) ,char)
     (read-char ,stream)
     ,@body))

(defmacro expect (stream char &optional (non-strict nil))
  "If the next char in the stream is char it is consumed, otherwise an error is raised."
  `(if (eq (peek-char ,non-strict ,stream) ,char)
       (read-char ,stream)
       (error "Expecting ~S~%" ,char)))

read-while takes a stream, a predicate and a buffer. It reads characters from the stream while the predicate is fulfilled. It returns true if it has read anything, false otherwise. After a call to read-while the matched string will be stored in the buffer passed (note: this is not necessarily good practice since passing the buffer around is clumsy; the alternative would have been to let read-while allocate the buffer).
parse-int parses an int from the stream. The function uses the built-in parse-integer to do the "heavy lifting". All it does is build a string and pass it to parse-integer.
the when-char macro executes the specified piece of code when the next char in the stream is the specified char.
expect raises an error if the next character in the stream is not the one specified.

It's time for the actual implementation of the generator.

(defun make-stream (start end &optional (step 1))
  "Constructs a stream of numbers within the given range."
  (if (and (not (null end)) (funcall (if (< step 0) #'< #'>) start end))
      '()
      (cons-stream start (make-stream (+ start step) end step))))

(defun generator (stream char)
  (declare (ignore char))
  (let* ((sb (make-array 0 :element-type 'character :fill-pointer 0 :adjustable t))
	 (start (parse-int stream sb)) (end) (step 1))
    (when-char stream #\, (setf step (- (parse-int stream sb) start)))
    (when-char stream #\. (expect stream #\.))

    (setf end (parse-int stream sb))
    (expect stream #\] t)
    `(make-stream ,start ,end ,step)))

First we need a function that constructs an integer stream. make-stream does exactly that. Next we define generator, the function that the reader-macro uses. It parses a generator obeying the syntax described in the beginning of the post and returns a stream of integers.
Finally, to test the generators, we define the well known take function from Haskell:

(defun take (n stream)
  (cond ((endp stream) nil)
	((= n 0) nil)
	(t (cons (car-stream stream) (take (- n 1) (cdr-stream stream))))))

take returns a list made out of the first n elements of the stream.
Some usage examples:

CL-USER> (take 10 [1..])
(1 2 3 4 5 6 7 8 9 10)
CL-USER> (take 10 [1, 3 ..])
(1 3 5 7 9 11 13 15 17 19)
CL-USER> (take 10 [1 .. 5])
(1 2 3 4 5)
CL-USER> (take 10 [1, -1 .. 5])
NIL
CL-USER> (take 10 [1, -1 .. -10])
(1 -1 -3 -5 -7 -9)
CL-USER>

Hope this was not so painful. Btw, can your language do this?

You might have read about Alex’s challenge, but if you didn’t, it was about implementing a counter (a function that returns consecutive values on each call). I’ll show a small implementation in Haskell. (Note: I don’t know Haskell, so beware of poor style, bad explanations and choices or even dragons.)

First, what is Haskell? It’s a pure functional programming language with lazy evaluation, which means that each function always returns the same result when called with the same arguments (i.e. there are no side effects). This could appear shocking (both because of possible prior experience with imperative languages and because of the problems that appear when dealing with IO operations), but Haskell does have a way to solve these issues.

A nice thing about it is it’s type system which provides automatic type inference (when it’s possible), polymorphic types, abstract data types and some other interesting stuff.

A simple program in Haskell is:

module Main where

fact 0 = 1
fact n = n * fact (n – 1)

main = do

putStr “Choose a number: “
line <- getLine
let n = read line
putStrLn $ line ++ “! = ” ++ (show $ fact n)

So.. what’s happening here? We can see a few things:

• the program consists of a module with a few function definitions
• we can use pattern matching for the factorial function (“fact”). The function is written similarly to the mathematical notation and works pretty much the same: the first definition that matches with the argument is chosen. Note that the order of the definitions matters: if you swap the respective lines, the program will keep applying the general rule and never finish.
• the “main” function has some weird syntax: the “do” keyword and the “<-” stuff. For now let’s say only that they are used to simulate imperative programming. Just keep in mind that let is used for giving a name to an expression and the arrow is used when doing things like keyboard input.
• “read line” will parse a string and read an integer value from it (“read” can read many things, but the compiler “sees” that n is used as an integer so it must be an integer value).
• “show” does the opposite: it will convert a value to a string.
• the strange dollar symbol ($) is used; because in Haskell function application has a high priority, “show fact n” would be interpreted as “(show fact) n”, which would be wrong. The dollar operator has a low priority and gives it’s second argument (the one to it’s right) to it’s first one: “show $ fact n” can be written instead of “show (fact n)”.
• the whitespace is important and can replace “;”-like separators (there’s also a mode which uses curly braces and semicolons instead of whitespace).

What about the challenge? When I said that the counter could be written as “[1..]” I skipped a few corners. This beast is, actually, an infinite list of integers starting from one. Because Haskell is a lazy language, it won’t evaluate the entire expression (or list), but only the needed elements. An effect similar to Alex’s counter can be obtained using the following code:

module Main where

import Control.Monad.State

update f = do

x <- get
put (f x)
return x

inc = update (+ 1)

test = evalState $ do

x <- inc
y <- inc
z <- inc
return (x, y, z)

main = print $ test 42

The code uses the State monad (two words that I didn’t say anything about). Since Haskell is pure, it cannot directly represent state, so a solution would be to pass it as an argument to the function, but that’s usually unnerving. In this case, the do notation hides this threaded argument, just like it did IO before. The get and put helpers are used to access the state and my update function replaces the state with the result of a function applied to it and returns the old value. In this case, this function adds one to its argument. Arrows “extract” these values from the function call and use them to build a tuple of three consecutive numbers. Since any function needs an initial state, I use the evalState function to evaluate “test” and return it’s value (I’m not interested in the new counter value at the end of the function). The initial seed it’s 42 and one can see here partial function application (or currying). The evalState function has two arguments, yet “test” only supplies one of them. The result is a function that takes only one arguments and calls evalState with the two gathered values.

Let’s try running it (if you’re really interested, you can use GHC or Hugs to play with this language):

Prelude Main> main
(42,43,44)
Prelude Main> test 7
(7,8,9)
Prelude Main> test 0
(0,1,2)

It seems to be working, so I think one can consider the challenge answered :).

Yet, I’ll give another definition of “update”, as a small teaser:

update = State . ap (,)

Until next time, enjoy :).

(1 2 3)

is internally represented as:

(cons 1 (cons 2 (cons 3 nil)))

Yes, it’s a simply linked list. The value (1, 2, 3, etc) is called car and the next pointer is called cdr. The solution to our problem is, as I already said, simple: to make the list infinite while building it we won’t evaluate cdr, we’ll just promise to do so when it’s really needed. We can do this by using two primitives: delay and force. In Common Lisp they could be implemented like:

(defmacro delay (&rest what)
  `(lambda () ,@what))

(defmacro force (what)
  `(apply ,what ()))

So, using the “lazy” primitives delay to delay evaluation and force to force it we can define the next infinite sequence primitives:

(defmacro cons-stream (x y)
  `(cons ,x (delay ,y)))

(defmacro car-stream (x)
  `(car ,x))

(defmacro cdr-stream (x)
  `(force (cdr ,x)))

More details on lazy lists can be found in the SICP, a great book by the way (section 3.5, they are called streams).

Next time: the actual generator code (finally :) ).

A few days ago I was talking to a friend of mine about Lisp and Haskell (I think the whole discussion started from this). He likes Haskell more than he likes Lisp (actually he finds Lisp unreadable). I like Haskell for being so concise and elegant, but I wouldn’t program in it (actually, to quote myself: “I sometimes find Haskell to be too concise for me”). To get back to the story, I was taunting him with something like:

CL-USER> (defun make-counter (seed) #'(lambda () (setf seed (1+ seed))))
MAKE-COUNTER

For people that don’t know Lisp this code defines a function returning a lambda that closes over it’s only parameter (the initial value of the counter) and returns it’s successor when called. That was clear, right? No? Maybe an example will make things clear:

CL-USER> (setf (symbol-function 'counter) (make-counter 0))
#<CLOSURE (LAMBDA ()) {1003714249}>
CL-USER> (counter)
1
CL-USER> (counter)
2
CL-USER> (counter)
3

For those who don’t know Haskell either (and for whom, I think, this post won’t make much sense) it doesn’t allow side-effects. What does that mean? Well, amongst other things, you can’t modify variables once they are initialised. So you wouldn’t be able to increment seed in a Haskell program (well, actually you can with monads, but that’s another story). His reply was short but eloquent:

[1..]

Yeah, sure, Haskell generators, so elegant and concise. I must admit I was kind of pissed so I foolishly threw the glove: “Lisp can do this too, with reader macros. I will implement Haskell-like generators in Lisp if you implement my example in Haskell”.

Next time: lazy lists in Lisp a.k.a. streams.

That’s it. Let’s get to the first post.