如何在 F# 中“去除丑陋”这些嵌套的异步部件

Question

first, here is the code:

let getCandlesFromAsync (exchange: IExchange) (instrument: Instrument) (interval: TimeSpan) (fromTime: DateTime) (toTime: DateTime) =
    async {
        let rec getAsync (c: CandleData list) (f: DateTime) (t: DateTime) =
            async {
                //info $"requesting {instrument}: {f} - {t}"
                let! candles = exchange.GetCandlesAsync(instrument, interval, f, t)
                if candles.IsError then
                    return (failwith candles.GetError.Describe)
                else
                    //info $"received data {instrument}: {candles.Get.[0].Timestamp} - {candles.Get.[^0].Timestamp}"
                    let c = c @ candles.Get
                    if c.[^0].Timestamp < t - interval then
                        return! getAsync c (c.[^0].Timestamp + interval) t
                    else
                        return c
            }

        let cache = DataCache.getCache instrument
        let candlesFromCache = getCandlesFromCache cache interval fromTime toTime

        let firstTimestamp =
            match candlesFromCache.IsEmpty with
            | true  -> fromTime
            | false -> candlesFromCache.[^0].Timestamp + interval


        // check if we need some new data
        let downloadedCandles =
            async {
                if firstTimestamp < toTime then
                    let! x = getAsync [] firstTimestamp toTime
                    putCandlesInCache cache x
                    return x
                else
                    return []
            }

        let! d = downloadedCandles
        return candlesFromCache @ d
    }

This code is supposed to download price candles from an exchange. It has to run at regular interval and catch up with the new data.

Since I need data from a range of timestamps, I try to cache the data that has previously been requested from the exchange. At the range is always moving forward, I only have to check how much data I already have in the range, and how much I need to get.

The code is split into several parts:

• code that gets data from the cache for a time range (not posted here, but not relevant). It returns CandleData list .
• code that requests data from a time range from the exchange (getAsync), it returns async<CandleData list> .
• a small piece of code that determines what is missing and glues the pieces together (the second half of the function).

The issue here is that the whole function is expected to be async, but getAsync is recursive, so it has its own async block. Then the code that glues things together has to call getAsync and attach the data to what comes from the cache, so the whole thing is wrapped in an async block as well...

There has to be a cleaner way to do this, but I'm not sure how. Any suggestions would be welcome!

Answer 1

Separating the functions is the best practice. It doesn't necessarily reduce the number of async s but it makes the code cleaner and easier to understand.

The function that downloads from exchange may be on its own:

let downloadFromExchange (exchange: IExchange) (instrument: Instrument) (interval: TimeSpan) (f: DateTime) (t: DateTime) =
    let rec getAsync (previousCandles: CandleData list) (f: DateTime) =
        async {
            //info $"requesting {instrument}: {f} - {t}"
            if f < t then return previousCandles else
            let! candles = exchange.GetCandlesAsync(instrument, interval, f, t)
            if candles.IsError then
                return (failwith candles.GetError.Describe)
            else
                //info $"received data {instrument}: {candles.Get.[0].Timestamp} - {candles.Get.[^0].Timestamp}"
                let c = previousCandles @ candles.Get
                match c.[^0].Timestamp + interval with
                | fr when fr < t -> return! getAsync c fr
                | _              -> return  c
        }
    getAsync [] f

I changed the code a little bit to make it clearer for me. I could be wrong but it seems to me the expression c.[^0].Timestamp may result in an exception (or an infinite loop) if the list is empty either in the first call or in a recursive invocation.

let getCandlesFromAsync exchange (instrument: Instrument) (interval: TimeSpan) (fromTime: DateTime) (toTime: DateTime) =
    async {
        let cache            = DataCache.getCache instrument
        let candlesFromCache = getCandlesFromCache cache interval fromTime toTime

        let firstTimestamp =
            match candlesFromCache.IsEmpty with
            | true  -> fromTime
            | false -> candlesFromCache.[^0].Timestamp + interval

        let! x = downloadFromExchange exchange instrument interval firstTimestamp toTime
        putCandlesInCache cache x
        return candlesFromCache @ x
    }

I put the condition from < to in the download function, that way the code is cleaner.