Clojure за 15 минут

Краткий экскурс в синтаксис Clojure, который настолько лаконичен, что вы сможете прочитать этот раздел примерно за 15 минут (или меньше).

Комментарии

;; две точки с запятой для комментария строки, ; одна точка с запятой для комментария остальной части строки

#_ макрос чтения комментариев, чтобы закомментировать следующую форму

(comment ) форма для комментариев ко всем содержащимся формам

Clojure записан в формах

Clojure написан в «формах», которые представляют собой списки элементов, заключенных в круглые скобки () и разделенных пробелами.

Clojure считает первое значение в форме вызовом функции. Дополнительные значения в форме передаются в качестве аргументов вызываемой функции.

Clojure организован в виде одного или нескольких пространств имен. Пространство имен представляет собой путь к каталогу и имя файла, который содержит код конкретного пространства имен.

;; Define the namespace test (ns test.code)  ;; src/test/code.clj  ;; Define a longer namespace (ns com.company.product.component.core)  ;; src/com/company/product/component/core.clj 

Манипулирование строками

Функция str создает новую строку из всех переданных аргументов

(str "Hello" " " "World") ; => "Hello World"

clojure.string возвращает строковые значения (другие функции возвращают символы в качестве результата)

Math (математика), Truth (истина) и префиксная нотация

Функции используют префиксную нотацию, поэтому вы можете легко выполнять математические вычисления с несколькими значениями

(+ 1 2 3 5 7 9 12) ; => 40 (- 24 7 3) ; => 14 (* 1 2) ; => 2 (/ 27 7) ; => 22/7

Математический метод очень точен, нет необходимости в правилах предшествования операторов (так как операторов нет)

Благодаря вложенным формам вычисления очень точны

(+ 1 (- 3 2)) ; = 1 + (3 - 2) => 2

Равенство — это =

(= 1 1) ; => true (= 2 1) ; => false

; вам нужно использовать в логике not, так  (not true) ; => false

(not= true false) ; => true

Типы

Clojure имеет строгую типизацию, поэтому в Clojure все является типом.

Clojure является динамически типизированным, поэтому сам определяет тип. Тип не нужно указывать в коде, что делает код более простым и лаконичным.

Поскольку Clojure является размещаемым на уже существующей платформе языком, он использует систему типов используемой среды, где это уместно. Например, Clojure под капотом применяет объектные типы Java для булевых данных, строк и чисел.

Для проверки типа кода в Clojure используйте функции class или type.

(class 1) ; Integer literals are java.lang.Long by default (class 1.); Float literals are java.lang.Double (class ""); Strings always double-quoted, and are java.lang.String (class false) ; Booleans are java.lang.Boolean (class nil); The "null" value is called nil

Vectors (векторы) и Lists (списки) — это тоже классы java!

