M. Tofte. Type inference for polymorphic references. Information and Computation, 89:1--34, November 1990.  Home/Search   Document Not in Database   Summary   Related Articles   Check

....program accepted would be to explicitly force it to accept only lists of a xed ground type (int and string are just possible choices) This typing seeming too restrictive, more re ned type systems were developed to handle the speci city of types affected by side e ects. The Tofte discipline [15], used in Standard ML 90 [11] introduces imperative type variables for references, marked by a , which must be instantiated to ground types whenever a side e ect may occur, i.e. after any function application or reference cell creation. This was extended in Standard ML of New Jersey to allow ....

M. Tofte. Type inference for polymorphic references. Information and Computation, 89:1-34, 1990.

.... Language Following Harper [Har93] wesay that a store oe is well formed with respect to a context Delta, written Delta oe, if 8loc 2 BV( Delta)# if Delta loc : con Ref then Delta oe(x) con: This formulation of store typing avoids the need for complex maximal fixed point constructions [Tof90] An essentially similar observation was made byWrightandFelleisen [WF91] Fix a base type ans of answers to which a complete, closed program might evaluate. We can say that a machine state is well formed, written ( Delta#oe#E#phrase)# if and only if Delta E[phrase] ans, phrase ....

Mads Tofte. Type inference for polymorphic references. Information and Computation, 89(1):1--34, November 1990.

....2. This de nition requires no changes if we enrich the language with imperative features. A more precise de nition ( the values in type C are objects of the form new D(o) where D : C and, o i 2 [ F i ] where F i is the type of the i eld of class D ) would require a co inductive reading (cf. [33]) to make sense in the imperative setting. Intuitively, the reason we can get away with this permissive interpretation of object types is that later, e.g. in the proof of soundness, we will never deal with arbitrary elements of [ C] but only with elements that we also know are well typed ....

M. Tofte. Type inference for polymorphic references. Information and Computation, 89(1), Nov. 1990.

....for the applicative one, even though they have exactly the same semantics. As demonstrated here, the programming style (imperative vs. applicative) interferes with the type speci cations. This clearly goes against modular programming. Some enhancements to the ML type system have been proposed [4, 16, 17, 1], that weaken the restrictions over polymorphic mutable data. Standard ML [11] incorporates some of these ideas. These enhanced type systems make it possible to de ne many useful generic functions over mutable data structures, such as the function that copies a vector. However, these systems are ....

....rst the systems proposed for ML. All these systems rely on detecting the creation of mutable values (e.g. by special typechecking rules for the ref construct) and ensuring that the resulting mutable values have monomorphic types. The rst system we consider is the one proposed by Tofte [16, 17], and adopted in Standard ML [11] It makes use of weak type variables (written with a superscript) to prohibit polymorphic references. Weak type variables cannot be generalized by a let binding, unless the corresponding expression is guaranteed to be non expansive, i.e. that it does not create ....

M. Tofte. Type inference for polymorphic references. Information and Computation, 89(1), 1990.

.... modi ed in place) and rst class continuations (objects that capture the control state of the evaluator) In the ML community, it has long been known that the naive polymorphic typing for references is unsound; strong typing restrictions must be put on polymorphic references to ensure soundness [19]. Recently, it has been shown that the natural polymorphic typing for continuations [4] is unsound for similar reasons [8, 9] In this paper, we show that these diculties are not inherent to the polymorphic typing of references and continuations, but speci c to the ML semantics for ....

....by value, some typing restrictions must be put on generalization and or on the constructs that build references and continuations to avoid the inconsistent use of one reference or continuation object with di erent types. Several polymorphic type systems have been proposed that achieve this goal [3, 19, 15, 13, 20, 18], but they are either overly restrictive (many useful polymorphic functions that use references or continuations are rejected) or complicated and hard to understand from the programmer s standpoint. In contrast, with polymorphism by name, the simple, intuitive polymorphic type disciPage 1 ....

[Article contains additional citation context not shown here]

M. Tofte. Type inference for polymorphic references. Information and Computation, 89(1), 1990.

