Як може функціонувати час у функціональному програмуванні?

Я мушу визнати, що я мало знаю про функціональне програмування. Я читав про це звідси і там, і так дізнався, що у функціональному програмуванні функція повертає той самий вихід, за той же вхід, незалежно від того, скільки разів функція викликається. Це точно як математична функція, яка оцінює один і той же вихід на те саме значення вхідних параметрів, яке бере участь у вираженні функції.

Наприклад, врахуйте це:

f(x,y) = x*x + y; // It is a mathematical function

Незалежно від того, скільки разів ви використовуєте f(10,4), його значення завжди буде 104. Таким чином, де б ви не писали f(10,4), ви можете замінити його 104, не змінюючи значення цілого виразу. Ця властивість називається референтною прозорістю виразу.

Як говорить Вікіпедія ( посилання ),

І навпаки, у функціональному коді вихідне значення функції залежить лише від аргументів, які вводяться у функцію, тому виклик функції f вдвічі з однаковим значенням для аргументу x дасть однаковий результат f (x) обох разів.

Чи може функціонал часу (який повертає поточний час) існувати у функціональному програмуванні?

• Якщо так, то як воно може існувати? Чи не порушує принцип функціонального програмування? Це особливо порушує референтну прозорість, яка є однією з властивостей функціонального програмування (якщо я правильно це розумію).

• Або якщо ні, то як можна знати поточний час у функціональному програмуванні?

Ще один спосіб пояснити це: жодна функція не може отримати поточний час (оскільки вона постійно змінюється), але дія може отримати поточний час. Скажімо, getClockTimeце константа (або нульова функція, якщо вам подобається), яка представляє дію отримання поточного часу. Ця дія є однаковою щоразу, незалежно від того, коли вона використовується, тому вона є реальною постійною.

Так само, скажімо print, це функція, яка займає деякий час подання та друкує її на консолі. Оскільки виклики функцій не можуть мати побічні ефекти чистою функціональною мовою, ми замість цього уявляємо, що це функція, яка приймає часову позначку і повертає дію друку на консоль. Знову ж таки, це реальна функція, тому що якщо ви надаєте їй одну і ту ж часову позначку, вона буде щоразу повертати ту саму дію друку.

Тепер, як можна надрукувати поточний час на консолі? Ну, ви повинні поєднати дві дії. То як ми можемо це зробити? Ми не можемо просто перейти getClockTimeдо print, так як друк очікує мітку часу, а не дія. Але ми можемо уявити, що існує оператор, >>=який поєднує дві дії, одну, яка отримує часову позначку, і ту, яка приймає одну як аргумент і друкує її. Застосовуючи це до раніше згаданих дій, результатом є ... tadaaa ... нова дія, яка отримує поточний час і друкує його. І це, до речі, саме так робиться в Haskell.

Prelude> System.Time.getClockTime >>= print
Fri Sep  2 01:13:23 東京 (標準時) 2011

Отже, концептуально ви можете переглянути це таким чином: Чиста функціональна програма не виконує жодного вводу-виводу, вона визначає дію , яку потім виконує система виконання. Дія одне і те ж кожен раз, але результат його виконання залежить від обставин , коли воно виконується.

Я не знаю, чи це було ясніше, ніж інші пояснення, але іноді це допомагає мені думати про це таким чином.

Так і ні.

Різні функціональні мови програмування вирішують їх по-різному.

У Haskell (дуже чистому) все це має відбуватися у тому, що називається Monad I / O - дивіться тут .

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

В інших мовах, таких як F #, просто вбудовано деяку нечистоту, і тому ви можете мати функцію, яка повертає різні значення для одного і того ж вводу - як і звичайні обов'язкові мови.

Як згадував Джеффрі Бурка у своєму коментарі: Ось приємний вступ до монади вводу-виводу прямо з вікі Haskell.

У Хаскеллі використовується конструкція, яка називається монадою для обробки побічних ефектів. В основному монада означає, що ви інкапсулює значення в контейнер і маєте деякі функції для ланцюга функцій від значень до значень всередині контейнера. Якщо наш контейнер має тип:

data IO a = IO (RealWorld -> (a,RealWorld))

ми можемо безпечно реалізовувати дії з виводу. Цей тип означає: Дія типу IO- це функція, яка приймає маркер типу RealWorldі повертає новий маркер разом з результатом.

Ідея цього полягає в тому, що кожна дія IO мутує зовнішній стан, представлене магічним ознакою RealWorld. Використовуючи монади, можна зв'язати кілька функцій, які мутують реальний світ разом. Найважливішою функцією монади є >>=виражене зв’язування :

(>>=) :: IO a -> (a -> IO b) -> IO b

>>=виконує одну дію і функцію, яка приймає результат цієї дії і створює з цього нову дію. Тип повернення - це нова дія. Наприклад, зробимо вигляд, що є функція now :: IO String, яка повертає рядок, що представляє поточний час. Ми можемо зв'язати це з функцією putStrLnдля його роздруківки:

now >>= putStrLn

Або написано в do-нотації, яка більше знайома імперативному програмісту:

do currTime <- now
   putStrLn currTime

Все це чисто, оскільки ми відображаємо мутацію та інформацію про світ зовні RealWorld. Отже щоразу, виконуючи цю дію, ви отримуєте, звичайно, різний вихід, але вхід не той самий: RealWorldмаркер інший.

Більшість функціональних мов програмування не є чистими, тобто вони дозволяють функціям не залежати лише від їх значень. У цих мовах цілком можливо мати функцію, що повертає поточний час. З мов, якими ви позначили це питання, стосується Scala та F # (а також більшості інших варіантів ML ).

У таких мовах, як Haskell і Clean , які є чистими, ситуація інша. У Haskell поточний час був би доступний не через функцію, а так звану IO-дію, що є способом Haskell інкапсуляції побічних ефектів.

У «Чистому» це буде функцією, але функція сприймає світову цінність як аргумент і повертає свіжу світову цінність (крім поточного часу) як результат. Система типів гарантує, що кожне світове значення може бути використане лише один раз (і кожна функція, яка споживає світову цінність, створює нову). Таким чином, функцію часу потрібно було б викликати з різним аргументом кожен раз, і тому було б дозволено щоразу повертати інший час.

"Поточний час" - це не функція. Це параметр. Якщо ваш код залежить від поточного часу, це означає, що ваш код параметризований часом.

Це абсолютно можна зробити чисто функціональним способом. Існує кілька способів зробити це, але найпростішим є отримання функцією часу повертати не тільки час, але і функцію, яку ви повинні зателефонувати, щоб отримати наступне вимірювання часу .

У C # ви можете реалізувати це так:

// Exposes mutable time as immutable time (poorly, to illustrate by example)
// Although the insides are mutable, the exposed surface is immutable.
public class ClockStamp {
    public static readonly ClockStamp ProgramStartTime = new ClockStamp();
    public readonly DateTime Time;
    private ClockStamp _next;

    private ClockStamp() {
        this.Time = DateTime.Now;
    }
    public ClockStamp NextMeasurement() {
        if (this._next == null) this._next = new ClockStamp();
        return this._next;
    }
}

(Майте на увазі, що цей приклад мав бути простим, а не практичним. Зокрема, вузли списку не можуть бути зібрані сміття, оскільки вони укорінені ProgramStartTime.)

Цей клас "ClockStamp" діє як незмінний пов'язаний список, але насправді вузли створюються на вимогу, щоб вони могли містити "поточний" час. Будь-яка функція, яка хоче виміряти час, повинна мати параметр «clockStamp», а також повинна повертати своє останнє вимірювання часу в результаті (щоб абонент не бачив старих вимірів), наприклад:

// Immutable. A result accompanied by a clockstamp
public struct TimeStampedValue<T> {
    public readonly ClockStamp Time;
    public readonly T Value;
    public TimeStampedValue(ClockStamp time, T value) {
        this.Time = time;
        this.Value = value;
    }
}

