lazy application

type dlist<'a> = ('a list -> 'a list) list

let dmap f (xs: dlist<'a>) : dlist<'a> = List.map f :: xs

let drun (xs: dlist<'a>) = List.foldBack (<|) xs []

let inline cons x xs = x :: xs

let drange from count =
    let rec loop curr acc : dlist<int> =
        if curr = from - 1 then acc else

        loop (curr - 1) (cons curr :: acc)
    
    loop count []

let res = 
    drange 1 10_000_000
    |> dmap ((+) 1)
    |> drun
    |> List.skip 9_999_980

printfn "%A" res

lazy application extended

type [<Struct>] dlist<'a, 'b> = 
  { application: ('a list -> 'a list) list
    transform: 'a -> 'b }

type dlist<'a> = dlist<'a, 'a>

let dmap f xs = { application = xs.application; transform = xs.transform >> f }

let drun xs =
    xs.application
    |> List.fold (|>) []
    |> List.map xs.transform

let inline cons x xs = x :: xs

let drange from count : dlist<int> =
    let rec loop curr acc  =
        if curr = count + 1 then acc else

        loop (curr + 1) (cons curr :: acc)

    { application = loop from []; transform = id }

let res = 
    drange 1 10_000_000
    |> dmap ((+) 1 >> string)
    |> drun
    |> List.skip 9_999_980

printfn "%A" res