.... raw expressions a 1 : a n such that j= e : E and E (function p 1 a 1 j : j p n a n ) 1 2 ) function p 1 b 1 j : j p n b n ) j= dynamic(v : if and only if = dyn and j= v : The use of the typing relation to de ne j= over functional values is taken from [25]. The semantic typing relation extends to type schemes and to environments: j= v : if and only if j= v : for all types j= e : E if and only if e and E have the same domain, and j= e(x) E(x) for all x in their domain. The following property shows that semantic typing is stable ....

Mads Tofte. Type inference for polymorphic references. Information and Computation, 89(1), 1990.

....1 2 : 8 1 : n : Here and elsewhere, we write x for an identi er, i for an integer constant, f for a oating point constant, and for a type variable. Primitives are presented as prede ned identi ers such as add float. To the source language we apply Milner s type discipline [10, 16]. We recall the typing rules below. They de ne the familiar predicate E a : under assumptions E, term a has type ) Here, E is a nite mapping from identi ers x to type schemes . E x : E i : int E f : float E x : 1 a : 2 E x: a : 1 2 E a 2 : 1 2 ....

....) as expected. 2 3.4 Operational semantics In this section, we give operational semantics for the source language and for the target language, in preparation for a proof of the semantic correctness of the translation. We de ne two evaluation predicates, mapping terms to values, in the style of [12, 16]. The syntax for values is: v : i j f j hvi j v 1 ; v 2 j clos(k; x: a; e) j op op : add j : A value is either a constant; a pointer hvi to a heap cell containing value v; an (unallocated) pair of two values v 1 ; v 2 ; a primitive operation op; or a closure clos(k; x: a; e) of ....

[Article contains additional citation context not shown here]

M. Tofte. Type inference for polymorphic references. Information and Computation, 89(1), 1990.

....: a,m ref # and the other part r(1) a,m # 1 .Their frame axiom introduction rule is useful when aliasing is not 11 expected to occur because their predicates R are stronger than just typing judgments. Other related work. The use of a store typing mapping locations to types is not new. Tofte [32] uses this approach in his type soundness proof for polymorphic references. Tofte, however, makes use of coinduction to handle cycles in the memory graph. Harper [9] has shown how a progressand preservation proof can be arranged so that there is no need for coinduction. Our model, meanwhile, can ....

M. Tofte. Type inference for polymorphic references. Information and Computation, 89:1--34, November 1990. 13

....system to allow polymorphic use of functions that create references [Dam85] Unfortunately, although his soundness theorem is not known to be false, the soundness proof is incorrect. Tofte was the rst to give a type discipline for polymorphic references together with a correct soundness proof [Tof88, Tof90]. The central idea of Tofte s solution is to partition the types into imperative and applicative types, requiring all type variables that occur in an imperative type to be imperative. Values of imperative type can be stored, but only applicative type variables are treated polymorphically, ....

