Results 1 
7 of
7
Finally Tagless, Partially Evaluated  Tagless Staged Interpreters for Simpler Typed Languages
"... We have built the first family of tagless interpretations for a higherorder typed object language in a typed metalanguage (Haskell or ML) that require no dependent types, generalized algebraic data types, or postprocessing to eliminate tags. The statically typepreserving interpretations include an ..."
Abstract

Cited by 28 (7 self)
 Add to MetaCart
We have built the first family of tagless interpretations for a higherorder typed object language in a typed metalanguage (Haskell or ML) that require no dependent types, generalized algebraic data types, or postprocessing to eliminate tags. The statically typepreserving interpretations include an evaluator, a compiler (or staged evaluator), a partial evaluator, and callbyname and callbyvalue CPS transformers. Our main idea is to encode HOAS using cogen functions rather than data constructors. In other words, we represent object terms not in an initial algebra but using the coalgebraic structure of the λcalculus. Our representation also simulates inductive maps from types to types, which are required for typed partial evaluation and CPS transformations. Our encoding of an object term abstracts over the various ways to interpret it, yet statically assures that the interpreters never get stuck. To achieve selfinterpretation and show Jonesoptimality, we relate this exemplar of higherrank and higherkind polymorphism to plugging a term into a context of letpolymorphic bindings.
A polymorphic modal type system for Lisplike multistaged languages
 In The 33rd ACM SIGPLANSIGACT Symposium on Principles of Programming Languages
, 2006
"... This article presents a polymorphic modal type system and its principal type inference algorithm that conservatively extend ML by all of Lisp’s staging constructs (the quasiquotation system). The combination is meaningful because ML is a practical higherorder, impure, and typed language, while Lis ..."
Abstract

Cited by 14 (0 self)
 Add to MetaCart
This article presents a polymorphic modal type system and its principal type inference algorithm that conservatively extend ML by all of Lisp’s staging constructs (the quasiquotation system). The combination is meaningful because ML is a practical higherorder, impure, and typed language, while Lisp’s quasiquotation system has long evolved complying with the demands from multistaged programming practices. Our type system supports open code, unrestricted operations on references, intentional variablecapturing substitution as well as captureavoiding substitution, and lifting values into code, whose combination escaped all the previous systems.
A logical foundation for environment classifiers, in
 P.L. Curien (Ed.), Proceedings of the 9th International Conference on Typed LambdaCalculi and Applications (TLCA’09
"... Abstract. Taha and Nielsen have developed a multistage calculus λ α with a sound type system using the notion of environment classifiers. They are special identifiers, with which code fragments and variable declarations are annotated, and their scoping mechanism is used to ensure statically that ce ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
Abstract. Taha and Nielsen have developed a multistage calculus λ α with a sound type system using the notion of environment classifiers. They are special identifiers, with which code fragments and variable declarations are annotated, and their scoping mechanism is used to ensure statically that certain code fragments are closed and safely runnable. In this paper, we investigate the CurryHoward isomorphism for environment classifiers by developing a typed λcalculus λ ⊲. It corresponds to multimodal logic that allows quantification by transition variables—a counterpart of classifiers—which range over (possibly empty) sequences of labeled transitions between possible worlds. This interpretation will reduce the “run ” construct—which has a special typing rule in λ α —and embedding of closed code into other code fragments of different stages— which would be only realized by the crossstage persistence operator in λ α —to merely a special case of classifier application. We prove that λ ⊲ enjoys basic properties including subject reduction, confluence, and strong normalization and that the execution of a welltyped λ ⊲ program is properly staged. Finally, we show that the proof system augmented with a classical axiom is sound and complete with respect to a Kripke semantics of the logic. 1
Intersection types for unbind and rebind (Extended Abstract) ∗
"... We define a type system with intersection types for an extension of lambdacalculus with unbind and rebind operators. In this calculus, a term t with free variables x1,...,xn, representing open code, can be packed into an unbound term 〈 x1,...,xn  t 〉, and passed around as a value. In order to exec ..."
Abstract
 Add to MetaCart
We define a type system with intersection types for an extension of lambdacalculus with unbind and rebind operators. In this calculus, a term t with free variables x1,...,xn, representing open code, can be packed into an unbound term 〈 x1,...,xn  t 〉, and passed around as a value. In order to execute inside code, an unbound term should be explicitly rebound at the point where it is used. Unbinding and rebinding are hierarchical, that is, the term t can contain arbitrarily nested unbound terms, whose inside code can only be executed after a sequence of rebinds has been applied. Correspondingly, types are decorated with levels, and a term has type τ k if it needs k rebinds in order to reduce to a value of type τ. With intersection types we model the fact that a term can be used differently in contexts providing a different numbers of unbinds. In particular, toplevel terms, that is, terms not requiring unbinds to reduce to values, should have a value type, that is, an intersection type where at least one element has level 0. With the proposed intersection type system we get soundness under the callbyvalue strategy, an issue which was not resolved by previous type systems.
unknown title
"... Denotation of syntax and metaprogramming in contextual modal type theory (CMTT) ..."
Abstract
 Add to MetaCart
Denotation of syntax and metaprogramming in contextual modal type theory (CMTT)
Eria: Meta Programming with Programmable Inference
"... Eria is a meta language for embedded domain specific languages (EDSLs) which combines objectoriented (OO) programming with logic programming to enable usable embedding of typed object languages in the method chaining style. Most of existing research in EDSLs focuses on improving the efficiency of E ..."
Abstract
 Add to MetaCart
Eria is a meta language for embedded domain specific languages (EDSLs) which combines objectoriented (OO) programming with logic programming to enable usable embedding of typed object languages in the method chaining style. Most of existing research in EDSLs focuses on improving the efficiency of EDSLs, and the usability of the EDSLs has not been studied much. Eria is designed so that a wide range of EDSLs can be encoded with high usability. The key to high usability embedding of EDSLs is not only type inference but also term inference in the host language. Combining OO features with the Horn Logic, Eria allows users to define rules in the form of Horn clauses on the type level and uses the SLD resolution [19] to instantiate type variables in a type and infer terms that inhabit the type. We also created a decidable restriction of the SLD resolution. In this paper, we introduce the Eria programming language, show several examples of application of Eria, and formally present FE, a core calculus of Eria based on the FGJ [15]. 1.
Constructive LinearTime Temporal Logic: Proof Systems and Kripke Semantics
"... In this paper we study a version of constructive lineartime temporal logic (LTL) with the “next ” temporal operator. The logic is originally due to Davies, who has shown that the proof system of the logic corresponds to a type system for bindingtime analysis via the CurryHoward isomorphism. Howev ..."
Abstract
 Add to MetaCart
In this paper we study a version of constructive lineartime temporal logic (LTL) with the “next ” temporal operator. The logic is originally due to Davies, who has shown that the proof system of the logic corresponds to a type system for bindingtime analysis via the CurryHoward isomorphism. However, he did not investigate the logic itself in detail; he has proved only that the logic augmented with negation and classical reasoning is equivalent to (the “next ” fragment of) the standard formulation of classical lineartime temporal logic. We give natural deduction, sequent calculus and Hilbertstyle proof systems for constructive LTL with conjunction, disjunction and falsehood, and show that the sequent calculus enjoys cut elimination. Moreover, we also consider Kripke semantics and prove soundness and completeness. One distinguishing feature of this logic is that distributivity of the “next ” operator over disjunction “○(A ∨ B) ⊃ ○A ∨ ○B” is rejected in view of a typetheoretic interpretation. Key words: constructive lineartime temporal logic, Kripke semantics, sequent calculus, cut elimination 1.