// Times an empty loop.
public static TimeStampedValue<TimeSpan> TimeALoop(ClockStamp lastMeasurement) {
    var start = lastMeasurement.NextMeasurement();
    for (var i = 0; i < 10000000; i++) {
    }
    var end = start.NextMeasurement();
    var duration = end.Time - start.Time;
    return new TimeStampedValue<TimeSpan>(end, duration);
}

public static void Main(String[] args) {
    var clock = ClockStamp.ProgramStartTime;
    var r = TimeALoop(clock);
    var duration = r.Value; //the result
    clock = r.Time; //must now use returned clock, to avoid seeing old measurements
}

Звичайно, провести це останнє вимірювання в, і в, і в, і в, трохи незручно. Існує багато способів приховати котельну плиту, особливо на рівні мовної розробки. Я думаю, що Haskell використовує подібний трюк, а потім приховує потворні частини, використовуючи монади.

Я здивований, що жоден з відповідей чи коментарів не згадує вугілля або коіндукцію. Зазвичай про коіндукцію згадують, коли міркують про нескінченну структуру даних, але вона також застосовна до нескінченного потоку спостережень, наприклад, реєстру часу в ЦП. Вугільна модель моделює прихований стан; та моделі коіндукції, що дотримуються цього стану. ( Побудова нормальних моделей індукції стан.)

Це гаряча тема в Реактивне функціональне програмування. Якщо вас цікавлять подібні речі, прочитайте це: http://digitalcommons.ohsu.edu/csetech/91/ (28 pp.)

Так, для чистої функції можна повернути час, якщо цей час заданий як параметр. Різні аргументи часу, різний часовий результат. Потім сформуйте й інші функції часу та поєднайте їх з простим словником функцій (-of-time) -трансформації (вищого порядку). Оскільки підхід без стану, час тут може бути безперервним (незалежним від роздільної здатності), а не дискретним, що значно підвищує модульність . Ця інтуїція є основою функціонального реактивного програмування (FRP).

Так! Ви праві! Тепер () або CurrentTime () або будь-який метод підпису такого аромату жодним чином не демонструє референсної прозорості. Але за інструкцією до компілятора вона параметризується системним входом тактової частоти.

За результатами, Now () може виглядати як такий, що не дотримується еталонної прозорості. Але реальна поведінка системного годинника та функції, що знаходиться на ньому, дотримується референтної прозорості.

Так, функція отримання часу може існувати у функціональному програмуванні, використовуючи дещо змінену версію функціонального програмування, відому як нечисте функціональне програмування (за замовчуванням або головна - це чисте функціональне програмування).

У разі отримання часу (або читання файлу, або запуску ракети) код повинен взаємодіяти із зовнішнім світом, щоб виконати роботу, і цей зовнішній світ не базується на чистих основах функціонального програмування. Щоб чистий функціональний світ програмування міг взаємодіяти з цим нечистим зовнішнім світом, люди запровадили нечисте функціональне програмування. Зрештою, програмне забезпечення, яке не взаємодіє із зовнішнім світом, не є корисним, крім того, як робити деякі математичні обчислення.

