String and Atom Manipulation

Analogy categoryAnalogies

Atoms vs Strings vs Character Codes

Atoms are interned, unique symbolic constants, written lowercase or quoted like 'this', used both as identifiers and functor names and as simple text. In SWI-Prolog, double-quoted text like "this" defaults to a first-class string type, a separate, non-atom text type not used as a term functor; older or strictly ISO systems instead default double-quoted text to a list of character codes, integer Unicode/ASCII code points. Which representation "..." actually produces is controlled by the double_quotes Prolog flag, so it is worth checking rather than assuming.

🏏

Cricket analogy: An atom is like a fixed, official player name on a team sheet, kohli, that's interned and reused identically everywhere it appears, while a string is more like a free-form match report sentence that can be built, sliced, and rewritten without being tied to being a fixed identifier.

Converting Between Types

A family of conversion predicates moves text between representations: atom_codes/2 and atom_chars/2 convert an atom to a list of character codes or one-character atoms and back, atom_string/2 converts between an atom and a string, and atom_number/2 parses a number out of an atom's text or formats a number into an atom, which is essential when turning user input or file text into usable numeric values. atomic_list_concat/2 and atomic_list_concat/3 build one atom out of a list of parts and, given a separator, can also split an atom back into parts.

🏏

Cricket analogy: atom_number/2 converting the atom '42' into the number 42 is like a scorer converting a handwritten scorecard entry into an actual countable run total, while atomic_list_concat/3 combining ['kohli','_',42] into 'kohli_42' is like stitching a player's name and shirt number into one printed jersey label.

prolog

?- atom_number('42', N).
N = 42.

?- atom_codes(hello, Codes).
Codes = [104, 101, 108, 108, 111].

?- atomic_list_concat([player, '_', 42], Atom).
Atom = player_42.

?- string_concat("Hello, ", "World!", S).
S = "Hello, World!".

?- split_string("a,b,,c", ",", "", Parts).
Parts = ["a", "b", "", "c"].

Splitting, Concatenating, and Searching Text

split_string/4 splits input text on a set of separator characters and can strip a set of padding characters from each piece in the same call, making it convenient for parsing lightweight delimited formats. sub_atom/5, matched against Atom with Before, Length, After, and Sub, is the general workhorse for substring search and extraction; with Sub bound and the position arguments left unbound, it backtracks through every occurrence of that substring inside Atom, much like append/3 enumerates list splits. atom_concat/3 and string_concat/3 join text and, used with unbound arguments, can likewise split text at every possible point.

🏏

Cricket analogy: sub_atom/5 enumerating every substring of a commentary atom is like a scorer scanning a full innings text for every occurrence of the word 'SIX', backtracking through the whole commentary to find each match's position.

sub_atom(Atom, Before, Length, After, Sub) is fully relational: with Sub bound and the others unbound, it searches for every occurrence of Sub inside Atom on backtracking, making it a compact tool for substring search without writing custom recursion.

Case Conversion and Text Predicates

upcase_atom/2 and downcase_atom/2 (with string_upper/2 and string_lower/2 as their string-type counterparts) perform case transforms; char_type/2 classifies individual characters, for example as alpha, digit, or space, which is useful for validating input; and format/2 builds formatted output by combining a template atom or string containing directives like ~w, ~a, and ~d with a list of values to substitute in, similar to a printf-style formatting function.

🏏

Cricket analogy: upcase_atom/2 converting 'kohli' to 'KOHLI' is like a scoreboard operator switching a player's name display to all caps for the big screen, a purely cosmetic formatting change that doesn't alter who the player is.

In SWI-Prolog, double-quoted text defaults to the string type, a distinct, non-atom type, but this is controlled by the double_quotes Prolog flag and differs from strict ISO or older systems where double quotes default to a list of character codes; always check the flag setting (or your system's default) before assuming what "text" actually represents in a given program.

Atoms are interned symbolic constants used as identifiers and functor names; strings (in SWI-Prolog) are a separate text type for building and slicing text.
The double_quotes flag controls whether "text" is read as a string, a code list, or a char list, and this varies by Prolog system and configuration.
atom_number/2, atom_codes/2, atom_chars/2, and atom_string/2 convert between atoms, numbers, code lists, char lists, and strings.
atomic_list_concat/2-3 both joins parts into one atom and, given a separator, can split an atom into parts.
sub_atom/5 is a fully relational substring predicate that can search for every occurrence of a substring via backtracking.
split_string/4 splits text on separator characters and can also strip padding characters in the same call.
upcase_atom/2, downcase_atom/2, and char_type/2 handle case conversion and character classification.