Mendefinisikan dan Menggunakan Ruang Nama

Imagine building a large application with many files and functions. Without organization, you might accidentally use the same name for different things, leading to confusion and errors.

Namespaces in Clojure help you organize your code into logical groups, preventing these naming conflicts and making your projects easier to manage.

Every Clojure source file starts with a ns declaration. This macro defines the namespace for the code within that file. It usually matches the file's path.

For example, a file named src/my_app/core.clj would typically declare my-app.core as its namespace.

Clojure namespaces follow a hierarchical structure, much like Java packages or file paths. They typically use kebab-case (hyphens) for names.

• my-project.core: The main entry point or core utilities.
• my-project.utils: General utility functions.
• my-project.db.sql: Database interaction logic.

This structure helps keep your code modular and easy to navigate.

To use functions defined in another namespace (or a library), you need to require it. The require declaration typically goes inside your ns form, using a vector of namespace symbols.

Here, we load clojure.string, a built-in library for string manipulation.

Typing out full namespace names can be tedious. The :as keyword, used within the :require vector, allows you to create a shorter alias for a required namespace.

This makes your code more concise and readable without sacrificing clarity.

Sometimes you only need a few functions from a large namespace, or you want to avoid name clashes. You can use the :refer option within :require to explicitly bring only the specified symbols into your current namespace's scope.

You might have noticed that you don't need to explicitly require functions like +, map, println, or defn.

This is because these essential functions are part of the clojure.core namespace, which is automatically loaded and referred by every new namespace you create. It's Clojure's standard library.

The in-ns macro changes the current namespace. This is primarily useful when working interactively in the REPL (Read-Eval-Print Loop) to switch contexts without changing your source file.

In general, you won't use in-ns in your application's source code.

Older Clojure code or tutorials might mention the use macro. It's similar to require but automatically brings all public functions from the required namespace into the current one.

While convenient, this can easily lead to naming conflicts (e.g., if two libraries define a count function). For this reason, use is generally discouraged in favor of require with :as or :refer.

Which of the following statements about Clojure namespaces and their usage are TRUE?

In this lesson, you learned how crucial namespaces are for organizing Clojure projects and preventing naming clashes. We covered:

• Defining a namespace with the ns macro.
• The importance of hierarchical naming conventions.
• Loading external code using require.
• Creating aliases with :as for cleaner code.
• Selectively importing symbols with :refer.
• Why clojure.core functions are always available.
• The role of in-ns in the REPL and why use is generally avoided.

Mastering namespaces is key to building maintainable and scalable Clojure applications!