Results 1  10
of
28
Gradual Typing for Functional Languages
 IN SCHEME AND FUNCTIONAL PROGRAMMING WORKSHOP
, 2006
"... Static and dynamic type systems have wellknown strengths and weaknesses, and each is better suited for different programming tasks. There have been many efforts to integrate static and dynamic typing and thereby combine the benefits of both typing disciplines in the same language. The flexibility o ..."
Abstract

Cited by 64 (10 self)
 Add to MetaCart
Static and dynamic type systems have wellknown strengths and weaknesses, and each is better suited for different programming tasks. There have been many efforts to integrate static and dynamic typing and thereby combine the benefits of both typing disciplines in the same language. The flexibility of static typing can be improved by adding a type Dynamic and a typecase form. The safety and performance of dynamic typing can be improved by adding optional type annotations or by performing type inference (as in soft typing). However, there has been little formal work on type systems that allow a programmercontrolled migration between dynamic and static typing. Thatte proposed QuasiStatic Typing, but it does not statically catch all type errors in completely annotated programs. Anderson and Drossopoulou defined a nominal type system for an objectoriented language with optional type annotations. However, developing a sound, gradual type system for functional languages with structural types is an open problem. In this paper
Gradual typing for objects
 In ECOOP 2007, volume 4609 of LCNS
, 2007
"... Abstract. Static and dynamic type systems have wellknown strengths and weaknesses. In previous work we developed a gradual type system for a functional calculus named λ? →. Gradual typing provides the benefits of both static and dynamic checking in a single language by allowing the programmer to co ..."
Abstract

Cited by 46 (8 self)
 Add to MetaCart
Abstract. Static and dynamic type systems have wellknown strengths and weaknesses. In previous work we developed a gradual type system for a functional calculus named λ? →. Gradual typing provides the benefits of both static and dynamic checking in a single language by allowing the programmer to control whether a portion of the program is type checked at compiletime or runtime by adding or removing type annotations on variables. Several objectoriented scripting languages are preparing to add static checking. To support that work this paper develops Ob? <:, a gradual type system for objectbased languages, extending the Ob<: calculus of Abadi and Cardelli. Our primary contribution is to show that gradual typing and subtyping are orthogonal and can be combined in a principled fashion. We also develop a smallstep semantics, provide a machinechecked proof of type safety, and improve the space efficiency of higherorder casts. 1
Building formal method tools in the Isabelle/Isar framework
 THEOREM PROVING IN HIGHER ORDER LOGICS (TPHOLS 2007), LNCS
, 2007
"... We present the generic system framework of Isabelle/Isar underlying recent versions of Isabelle. Among other things, Isar provides an infrastructure for Isabelle plugins, comprising extensible state components and extensible syntax that can be bound to tactical ML programs. Thus the Isabelle/Isar ..."
Abstract

Cited by 10 (6 self)
 Add to MetaCart
We present the generic system framework of Isabelle/Isar underlying recent versions of Isabelle. Among other things, Isar provides an infrastructure for Isabelle plugins, comprising extensible state components and extensible syntax that can be bound to tactical ML programs. Thus the Isabelle/Isar architecture may be understood as an extension and refinement of the traditional “LCF approach”, with explicit infrastructure for building derivative systems. To demonstrate the technical potential of the framework, we apply it to a concrete formal methods tool: the HOLZ 3.0 environment, which is geared towards the analysis of Z specifications and formal proof of forwardrefinements.
Mizar Light for HOL Light
 Theorem Proving in Higher Order Logics: TPHOLs 2001, LNCS 2152
, 2001
"... There are two dierent approaches to formalizing proofs in a computer: the procedural approach (which is the one of the HOL system) and the declarative approach (which is the one of the Mizar system). ..."
Abstract

Cited by 9 (3 self)
 Add to MetaCart
There are two dierent approaches to formalizing proofs in a computer: the procedural approach (which is the one of the HOL system) and the declarative approach (which is the one of the Mizar system).
A Comparison of the Mathematical Proof Languages Mizar and Isar
 Journal of Automated Reasoning
, 2002
"... The mathematical proof checker Mizar by Andrzej Trybulec uses a proof input language that is much more readable than the input languages of most other proof assistants. This system also di#ers in many other respects from most current systems. John Harrison has shown that one can have a Mizar mode on ..."
Abstract

