F # эквивалентно Scala ленивым Валу с футляром класс/предвзято объединение

Question

В Scala я могу сделать что-то вроде этого:

abstract class MyData 
case class A() extends MyData 
case class B() extends MyData 

implicit class HeavyComputationProvider(val data : MyData) { 
    private def _HeavyComputation() = /* */; 
    lazy val HeavyComputation = this._HeavyComputation(); 
} 

// Example usage: 
val a = A 
println a.HeavyComputation // This will calculate 
println a.HeavyComputation // This will use the cached value 

Это имеет преимущество кэширования при повторном использовании, но не рассчитал, когда он не используется.

Как вы предоставляете ленивый HeavyComputation для следующего типа F #?

type MyData = 
    | A 
    | B 

type MyData with 
    member private this.__HeavyComputation = (* *) 

    // Error: This declaration element is not permitted in an augmentation and this is unavailable 
    let _HeavyComputation = lazy((* *)) 
    // This will just create a *new* lazy computation each time 
    member this._HeavyComputation = lazy(this.__HeavyComputation) 
    // This should lazily compute & cache, transparent to the caller 
    member this.HeavyComputation = this._HeavyComputation.Force 

Answer 1

Я думаю, что нет прямого эквивалента подхода Scala. Для этого необходимо сохранить некоторое дополнительное состояние как часть объекта (например, ленивое значение), а F # не позволяет добавлять дополнительное состояние к объектам после их определения.

Ближайший вещь, которую вы можете сделать, это написать тип обертки, которая сохраняет исходную MyData значение вместе с дополнительным ленивых вычислений:

type MyData = 
    | A 
    | B 

type MyDataWithComputation(data:MyData) = 
    let _HeavyComputation = lazy(1) 
    member this.MyData = data 
    member this.HeavyComputation = _HeavyComputation.Value 

, а затем использовать его следующим образом:

let myd = MyDataWithComputation(A) 
myd.HeavyComputation 
myd.HeavyComputation