| 词汇 | example_english_compiler |
| 释义 | Examples of compilerThese 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. Dictionary compilers recognise this problem and provide separate definitions for such compounds. In many cases this approach may be too conservative, but as a general principle we should assume the competence of the compilers. Since the two books were part of the same project, perhaps both writers were also on the team of compilers. Furthermore, could be the adequate theory to establish the correctness of functional compilers. A second direction is to examine how the full -calculus can be used to assert the correctness of some phases of realistic compilers. In principle, good compilers could pass them in registers. Our method can extend the power of compilers for such languages in revealing the available parallelism automatically. We believe that the construction of this simple touch optimization algorithm clearly illustrates how semantics can contribute to the development of advanced compilers. In his prior work on the correctness of sequential compilers, he derived compilers from the semantic mappings that translate syntax into -calculus expressions. Many useful functions can be recognised as representation changers; examples include compilers and arithmetic functions such as addition and multiplication. The main area of application of our methods is the automatic transformation of interpretive language specifications into compilers. Advice on structuring compilers and proving them correct. By self-application, the partial evaluator can be used to compile and to generate stand-alone compilers from a denotational or interpretive specification of a programming language. Abstract program specifications give compilers more freedom in code generation and often a better understanding of what is to be computed. Firstly, this variability gives some compilers an advantage (but not an unfair advantage). The initial benchmarking efforts revealed important differences between the various compilers. Operational semantics is needed for low-level correctness proofs (for example, for compilers). By considering both a flow analysis and the transformation it justifies together, this proof suggests a framework for incorporating flow analyses into verified compilers. Potentially coordination equivalences will aid the derivation and transformation of parallel and distributed programs, and may be incorporated into compilers. In those days syntax-directed compilers were studied at the research level, but were considered inefficient for implementation in the available machines. However, compiling and updating a suitably expansive database is resource intensive and may be subject to the compilers' own knowledge and bias. Shortly afterwards, computerised databases became available to compilers, along with scanning procedures and large-size data-storage systems. Thus, despite the compiler's best intentions, the resulting selections sometimes degenerate into a collection of sound bites. To reduce the number of unnecessary copies of polymorphic functions, monomorphizing compilers typically instantiate polymorphic functions to machine-level types rather than source languag e types. Many compilers will specialise automatically, in some cases this has been achieved manually. Such a presence requires the usual support materials such as efficient compilers and appropriate textbooks. Nevertheless, newer compilers are more likely to optimize function-static data well, removing the need for the optimization in the first place. Linear versions are preserved by weak head reduction, a notion of reduction considered by functional language compilers. We hope that the compiler's speed can be improved to the point of invisibility so that it can be used by non-programmers in image editors. Most compilers try to optimise the case when a curried function is applied to all its arguments at once. Users interact with the debugger via an interactive debug monitor, which is a recursively invoked, specialized variant of the compiler's standard top-level loop. Section 2 describes the tools that are used to build nanopass compilers. To address these problems, we have developed a "nanopass" methodology and a domain-specific language for writing nanopass compilers. We are also interested in using the nanopass technology to construct production compilers, where the overhead of many traversals of the code may be unacceptable. I suppose that time will tell as the results of applying them to commercially successful production compilers become known. Additionally, the full -calculus appears as an adequate formalism for proving the correctness of skeleton compilers. We also believe that our simple approaches to handling polymorphism and higherorder functions may be generally useful for implementing type-preserving compilers. By doing so, compilers provide an important help to programmers in detecting errors. With multi-return function calls, there is never any issue with the compiler's ability to stack-allocate call frames. Also, most automatic program transformations, as may take place in compilers, deal with static program text or code. Real compilers, of course, flatten the code by introducing arbitrary labels, but that merely complicates matters here without adding anything. The two existing action compilers are handwritten; we automatically generate one from an action interpreter. From denotational definitions of small languages our partial evaluator can generator compilers with a very natural structure - they look almost 'hand-written'. The issues faced by compilers of bilingual dictionaries, from character sets to sense distinctions, are neatly described. While it clearly does not have the variety of generators/modifiers as some sound compilers have, it has a great potential for evolution. The debugger instruments code by transforming the compiler's elaborated abstract syntax representation, after parsing and type checking, but before translation into /l-language. As a result, we have not compared its absolute performance with other compilers. Dead code elimination is sometimes performed in compilers for efficiency reasons, but it is also useful for developers: dead code clutters the program. Languages and compilers based on -calculus representations tend to assume that expressions and function-call are very lightweight, fine-grain mechanisms. The compilers offer two senses for the term 'applied linguistics'. The writers may or may not have been the same persons as the compilers, although presumably the two groups overlapped to some degree. At the same time, however, we would like to draw attention to the compiler's skill in finding - one might say creating - such patterns. If there were no demand for such works of reference, publishers and compilers would not engage in the awful toil of producing them. Since the compilers rightly stress that the volume can be but a selective one, attention must be given to the principle guiding selection. Programming libraries constitute a lower-level in computer music practice, when compared to sound compilers. Other compilers accept the definition, making programs vulnerable to uncaught type errors. We now examine how a few compilers perform pattern matching diagnostics. Unlike other functional language compilers known to us, our translator supports unboxed representations even for variant records. Unhappily, transducers are needed not only for abstraction but also to interface to existing compilers. Today's compilers are often written using many simple passes. Selfapplicable specializers have been used successfully for generating compilers. While selfapplicable specializers have been used to generate compilers and other program generators, the generation of specializers by self-application seems far away. In this section we discuss modifications that must be made to compilers. The process networks are thus embedded in a general purpose programming language, obviating the need for special compilers and language support systems. We certainly have to dispel the rumor that functional languages are for teaching compilers, interpreters, and type systems. Such assumptions are also subverted by bugs in the implementation of compilers, runtime support, and the underlying operating systems and hardware. Here we illustrate these claims by proving the correctness of four simplified compilers and runtime systems modelled as abstract machines. We claim that w could be the archetypal output language of functional compilers, just as the -calculus is their universal input language. The idea is implemented in some functional-language compilers, but has not appeared in the open literature so far. By considering both an analysis and the transformation it justifies together, this proof suggests a framework for incorporating flow analyses into verified compilers. Several of the compilers benchmarked here include support for concurrency or parallelism. Over 25 compilers for both lazy and strict functional languages have been benchmarked using a single floating-point intensive program. The toolkit has already been heavily used in compilers and in various pattern matching applications - both of which have made extensive use of multithreading. On the other hand, batch compilers are often slow, but the resulting programs are much faster than their interpreted counterparts. Many useful functions can be recognised as representation changers; examples include compilers, and arithmetic functions such as addition and multiplication. The tables show the times taken to generate compilers, to compile the example programs, and to run the target programs, respectively. At that time, there were very few papers available on compilers. A further analysis by the compilers reveals, we are informed, that of these 32 companies: 24 are loss making. An alternate view is to add slicing constructs to the language, which could allow compilers to do produce more efficient slicing code. Both compilers again favour selection/recursion, and perform worst for copy/recursion. Generally, performance can vary significantly with compilers and architecture as well as the amount of time that is spent by the implementer tuning an approach. Section 3 explains why interpreters cannot exploit some important features of modern computer architecture in the way that compilers can. However, instrumenting compilers is almost impossible for them. The truths of the genealogies were, by and large, the truths of the compilers. Each transect can be scrolled and viewed at different scales, and is accompanied by an explanatory text written by the compilers. Syntax for this feature varies between compilers as it is non-standard. The faster compilers also generally allocate less space. The programming efforts required to make these optimisations effective will thus be as varied as the offerings of the compilers themselves. However, many of the compilers are experimental and in constant flux. With so many compilers under scrutiny, it is not surprising that a large number of machines are involved in the different compilations. Higher-order functions are generally expensive to implement so many compilers will make attempts to reduce how often such functions are used. First year students are told that such considerations are the subject of a later subject in compilers. We tried the partial evaluator on two small language definitions and investigated the structure of the generated compilers. Only recently, there have been efforts to integrate dependent systems into intermediate languages in compilers and programming languages. The main technical results are the correctness proofs of the translations and the non-standard compilers generated by partial evaluation. Most modern compilers provide support for inlining function calls. 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. |
反思网英语在线翻译词典收录了377474条英语词汇在线翻译词条，基本涵盖了全部常用英语词汇的中英文双语翻译及用法，是英语学习的有利工具。