Justin Owen Graver, `Type-checking and type-inference for object-oriented programming languages', PhD dissertation, Department of Computer Science, University of Illinois at Urbana-Champaign, August 1989. UIUCD-R-89-1539.  Home/Search   Document Not in Database   Summary   Related Articles   Check

.... 60 62 Definitions of class based inheritance are given in [57, 49, 110, 46, 63, 96, 9, 93] Annotated Bibliography 103 Slide 63 66 The soundness of covariance in Eiffel is questioned in [34] the soundness of the pure Simula version is argued in [60] Slide 67 Typed Smalltalk is developed in [51, 45, 44]. A system which preserve recursive structure is described in [78, 77, 83] Preservation of recursion in Eiffel is explained in [94] Slide 68 72 Covariance vs. contravariance is discussed briefly in the introduction or conclusion of most of the referenced papers. See also archives of the ....

.... shown in [84] Abstract data types are employed in [86, 85] their relation to classes is discussed earlier in [31] Large languages are presented in [13, 11] Slide 86 Type inference for simple subtyping is developed in [69, 102, 59, 74, 105, 55, 104] Slide 88 94 Class inference is developed in [101, 45, 79, 76, 4]. Slide 96 ML modules are described in [67, 106] Slide 97 Approaches to genericity are discussed in [63, 49, 61, 73, 83] Annotated Bibliography 104 Slide 98 Multi methods are presented in [53, 72, 24, 25] Slide 99 The Self language is described in [108, 26, 27, 28, 48, 3] ....

Justin Owen Graver. Type-Checking and Type-Inference for Object-Oriented Programming Languages. PhD thesis, Department of Computer Science, University of Illinois at UrbanaChampaign, August 1989. UIUCD-R-89-1539.

.... type information upon which to base optimizations like procedure inlining [Joh87] In an effort to improve the speed of Smalltalk programs, Ralph Johnson and his group at the University of Illinois at UrbanaChampaign have designed an extension to Smalltalk called Typed Smalltalk [Joh86, JGZ88, McC89, Hei90, Gra89, GJ90]. They added explicit type declarations to Smalltalk and built an optimizing compiler, called TS, that uses these type declarations to improve run time performance. A type in Typed Smalltalk is either a (possibly singleton) set of classes or a signature. A variable declared to be of a ....

Justin Owen Graver. Type-Checking and Type-Inference for Object-Oriented Programming Languages. Ph.D. thesis, University of Illinois at Urbana-Champaign, 1989.

....much of the usual effort required. The programmer specifies only type definitions, the types that each class conforms to, and the types of global, class, and instance variables. The types of local variables, methods, and closures can all be inferred, eliminating up to 90 of all type annotations [Graver, 1989]. 2. Type Systems Many different type systems have been proposed for object oriented programming systems. This section discusses the software engineering tradeoffs inherent in many of these choices, motivating the type system used in our model. 2.1. Structural Subtyping Cardelli [Cardelli, ....

....meaning that the types inferred for the procedural language may have little relation to the original program. 3.4. Typed Smalltalk The Typed Smalltalk project, headed by Ralph Johnson and Justin Graver, designed and implemented a static type specification and inference system for Smalltalk [Graver, 1989]. Their inference algorithm is intended to automatically infer types for non primitive methods, local variables, blocks, and literals. In their survey this includes over 95 of all Smalltalk methods and 90 of variables. The type system focuses on guaranteeing type safety and improving ....

Justin O. Graver. Type-Checking and Type-Inference for Object-Oriented Programming Languages, Ph.D. thesis, University of Illinois at Urbana-Champaign, August 1989.

.... understand and the messages to be sent to it (the infamous does not understand error) How such type information is added to the program code would seem to lie at the heart of the acceptability of this solution , as shown by moves away from type declarations, and towards type inference [Joh86, Gra89, PS91a] To summarise, programmers want more from their systems better speed, better feedback. It is proposed that the fulfillment of one or other of these desires, or even both, can be aided either by information provided by the programmers themselves annotations, for example types, ....

....as SELF, with the child class passing on messages for which it does not provide the method code. As with classes, inheritance would appear to be more of a convenient organising tool rather than an essential part of object oriented programming languages. In fact, as both Wolczko [Wol88] and Graver [Gra89] have shown, it is possible to process out the simple, single inheritance described here, to produce a simple set of classes. When compared to traditional imperative languages, for example Pascal, there are some features of object oriented languages which stand out. All values are objects, ....

[Article contains additional citation context not shown here]

Justin O. Graver. Type-Checking and Type-Inference for Object-Oriented Programming Languages. PhD thesis, Department of Computer Science, University of Illinois at Urbana-Champaign, August 1989. UIUCDCS--R--89--1539.

....is no longer a subtype of MethodNode. However, we still would like the subclass to inherit the code from the superclass. The solution that we adopt is to parameterize the classes MethodNode and FieldAccessorNode by the type of their decl field (this solution was proposed, for example, in [Graver 89] Now, FieldAccessorNode is a subtype of MethodNode, provided they are instantiated with the same type. It turns out that this solution does not work well for evolving programs: adding a type parameter to MethodNode causes proliferation of instantiation type annotations throughout existing ....

Justin O. Graver. Type-Checking and Type-Inference for Object-Oriented Programming Languages. Ph.D. thesis, University of Illinois, 1989.

.... The type system for Typed Smalltalk is the first type system for a Smalltalk like language that is both type safe and flexible enough to handle the kind of polymorphic procedures used in Smalltalk [Joh86, GJ90] There is also a type inference system that can infer the type of each procedure [Gra89] Previous papers have focused on the specification of the type system. This thesis describes the design and implementation of the current Typed Smalltalk (TS) type system. Most type systems for object oriented languages unify types and classes, and ensure that subclasses are subtypes. ....

....a method can be viewed as a table relating argument types to return types. The return type of a message send can be determined by looking up the argument types of the message send in this table. 3 Type Inference The type system described in this thesis is based on the theory developed by Graver [Gra89] A complete and useful type inference system should perform the following two tasks when type checking a method: ffl Infer the types of arguments and temporaries in a method when the user does not declare them ffl Infer a specific return type for each of the method s possible argument types. ....

[Article contains additional citation context not shown here]

Justin Graver. Type-Checking and Type-Inference for Object-Oriented Programming Languages. PhD thesis, University of Illinois at Urbana-Champaign, 1989.

....supersets of both the possible values of expressions and of the possible inheritance graphs. The apparent circularity is resolved by computing a global fixed point, in polynomial time. In most other type inference algorithms for object oriented languages, for example that of Graver and Johnson [8, 7] and our own [11, 10, 13] inheritance is expanded away rather than dealt with directly. Using prototypes, however, expansion is impossible, since a parent may have an independent state. This paper demonstrates how to handle inheritance without expansion. It also shows how to handle blocks with ....

Justin Owen Graver. Type-Checking and Type-Inference for Object-Oriented Programming Languages. PhD thesis, Department of Computer Science, University of Illinois at Urbana-Champaign, August 1989. UIUCD-R-89-1539.

....can aid in both the documentation and compilation of the program, while dynamically typed languages may lead to code that is more flexible and easier to reuse. Dynamically typed languages are usually less efficient since they lack type information to guide compilation. Type inferencing systems[Gra89] can improve the efficiency of dynamically typed languages by allowing types to be determined at compile time and corresponding optimizations to be made. Orthogonal to static and dynamic typing is whether a language is strongly or weakly typed[Set89] Strongly typed languages allow only type ....

Justin O. Graver. Type-Checking and Type-Inference for Object-Oriented Programming Languages. PhD thesis, Department of Computer Science, University of Illinois at Urbana-Champaign, 1989.

....supersets of both the possible values of expressions and of the possible inheritance graphs. The apparent circularity is resolved by computing a global fixed point, in polynomial time. In most other type inference algorithms for object oriented languages, for example that of Graver and Johnson [7, 6] and our own [10, 9] inheritance is expanded away rather than dealt with directly. Using prototypes, however, expansion is impossible, since a parent may have an independent state. This paper demonstrates how to handle inheritance without expansion. It also shows how to handle blocks with ....

Justin Owen Graver. Type-Checking and Type-Inference for ObjectOriented Programming Languages. PhD thesis, Department of Computer Science, University of Illinois at Urbana-Champaign, August 1989. UIUCD-R-89-1539.

....supersets of both the possible values of expressions and of the possible inheritance graphs. The apparent circularity is resolved by computing a global xed point, in polynomial time. In most other type inference algorithms for object oriented languages, for example that of Graver and Johnson [8, 7] and our own [11, 10, 13] inheritance is expanded away rather than dealt with directly. Using prototypes, however, expansion is impossible, since a parent may have an independent state. This paper demonstrates how to handle inheritance without expansion. It also shows how to handle blocks with ....

Justin Owen Graver. Type-Checking and Type-Inference for Object-Oriented Programming Languages. PhD thesis, Department of Computer Science, University of Illinois at Urbana-Champaign, August 1989. UIUCD-R-89-1539.

....hard to preserve the type of the original value. It was long believed that bounded parametric polymorphism was sufficient [13] but it has been realized that considerably more fine grained type systems are required to handle even simple updates [12] Graver and Johnson s type system for Smalltalk [29, 27, 28] has much in common with ours. Their types are essentially finite sets of classes, but they have to axiomatize a subtype relation that corresponds exactly to set inclusion because the type system involves type variables. They also employ a notion of signature type which essentially denotes the ....

Justin Owen Graver. Type-Checking and Type-Inference for Object-Oriented Programming Languages. PhD thesis, Department of Computer Science, University of Illinois at Urbana-Champaign, August 1989. UIUCD-R-891539.

.... which we earlier have shown to be spanned by inheritance and type substitution (a new genericity mechanism) 13, 12] Our analysis of the compilation technique is based on the assumptions that types are finite sets of classes and that variables can only contain instances of the declared classes [7, 8, 14]. 2.2 Structural subclassing Subclassing is usually tied to the use of class names. This means that a class is a subclass of only its ancestors in the explicitly created class hierarchy. In other words, a superclass must be created before the subclass. For an example, see figure 1A where Device ....

Justin Owen Graver. Type-Checking and Type-Inference for Object-Oriented Programming Languages. PhD thesis, Department of Computer Science, University of Illinois at Urbana-Champaign, August 1989. UIUCD-R-89-1539.

.... 13 A different approach is taken by the Typed Smalltalk project [Joh86, JGZ88] Users must annotate programs with type declarations for instance variables, class variables, global variables, and primitives, and then either run an inferencer to compute the types of methods and local variables [Gra89, GJ90] (which, like type inference in ML, provides the compiler with little information to support optimizations) or hand declare selected methods and local variables with more specific representation level type information. This representationlevel type information is used by the TS optimizing ....

Justin Owen Graver. Type-Checking and TypeInference for Object-Oriented Programming Languages. Ph.D. thesis, University of Illinois at Urbana-Champaign, 1989.

....descriptions are reads: #even , reads: #a) writes: #b) allocs: #c) and (writes: #region) pure , which is the same as writes: #region . Arbitrary effects may be indicated using variables. A type describes the value an expression computes. The type system of TS is discussed fully in [Gra89], so only the extensions made to accommodate the effect system will be mentioned here. One such extension allows a type to indicate the region in which a value is allocated. For example, the type SmallInteger in: #static describes a SmallInteger allocated in the #static region of memory, which ....

....select: and then to new: using some run time convention. After the expression is evaluated, the storage allocated for R can be deallocated. 4 Type and Effect System Specification The description of the type and effect system presented in this section is based on that of the type system given in [Gra89], with which some familiarity is assumed. It focuses on deviations from, and additions to, that type system. 4.1 Syntax The abstract and concrete syntax for type expressions is shown in Figure 5, that for effect expressions in Figure 6, and that for region expressions in Figure 7. The abstract ....

[Article contains additional citation context not shown here]

Justin Graver. Type-Checking and Type-Inference for Object-Oriented Programming Languages. PhD thesis, University of Illinois at Urbana-Champaign, 1989.

....paper [17] we demonstrated how to program the classes True, False, Natural, and List is this basic language. Suzuki [24] was the first to address the problem of type inference for such a language; his algorithm was not capable of checking most common programs, however. Later, Graver and Johnson [10, 9] provided an algorithm for a simplified problem, where the types of instance variables must be specified by programmer so that only the types of arguments are to be inferred. Recently, Hense [11] addressed the problem of inferring types that are useful in connection with separate compilation. This ....

Justin Owen Graver. Type-Checking and Type-Inference for Object-Oriented Programming Languages. PhD thesis, Department of Computer Science, University of Illinois at Urbana-Champaign, August 1989. UIUCD-R-89-1539.

....can be derived from the program without keeping track of nil values or flow analyzing the contents of instance variables. This makes the algorithm capable of checking most common programs; in particular, it allows for polymorphic methods. The algorithm is similar to previous work on type inference [18, 14, 27, 1, 2, 19, 12, 10, 9] in using type constraints, but it differs in handling late binding by conditional constraints and in resolving the constraints by least fixed point derivation rather than unification. The example language resembles Smalltalk [8] but avoids metaclasses, blocks, and primitive methods. Instead, it ....

....allow separate compilation but sacrifice flexibility. The relations between types and implementation are summarized in figure 1. When programs are: Their implementation is: Untyped Interpretation Typable Compilation Typed Separate Compilation Figure 1: Types and implementation. Graver and Johnson [10, 9], in their type system for Smalltalk, take an intermediate approach between untyped and typed in requiring the programmer to specify types for instance variables whereas types of arguments are inferred. Suzuki [27] in his pioneering work on inferring types in Smalltalk, handles late binding ....

[Article contains additional citation context not shown here]

Justin Owen Graver. Type-Checking and Type-Inference for Object-Oriented Programming Languages. PhD thesis, Department of Computer Science, University of Illinois at Urbana-Champaign, August 1989. UIUCD-R89 -1539.

....supersets of both the possible values of expressions and of the possible inheritance graphs. The apparent circularity is resolved by computing a global fixed point, in polynomial time. In most other type inference algorithms for object oriented languages, for example that of Graver and Johnson [7, 6] and our own [10, 9] inheritance is expanded away rather than dealt with directly. Using prototypes, however, expansion is impossible, since a parent may have an independent state. This paper demonstrates how to handle inheritance without expansion. It also shows how to handle blocks with ....

Justin Owen Graver. Type-Checking and Type-Inference for Object-Oriented Programming Languages. PhD thesis, Department of Computer Science, University of Illinois at Urbana-Champaign, August 1989. UIUCD-R-89-1539.

....exhibited by many Smalltalk methods. Functional polymorphism can be described, in the usual manner, with (implicit) bounded universal quantification of type variables. Inclusion polymorphism can be described with explicit union types or signatures. For a detailed discussion of these issues see [Gra89]. 3 Types The abstract and concrete syntax for type expressions is shown in Figure 2 (abstract syntax on the left and concrete syntax on the right) In the concrete syntax grammar terminals are underlined, something) represents zero or more repetitions of the something, and (something) ....

....as ElementType Character . If the range declaration of a class type parameter is omitted it is assumed to be Anything. 3. 6 Typed Method Definitions The types of method arguments, temporary variables, and block arguments can be explicitly declared or inferred by the TS type inference mechanism [Gra89]. The only difference between a typed method and an untyped method is that the typed method has type declarations. Type declarations must precede any part of the method definition. A typed method template is shown in Figure 4. The arguments for the fields arguments: temporaries: and ....

[Article contains additional citation context not shown here]

Justin Graver. Type-Checking and TypeInference for Object-Oriented Programming Languages. PhD thesis, University of Illinois at Urbana-Champaign, 1989.

No context found.

Justin Owen Graver, `Type-checking and type-inference for object-oriented programming languages', PhD dissertation, Department of Computer Science, University of Illinois at Urbana-Champaign, August 1989. UIUCD-R-89-1539.

Online articles have much greater impact   More about CiteSeer.IST   Add search form to your site   Submit documents   Feedback  

CiteSeer.IST - Copyright Penn State and NEC