require

added
1.0

ns
clojure.core

type
function

(require & args)

Loads libs, skipping any that are already loaded. Each argument is
either a libspec that identifies a lib, a prefix list that identifies
multiple libs whose names share a common prefix, or a flag that modifies
how all the identified libs are loaded. Use :require in the ns macro
in preference to calling this directly.

Libs

A 'lib' is a named set of resources in classpath whose contents define a
library of Clojure code. Lib names are symbols and each lib is associated
with a Clojure namespace and a Java package that share its name. A lib's
name also locates its root directory within classpath using Java's
package name to classpath-relative path mapping. All resources in a lib
should be contained in the directory structure under its root directory.
All definitions a lib makes should be in its associated namespace.

'require loads a lib by loading its root resource. The root resource path
is derived from the lib name in the following manner:
Consider a lib named by the symbol 'x.y.z; it has the root directory
<classpath>/x/y/, and its root resource is <classpath>/x/y/z.clj. The root
resource should contain code to create the lib's namespace (usually by using
the ns macro) and load any additional lib resources.

Libspecs

A libspec is a lib name or a vector containing a lib name followed by
options expressed as sequential keywords and arguments.

Recognized options:
:as takes a symbol as its argument and makes that symbol an alias to the
lib's namespace in the current namespace.
:refer takes a list of symbols to refer from the namespace or the :all
keyword to bring in all public vars.

Prefix Lists

It's common for Clojure code to depend on several libs whose names have
the same prefix. When specifying libs, prefix lists can be used to reduce
repetition. A prefix list contains the shared prefix followed by libspecs
with the shared prefix removed from the lib names. After removing the
prefix, the names that remain must not contain any periods.

Flags

A flag is a keyword.
Recognized flags: :reload, :reload-all, :verbose
:reload forces loading of all the identified libs even if they are
already loaded
:reload-all implies :reload and also forces loading of all libs that the
identified libs directly or indirectly load via require or use
:verbose triggers printing information about each load, alias, and refer

Example:

The following would load the libraries clojure.zip and clojure.set
abbreviated as 's'.

(require '(clojure zip [set :as s]))

                ;; Require clojure.java.io and call its file function:

user=> (require '(clojure.java.io))
user=> (clojure.java.io/file "filename")
#<File filename>
            
                ;; alias clojure.java.io as io
user=> (require '[clojure.java.io :as io])
nil

user=> (io/file "Filename")
#<File Filename>

;; alias clojure.java.io as io using prefixes
user=> (require '(clojure.java [io :as io2]))
nil

user=> (io2/file "Filename")
#<File Filename>
            
                (ns rosettacode.24game
  (:require [clojure.string :as str]))

(defn parse-infix-data
  "input '1+2+3+4'
   output (1 + 2 + 3 + 4)
   where the numbers are clojure numbers, and the symbols are clojure operators"
  [string] (map read-string (next (str/split string #""))))
            
                (require '(clojure.contrib [sql :as sql]))
            
                (ns myproject.core
  (:use [clojure.core] :reload)
  (:require [clojure.string :as str :refer [replace]] :reload-all))

(str/replace "foo" #"o" "e")
"fee"

; similar but using a prefix.
(ns myproject.core
  (:require (clojure [core]
                     [string :as str :refer [replace]] ))) 


            
                ; rename a function name (thanks for @noisesmith)
; rename 'clojure.repl/doc' to 'd'
user=> (require '[clojure.repl :as r :refer [doc] :rename {doc d}])
nil
user=> (d doc)
-------------------------
clojure.repl/doc
([name])
Macro
  Prints documentation for a var or special form given its name
nil