Examples of lazy

This example is from Wikipedia and may be reused under a CC BY-SA license.
A lazy list is represented by an unevaluated function, or "thunk".
In addition, students have to understand type classes, data types, and lazy evaluation, because these are used to create the modular solution.
Lazy languages are well suited to sequence generation because of the ease with which they handle infinite sequences.
Chapter 4 describes mark-sweep collection, mark-stack management (including pointer reversal), mark-bit placement, and lazy sweeping.
A convenient aspect of lazy evaluation is that sometimes the user will not be plagued with questions the answer to which is irrelevant.
We show that lazy streams, for instance, remain possible.
He also gives an ad-hoc formalization of lazy lists.
In fact, the lazy option is a more challenging one.
In a real language, we may be interested in having the ability to express both lazy and strict operations.
Also, even with lazy evaluation, this program performs a superfluous traversal through the intermediate result.
Maybe there are people who want to read lazy voices and lazy books.
Another implementation that could be efficient would be rational numbers with lazy computations.
The lazy constraint and its values at different levels, as well as the effort costs of various surface realizations, are motivated by articulatory difficulty.
In a fully lazy setting, this last point will not hold: we have reached a limit for the token-passing approach.
In addition, it is worth remarking that our theorems apply equally well to the call-by-name, call-by-value and lazy variants of the above models.
A husband who is too demanding, too lazy, or too often in the rumshop may be subject to public shaming by his wife.
Nonetheless, when the directive was not followed, the manager accused the employee of being lazy.
Note that if process synchronisation is allowed and eager equivalence and/or lazy equivalence do not coincide with performance congruence, they are not even compositional.
Thus, over the actual language, the lazy experiments have more discriminating power than the eager ones.
Such questions don't arise in the lazy-stream approach.
The lazy conversion generated by sequencing conv1 and conv2 takes a term and applies conv1 to it.
Now with machines things are easier and people are lazy; they take the easy way out.
Certainly they can be lazy, facile labelling that pre-empts further thought.
She thinks this was done long ago and so consistently that our lazy periodizations need to be revised.
Interestingly, only minor changes (seven lines of code) are necessary to transform the eager debugger into a fully lazy one.
Communication lifting is a worthwhile optimization to be included in a compiler for a lazy functional language.
Indeed, it is quite surprising that the lazy debugger, for example, differs only in seven lines of code from its eager counterpart.
Lazy evaluation is the cause of this economic pattern of evaluation.
We have implemented some of the simpler algorithms in a lazy functional language.
However, to achieve a good sequential performance for the synchronous networks embedded in a lazy functional program we use program transformation techniques.
In a lazy language this might be acceptable as the intermediate list would only be constructed on demand.
The profiler counts function calls and accurately profiles the time and heap space used by lazy, higher-order functional programs.
The heart of the problem is data structure sharing interacting with lazy evaluation.
Lazy functions are not incorporated in the spreadsheet.
The definitions of these cases in the table are consistent with lazy evaluation of the right argument of ++.
Evaluation of a single cell expression is chosen to correspond to evaluation of an initial term in a standard lazy functional language.
Only minor changes (7 lines of code!) are necessary to transform the eager debugger into a truly lazy one.
Using a lazy functional language gives an edge over other programming paradigms in terms of the ease of coding.
The difference between dynamic and lexical profiling is important for systems which use lazy evaluation.
A call-by-name evaluator can be expressed simply by introducing a rule of this form to express the lazy evaluation of arguments.
A system for representing the evaluation of lazy functions.
The required values ui and umi of the new lists appear in a lazy context.
Nondeterministic call by name is neither lazy nor by name.
Using the primitives of domain theory, we defined and implemented a lazy higherorder functional programming language.
An example of a nonflat domain would be the domain of lazy lists.
The computational model for functional programming is based on rewriting and lazy evaluation for imperative programs on memory states and state transitions.
The techniques may be used in any lazy functional language with a higher-order/polymorphic style type system.
We do not consider the extensions in the context of instrumented semantics or lazy state.
As in non-live lazy languages, all demands for computation start at the outputs, but in a live language, everything on the screen is an output.
Neither are we aware of any previous attempt to define a model for the pattern of use of an adt in a lazy functional language.
However, there is some reason to hope that usable, lazy debuggers could soon be developed.
A more fundamental reason is that it is difficult to develop good debuggers for lazy languages.
In sections 6 and 7 we translate eager and lazy functional computation respectively into concurrent computation and prove that complexity is preserved.
We model eager functional programming in the -calculus with weak call-by-value reduction and lazy functional programming in the call-by-need calculus with standard reduction.
The code in figure 5 uses trees of states to implement a backtracking solver, btsolver0, using a lazy pipeline.
Within functional languages there are two main schemes for deciding the order of evaluation of an expression: lazy and eager.
A lazy framework that supports this approach is shown in figure 16.
Due to the coroutine-like evaluation in lazy languages, their implementations already have many of the mechanisms required by parallel and distributed languages.
To transliterate this grammar into a lazy functional program, one function is introduced for each non-terminal.
In this section, we introduce an improved type of explicit environment passing scheme that will provide these vital properties for a lazy functional language.
Both eager and lazy data-structures are available within a unified framework.
Traditional debugging techniques are, however, not suited for lazy functional languages, since computations generally do not take place in the order one might expect.
Now suppose that we had had lazy semantics instead.
The situation is akin to running a lazy functional program without garbage collection.
The second property follows from the fact that the complexity of the inflationary lazy choice fixpoint is polynomial time.
Thus, the strategy differs from typical lazy functional languages only in the instantiation of free variables.
We define the lazy narrowing strategy in the following definition.
The basic idea is that both relations and deterministic lazy functions are particular cases of non-deterministic lazy functions.
Finally, let us show an example which illustrates the removal of dead code due to lazy evaluation.
A demand driven i computation strategy for lazy narrowing.
A lazy variant of control flow compilation is also presented.
The experiments reported in the paper show that lazy control flow compilation is superior in both artificial and real life settings.
We are not alone in our attempt to investigate the advantages and disadvantages of lazy functional programming when applied to implementing graph algorithms.
Effective detection of implicit parallelism is a particularly important problem in lazy languages.
In this section, related work on debugging for lazy functional languages will be reviewed and compared with our work.
To sum up, debugging of lazy functional programs is made difficult by delayed evaluation, counter-intuitive evaluation order and partially evaluated expressions.
By abstracting over a strict variable we get call by value (strict abstraction); in the other case we have call by name (lazy abstraction).
Cut-elimination for lazy proof-nets is confluent and strongly normalising.
These examples are from corpora and from sources on the web. Any opinions in the examples do not represent the opinion of the Cambridge Dictionary editors or of Cambridge University Press or its licensors.