Как гарантировать ссылочную прозрачность в приложениях F#?

Короткий ответ на этот вопрос заключается в том, что нет способа гарантировать ссылочную прозрачность в F#. Одним из больших преимуществ F# является то, что он имеет фантастическое взаимодействие с другими языками .NET, но недостатком этого, по сравнению с более изолированным языком, таким как Haskell, является наличие побочных эффектов, и вам придется иметь с ними дело.

---

Как вы на самом деле справляетесь с побочными эффектами в F# - это совершенно другой вопрос.

На самом деле вас ничто не остановит. от введения эффектов в систему типов в F# во многом так же, как вы могли бы в Haskell, хотя фактически вы "выбираете" этот подход, а не навязываете его вам.

Все, что вам действительно нужно, - это некоторая инфраструктура, подобная этой:

/// A value of type IO<'a> represents an action which, when performed (e.g. by calling the IO.run function), does some I/O which results in a value of type 'a.
type IO<'a> = 
    private 
    |Return of 'a
    |Delay of (unit -> 'a)

/// Pure IO Functions
module IO =   
    /// Runs the IO actions and evaluates the result
    let run io =
        match io with
        |Return a -> a            
        |Delay (a) -> a()

    /// Return a value as an IO action
    let return' x = Return x

    /// Creates an IO action from an effectful computation, this simply takes a side effecting function and brings it into IO
    let fromEffectful f = Delay (f)

    /// Monadic bind for IO action, this is used to combine and sequence IO actions
    let bind x f =
        match x with
        |Return a -> f a
        |Delay (g) -> Delay (fun _ -> run << f <| g())

return приносит значение в пределах IO.

fromEffectful берет побочную функцию unit -> 'a и вносит ее в IO.

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

run запускает IO для выполнения всех вложенных эффектов. Это похоже на unsafePerformIO в Хаскелле.

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

---

Еще один стоящий вопрос: полезно ли это в F#?

Фундаментальное различие между F# и Haskell заключается в том, что F# - это нетерпеливый язык по умолчанию, в то время как Haskell-ленивый по умолчанию. хаскель сообщество (и я подозреваю, что сообщество .NET, в меньшей степени) узнало, что когда вы объединяете ленивую оценку и побочные эффекты/IO, могут произойти очень плохие вещи.

Когда вы работаете в монаде Ио в Хаскелле, вы (как правило) гарантируете что-то о последовательной природе Ио и гарантируете, что одна часть ИО выполняется раньше другой. Вы также гарантируете что-то о том, как часто и когда могут произойти эффекты.

Один пример, который я люблю представлять в F#, это один:

let randomSeq = Seq.init 4 (fun _ -> rnd.Next())
let sortedSeq = Seq.sort randomSeq

printfn "Sorted: %A" sortedSeq
printfn "Random: %A" randomSeq

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

Напротив, когда вы работаете с нетерпеливо оцениваемыми структурами данных, последствия, как правило, менее коварны, поэтому я думаю, что требованиедля явных эффектов в F# значительно уменьшено по сравнению с Haskell.

---

Тем не менее, большое преимущество того, чтобы сделать все эффекты явными в системе типов, заключается в том, что это помогает обеспечить хорошее дизайн. Такие, как Марк Seemann, скажут вам, что лучшая стратегия для проектирования надежной системы, будь то объектно-ориентированная или функциональная, включает в себя изоляцию побочных эффектов на краю вашей системы и опору на референтно прозрачное, хорошо поддающееся модульному тестированию ядро.

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

Возвращаясь к оригинальный вопрос о том, стоит ли это в F#, хотя я все еще должен ответить "я не знаю". Я работал над библиотекойдля референциально прозрачных эффектов в F#, чтобы исследовать эту возможность самостоятельно. Там больше материала на эту тему, а также гораздо более полная реализация IO там, если вам интересно.

---

Наконец, я думаю, что стоит помнить, что проклятие исключенного среднего, вероятно, нацелено на Программирование языковые дизайнеры больше, чем ваш типичный разработчик. Если вы работаете на нечистом языке, вам нужно будет найти способ справиться с побочными эффектами и укротить их, точная стратегия, которой вы следуете, чтобы сделать это, открыта для интерпретации, и то, что лучше всего соответствует потребностям вас и/или вашей команды, но я думаю, что F# дает вам множество инструментов для этого. Наконец, мой прагматичный и опытный взгляд на F# говорит мне, что на самом деле "в основном функциональное" программирование-это все еще большое улучшение по сравнению с его конкурентами почти все время.