As I know many functional programming languages do not reduce terms completely. Instead, they implement lazy evaluation, call by value strategies.
I think they do so because
1) strong reduction takes more steps to be completed, thus make the computation slow
2) strong reduction is not needed.
3) implementing strong reduction complicates the implementation.
am I right?
I want to know why the strong reduction is not implemented while it is possible.
The main reason why lazy calculations take place is memory and CPU usage saving.
Assume you have a query which returns 1bln entries. Should we load all these entries into memory?
Loading is not an efficient solution. And the main reason is that you can not use all bln entries even if they are loaded into memory.
Dear Peter, not sure if we are talking about the same thing.
Lazy loading means refering to the set of objects without initializing. The object initialization takes memory and CPU usage, so this is what I mean. So the lazy loading saves the memory and CPU usage.
https://en.wikipedia.org/wiki/Lazy_loading
And also one more article, may be helpful:
https://www.codeproject.com/Articles/652556/Can-you-explain-Lazy-Loading
I get your point.
Frankly saying I was talking about the Functional Language and regular DB queries (SQL like expressions) integratyion in OO languages (C#, Java, etc) in this case we will mainly have memory grow if we perform strict execution because of object construction space.
thanks you all for useful discussion.
Dear Gevorg,
I mean this https://en.wikipedia.org/wiki/Lazy_evaluation, which is different from lazy loading.
- Badges
- Science topic
- Similar topics
- Computer Science
- Computing