LISP - Merging Strings

Modern String Concatenation in Common Lisp

Common Lisp offers several robust mechanisms for combining, or concatenating, strings. While fundamental, mastering these techniques is key to writing clean and efficient Lisp code. This tutorial covers the standard built-in methods and introduces modern best practices using popular community libraries.

Core Techniques for String Merging

• concatenate: The standard, general-purpose function for joining any kind of sequence, including strings.
• format: A powerful and flexible tool for creating formatted strings from various data types.
• str:concat (Modern Practice): A convenient function from the popular str library, often preferred in modern projects.

Method 1: Using the concatenate Function

The concatenate function is a standard Common Lisp tool for joining sequences. To use it for strings, you must specify 'string as the first argument, indicating the type of the resulting sequence. It can join two or more strings.

Code Example: main.lisp

;; The CONCATENATE function requires the result type as its first argument.
(concatenate 'string "Hello, " "World!" " Welcome to Lisp.")

;; Output:
;; "Hello, World! Welcome to Lisp."

Method 2: Using the format Function

format is Common Lisp’s versatile tool for producing formatted text, similar to printf in C. It uses control directives (like ~a for aesthetic representation or ~s for syntactic representation) to embed values into a string template.

You can direct the output to a stream (like t for standard output) or have it return a new string by using nil as the first argument.

Code Example: main.lisp

;; Using FORMAT to build and return a string (destination is nil).
(let ((name "Alex")
      (language "Common Lisp"))
  (format nil "Hello, ~a! Welcome to the world of ~a." name language))

;; Output:
;; "Hello, Alex! Welcome to the world of Common Lisp."

;; Using FORMAT to print directly to the console (destination is t).
(format t "~%This message is printed directly.")

;; Output to console:
;; This message is printed directly.

Method 3 (Modern Practice): The str Library

For modern Lisp development, many programmers use the str library for its convenience and rich feature set. It provides a simple str:concat function that is often more readable than concatenate for simple string joining.

Development Workflow: Using Quicklisp

To use the str library, you’ll need a package manager like Quicklisp. Here’s the typical workflow:

;; 1. Load Quicklisp (assuming it's already set up).
(ql:quickload "str")

;; 2. Now you can use functions from the library.
(str:concat "Modern " "Lisp " "is " "awesome!")

;; Output:
;; "Modern Lisp is awesome!"

Distinction: Merging vs. Sorting and Merging

It’s important not to confuse string concatenation with sequence merging. The merge function in Common Lisp is used to combine two already sorted sequences into a single sorted sequence, based on a predicate.

Example: Sorting and Merging String Lists

The following example demonstrates how merge works with lists of strings. It does not concatenate them end-to-end, but rather interleaves them based on alphabetical order defined by the string< predicate.

(let ((list1 '("apple" "mango" "peach"))
      (list2 '("banana" "cherry" "orange")))
  (merge 'list list1 list2 #'string<))

;; Output:
;; ("apple" "banana" "cherry" "mango" "orange" "peach")

Best Practices and Summary

• For simple, direct concatenation: Use str:concat in modern projects for readability.
• For embedding values and complex formatting: format is the unparalleled, standard choice.
• For generic sequence joining: concatenate is the low-level, powerful tool to use when you need to be explicit about the sequence type.
• For ordered interleaving: Use merge only when you need to combine sorted sequences, not for simple concatenation.