memoization.fs

type Timed<'T> =
    { Timestamp: DateTimeOffset
      Value: 'T }

type Clock = unit -> DateTimeOffset

let Timed (c: Clock) v =
    { Timestamp = c ()
      Value = v }

let memoizeAsyncFn (clock: Clock) (expiresAt: DateTimeOffset) fn =
    let d = ConcurrentDictionary ()

    let tryFind k =
        match d.TryGetValue k with
        | true, timedValue ->
            if timedValue.Timestamp >= expiresAt then
                None
            else
                Some timedValue.Value
        | false, _ -> None

    let addOrUpdate k v =
        let v = Timed clock v
        let setter = Func<_, _,_>(fun _ _ -> v)
        d.AddOrUpdate (k, v, setter)

    async {
        while true do
            for kvp in d do
                if kvp.Value.Timestamp >= expiresAt then
                    let _ = d.Remove kvp.Key
                    ()
                else
                    ()
            do! Async.Sleep 60000
    } |> Async.Start

    fun x ->
        match tryFind x with
        | Some v -> async { return v }
        | None ->
            async {
                let! v = fn x
                let _ = addOrUpdate x v
                return v
            }