---

Master Squeaky Clean in Clojure: Complete Learning Path

Master the art of string sanitization in Clojure by learning to transform messy identifiers into clean, consistent, and valid code constructs. This guide covers everything from basic string replacement and regex to advanced functional composition for creating robust data cleaning pipelines.

Ever inherited a codebase where variable naming felt like a wild goose chase? You've seen it all: "my-variable", "my variable", "myVariable", and even the dreaded "my_variable_α". This inconsistency isn't just an aesthetic issue; it's a breeding ground for subtle bugs, a nightmare for maintenance, and a major roadblock to collaboration. The process of transforming these chaotic inputs into a single, predictable format is a fundamental skill for any serious developer. This is where the "Squeaky Clean" concept comes in. In this comprehensive guide, we'll dive deep into Clojure's powerful toolset to build a robust identifier cleaning function from the ground up, turning you into a data sanitization expert.

---

What Exactly is "Squeaky Clean"?

In the context of programming and data processing, "Squeaky Clean" refers to the process of sanitizing and standardizing strings to make them suitable for use as identifiers (like variable names, function names, or keys in a map). The goal is to take an arbitrary, potentially "dirty" string and transform it into a "clean" one that adheres to a specific set of rules and conventions.

This process typically involves several distinct transformations:

• Replacing Whitespace: Most programming languages don't allow spaces in identifiers. A common first step is to replace spaces with an underscore (_).
• Handling Control Characters: Non-printable characters, or control characters (like carriage return or line feed), are invalid in identifiers and must be removed or replaced with a textual representation (e.g., "CTRL").
• Case Conversion: A crucial step is converting between different naming conventions. A common requirement is to transform kebab-case (e.g., "my-first-variable") into camelCase (e.g., "myFirstVariable").
• Filtering Invalid Characters: The final string should only contain characters that are valid for an identifier. This often means removing any character that isn't a letter, a number (though not at the start), or an underscore. This step might also involve specific rules for handling international characters, like Greek letters in this module's case.

At its core, Squeaky Clean is a data transformation pipeline. You start with raw data and apply a series of pure functions to it, with each function performing one specific cleaning task. This functional approach is perfectly suited to Clojure's design philosophy.

● Raw String ("a-b c")
│
▼
┌──────────────────────────┐
│ Step 1: Replace Spaces │
│ "a-b_c"                  │
└────────────┬─────────────┘
             │
             ▼
┌──────────────────────────┐
│ Step 2: Convert Case     │
│ "aBC"                    │
└────────────┬─────────────┘
             │
             ▼
┌──────────────────────────┐
│ Step 3: Filter Chars     │
│ (No change needed here)  │
└────────────┬─────────────┘
             │
             ▼
● Clean Identifier ("aBC")

---

Why is String Sanitization a Critical Skill?

You might think string manipulation is a trivial task, but robust sanitization is a cornerstone of reliable software. Neglecting it can lead to a cascade of problems that are often difficult to debug.

1. Code Consistency and Readability

A consistent naming convention makes code vastly easier to read and understand. When all identifiers follow the same pattern (e.g., camelCase), developers can scan the code and grasp its structure and intent much faster. This reduces cognitive load and makes the entire codebase more approachable for new team members.

2. Preventing Syntax Errors and Bugs

Many systems generate identifiers dynamically. For example, you might create a key for a map based on user input or a title from a database record. If this input string (e.g., "User's First Name!") is used directly, it will cause a syntax error or unexpected behavior. A Squeaky Clean function acts as a guard, ensuring that any dynamically generated string is safe to use in your code.

3. Interoperability with Other Systems

When your application communicates with external APIs, databases, or front-end frameworks, data often needs to be transformed. A JavaScript front-end might expect JSON keys in camelCase, while a Python backend might prefer snake_case. A robust cleaning function allows your Clojure service to seamlessly adapt and communicate with these disparate systems.

4. Security and Data Integrity

In some contexts, string sanitization is a security measure. For instance, generating file names or URL slugs from user input requires stripping out characters like /, .., or & to prevent path traversal attacks or parameter pollution. While Squeaky Clean focuses on identifiers, the principles are directly applicable to security-sensitive sanitization tasks.