Cited by 9 (3 self)
 Add to MetaCart
The mathematical proof checker Mizar by Andrzej Trybulec uses a proof input language that is much more readable than the input languages of most other proof assistants. This system also di#ers in many other respects from most current systems. John Harrison has shown that one can have a Mizar mode on top of a tactical prover, allowing one to combine a mathematical proof language with other styles of proof checking. Currently the only fully developed Mizar mode in this style is the Isar proof language for the Isabelle theorem prover. In fact the Isar language has become the o#cial input language to the Isabelle system, even though many users still use its lowlevel tactical part only.
A Comparison of Mizar and Isar
 J. Automated Reasoning
, 2002
"... Abstract. The mathematical proof checker Mizar by Andrzej Trybulec uses a proof input language that is much more readable than the input languages of most other proof assistants. This system also differs in many other respects from most current systems. John Harrison has shown that one can have a Mi ..."
Abstract

Cited by 8 (0 self)
 Add to MetaCart
Abstract. The mathematical proof checker Mizar by Andrzej Trybulec uses a proof input language that is much more readable than the input languages of most other proof assistants. This system also differs in many other respects from most current systems. John Harrison has shown that one can have a Mizar mode on top of a tactical prover, allowing one to combine a mathematical proof language with other styles of proof checking. Currently the only fully developed Mizar mode in this style is the Isar proof language for the Isabelle theorem prover. In fact the Isar language has become the official input language to the Isabelle system, even though many users still use its lowlevel tactical part only. In this paper we compare Mizar and Isar. A small example, Euclid’s proof of the existence of infinitely many primes, is shown in both systems. We also include slightly higherlevel views of formal proof sketches. Moreover a list of differences between Mizar and Isar is presented, highlighting the strengths of both systems from the perspective of endusers. Finally, we point out some key differences of the
Miscellaneous Isabelle/Isar examples for higherorder logic. Part of the Isabelle distribution, http://isabelle.in.tum.de/library/ HOL/Isar examples/document.pdf
, 2001
"... Isar offers a highlevel proof (and theory) language for Isabelle. We give various examples of Isabelle/Isar proof developments, ranging from simple demonstrations of certain language features to a bit more advanced applications. The “real ” applications of Isabelle/Isar are found elsewhere. Content ..."
Abstract

Cited by 5 (2 self)
 Add to MetaCart
Isar offers a highlevel proof (and theory) language for Isabelle. We give various examples of Isabelle/Isar proof developments, ranging from simple demonstrations of certain language features to a bit more advanced applications. The “real ” applications of Isabelle/Isar are found elsewhere. Contents 1 Basic logical reasoning 3 1.1 Pure backward reasoning.................... 3 1.2 Variations of backward vs. forward reasoning......... 4 1.3 A few examples from “Introduction to Isabelle ”........ 5
Specification model library for the interactive program prover jive
, 2004
"... This paper deals with the transformation of JML model classes to abstract data type definitions that can be used in a theorem prover like Isabelle/HOL. It will show some different approaches that can be used to achieve this transformation, such like primitive lists or inductively defined sets for so ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
This paper deals with the transformation of JML model classes to abstract data type definitions that can be used in a theorem prover like Isabelle/HOL. It will show some different approaches that can be used to achieve this transformation, such like primitive lists or inductively defined sets for some model classes. The two model classes JMLMath and JMLObjectSequence will help us to cover as much aspects as possible of JML. This becomes clear when we look at the JML specification of the two classes: JMLMath actually consists only of static declarations whereas, JMLObjectSequence will cover quite a lot of the dynamic aspects of the language. The main goal is to develop some ideas concerning automated transformation and to discuss them. CONTENTS 3
A Semantic Analysis of C++ Templates
, 2006
"... Templates are a powerful but poorly understood feature of the C++ language. Their syntax resembles the parameterized classes of other languages (e.g., of Java). But because C++ supports template specialization, their semantics is quite di#erent from that of parameterized classes. Template specia ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
Templates are a powerful but poorly understood feature of the C++ language. Their syntax resembles the parameterized classes of other languages (e.g., of Java). But because C++ supports template specialization, their semantics is quite di#erent from that of parameterized classes. Template specialization provides a Turingcomplete sublanguage within C++ that executes at compiletime. Programmers put this power to many uses. For example, templates are a popular tool for writing program generators.