The Nerdiest Place on Earth

I’ve added some stuff to my word scrambler.

I added a function that prompts you for each permutation of a word and asks you if it’s valid or not:

CL-USER> (check-word "cat")
Is "cat" a valid word? (I think it's not.) (y/n) y

Is "cta" a valid word? (I think it's not.) (y/n) n

Is "act" a valid word? (I think it's not.) (y/n) y

Is "atc" a valid word? (I think it's not.) (y/n) n

Is "tca" a valid word? (I think it's not.) (y/n) n

Is "tac" a valid word? (I think it's not.) (y/n) y

T
CL-USER>

In the process, it keeps track of valid and invalid words:

CL-USER> *valid-words*
("tac" "act" "cat")
CL-USER> *invalid-words*
("tca" "atc" "cta")
CL-USER>

Then, if I run it again, it “learns” (in a very, very rudimentary way) which words are valid and which aren’t:

CL-USER> (check-word "cat")
Is "cat" a valid word? (I think it is.) (y/n) y

Is "cta" a valid word? (I think it's not.) (y/n) n

Is "act" a valid word? (I think it is.) (y/n) y

Is "atc" a valid word? (I think it's not.) (y/n) n

Is "tca" a valid word? (I think it's not.) (y/n) n

Is "tac" a valid word? (I think it is.) (y/n) y

T
CL-USER>

The obvious missing piece is that the program can’t infer rules based on the facts you give it. I don’t really know how I might make it do that. Here’s the code for what I have so far:

(defparameter *valid-words* nil)
(defparameter *invalid-words* nil)
(defparameter *valid-words-filename* "valid-words.txt")
(defparameter *invalid-words-filename* "invalid-words.txt")

(defun all-permutations (list)
  (cond ((null list) nil)
        ((null (cdr list)) (list list))
        (t (loop for element in list
             append (mapcar (lambda (l) (cons element l))
                            (all-permutations (remove element list)))))))

(defun make-distinct (list)
  (let ((count 0)
        (result nil))
    (dolist (element list)
      (push (list element count) result)
      (incf count))
  (reverse result)))

(defun make-simple (list)
  (let ((result nil))
    (dolist (element list)
      (push (first element) result))
    (reverse result)))

(defun clean-list (list)
  (let ((result nil))
    (dolist (element list)
      (push (list-to-string (make-simple element)) result))
    (reverse result)))

(defun scramble-list (list)
  (clean-list (all-permutations (make-distinct list))))

(defun scramble (string)
  (remove-duplicates
   (scramble-list (loop for char across string collect char))
   :test #'string-equal))

(defun list-to-string (list)
  (concatenate 'string list))

(defun user-thinks-word-is-valid (word)
  (let ((opinion))
    (if (is-valid word)
        (setf opinion "I think it is.")
        (setf opinion "I think it's not."))
  (y-or-n-p (format nil "Is \"~a\" a valid word? (~a)" word opinion))))

(defun check-word (word)
  (dolist (scrambley (scramble word))
    (if (user-thinks-word-is-valid scrambley)
        (push scrambley *valid-words*)
        (push scrambley *invalid-words*)))
  (save-words))

(defun save-words ()
  (save *valid-words-filename* *valid-words*)
  (save *invalid-words-filename* *invalid-words*)
  t)

(defun save (filename expression)
  (with-open-file (out filename :direction :output :if-exists :supersede)
    (with-standard-io-syntax
      (print expression out))))

(defun load-from-file (filename)
  (with-open-file (in filename)
    (with-standard-io-syntax
      (read in))))

(defun load-words ()
  (setf *valid-words* (load-from-file *valid-words-filename*))
  (setf *invalid-words* (load-from-file *invalid-words-filename*)))

(defun is-valid (word)
  (if (find word *valid-words* :test #'string-equal) t))

In a previous post, I said that I’d like to write a program that gives me all the permutations of the letters in a word that spell valid English words. Well, I’ve gotten a significant portion of the way there. I have a function that will take any word and scramble it into all its possible permutations, valid English or not. Here are a few examples:

CL-USER> (scramble "hi")
("hi" "ih")
CL-USER> (scramble "the")
("the" "teh" "hte" "het" "eth" "eht")
CL-USER> (scramble "horse")
("horse" "hores" "hosre" "hoser" "hoers" "hoesr" "hrose" "hroes" "hrsoe"
 "hrseo" "hreos" "hreso" "hsore" "hsoer" "hsroe" "hsreo" "hseor" "hsero"
 "heors" "heosr" "heros" "herso" "hesor" "hesro" "ohrse" "ohres" "ohsre"
 "ohser" "ohers" "ohesr" "orhse" "orhes" "orshe" "orseh" "orehs" "oresh"
 "oshre" "osher" "osrhe" "osreh" "osehr" "oserh" "oehrs" "oehsr" "oerhs"
 "oersh" "oeshr" "oesrh" "rhose" "rhoes" "rhsoe" "rhseo" "rheos" "rheso"
 "rohse" "rohes" "roshe" "roseh" "roehs" "roesh" "rshoe" "rsheo" "rsohe"
 "rsoeh" "rseho" "rseoh" "rehos" "rehso" "reohs" "reosh" "resho" "resoh"
 "shore" "shoer" "shroe" "shreo" "sheor" "shero" "sohre" "soher" "sorhe"
 "soreh" "soehr" "soerh" "srhoe" "srheo" "srohe" "sroeh" "sreho" "sreoh"
 "sehor" "sehro" "seohr" "seorh" "serho" "seroh" "ehors" "ehosr" "ehros"
 "ehrso" "ehsor" "ehsro" "eohrs" "eohsr" "eorhs" "eorsh" "eoshr" "eosrh"
 "erhos" "erhso" "erohs" "erosh" "ersho" "ersoh" "eshor" "eshro" "esohr"
 "esorh" "esrho" "esroh")

Here’s the code:

(defun all-permutations (list)
  (cond ((null list) nil)
        ((null (cdr list)) (list list))
        (t (loop for element in list
             append (mapcar (lambda (l) (cons element l))
                            (all-permutations (remove element list)))))))

(defun make-distinct (list)
  (let ((count 0)
        (result nil))
    (dolist (element list)
      (push (list element count) result)
      (incf count))
  (reverse result)))

(defun make-simple (list)
  (let ((result nil))
    (dolist (element list)
      (push (first element) result))
    (reverse result)))

(defun clean-list (list)
  (let ((result nil))
    (dolist (element list)
      (push (list-to-string (make-simple element)) result))
    (reverse result)))

(defun scramble-list (list)
  (clean-list (all-permutations (make-distinct list))))

(defun scramble (string)
  (scramble-list (loop for char across string collect char)))

(defun list-to-string (list)
  (concatenate 'string list))

The next step will be to make the program generate only valid English words. My initial thought here was that I would program in all the rules for what makes a valid English word. After I thought about that a little bit, though, I realized that I can’t even think of all the rules or even necessarily express what they are. I just know a valid English word when I see it.

For this reason, I thought it might be better to make the computer learn, with human help, what sequences are valid or invalid. This might be done by generating a list, then asking a person which items are valid. Let’s take the output of “apple” as an example:

CL-USER> (scramble "apple")
("apple" "appel" "aplpe" "aplep" "apepl" "apelp" "apple" "appel" "aplpe"
 "aplep" "apepl" "apelp" "alppe" "alpep" "alppe" "alpep" "alepp" "alepp"
 "aeppl" "aeplp" "aeppl" "aeplp" "aelpp" "aelpp" "paple" "papel" "palpe"
 "palep" "paepl" "paelp" "ppale" "ppael" "pplae" "pplea" "ppeal" "ppela"
 "plape" "plaep" "plpae" "plpea" "pleap" "plepa" "peapl" "pealp" "pepal"
 "pepla" "pelap" "pelpa" "paple" "papel" "palpe" "palep" "paepl" "paelp"
 "ppale" "ppael" "pplae" "pplea" "ppeal" "ppela" "plape" "plaep" "plpae"
 "plpea" "pleap" "plepa" "peapl" "pealp" "pepal" "pepla" "pelap" "pelpa"
 "lappe" "lapep" "lappe" "lapep" "laepp" "laepp" "lpape" "lpaep" "lppae"
 "lppea" "lpeap" "lpepa" "lpape" "lpaep" "lppae" "lppea" "lpeap" "lpepa"
 "leapp" "leapp" "lepap" "leppa" "lepap" "leppa" "eappl" "eaplp" "eappl"
 "eaplp" "ealpp" "ealpp" "epapl" "epalp" "eppal" "eppla" "eplap" "eplpa"
 "epapl" "epalp" "eppal" "eppla" "eplap" "eplpa" "elapp" "elapp" "elpap"
 "elppa" "elpap" "elppa")

Since it’s sometimes debatable whether a word could work or not, it would probably be best to ask whether a word is definitely invalid or not, rather than the other way around.

Is “apple” invalid? No. Is “appel” invalid? No. Is “aplpe” invalid? Definitely. But what part of it is invalid? Knowing that it’s invalid isn’t necessarily all that useful to the computer unless we know why it’s invalid.

Maybe the way to go is to keep track of specific instances of invalid words, then see what all those words have in common and form rules based on that. For “aplpe,” the invalid parts are “aplpe,” “aplp,” “plpe,” “apl,” “plp,” “lpe,” “pl,” “lp,”, “p” and “l”. The valid parts are “ap,” “pe” and “a”.

So far, here’s our list of valid words and invalid words:

Valid	Invalid
apple appel ap pe a	aplpe aplp plpe apl lpe pl lp p l

Let’s move on to a slightly more interesting example. One of the permutations of is “peapl,” which is invalid. Add an “e” to the end of that to make “peaple,” though and it’s fine. Let’s see what happens when we apply the foregoing technique to this invalid word:

Invalid parts: eapl, apl, pl, p, l

Valid parts: peap, pea, eap, pe, ea, ap, a

That makes this our new list:

Valid	Invalid
apple appel peap eap pea ap pe a	aplpe aplp eapl plpe apl lpe pl lp p l

I just noticed that I missed something. If we’re dissecting the invalid words and adding the valid and invalid parts to our list, we should be doing the same thing, or at least something similar, with the valid words. But since all parts of a valid word are valid letter sequences, shouldn’t every part of a valid word end up in the “valid” column? What happens if we do this for the word “apple”?

Valid parts: app, ple, ap, le

Invalid parts: appl, pple, ppl, pp, pl

That’s a little disconcerting. What we’ve illustrated here is that valid words can be comprised of invalid letter sequences, as long as some other letters before or after the invalid sequence set things straight again. What’s the difference between the “pl” in “apple” and the “pl” in “peapl“? What’s the difference between the “pp” in “apple” and the “pp” in “ppl”? Well, in those particular cases, “pl” can’t end a word and “pp” can’t be followed by a consonant. The only way to really preserve these distinctions is to keep track of the entire word in the valid/invalid list.

Even though our latest findings make things a little more complicated, they don’t make our valid/invalid list any less true. All the words in the “valid” list are valid and all the ones in the “invalid” list are not. However, just because a word contains something invalid doesn’t mean the entire word is invalid. The only good our list does for us right now is it tells us that if a word exactly matches something on the “invalid” list, it’s not valid. That’s not a terribly comprehensive solution. We’ll have to come up with something better.

More thoughts to come on this in future posts. My brain hurts.

A Google search for “lisp list to string” doesn’t give you anything too helpful, which is kind of weird because it’s really easy.

The CONCATENATE function lets you concatenate any number of items into whatever type of thing you want. Since CONCATENATE is fine with any number of arguments as long as you give it a type, you can pass it just one list, like this:

CL-USER> (concatenate 'string '(#\h #\e #\l #\l #\o))
"hello"

That’s all.

Although I’m no stranger to recursion, it took me a little bit to figure out how to do it in Lisp. Today I decided to see if I could write up a simple example.

I set my sights low for the goal: I want to take a list and print the whole thing, then all but the first item, then all but the first two items, and so on until there’s only one item left. For example, if I had the list (1 2 3 4), the output would look like this:

(1 2 3 4)
(2 3 4)
(3 4)
(4)

With all recursive functions, you need a base case, and the base case here would be that the length of the list is one. The LENGTH function is good for that:

CL-USER> (length (list 1 2 3 4))
4
CL-USER> (length (list 1))
1

That tells us the length of a list, but we aren’t really interested in the length of our list. We don’t need to be that specific. We just want to know whether the list is longer than 1 or not. We can get that with a simple call to the > function:

CL-USER> (> (length (list 1 2 3 4)) 1)
T
CL-USER> (> (length (list 1)) 1)
NIL

To make than easier to grab a hold of, let’s define a function:

CL-USER> (defun longer-than-1 (list)
           (if (> (length list) 1) t))
LONGER-THAN-1
CL-USER> (longer-than-1 (list 1 2 3 4))
T
CL-USER> (longer-than-1 (list 1))
NIL

Now that we have that taken care of, let’s turn our attention to the task of printing the list. To print text, you can use FORMAT like this:

CL-USER> (format t "hello, world")
hello, world
NIL

The same doesn’t quite work for lists, though. If you try to do (format t (list 1 2 3 4)), you’ll get an error. You need the flag ~s, which stands for s-expression, in order to do that:

CL-USER> (format t "~s" (list 1 2 3 4))
(1 2 3 4)
NIL

Now that we have printing and length-figuring-out under control, writing the function that prints a shrinking version of the list isn’t too hard:

(defun show-list (list)
  (format t "~s" list)
  (if (eql (longer-than-1 list) t)
      (show-list (rest list))
      nil))

The first line should look familiar; that’s where we print the list. The rest of the function is just one more function call to IF. If the list is longer than 1, show the rest of the list. Otherwise don’t do anything. Let’s see how it runs:

CL-USER> (show-list (list 1 2 3 4))
(1 2 3 4)(2 3 4)(3 4)(4)
NIL

Pretty good, except it might be nice if there were a newline between each list. We can do that with a ~n, like this:

(format t "~s~%" list)

Now let’s see how it behaves:

CL-USER> (show-list (list 1 2 3 4))
(1 2 3 4)
(2 3 4)
(3 4)
(4)
NIL

That looks just like our original goal, so it looks like we got it right. Here’s the full program:

(defun longer-than-1 (list)
  (if (> (length list) 1) t))

(defun show-list (list)
  (format t "~s~%" list)
  (if (eql (longer-than-1 list) t)
      (show-list (rest list))
      nil))

Although I’m usually of the opinion “the shorter, the better” for functions, I’m not sure that we’re making things any simpler by moving the length test into the LONGER-THAN-1 function. I’m going to bring that logic into the SHOW-LIST function.

(defun show-list (list)
  (format t "~s~%" list)
  (if (> (length list) 1)
      (show-list (rest list))
      nil))

There. That’s definitely shorter and I think it’s actually a little clearer.

In my last post, titled My First Lisp Program, I wrote a simple program that would tell me whether each letter in a word was a consonant or a vowel. The program looked like this:

(defun string-to-list (string)
  (loop for char across string collect char))

(defun is-vowel (char)
  (if (find char "aeiou") t))

(defun letter-type (char)
  (if (is-vowel char) "vowel" "consonant"))

(defun analyze-word (word-string)
  (loop for char across word-string collect (letter-type char)))

Then someone posted a comment saying he might instead write a couple of the functions like this:

(defun letter-type (char)
  (case char ((#\a #\e #\i #\o #\u) :vowel) (t :consonant))

(defun analyze-word (word)
  (map `list `letter-type (string-downcase word)))

This code gives output that’s slightly different and, if I understand what the poster was saying, slightly faster:

CL-USER> (analyze-word "hello")
(:CONSONANT :VOWEL :CONSONANT :CONSONANT :VOWEL)

I’m certainly not concerned with speed here but it’s interesting to see how someone else would have written the same thing differently. I can’t say I fully understand how the CASE function works, I’ve only done seen a couple MAP examples and I my understanding of keys (:vowel and :consonant are keys, as opposed to “vowel” and “consonant” which are strings) is foggy at best. And what are those backticks for?

Conveniently, since Lisp is comprised of s-expressions (covered in this chapter of this book), we can break these functions down and look at their building blocks separately.

LETTER-TYPE and CASE

Let’s look at LETTER-TYPE first:

(defun letter-type (char)
  (case char ((#\a #\e #\i #\o #\u) :vowel) (t :consonant))

This function relies heavily on a function called CASE. Upon closer inspection, it turns out CASE is actually a macro. The CMU page for it says so. They show that the form of the macro is this:

(case keyform
  (keylist-1 consequent-1-1 consequent-1-2 ...)
  (keylist-2 consequent-2-1 ...)
  (keylist-3 consequent-3-1 ...)
  ...)

Do you understand that? I don’t. They don’t give any examples, either, so that doc isn’t all that helpful, at least not to me. Let’s see if we can kind of figure out what’s going on:

(defun letter-type (char)
  (case char ((#\a #\e #\i #\o #\u) :vowel) (t :consonant))

That’s our definition for LETTER-TYPE. Can we pull out the CASE call, replace char with some character, and feed that through the REPL?

CL-USER> (case #\a ((#\a #\e #\i #\o #\u) :vowel) (t :consonant))
:VOWEL

Yes, we can. That’s what you would expect, too. Just to be sure, let’s try a consonant:

CL-USER> (case #\b ((#\a #\e #\i #\o #\u) :vowel) (t :consonant))
:CONSONANT

Yup. If we examine the CASE call, we can see that there are three arguments: #\a, ((#\a #\e #\i #\o #\u) :vowel) and (t :constant).

What is #\a? In my loose understanding, it’s a character, and that’s probably all that’s important for now.

What is ((#\a #\e #\i #\o #\u) :vowel)? It’s a list. The first item is (#\a #\e #\i #\o #\u) and the second item is :vowel. Let’s not analyze it further than that just yet.

What is (t :constant)? That’s a list as well. The first element is t (AKA the constant TRUE) and the second is :consonant.

We already have one CASE example, but let’s see if we can make our own example that might be easier to understand. What about looking for a number in a list of numbers instead of looking for a character in a list of characters?

CL-USER> (case 1 ((list 1 2 3) :yes) (t :no))
:YES

That seems to have the expected output. We’re asking, is 1 in the list 1, 2, 3? It is, so the answer is yes. Let’s try looking for something that’s not there:

CL-USER> (case 5 ((list 1 2 3) :yes) (t :no))
:NO

That’s the expected output as well.

Now that we’re looking at CASE from a couple different angles, it’s a little easier to tell what’s going on. It seems that if the first argument (in the latter case, 5) is found in the first list (1 2 3), the output will be the item inside that form (:yes). Otherwise, it will go on to the next list. I’m guessing that the (t :no) is kind of a catch-all, and if control gets there, :no will always be the output.

CL-USER> (case 1 (t :no))
:NO

That behavior is in-line with that expectation.

Now that we understand the CASE macro better, maybe its form will make more sense.

(case keyform
  (keylist-1 consequent-1-1 consequent-1-2 ...)
  (keylist-2 consequent-2-1 ...)
  (keylist-3 consequent-3-1 ...)
  ...)

It certainly does. In our last numeric example, 5 is the keyform, (list 1 2 3) is keylist-1, :yes is consequent-1-1, t is keylist-2 and :no is consequent-2-1.

There’s something a little funny, though. In the LETTER-TYPE function, the first keylist looked listy, but it wasn’t wrapped in a LIST call. Does CASE accept different types for its keylists or is LIST just not necessary?

CL-USER> (case 1 ((1 2 3) :yes) (t :no))
:YES

It looks like LIST is just not necessary. Our number example works just fine without it.

That demystifies the mysteries of CASE (at least enough for me, for now), and since LETTER-TYPE is mostly just a CASE call, let’s move on to ANALYZE-WORD.

Here’s what the function looks like again:

(defun analyze-word (word)
  (map `list `letter-type (string-downcase word)))

I don’t understand a lot about this function, so let’s start out with the highest-level part of it: MAP.

The MAP Function

Peter Seibel talks about MAP in the Collections chapter of his book. The first example he gives is this:

CL-USER> (map 'vector #'* #(1 2 3 4 5) #(10 9 8 7 6))
#(10 18 24 28 30)

It’s not too hard to tell what’s going on here: each number in the first list got multiplied by its corresponding number in the second list. That weird-looking argument, #'*, is the way you pass functions as arguments in Lisp. If we wanted to use a different function from *, we could:

CL-USER> (map 'vector #'list #(1 2 3 4 5) #(10 9 8 7 6))
#((1 10) (2 9) (3 8) (4 7) (5 6))

The 'vector argument tells MAP that the output should be a vector. We could get a list, instead, if we wanted to:

CL-USER> (map 'list #'* #(1 2 3 4 5) #(10 9 8 7 6))
(10 18 24 28 30)

Just like we did with CASE, let’s pull MAP out and use it by itself. In place of word, we’ll use “hello”:

CL-USER> (map `list `letter-type (string-downcase "hello"))
(:CONSONANT :VOWEL :CONSONANT :CONSONANT :VOWEL)

That works. To make things even simpler, let’s take out the STRING-DOWNCASE call. All that does is makes sure everything’s lower-case.

CL-USER> (map `list `letter-type "hello")
(:CONSONANT :VOWEL :CONSONANT :CONSONANT :VOWEL)

Same thing. Since we now know what the first two parameters MAP expects are, list and letter-type make plenty of sense. The "hello" may seem odd, but we’ll get to that in a second. First, I’m curious: why does this MAP call use backticks when our other one used single quotes? Do they have to be backticks?

CL-USER> (map 'list 'letter-type "hello")
(:CONSONANT :VOWEL :CONSONANT :CONSONANT :VOWEL)

Apparently not. Single quotes work just as well as backticks in this case. Let’s compare our two MAP calls.

Example A:

(map 'vector #'* #(1 2 3 4 5) #(10 9 8 7 6))

Example B:

(map 'list 'letter-type "hello")

Example A has a vector output and Example B has a list output, but that distinction is pretty trivial. What’s more important is the function and vectors being passed. At first, I was confused as to why Example A passed two vectors and Example B only passes one, but it actually makes sense once you think about it: the * function accepts two parameters and LETTER-TYPE takes just one. And a string is just a special vector, as you can see if we do this:

CL-USER> (map 'list 'letter-type #(#\h #\e #\l #\l #\o))
(:CONSONANT :VOWEL :CONSONANT :CONSONANT :VOWEL)

So it looks like one of MAP’s uses is a handy way to apply a single function to each element in a list.

Keys

I don’t feel qualified to explain keys yet, and I can’t find any great explanation online. Perhaps a future exercise will force us to gain an understanding of keys. For this one, they’re not really necessary.

In any case, we learned how to use two new things: CASE and MAP.

Over the last couple weeks or so, I’ve been reading a book called Practical Common Lisp by Peter Seibel. (This excellent book is available on Amazon or online for free.) The book is not about Lisp that’s both practical and common as I assumed when I first read the title, but rather it’s a practical presentation of the language known as Common Lisp. Common List is a popular dialect of the original Lisp language.

Armed with my new Lisp knowledge along with Lisp in a Box, which Seibel walks you through in his REPL chapter, I decided today that I was finally ready to write my first program. Conveniently, I have a real-life problem for which Lisp is probably well-suited to solve.

For weird reasons I don’t feel like explaining, I want to be able to take a person’s name and shuffle the letters around however many times it takes to list all the valid English words that could be made from the letters in that person’s name. For example, the name Pat could spell “pat,” “apt” and “tap,” but not “pta,” atp” or “tpa” because the latter three aren’t valid English words.

At first I thought it wouldn’t be that hard to determine whether or not a word is a valid English word, but then I realized that I don’t even know how I’d explain all the rules to a human. (It looks like the key might be phonotactics, but in any case it’s too much to bite off coming straight from “hello, world.”) So I settled for the next best thing: a program that tells you whether each letter in a word is a consonant or a vowel.

Here’s the code I came up with:

(defun string-to-list (string)
  (loop for char across string collect char))

(defun is-vowel (char)
  (if (find char "aeiou") t))

(defun letter-type (char)
  (if (is-vowel char) "vowel" "consonant"))

(defun analyze-word (word-string)
  (loop for char across word-string collect (letter-type char)))

Let’s go through the reasoning for these functions one-by-one, starting with this one:

(defun string-to-list (string)
  (loop for char across string collect char))

The name Lisp came from LISt Processing, and list processing is something that Lisp is very good at. Since a word is nothing more than a list of letters, I thought it made sense to convert a string into a list of characters to make the string easier for Lisp to deal with. Here, I’m defining function called string-to-list that takes a string as an argument. It goes through the string and adds each character in the string to a list. Here it is in action:

CL-USER> (string-to-list "hello")
(#\h #\e #\l #\l #\o)

Why the pound signs and slashes before each letter? I wish I could tell you. I don’t understand that part yet.

Now that I have my string in a list format that’s easier to deal with, I can do some interesting things with it, like use Lisp’s FIND function to see whether a string contains a certain character:

CL-USER> (find #\h (string-to-list "hello"))
#\h
CL-USER> (find #\q (string-to-list "hello"))
NIL
CL-USER>

The FIND function will return the value of the item of interest if the item is found, or NIL if it’s not found. I decided to use find in a function to tell me whether or not a letter is a vowel:

(defun is-vowel (char)
  (if (find char "aeiou") t))

Let’s see if it works:

CL-USER> (is-vowel #\a)
T
CL-USER> (is-vowel #\b)
NIL
CL-USER> (is-vowel #\u)
T
CL-USER> (is-vowel #\d)
NIL
CL-USER>

Yup. But since T and NIL aren’t very meaningful to the average person, I wrote a more function with more verbose output:

(defun letter-type (char)
  (if (is-vowel char) "vowel" "consonant"))

Pretty simple. Let’s try it out:

CL-USER> (letter-type #\a)
"vowel"
CL-USER> (letter-type #\b)
"consonant"
CL-USER> (letter-type #\c)
"consonant"
CL-USER>

Great. That makes it pretty easy to write the function that tells us whether each letter in a word is a consonant or a vowel. Since we already know how to loop through a string from string-to-list and we have a function that tells us whether a character is a consonant or vowel, we can just put those two ideas together:

(defun analyze-word (word-string)
  (loop for char across word-string collect (letter-type char)))

Let’s try it out with a few words:

CL-USER> (analyze-word "does")
("consonant" "vowel" "vowel" "consonant")
CL-USER> (analyze-word "it")
("vowel" "consonant")
CL-USER> (analyze-word "work")
("consonant" "vowel" "consonant" "consonant")
CL-USER>

Seems to work perfectly. If course, we conveniently avoided the tricky letter y, but that’s beyond the scope of what I’m willing to do with my first Lisp program.

Hopefully my next Lisp example will be more cohesive and informed. I just wanted to see what I could jump right in without really knowing anything. In the meantime, I’m going to keep reading Practical Common Lisp.