Является ли функция немедленно нечистой, если она принимает функцию в качестве параметра?

Так как чистота входного параметра неизвестна до времени выполнения, считается ли функция немедленно нечистой, если она принимает функцию в качестве входного параметра?

Связано: если функция применяет чистую функцию, которая определена вне функции, но не передана в качестве параметра, будет ли она все еще чистой, если она удовлетворяет критериям отсутствия побочных эффектов, а результат зависит исключительно от ввода?

Для контекста я пишу функциональный код на JavaScript.

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

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

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

Это фактически означает, что для языков, которые не обеспечивают чистоту (то есть почти для всех), невозможно определить чистую функцию, которая вызывает функции, переданные в качестве аргументов. Все еще полезно писать их как можно более чистыми и рассуждать о них как о чистых функциях, но вы должны проявлять осторожность, потому что предположение, что это чисто, будет нарушено, если вы передадите неверные аргументы.

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

Так как чистота входного параметра неизвестна до времени выполнения, считается ли функция немедленно нечистой, если она принимает функцию в качестве входного параметра?

Контрпример:

function pure(other_function) {
    return 1;
}

Неважно, other_functionявляется ли это чистая функция, нечистая функция или не функция вообще. pureФункция является чистой.

Другой контрпример:

function identity(x) {
    return x;
}

Эта функция чиста, даже если xэто нечистая функция. identity(impure_function)всегда будет возвращаться impure_function, независимо от того, сколько раз вы повторите вызов. Не имеет значения, identity(impure_function)()всегда ли возвращает одно и то же; функция , в возвращаемом значении возвращаемого значения в не влияет на его чистоту.

В общем, если функция может вызвать функцию, переданную в качестве аргумента, она не является чистой. Например, функция function call(f) {f();}не является чистой, потому что, хотя она не упоминает ни о каком глобальном или изменяемом состоянии, она fможет вызывать alertвидимые побочные эффекты.

Если функция принимает функции в качестве аргументов, но не вызывает их или не вызывает их, то она может быть чистой. Это может все еще быть нечистым, если он делает какую-то другую нечистую вещь. Например, function f(ignored_function) {alert('This isn't pure.');}нечист, даже если он никогда не звонит ignored_function.

Так как чистота входного параметра неизвестна до времени выполнения, считается ли функция немедленно нечистой, если она принимает функцию в качестве входного параметра?

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

если функция применяет чистую функцию, которая определена вне функции, но не передана в качестве параметра, будет ли она все еще чистой, если она удовлетворяет критерию отсутствия побочных эффектов и выход зависит только от ввода?

Да. Итак, давайте сосредоточимся на том, что здесь важно. Вызов функции чистый или нет, сам по себе бесполезен. Чистые функции полезны, потому что создание одного и того же вывода для любого ввода, не зависящего от состояния или наличия побочных эффектов, является очень полезным набором свойств. Это означает, что после запуска вашей функции вы можете «запомнить» ответ для этого ввода, и он всегда будет верным. Вам также не нужно снова запускать функцию, чтобы генерировать побочные эффекты.И вы можете запустить эту функцию параллельно (или не по порядку) с другими функциями и знать, что у них не будет никаких скрытых взаимодействий, которые ведут себя плохо.

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

Как сказал Теластин: Технически, да, если только в вашем языке нет способа гарантировать, что функция ввода также чиста.

Это не гипотетически, есть действительно хорошие способы гарантировать это. По крайней мере, на строго типизированном языке.

Такая чистая функция, которую вы написали бы в JavaScript как

function foo(f) {
   return f(1) + 2;
}

можно перевести непосредственно на Haskell:

foo :: (Int -> Int) -> Int
foo f = f 1 + 2

Теперь в JavaScript вы можете делать такие злые вещи, как

js> foo (function(x) {console.log("muharhar"); return 0})
muharhar
2

Это невозможно в Хаскеле . Причина в том, что что-то вроде побочного эффекта console.log()всегда должно иметь тип результата IO something, а не только somethingодин.

GHCi> foo (\x -> print "muarhar" >> return 0)

<interactive>:7:12:
    Couldn't match expected type ‘Int’ with actual type ‘IO b0’
    In the expression: print "muarhar" >> return 0
    In the first argument of ‘foo’, namely
      ‘(\ x -> print "muarhar" >> return 0)’
    In the expression: foo (\ x -> print "muarhar" >> return 0)

Для этого выражения для проверки типов нам нужно дать fooсигнатуру типа

foo :: (Int -> IO Int) -> Int

Но оказывается, что я больше не могу это реализовать: поскольку функция аргумента имеет IOсвой результат, я не могу использовать его внутри foo.

<interactive>:8:44:
    Couldn't match expected type ‘Int’ with actual type ‘IO Int’
    In the first argument of ‘(+)’, namely ‘f 1’
    In the expression: f 1 + 2

Единственный способ использовать IOдействие в fooтом случае, если результат fooимеет IO Intсам тип :

foo :: (Int -> IO Int) -> IO Int
foo f = do
   f1 <- f 1
   return (f1 + 2)

Но на данный момент из подписи ясно, fooчто это не чистая функция.

Нет это не так.

Если переданная функция является нечистой И ваша функция вызывает переданную функцию, то ваша функция будет считаться нечистой.

Отношение чистый / нечистый немного похоже на синхронизацию / асинхронность в JS. Вы можете свободно использовать чистый код из нечистых, но не наоборот.