За что мне не нравится Java. Проверки на null

Хотя сам занимаюсь разработкой на Java, язык этот мне кажется чересчур громоздким и многословным. Много в нем недостатков, но сегодня коснусь одного, уж очень сильно раздражающего.

При вызове методов постоянно нужно следить за null-ами. Написал метод – будь добр, проверь все параметры на null. Вызвал метод – проверь полученное значение на null. Делать это нужно постоянно, а исходник страдает обилием проверок, здорово захламляющих логику.

В отличие от Java, язык Clojure, наследник Lisp-а, позволяет изменять собственный синтаксис. Главная фишка Clojure – макросы и программирование на уровне абстрактного синтаксического дерева. Воспользуемся этими вкусностями и автоматизируем проверку на null всех параметров функции.

(defn nil-parameter [f] (println "One of the parameters of the function" f "is nil!"))

(defmacro defn-checked [name parameters & body]

   `(defn ~name ~parameters

      (if (or ~@(map (fn [p] `(nil? ~p)) parameters) )

        (nil-parameter (str ~name))

        (do ~@body ))))

Теперь можно создать функцию при помощи новой синтаксической конструкции defn-checked также, как и при помощи defn.

(defn-checked my [p1 p2] (println "123"))

На стадии компиляции исходника Clojure преобразует этот код в следующий.

(defn my [p1 p2]

   (if (or (nil? p1) (nil? p2))

     (nil-parameter (str my))

       (do

         (println "123"))))

Чуть сложнее делать проверки возвращаемых значений. Показанный ниже макрос использует возможности программирования на АСТ для преобразования списка bindings.

(defn nil-value [] (println "One of the values is nil!"))

(defmacro let-checked [bindings & body]

   (let [indexed-bindings (map vector (iterate inc 0) bindings)

          symbols (map #(second %) (filter #(even? (first %)) indexed-bindings))

          values (map #(second %) (filter #(odd? (first %)) indexed-bindings))

          results (gensym "results")

          indexed-symbols (map vector symbols (iterate inc 0))]

          `(let [~results ~(vec values)]

              (if (not (empty? (filter #(nil? %) ~results)))

                (nil-value)

                (let [~@(reduce join 

                                          (map (fn [s] [(first s) 

                                                   `(nth ~results ~(second s))]) indexed-symbols))]

                ~@body)))))

Теперь можем использовать новую конструкцию let-checked также, как и let:

(let-checked [a 5

                    b (+ 1 2)]

  (+ a b))

На стадии раскрытия макросов Clojure создаст следующий код.

(let [results [5 (+ 1 2)]]

   (if (not (empty? (filter (fn [p] (nil? p)) results)))

     (nil-value)

     (let [a (nth results 0)

            b (nth results 1)]

       (+ a b))))

Как видите, вначале будут вычислены все значения и занесены в вектор results. Затем произойдет проверка, есть ли хоть один null среди значений results. И только если все значения не равны null, произойдет привязка новых символов a и b к элементам вектора results, и будет выполнено тело выражения.

А ваш язык программирования может такое?