Мало функціональних мов програмування має вбудовану в них функцію домішок таким чином, що не просто відокремити, який код нечистий, а чистий (наприклад, F # тощо), а деякі функціональні мови програмування переконайтеся, що, коли ви робите якісь нечисті речі цей код явно виділяється порівняно з чистим кодом, як Haskell.

Ще один цікавий спосіб це побачити в тому, що функція отримання часу в функціональному програмуванні займе "світовий" об'єкт, який має поточний стан світу, наприклад, час, кількість людей, що живуть у світі, і т. Д. Потім отримує час, з якого світу об'єкт буде завжди чистим, тобто ви проходите в одній світовій державі, ви завжди отримаєте той самий час.

Ваше запитання пов'язує два суміжні заходи комп'ютерної мови: функціональний / імперативний та чистий / нечистий.

Функціональна мова визначає зв'язки між входами та виходами функцій, а імперативна мова описує конкретні операції в певному порядку для виконання.

Чиста мова не створює і не залежить від побічних ефектів, а нечиста мова використовує їх протягом усього часу.

Стовідсоткові чисті програми в основному марні. Вони можуть виконати цікавий розрахунок, але оскільки вони не можуть мати побічні ефекти, вони не мають вводу та виводу, тому ви ніколи не дізнаєтесь, що вони обчислили.

Щоб бути корисною, програма повинна бути як мінімум нечистою. Один із способів зробити чисту програму корисною - помістити її всередину тонкої нечистої обгортки. Як і ця неперевірена програма Haskell:

-- this is a pure function, written in functional style.
fib 0 = 0
fib 1 = 1
fib n = fib (n-1) + fib (n-2)

-- This is an impure wrapper around the pure function, written in imperative style
-- It depends on inputs and produces outputs.
main = do
    putStrLn "Please enter the input parameter"
    inputStr <- readLine
    putStrLn "Starting time:"
    getCurrentTime >>= print
    let inputInt = read inputStr    -- this line is pure
    let result = fib inputInt       -- this is also pure
    putStrLn "Result:"
    print result
    putStrLn "Ending time:"
    getCurrentTime >>= print

Ви обговорюєте дуже важливий предмет у функціональному програмуванні, тобто виконуючи введення-виведення. Шлях чистих мов проходить через це за допомогою вбудованих мов, що стосуються домену, наприклад, підмовою, завданням якої є кодування дій , що може мати результати.

Наприклад, час виконання Haskell очікує, що я визначу дію під назвою main що складається з усіх дій, що складають мою програму. Потім виконується ця дія. Більшість часу він виконує чистий код. Час від часу виконання буде використовувати обчислені дані для виконання вводу-виводу та повернення даних назад у чистий код.

Ви можете поскаржитися, що це звучить як обман, і певним чином це так: визначаючи дії та очікуючи виконання їх виконання, програміст може зробити все, що може зробити звичайна програма. Але система сильного типу Haskell створює сильний бар'єр між чистими та "нечистими" частинами програми: ви не можете просто додати, скажімо, дві секунди до поточного часу процесора, і роздрукувати його, ви повинні визначити дію, що призводить до поточного Час процесора, і переведіть результат на іншу дію, яка додає дві секунди і друкує результат. Написання занадто великої кількості програми вважається поганим стилем, тому що це важко зробити висновок, які ефекти викликаються, порівняно з типами Haskell, які говорять нам про все, що ми можемо знати, що таке значення.

Приклад: clock_t c = time(NULL); printf("%d\n", c + 2);у С, порівняно main = getCPUTime >>= \c -> print (c + 2*1000*1000*1000*1000)з Хаскелом. Оператор >>=використовується для складання дій, передаючи результат першої функції функції, що призводить до другої дії. Це виглядає досить притаманно, компілятори Haskell підтримують синтаксичний цукор, що дозволяє нам записати останній код наступним чином:

type Clock = Integer -- To make it more similar to the C code

-- An action that returns nothing, but might do something
main :: IO ()
main = do
    -- An action that returns an Integer, which we view as CPU Clock values
    c <- getCPUTime :: IO Clock
    -- An action that prints data, but returns nothing
    print (c + 2*1000*1000*1000*1000) :: IO ()

Останнє виглядає досить імперативно, чи не так?

Якщо так, то як воно може існувати? Чи не порушує принцип функціонального програмування? Особливо це порушує референтну прозорість

Вона не існує в чисто функціональному сенсі.

Або якщо ні, то як можна знати поточний час у функціональному програмуванні?

Спочатку може бути корисно знати, як час витягується на комп’ютері. По суті, є вбудована схема, яка відслідковує час (саме тому комп'ютеру зазвичай потрібна батарея з невеликим осередком). Тоді може бути якийсь внутрішній процес, який встановлює значення часу в певному регістрі пам'яті. Це по суті зводиться до значення, яке може бути отримано ЦП.

Для Haskell існує концепція "IO action", яка представляє тип, який можна зробити для здійснення певного процесу вводу-виводу. Тож замість посилання на timeзначення ми посилаємось на IO Timeзначення. Все це було б суто функціональним. Ми не посилаємось, timeа щось, що відповідає принципу "прочитати значення регістра часу" .

Коли ми насправді виконуємо програму Haskell, дія IO насправді відбуватиметься.