M. Tofte. Type inference for polymorphic references. Information and Computation, 89(1):1{ 34, 1990.

....from the usual one. Our investigation makes clear that there is a fundamental tension between implicit polymorphism and the call by value interpretation of let. This is consistent with earlier results establishing the inconsistency between unrestricted polymorphism and polymorphic reference types [22, 12] and first class continuations [9, 10] The source of the inconsistency may be traced to conflicting motivations for the static and dynamic semantics of the language. The polymorphic typing rule for let is motivated by a substitution principle a let bound variable is deemed to have exactly ....

Mads Tofte. Type inference for polymorphic references. Information and Computation, 89:1--34, November 1990.

.... [21] and are directly compatible with extensions that make significant uses of types at run time [14] e.g. dynamic types [1, 3] Since polymorphic expressions are kept distinct from their instances, the anomalies that arise in implicitly polymorphic languages in the presence of references [25] and control operators [12] do not arise. Strategies that evaluate beneath type abstractions are inspired by the operational semantics of ML [5, 17] Evaluation proceeds beneath type abstractions, leading to a once for all instances evaluation of polymorphic terms. Type instantiation is retained ....

....free type variables, precluding primitives that inductively analyze their type arguments. The superficial e#ciency improvement gained by evaluating beneath type abstractions comes at considerable cost since it is incompatible with extensions such as mutable data structures and control operators [25, 12]. The call cc operator takes one normal argument, which it then calls with the current continuation; if the argument returns, then its value is the result of the call cc expression [4] For example (ignoring types) call cc (#f.3) yields 3 and call cc (#f.f 4; 3) yields 4. The obvious type for ....

Mads Tofte. Type inference for polymorphic references. Information and Computation, 89:1--34, November 1990.

....explored in ML [15, 28, 29] This style of polymorphism, called implicit polymorphism, is based on the idea that programs are type free, with types interpreted as predicates expressing properties of programs under evaluation. Numerous extensions of these ideas have been explored in the literature ([7, 25, 31, 45], to name just a few) Although implicit polymorphism is appealingly simple and natural, it does not scale well to more sophisticated language features such as modularity and abstract types [20] Recent languages, notably Quest [4] and LEAP [35] are based instead on the notion of explicit ....

.... [35] and are directly compatible with extensions that make significant uses of types at run time (for example, dynamic types [1, 4] Since polymorphic expressions are kept distinct from their instances, the anomalies that arise in implicitly polymorphic languages in the presence of references [45] and control operators [18] do not occur. The ML like strategies are inspired by the operational semantics of ML [29] Evaluation proceeds beneath constructor abstractions, leading to a once for all instances evaluation of polymorphic terms. Constructor application is retained as a computation ....

[Article contains additional citation context not shown here]

Mads Tofte. Type inference for polymorphic references. Information and Computation, 89:1--34, November 1990.

....LCF ML restriction 2(i) b) pg. 49 [GMW78] which requires a variable to have a monotype (a type with no type variables) if the variable is assigned to inside a abstraction within its scope, is also sound since every monotype is weak. This restriction was never proved sound, according to Tofte [Tof90]. 2 The Type System The syntax of the language we consider is core ML with a letvar construct and assignment. Following Tofte [Tof90] we distinguish a subset of the expressions called Values : This material is based upon activities supported by the National Science Foundation under ....

....is assigned to inside a abstraction within its scope, is also sound since every monotype is weak. This restriction was never proved sound, according to Tofte [Tof90] 2 The Type System The syntax of the language we consider is core ML with a letvar construct and assignment. Following Tofte [Tof90], we distinguish a subset of the expressions called Values : This material is based upon activities supported by the National Science Foundation under Agreements No. CCR 9400592 and CCR 9414421. Any opinions, ndings, and conclusions or recommendations expressed in this publication are those of ....

[Article contains additional citation context not shown here]

Tofte, M., Type Inference for Polymorphic References, Information and Computation, 89, pp. 1-34, 1990. 9

....is the large body of To appear in Science of Computer Programming, vol. 32, nos. 2 3, 1998. This material is based upon work supported by the National Science Foundation under Grants No. CCR 9414421 and CCR 9400592. Preprint submitted to Elsevier Preprint 31 March 1997 work surrounding ML [4,21,14,5,11,24,22,19]. However, none of these e orts addresses the polymorphic typing of a language that combines variables, arrays and pointers ( rst class references) which are key ingredients of traditional imperative languages. As a result, they cannot be directly applied to get MLstyle polymorphic extensions of ....

....the data types, making pointers rst class values. 2.2 Achieving Type Soundness in Polymorphic C Much e ort has been spent trying to develop sound polymorphic type systems for imperative extensions of core ML. Especially well studied is the problem of typing Standard ML s rst class references [21,14,5,11,24]. The problem is easier in a language with variables but no references, such as Edinburgh LCF ML, but subtle problems still arise [4] The key problem is that a variable can escape its scope via a lambda abstraction as in letvar stk : in v: stk : v : stk (This evaluates to a push ....

Mads Tofte. Type inference for polymorphic references. Information and Computation, 89:1-34, 1990.

....range of that function into the result of the application expression. The correctness of the rules (abs) and (app) relies on the anti monotonicity of the underlying ordering v in the domain position. The rule (let ) produces a constraint schema oe = 8ff: fi; S) for polymorphic, let bound values [2, 42]. The set variable fi names the result of the value; the simple constraint system S describes the data flow relationships of the value, using fi; and the set ff = fff 1 ; ff n g contains those internal set variables of the constraint system that must be duplicated at each reference to the ....

Tofte, M. Type inference for polymorphic references. Information and Computation 89, 1 (November 1990), 1--34.

.... restriction interferes with separate compilation of modules that export (possibly partially) applied view constructors, since their representations have non generalizable types such as: V of [ l of int m of bool ] list] This problem would be solved by adopting a weaker restriction [2, 18, 24, 31 33] into OCaml. On the bases of the ideas above, generic rules of the translation are given in Figure 8. Further details of the implementation are omitted. 5 Related Work and Future Work ML Like Exceptions. The representation part of a view is similar to ML like exceptions in that they carry ....

Mads Tofte. Type inference for polymorphic references. Information and Computation, 89(1):1--34, 1990.