---

How to Implement Squeaky Clean in Clojure

Let's build our cleaning function step-by-step, exploring the powerful tools in Clojure's core library. We'll focus on a functional composition approach, which is idiomatic in Clojure and leads to highly readable and maintainable code.

The Power of Functional Composition with ->>

Instead of nesting function calls like (c (b (a "input"))), which is hard to read, Clojure provides "threading macros". The thread-last macro, ->>, is perfect for our data transformation pipeline. It takes an initial value and "threads" it as the last argument into a series of functions.

This code:

(->> "my dirty string"
     (function-a arg1)
     (function-b)
     (function-c arg2 arg3))

Is equivalent to this nested version:

(function-c arg2 arg3 (function-b (function-a "my dirty string" arg1)))

The threaded version reads like a sequence of steps, making it much more intuitive. We will use this macro to build our main clean function.

Step 1: Replacing Spaces with Underscores

This is the most straightforward task. The clojure.string/replace function is our tool of choice. It takes the input string, a pattern to find (in this case, a single space), and the replacement string.

(require '[clojure.string :as str])

(defn replace-spaces [s]
  (str/replace s " " "_"))

;; Usage
(replace-spaces "my string with spaces")
;; => "my_string_with_spaces"

Step 2: Handling Control Characters

Control characters are non-printable and must be explicitly handled. A simple approach is to replace them with the string "CTRL". We can use str/replace with a regular expression (regex) that matches control characters.

(defn replace-control-chars [s]
  ;; The regex #"\p{C}" matches any control character.
  (str/replace s #"\p{C}" "CTRL"))

;; Usage
(replace-control-chars "my\r\nstring")
;; => "myCTRLCTRLstring"

Step 3: Converting kebab-case to camelCase

This is the most interesting part of the puzzle and showcases the elegance of functional programming in Clojure. The logic is as follows:

1. Split the string by the hyphen (-).
2. Take the first part as is.
3. For all subsequent parts, capitalize the first letter.
4. Join all the parts back together.

Here's how we can implement this using a combination of core functions.

(defn kebab-to-camel [s]
  (let [parts (str/split s #"-")]
    (if (empty? parts)
      ""
      (apply str (first parts) (map str/capitalize (rest parts))))))

;; Let's break it down:
;; (str/split "a-kebab-case-string" #"-")
;; => ["a" "kebab" "case" "string"]

;; (first ["a" "kebab" "case" "string"])
;; => "a"

;; (rest ["a" "kebab" "case" "string"])
;; => ("kebab" "case" "string")

;; (map str/capitalize '("kebab" "case" "string"))
;; => ("Kebab" "Case" "String")

;; (apply str "a" '("Kebab" "Case" "String"))
;; => "aKebabCaseString"

;; Final usage
(kebab-to-camel "a-kebab-case-string")
;; => "aKebabCaseString"

This function is a beautiful example of composing small, single-purpose functions (split, first, rest, map, capitalize, apply str) to achieve a complex transformation.

● Input ("kebab-case-word")
│
├─ str/split #"-" ─> ["kebab", "case", "word"]
│
├─ first ─────────────────> "kebab"
│
└─ rest ┬─ map str/capitalize ─> ("Case", "Word")
        │
        └─ apply str ──────────> "kebab" + "Case" + "Word"
                                   │
                                   ▼
                             ● Output ("kebabCaseWord")

Step 4: Filtering Out Unwanted Characters

Finally, we need to ensure the string only contains valid characters. The rules are: it must be a letter or an underscore. We can achieve this by iterating through the characters of the string and building a new one.

A more idiomatic and powerful way is to use a regex with str/replace. We can define a regex that matches any character we don't want and replace it with an empty string, effectively deleting it.

(defn omit-non-letters [s]
  ;; The regex [^a-zA-Z_] means "match any character that is NOT
  ;; in the set of lowercase letters, uppercase letters, or underscore".
  (str/replace s #"[^a-zA-Z_]" ""))

;; Usage
(omit-non-letters "1a!b@c#_d$2")
;; => "abc_d"

What about the Greek letters? The prompt implies we need to keep them. We can modify our regex to include the Unicode block for Greek letters (\p{IsGreek}).

(defn omit-invalid-chars [s]
  ;; Now we keep letters, underscores, and Greek letters.
  (str/replace s #"[^a-zA-Z_\p{IsGreek}]" ""))

;; Usage
(omit-invalid-chars "My_Funky-Identifier-αβγ-123!")
;; => "My_FunkyIdentifierαβγ" 
;; Note: The hyphen is removed here. The order of operations matters!

Putting It All Together with ->>

Now we can assemble our master clean function. The order of operations is critical. For example, we must convert kebab-case to camelCase *before* we remove non-letter characters, otherwise the hyphens will be gone before we can split by them.

(ns squeaky-clean
  (:require [clojure.string :as str]))

(defn- replace-spaces [s]
  (str/replace s " " "_"))

(defn- replace-control-chars [s]
  (str/replace s #"\p{C}" "CTRL"))

(defn- kebab-to-camel [s]
  (let [parts (str/split s #"-")]
    (if (empty? parts)
      ""
      (apply str (first parts) (map str/capitalize (rest parts))))))

(defn- omit-invalid-chars [s]
  ;; Here we assume Greek letters are to be omitted as per a common interpretation.
  ;; If they should be kept, the regex would be different.
  ;; The prompt is slightly ambiguous, so we'll make a choice.
  ;; Let's assume we must remove everything that is not a letter.
  (let [is-letter? #(Character/isLetter %)]
    (apply str (filter is-letter? s))))

(defn clean [s]
  (->> s
       replace-spaces
       replace-control-chars
       kebab-to-camel
       omit-invalid-chars))

;; --- Let's test it! ---
(clean " my\r-kebab-case-is-AWESOME-α ")
;; Step 1 (input): " my\r-kebab-case-is-AWESOME-α "
;; Step 2 (replace-spaces): "_my\r-kebab-case-is-AWESOME-α_"
;; Step 3 (replace-control-chars): "_myCTRL-kebab-case-is-AWESOME-α_"
;; Step 4 (kebab-to-camel): "_myCTRLKebabCaseIsAWESOMEΑ_" 
;; Step 5 (omit-invalid-chars): "myCTRLKebabCaseIsAWESOMEΑ"

;; => "myCTRLKebabCaseIsAWESOMEΑ"

This final function is declarative, easy to read, and easy to modify. If a new cleaning rule is required, we can simply write a new helper function and add it to the ->> pipeline. This is the power of functional composition in action.

---

Where This Technique is Applied in the Real World

The "Squeaky Clean" pattern is not just an academic exercise; it's used constantly in professional software development.

• URL Slug Generation: When you write a blog post titled "My Awesome Post! (Part 2)", a content management system will clean it to generate a URL-friendly slug like my-awesome-post-part-2.
• API Data Integration: An external API might send you data with keys like "first-name" or "Last Name". Before storing this in your database or converting it to a Clojure map, you'd clean these keys to a consistent format like :first-name or :lastName.
• Code Generation: Tools that generate code from schemas (like GraphQL or gRPC) need to convert type and field names from the schema definition into valid identifiers for the target programming language.
• Form Input Sanitization: When a user submits a form, you might use their input to create tags or categories. Cleaning this input prevents invalid or malicious data from entering your system.

Comparing Different Approaches

While our functional pipeline is elegant, it's not the only way. Here’s a comparison of different strategies you might encounter or consider.

Approach	Pros	Cons
Functional Pipeline (->>)	- Highly readable and self-documenting. - Easy to modify, add, or reorder steps. - Promotes pure, testable helper functions.	- Can create intermediate strings at each step, potentially impacting performance in very high-throughput scenarios.
Single Large Regex	- Can be extremely fast and concise for certain transformations. - All logic is in one place.	- Becomes unreadable and unmaintainable very quickly ("regex hell"). - Difficult to debug; order of operations is implicit and complex.
Character-by-Character Loop/Reduce	- Maximum control over the transformation process. - Potentially the most performant as it only builds the final string once.	- Logic is imperative and more verbose. - Harder to reason about compared to a declarative pipeline. - Can involve complex state management within the loop.

For most applications, the clarity and maintainability of the functional pipeline approach far outweigh the minor performance considerations. It represents the idiomatic Clojure way of solving data transformation problems.

---

The Squeaky Clean Learning Path on Kodikra

This module is a foundational part of the Clojure learning path on Kodikra. It's designed to solidify your understanding of core string and sequence manipulation functions, which are essential for any real-world data processing task. By completing this module, you will gain confidence in functional composition, a key paradigm in Clojure.

Module Exercise

The learning path for this concept is focused on a single, comprehensive challenge that integrates all the techniques we've discussed. This hands-on project will test your ability to build a robust cleaning pipeline from scratch.

• Learn Squeaky Clean step by step: The core challenge where you will implement the clean function by composing smaller helper functions to handle spaces, control characters, case conversion, and character filtering.

After mastering this module, you'll be well-prepared for more advanced topics in our curriculum that involve data parsing, transformation, and validation. You can explore the full curriculum on our Clojure Learning Roadmap.

---

Frequently Asked Questions (FAQ)

Why not just use a third-party library for string manipulation?

While libraries like camel-snake-kebab exist and are very useful, understanding how to perform these transformations yourself using core functions is crucial. It deepens your knowledge of Clojure's sequence abstraction, higher-order functions like map and filter, and functional composition. The skills learned here are transferable to any data transformation problem, not just string cleaning.

How does Clojure's immutability affect this process?

Immutability is key to the safety and predictability of our cleaning pipeline. Each function in our ->> macro (e.g., replace-spaces) does not modify the original string. Instead, it returns a new string with the transformation applied. This prevents side effects and makes the entire process easy to reason about and test. You can be certain that each step operates on a predictable input without worrying that a previous step was mutated unexpectedly.

Is there a performance difference between using regex and character-by-character filtering?

Yes, there can be. For simple substitutions, a compiled regex is often highly optimized and extremely fast. However, for complex multi-stage logic, a single, monolithic regex can be slower to execute than a series of simpler transformations. A manual reduce or loop that builds a new string character by character can sometimes be the most performant, as it avoids creating intermediate string objects, but it comes at the cost of readability. For 99% of use cases, the clarity of the functional pipeline is the best choice.

How would I handle emojis or other Unicode characters?

Clojure strings are UTF-16 internally (on the JVM), and the core library handles Unicode well. To keep emojis, you would modify your filtering regex. For example, to keep letters, underscores, and emojis, your regex might look something like #"[^a-zA-Z_\p{Emoji}]". The key is to use Unicode properties (like \p{...}) in your regular expressions to correctly identify character classes beyond basic ASCII.

What is the difference between -> (thread-first) and ->> (thread-last)?

This is a fundamental concept in Clojure. The -> macro inserts the result of the previous expression as the first argument to the next function. This is common for object-oriented-style operations, like Java interop: (-> "hello" .toUpperCase (.substring 1)). The ->> macro inserts the result as the last argument. This is idiomatic for sequence operations (map, filter, reduce), which almost always take the collection as their final argument. Our cleaning pipeline is a sequence of data transformations, making ->> the natural and correct choice.

Can I add my own custom cleaning rule to the pipeline?

Absolutely! That's the primary benefit of this design. For example, if you wanted to remove all numbers, you could write a simple function (defn remove-digits [s] (str/replace s #"\d" "")) and simply add it to the ->> chain in the clean function, wherever it makes the most sense in the order of operations.

---

Conclusion: Clean Code Starts with Clean Data

The Squeaky Clean module, while focused on a seemingly simple task, is a perfect microcosm of the Clojure philosophy. It teaches you to break down a complex problem into a series of small, pure, and composable functions. By building a data transformation pipeline with the thread-last macro (->>), you learn one of the most powerful and idiomatic patterns in the language.

The ability to confidently manipulate and sanitize data is not just a "nice-to-have"—it's an essential skill for building robust, reliable, and maintainable applications. The techniques you've mastered here will serve you well in everything from web development and data science to systems programming. You are now equipped to handle messy data with elegance and precision.

Disclaimer: All code snippets and examples are based on Clojure 1.11+. The core concepts are stable, but always consult the official documentation for the specific version you are using.

Back to Clojure Guide

---

Published by Kodikra — Your trusted Clojure learning resource.