может, если быть надлежащей функцией, а не специальной формой

Если , если была нормальной функцией, то оба ее аргумента - then форма и else форма - были бы оба вычислено перед вызовом функции if , потому что это правило оценки функции : оцените все аргументы для получения значений, затем предоставьте эту последовательность значений в качестве аргументов функции, обозначенной первым символом в списке.

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

Для полноты: в языке Pico, например, нет специальных форм, а if - это примитивная функция, в то время как Pico вдохновлен Scheme и по умолчанию имеет ускоренную оценку.

В Scheme вы могли бы написать

(define (true t f)
  (t))

(define (false t f)
  (f))

(define (function_if c t e)
  (c t e))

а затем

(function_if true (lambda () 'true) (lambda () 'false))
==> true

Что делает это управляемым в Pico, так это то, что вы можете определить функциональные параметры, которые принимают функциональные аргументы, которые "автоматически" задерживаются. Это означает, что вам не нужно самостоятельно выполнять обертку внутри ламбд. Таким образом, Pico имеет нетерпеливую оценку, но с ленивой оценкой по требованию, минуя необходимость в специальных формах.

Так, в синтаксисе Scheme с функциональными параметрами вы можете кодировать булевы как:

(define (true (t) (f))
  (t))

(define (false (t) (f))
  (f))

Тогда функция if становится:

(define (function_if c (t) (e))
  (c (t) (e)))

и

(function_if true 'true 'false)
==> true

В качестве другого примера, определение функции и - это (define (and p (q)) (p (q) false)).

Аналогично можно определить or, not, while, for, ... как функции, используя приведенную выше кодировку булевых чисел.

Короткий ответ: Нет.

Длинный(эр) ответ: (if ...) требует, чтобы вы контролировали порядок оценки аргументов. Лисп, будучи нетерпеливым языком, не может сделать это в функции.

Обходной путь: сделать это в макросе:

(defmacro _if (cnd true false)
    (let (  (gcond (gensym))
            (gresp (gensym)))
        `(let ( (,gcond ,cnd) ;`#quotes
                (,gresp nil))        
            (and ,gcond       (setf ,gresp (multiple-value-list ,true)))
            (and (not ,gcond) (setf ,gresp (multiple-value-list ,false)))
            (values-list ,gresp))))

Например:

[dsm@localhost:~]$ clisp -q
[1]> (defmacro _if (cnd true false)
    (let (  (gcond (gensym))
            (gresp (gensym)))
        `(let ( (,gcond ,cnd) ;`#quotes
                (,gresp nil))        
            (and ,gcond       (setf ,gresp (multiple-value-list ,true)))
            (and (not ,gcond) (setf ,gresp (multiple-value-list ,false)))
            (values-list ,gresp))))
_IF
[2]> (_if (= 1 1) (+ 2 3) "bar")
5
[3]> (_if (= 1 2) (+ 2 3) "bar")
"bar"
[4]> 

В таких языках, как Emacs Lisp и Common Lisp, специальные формы являются встроенными языковыми конструкциями. У них разные правила оценки, которые вызывают обычные функции. Для обычных вызовов функций оцениваются все аргументы. Итак, вы не можете написать IF как обычную функцию - условие определяет, какое предложение будет оценено. Также обычно вы не можете писать свои собственные специальные формы - в Common Lisp нет языковой конструкции для определения специальной формы (хотя отдельные реализации должны каким-то образом реализовывать существующие. Это приводит к макросам. С помощью макросов вы можете написать синтаксическое преобразование который преобразует одно выражение в другое. Чтобы иметь возможность писать IF как макрос, вам нужна другая условная форма, которую вы можете использовать для преобразованного кода. Lisp предоставляет условные выражения в качестве базовых конструкций. Предположим, COND является такой базовой конструкцией , тогда вы можете расширить IF до использования COND.

MY-IF в качестве макроса в Common Lisp:

(defmacro my-if (condition true-clause false-clause)
   `(cond (,condition ,true-clause)
          (t ,false-clause)))

Итак,

(my-if (foo-p) 'one 'two)

расширяется до

(cond ((foo-p) 'one)
      (t 'two))

В Scala можно смоделировать if с правильной оценкой побочных эффектов с использованием аргументов вызова по имени.

def If[A](cond : Boolean, truePart : => A, falsePart : => A) = if (cond) truePart else falsePart

Эту функцию также можно использовать для моделирования множества новых управляющих структур .

IF может быть функцией в функциональном языке с семантикой вызова по имени (ленивая оценка), как в Lambda Calculus или Algol. Фактически это, я думаю, лежит в основе отношений между машинами Тьюринга и Lambda Calculus как эквивалентными основами для вычислений. Однако в языках, имеющих побочные эффекты (например, присваивания переменным), это не слишком полезно, потому что важно когда все происходит.