....ML compiler [7] and the initial proposal for Standard ML [29] required that reference cells be completely monomorphic; that is, the compiler must be able to infer a type without type variables for any argument of the ref constructor. This is certainly safe, but insufficiently flexible. Tofte[41] generalized this idea, introducing weakly polymorphic references and imperative types. These allow a function that creates references to be applied to more than one type, as long as each such type is itself monomorphic. Tofte s imperative types are a substantial improvement, and make for a ....

Mads Tofte. Type inference for polymorphic references. Information and Computation, 89:1--34, November 1990.

....range of that function into the result of the application expression. The correctness of the rules (abs) and (app) relies on the anti monotonicity of the underlying ordering v in the domain position. The rule (let ) produces a constraint schema oe = 8ff: fi; S) for polymorphic, let bound values [2, 42]. The set variable fi names the result of the value; the simple constraint system S describes the data flow relationships of the value, using fi; and the set ff = fff 1 ; ff n g contains those internal set variables of the constraint system that must be duplicated at each reference to the ....

Tofte, M. Type inference for polymorphic references. Information and Computation 89, 1 (November 1990), 1--34.

....integration of universal types into C. Their technical development is somewhat similar to ours, but they leave the treatment of structures to future work. It is precisely structures that motivate existential types and our treatment of them. The well studied problem of polymorphic references in ML [5, 18, 16] also results from quanti ed types, aliasing, and mutation, so it is natural to suppose the work presented here is simply the logical dual of the same problem. We have not found the correspondence between the two issues particularly illuminating, but we nonetheless point out similarities that may ....

Mads Tofte. Type inference for polymorphic references. Information and Computation, 89:1-34, November 1990.

....are typical structures which need to be shared in a memory, independently of the chosen strategy. The framework Obj a deals also with graphs. As a positive consequence of having addresses, the technique of stack and store used to design static and dynamic features of imperative languages [10, 20, 24, 1, 5] is substituted in our framework by a technique of graphs (directed and possibly cyclic) which can undergo destructive updates through mutation of objects. This makes our framework more abstract, as it involves no particular structure for computing. Moreover it provides a small step semantics of ....

M. Tofte. Type inference for polymorphic references. Information and Computation, 89(1):1--34, 1990.

....consistently merge individually coherent theories for isolated constructs, or to apply what was found in one realm to another realm. A well known example is issues in transplanting polymorphism, initially developed for pure higher order functions, to the universe of imperative programming idioms [45]. The different nature of dynamics of assignment commands from that of pure higher order functions is the culprit of this difficulty. Given this variety, it looks hard to conceive any uniform framework of type structure for different language constructs: unless we have a tool, say syntax, which ....

Tofte, M., Type inference for polymorphic references, Info. & Conp., 89:1--34, 1990.

.... value restriction interferes with separate compilation of modules that export (possibly partially) applied view constructors, since their representations have non generalizable types such as: V of [ l of int m of bool ] list] This problem would be solved by adopting a weaker restriction [2, 17, 23, 29 31] into OCaml. On the bases of the ideas above, generic rules of the translation are given in Figure 8. Further details of the implementation are omitted. 5 Related Work and Future Work The representation part of a view is similar to ML like exceptions in that they carry arguments, have generative ....

Mads Tofte. Type inference for polymorphic references. Information and Computation, 89(1):1--34, 1990.

....variables occurring free in but not in A. The syntax restricts the expression bound by let to be a value, i.e. an expression that causes no immediate subcomputation [13, 25] The type system becomes unsound if the syntax of let is left unrestricted, this phenomenon rst pointed out by Tofte [23, 24] in the context of typing references in ML has been well documented in the case of continuations [8, 11, 26] For better readability we use the syntactic sugar (let x = a 1 in a 2 ) for ( x: a 2 ) a 1 ) for the monomorphic let. Some familiar facts follow immediately from the form of the type ....