(class [1 2 3]); => clojure.lang.PersistentVector (class '(1 2 3)); => clojure.lang.PersistentList

Коллекции и последовательности

Наиболее распространенные коллекции данных в Clojure:

• (1 2 "three") или (list 1 2 "three") — список значений, прочитанный от начала до конца (последовательный доступ)

• [1 2 "three"] или (list 1 2 "three") — вектор значений с индексом (произвольный доступ)

• {:key "value"} или (hash-map :key "value") — хэштаблица (хэшмапа) с нулем или более пар ключ-значение (ассоциативная связь)

• #{1 2 "three"} или (set 1 2 "three") — уникальный набор значений.

Список () определяется как вызов функции. Первый элемент списка — имя вызываемой функции, а дополнительные значения являются аргументами функции.

Функция ' quote сообщает читателю Clojure, что список следует рассматривать только как данные.

'(1 2 3)

Списки и векторы — это коллекции

(coll? '(1 2 3)) ; => true (coll? [1 2 3]) ; => true

Только списки являются последовательностями

(seq? '(1 2 3)) ; => true (seq? [1 2 3]) ; => false

Последовательности — это интерфейс для логических списков, которые могут быть ленивыми. «Ленивая» означает, что последовательность значений не оценивается до тех пор, пока к ней не обратятся.

Ленивая последовательность позволяет использовать большие или даже бесконечные серии, например, как:

 (range) ; => (0 1 2 3 4 ...) - an infinite series (take 4 (range)) ;  (0 1 2 3) - lazyily evaluate range and stop when enough values are taken

Используйте cons для добавления элемента в начало списка или вектора

(cons 4 [1 2 3]) ; => (4 1 2 3) (cons 4 '(1 2 3)) ; => (4 1 2 3)

Используйте conj, чтобы добавить элемент относительно типа коллекции, в начало списка или в конец вектора

(conj [1 2 3] 4) ; => [1 2 3 4] (conj '(1 2 3) 4) ; => (4 1 2 3)

Используйте concat для сложения списков или векторов вместе

(concat [1 2] '(3 4)) ; => (1 2 3 4)

Используйте filter, map для взаимодействия с коллекциями

(map inc [1 2 3]) ; => (2 3 4) (filter even? [1 2 3]) ; => (2)

Используйте reduce для их уменьшения

(reduce + [1 2 3 4]) ; = (+ (+ (+ 1 2) 3) 4) ; => 10

Reduce также может принимать аргумент начального значения

(reduce conj [] '(3 2 1)) ; => [3 2 1]

Эквивалент (conj (conj (conj (conj [] 3) 2) 1)

Функции

Используйте fn для создания новых функций, определяющих какое-то поведение. fn называют анонимной функцией, поскольку она не имеет внешнего имени, на которое можно сослаться, и ее нужно вызывать в форме списка.

(fn hello [] "Hello World") ; => hello

Оберните форму (fn ,,,) в круглые скобки, чтобы вызвать ее и вернуть результат

((fn hello [] "Hello World")) ; => "Hello World"

Создайте многократно используемую функцию с помощью def, создав имя, которым будет var. Поведение функции, определенное в def, может быть изменено, а выражение переоценено для использования нового поведения.

(defn hello-world []   "Hello World") ;; => "Hello World"

[] — это список аргументов для функции.

(defn hello [name]   (str "Hello " name)) (hello "Steve") ; => "Hello Steve"

Clojure поддерживает мультивариадические функции, позволяя одному определению функции отвечать на вызов функции с разным количеством аргументов.

(defn hello3   ([] "Hello World")   ([name] (str "Hello " name))) (hello3 "Jake") ; => "Hello Jake" (hello3) ; => "Hello World"

Функции могут упаковывать дополнительные аргументы в последовательность.

(defn count-args [& args]   (str "You passed " (count args) " args: " args)) (count-args 1 2 3) ; => "You passed 3 args: (1 2 3)"

Вы можете смешивать обычные и упакованные аргументы

(defn hello-count [name & args]   (str "Hello " name ", you passed " (count args) " extra args")) (hello-count "Finn" 1 2 3) ; => "Hello Finn, you passed 3 extra args"

Коллекции хэшмапов (hash-map)

(class {:a 1 :b 2 :c 3}) ; => clojure.lang.PersistentArrayMap

Ключевые слова подобны строкам с небольшим бонусом в плане эффективности

(class :a) ; => clojure.lang.Keyword

Мапы могут использовать любой тип в качестве ключа, но как правило, лучше всего подходят ключевые слова

(def stringmap (hash-map "a" 1, "b" 2, "c" 3)) stringmap  ; => {"a" 1, "b" 2, "c" 3}  (def keymap (hash-map :a 1 :b 2 :c 3)) keymap ; => {:a 1, :c 3, :b 2} (order is not guaranteed)

Запятые — это пробелы. Запятые всегда рассматриваются как пробелы и игнорируются Clojure-ридером.

Получение значения из мапы путем вызова ее как функции

(stringmap "a") ; => 1 (keymap :a) ; => 1

Ключевые слова позволяют извлекать их значение из мапы. Строки так не используются.

(:b keymap) ; => 2  ("a" stringmap) ; => Exception: java.lang.String cannot be cast to clojure.lang.IFn

При извлечении значения, которое не было представлено, возвращается nil.

(stringmap "d") ; => nil

Используйте assoc для добавления новых ключей в хэшмапы.

(assoc keymap :d 4) ; => {:a 1, :b 2, :c 3, :d 4}

Но помните, что типы clojure иммутабельны!

keymap ; => {:a 1, :b 2, :c 3}

Используйте dissoc для удаления ключей

(dissoc keymap :a :b) ; => {:c 3}

Установки

(class #{1 2 3}) ; => clojure.lang.PersistentHashSet (set [1 2 3 1 2 3 3 2 1 3 2 1]) ; => #{1 2 3}

Добавьте элемент с помощью conj

(conj #{1 2 3} 4) ; => #{1 2 3 4}

Удалите его с помощью disj

(disj #{1 2 3} 1) ; => #{2 3} ````  Test for existence by using the set as a function:  ```clojure (#{1 2 3} 1) ; => 1 (#{1 2 3} 4) ; => nil

В пространстве имен clojure.sets есть больше функций.

Полезные формы

Логические конструкции в clojure — это просто макросы, и выглядят они так же, как и все остальное

(if false "a" "b") ; => "b" (if false "a") ; => nil

Используйте let для создания временных привязок

(let [a 1 b 2]   (> a b)) ; => false

Группируйте утверждения вместе с помощью do

(do   (print "Hello")   "World") ; => "World" (prints "Hello")

Функции имеют неявный do

(defn print-and-say-hello [name]   (print "Saying hello to " name)   (str "Hello " name)) (print-and-say-hello "Jeff") ;=> "Hello Jeff" (prints "Saying hello to Jeff")

Так же как и let

(let [name "Urkel"]   (print "Saying hello to " name)   (str "Hello " name)) ; => "Hello Urkel" (prints "Saying hello to Urkel")

Пространства имен и библиотеки

Пространства имен используются для того, чтобы организовать код в логические группы. В верхней части каждого файла Clojure есть форма ns, которая определяет название пространства имен. Доменная часть названия пространства имен обычно является наименованием организации или сообщества (например, GitHub user/organisation).

(ns domain.namespace-name)

Все проекты Practicalli имеют домены пространства имен practicalli

(ns practicalli.service-name)

require позволяет коду из одного пространства имен быть доступным из другого пространства имен, либо из того же проекта Clojure, либо из библиотеки, добавленной в classpath (путь к классам) проекта.

Директива :as в require используется для указания имени псевдонима, которое сокращенно обозначает полное имя библиотеки.

Или :refer [function-name var-name] может использоваться для указания конкретных функций и данных (vars), которые доступны напрямую.

Требуемая (required) директива обычно добавляется к форме пространства имен

(ns practicalli.service-name   (require [clojure.set :as set]))

Функции из clojure.set можно использовать через псевдоним, а не через полное имя, т.е. clojure.set/intersection

(set/intersection #{1 2 3} #{2 3 4}) ; => #{2 3} (set/difference #{1 2 3} #{2 3 4}) ; => #{1}

Директива :require может быть использована для включения нескольких пространств имен библиотек

(ns test   (:require     [clojure.string :as string]     [clojure.set :as set]))

require может использоваться самостоятельно, обычно в блоке многофункционального кода

(comment   (require 'clojure.set :as set))

Java

В Java есть огромная и полезная стандартная библиотека, поэтому вы захотите узнать, как с ней работать.

Используйте import для загрузки пакета java

(import java.util.Date)

Или импорт из имени пакета java

(ns test   (:import     java.util.Date     java.util.Calendar))

Используйте имя класса с символом «.» в конце, чтобы создать новый экземпляр

(Date.) ; <a date object>

Используйте . для вызова методов. Или используйте горячую клавишу «.method».

(. (Date.) getTime) ; <a timestamp> (.getTime (Date.))  ; exactly the same thing.

Используйте / для вызова статических методов

(System/currentTimeMillis) ; <a timestamp> (system is always present)

Используйте doto, чтобы сделать ощущения от взаимодействия с (мутабельными [изменяемыми]) классами более толерантными

(import java.util.Calendar) (doto (Calendar/getInstance)   (.set 2000 1 1 0 0 0)   .getTime) ; => A Date. set to 2000-01-01 00:00:00

---

Язык программирования Clojure — это язык программирования общего назначения, на нём можно разрабатывать абсолютно что угодно. Но до недавнего времени разработка скриптов на Clojure была довольно трудной задачей, в основном, из-за медленного старта JVM.

Появление GraalVM позволило обойти это ограничение. Скрипты, написанные на Clojure, стартуют практически мгновенно. При этом в процессе разработки доступен REPL и весь арсенал языка Clojure. На бесплатном вебинаре вы познакомитесь с проектом Babashka и узнаете, как именно эта библиотека помогает разрабатывать скрипты. Приглашаем всех желающих.

Записаться на открытый урок можно на странице «Clojure Developer».