时间戳

首页 > 解决方案 > 究竟什么是懒惰式编程

language-agnostic - 究竟什么是懒惰式编程

问题描述

对于一个家庭作业项目，我正在 Typescript 中构建一个 Typesafe LINQ 框架，这里是项目描述：项目

描述说：“你的项目将以惰性风格生成一系列可执行函数。”

但我不知道Lazy在这里到底是什么意思？

我已经构建了一个包含所有运算符的表，但问题是所有函数都立即返回结果。

interface Table<T, U> {
    readonly data: Pair<List<T>, List<U>>
    Select: <K extends keyof T>(this: Table<T, U>, properties: K[]) => Table<Omit<T, K>, Pick<T, K> & U>
}

const Table = <T, U>(data: Pair<List<T>, List<U>>): Table<T, U> => ({
    data: data,
    Select: function <K extends keyof T>(this: Table<T, U>, properties: K[]): Table<Omit<T, K>, Pick<T, K> & U> {
        let selection = this.data.First.map(entry => pickMany(entry, properties))

        let result = this.data.map(
            first => first.map(entry => omitMany(entry, properties))
            ,
            second => merge_list_types(second.zip(selection))
        )

        return Table(result)
    },
})

所以我对 Lazy 的基本理解是，操作符应该返回一个可执行函数，该函数稍后会在程序中调用。但我不知道该怎么做。

老师们还为我提供了一个函数的包装器：

export interface Func<a, b> {
    f: (_: a) => b
    then: <c>(this: Func<a, b>, g: Func<b, c>) => Func<a, c>
}

export let Func = <a, b>(f: (_: a) => b): Func<a, b> => {
    return {
        f: f,
        then: function <c>(this: Func<a, b>, g: Func<b, c>): Func<a, c> {
            return Func<a, c>(x => g.f(this.f(x)))
        },
}

我应该只返回一个Func<Table<Something, Something>, Table<AnotherThing, AnotherThing>>, 让每个运营商让它变得懒惰吗？我不确定，似乎是一个不错的解决方案。但我可以在理解 Lazy 风格编程方面使用一些帮助。

标签： language-agnosticlazy-evaluation

解决方案

懒惰，在移植 LINQ 的上下文中，意味着返回一个在迭代时可以工作的对象，而不是做一些工作来迭代输入数据以生成可迭代的输出数据。

举个例子

Print(allNumbers.Where(isEven).Take(10))

如果Where是Eager，这需要无限时间，枚举每个数字。如果Where是Lazy，它只枚举最多 20 的数字。

推荐阅读