M. Tofte. Type inference for polymorphic references. Information and Computation, 89(1):1{ 34, 1990.

.... have been introduced to keep track of the lifetimes of references as required above, starting with Reynolds s syntactic control of interference (1978) the imperative lambda calculus (Swarup et al. 1991) lambda var (Odersky et al. 1993; Chen Odersky, 1994; Rabin, 1996) type and e ect systems (Tofte, 1990; Talpin Jouvelot, 1992b) coercions (Riecke, 1993; Riecke Viswanathan, 1995) and region calculi (Tofte Talpin, 1997) to name a few. The multitude of proposals and the fact that some variants of these proposals were initially unsound, witness the diculty of the problem. Instead of ....

Tofte, Mads. (1990). Type inference for polymorphic references. Inf. Comput., 89(1), 1-34.

....JG91, TJ92] effect masking is purely an artifact of the type system and has no operational significance. For example, the absence of visible effects provides a simple criterion for generalizing type variables that avoids the subtle problems that occur when mixing polymorphism and assignments [Tof90, Wri95] The encapsulation of memory regions can also be used to optimize storage allocation and deallocation in ML programs [TT94] In systems designed to exploit regions for optimization purposes, effect masking is used to guide deallocation of regions at runtime. As Tofte and Talpin argue, the ....

Mads Tofte. Type inference for polymorphic references. Inf. Comput., 89(1):1--34, November 1990.

....a modular and uniform treatment of both functional and imperative programming. Many treatments of functional operational semantics exist in the literature [Lan64, Aug84, Kah87, MTH90] To go further and accommodate imperative operations one can use the traditional stack and store approach [Plo81, Tof90, FH92, WF94, AC96, BF98] The greater complexity of the presentation of the latter works might lead one to conclude wrongly that implementing functional languages is easy in comparison with imperative languages. Such a false impression may be due in part to the fact that typical operational ....

M. Tofte. Type inference for polymorphic references. Information and Computation, 89(1):1-34, 1990.

....to, 3 whereas functional arrays are supposed to be non imperative. Therefore, returning an assignable I structure from make vector is not appropriate. Furthermore, in the Hindley Milner type system, imperative objects are allowed only a restricted form of polymorphism to ensure type safety [Tof90] Thus, the functional arrays implemented using I structures in this manner would have restricted polymorphism, which reduces the utility of such library implementations. Both problems described above may be solved by providing the ability to package the above implementation of the make vector ....

....through the abstraction both in static and dynamic semantics. We present a new language construct called close that achieves this functionality through the type system. The interaction of polymorphism and imperative programming has been the subject of active research in the past decade [Dam85, Tof90, AM89, LW91, Ler92, TJ92, Wri92] Several 27 type systems have been proposed in the literature spanning a wide range of expressiveness and complexity. We present a brief survey in Section 2.2. Since our main task is to provide an encapsulation mechanism for imperative program fragments, we ....

[Article contains additional citation context not shown here]

Mads Tofte. Type Inference for Polymorphic References. Information and Computation, 89:1--34, 1990.

....above will have a type tagged with and the function in the second example can have a type tagged with . Type variables carry a locality label because they may be instantiated to labelled types. 3. 1 Locality polymorphism Analogous to the well known fact that polymorphic references are unsound [14], references in our type system cannot be locality polymorphic. Suppose a thread p runs on processor and has the following expression associated to it let x = ref 3 in (fn y: deref x) rfork 0 fn w: x : 5) The program above is non deterministic: the result returned by thread p can be ....

....and Harper [5] we rst prove type preservation, then we prove that expressions that may lead to execution errors are untypable. In proofs for the Hindley Milner polymorphic type discipline, it is essential to prove a substitution lemma which, in its turn, is used to prove type preservation ([14], 16] In their proofs of Subject Reduction (Type Preservation) Wright and Felleisen are able to do with a single Substitution Lemma (Lemma 4.4 in [16] In their transition the type of the variable is the same as the type of the value to be substituted. In their rule for let expressions the ....

Mads Tofte. Type inference for polymorphic references. Information and Computation, 89(2):1-34, 1990.

....agencies. In existing high level typed languages, every location is stamped with a single type for the lifetime of the program. Failing to maintain this invariant has resulted in unsound type systems or misfeatures (witness the interaction between parametric polymorphism and references in ML [23, 27]) In low level languages that aim to expose the resources of the underlying machine, this invariant is untenable. For instance, because machines contain a limited number of registers, each register cannot be stamped with a single type. Also, when two stack allocated objects have disjoint ....

Mads Tofte. Type inference for polymorphic references. Information and Computation, 89:1--34, November 1990.

....system to allow polymorphic use of functions that create references [Dam85] Unfortunately, although his system has not been shown unsound, his claimed soundness proof is incorrect. Tofte was the first to give a type discipline for polymorphic references together with a correct soundness proof [Tof88, Tof90]. The central idea of Tofte s solution is to partition the types into imperative and applicative types, requiring all type variables that occur in an imperative type to be imperative. Values of imperative type can be stored, but only applicative type variables are treated polymorphically, ....

....this is sufficient to prove the correctness of our type system. Since store typings were defined in Section 4.2 using derivability in the type system, rather than as maximal fixed points, we do not have to use co induction in our proofs. This makes our soundness proof simpler than the one given in [Tof90]. We begin by proving some syntactic properties of the type system. In the following we use Gamma; R . e: to indicate that the judgement Gamma; R . e: is derivable. Our first lemma is a generalization of the standard property of closure of typing derivations under substitution. It shows ....

M. Tofte. Type inference for polymorphic references. Information and Computation, 89(1):1--34, 1990.

.... because the extension of type systems to the imperative case has sometimes uncovered new problems, e.g. multimethods for functional languages [8] and for imperative languages in[5] the Damas and Milner polymorphic type systems for functional languages [11] and for the imperative extension [24]) We plan to extend our study, starting with arrays and the associated dynamic checks, until we either have covered all of Java or we have uncovered loopholes in the type system. We aim to describe the language as in the [14] definition with the exception of method binding, which we model as ....

