What exactly is Lazy style programming - language-agnostic

Question

For a homework project I am building a Typesafe LINQ framework in Typescript, here is the project description: Project
The description says: "Your project will generate a chain of executable functions, in the lazy style."
But I don't know exactly what Lazy means here?
I have build a Table containing all the operators, but the problem is that all the functions return a result immediately.
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)
},
})
So my basic understanding of Lazy is that the operators should return a executable function, that will be called later in the program. But I don't know how to do that.
Also the teachers provided me with a wrapper for a function:
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)))
},
}
Should I just return a Func<Table<Something, Something>, Table<AnotherThing, AnotherThing>>, for every operator to make it lazy? I am not sure, seems like a decent solution. But I can use some help in the understanding of Lazy style programming.

Answer 1

Lazy, in the context of porting LINQ, means returning an object that does work when iterated over, rather than doing some work iterating over your input data to generate iterable output data.
As an example
Print(allNumbers.Where(isEven).Take(10))
If Where is Eager, this takes infinite time, enumerating every number. If Where is Lazy, it only enumerates numbers up to 20.