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.
?- 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.
Practice what you learned
1. What is an atom in Prolog primarily used for, distinct from a string?
2. What controls whether "text" is read as a string, code list, or char list in Prolog?
3. What does sub_atom(hello, B, L, A, Sub) do when Sub is bound to 'l' and the rest are unbound?
4. What does atomic_list_concat([player, '_', 42], Atom) produce?
5. Which predicate would you use to split a comma-separated string into a list of substrings?
Was this page helpful?
You May Also Like
Lists in Prolog
Learn how Prolog represents lists as recursive [Head|Tail] structures and how unification lets you construct, deconstruct, and pattern-match them.
Arithmetic in Prolog
Learn how Prolog evaluates arithmetic expressions with is/2, the difference between unification and arithmetic comparison, and common numeric predicates.
Recursive Predicates
Understand how Prolog predicates call themselves to process structures like lists and numbers, and how base cases and recursive cases work together.
Related Reading
Related Study Notes in Programming
Browse all study notesApache Spark Study Notes
Programming · 30 topics
ProgrammingApache Flink Study Notes
Programming · 30 topics
ProgrammingHadoop Study Notes
Programming · 30 topics
ProgrammingSnowflake Study Notes
Programming · 30 topics
ProgrammingApache Airflow Study Notes
Programming · 30 topics
Programmingdbt (Data Build Tool) Study Notes
Programming · 30 topics