Mads Tofte. Type Inference for Polymorphic References. In Information and Computation '80 Conference Proceedings, pages 1--34, November 1980.

....a term that models a graph. This approach provides a formally very clean way to achieve a model of cyclic structures but the loss of ordinary induction principles is a serious drawback when using the theory. The same holds, by the way, for the techniques used to reason about pointers in ML [Tof90, MT91] where one needs to use coinduction which is di cult to mix with usual term structure. Alternatively the condition is also similar to the de nition of rational trees which are known to be implementable in a nite setting as cyclic graphs [Cou83] but with that approach we loose the ....

M. Tofte. Type inference for polymorphic references. Information and Computation, 89(1):134, 1990. 34

....With this definition, all the typing difficulties common in functional settings resurface. 4. Soundness We show the type soundness of our operational semantics, using an approach similar to subject reduction. We build on the techniques developed by Tofte, Wright and Felleisen, Leroy, and Harper [16, 18, 24, 27]. Our proof technique is an extension of Harper s, in that we deal with closures and stacks and thus avoid introducing locations into the term language. The typing of results with respect to stores is delicate. We would not be able to determine the type of a result by examining its substructures ....

Tofte, M., Type inference for polymorphic references. Information and Computation 89, 134. 1990.

No context found.

Tofte, M. Type inference for polymorphic references. In Information and Computation, 89(1), pages 1-34, 1990.

No context found.

M. Tofte. Type inference for polymorphic references. Information and Computation, 89:1--34, November 1990.

No context found.

Mads Tofte. Type Inference for Polymorphic References. In Information and Computation'80 Conference Proceedings, pages 1--34, November 1980.

No context found.

M. Tofte. Type inference for polymorphic references. Information and Computation, 89:1--34, 1990.

No context found.

Mads Tofte. Type Inference for Polymorphic References. In Information and Computation'80 Conference Proceedings, pages 1--34, November 1980.

No context found.

Mads Tofte. Type Inference for Polymorphic References. In Information and Computation'80 Conference Proceedings, pages 1--34, November 1980.

No context found.

M. Tofte. Type inference for polymorphic references. Information and Computation, 89:1--34, 1990.

No context found.

Mads Tofte. Type inference for polymorphic references. Information and Computation, 89(1):1 -- 34, November 1990.

No context found.

Mads Tofte. Type inference for polymorphic references. Information and Computation, 89:1--34, November 1990.

No context found.

Mads Tofte. Type inference for polymorphic references. Information and Computation, 89:1--34, November 1990.

No context found.

Mads Tofte. Type inference for polymorphic references. Information and Computation, 89:1-- 34, November 1990.

No context found.

Mads Tofte. Type inference for polymorphic references. Information and Computation, 89(1):1--34, November 1990.

No context found.

M. Tofte. Type inference for polymorphic references. Information and Computation, 89(1):1--34, November 1990.

No context found.

M. Tofte. Type inference for polymorphic references. Information and Computation, 89:1--34 1990.

No context found.

M. Tofte. Type inference for polymorphic references. Information and Computation, 89(1):1-- 34, 1990.

No context found.

Tofte, M., Type inference for polymorphic references, Info. & Comp., 89:1-34, 1990.

No context found.

M. Tofte. Type inference for polymorphic references. Information and Computation,

First 50 documents  Next 50

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