Implementing first-class polymorphic delimited continuations by a type-directed selective CPS-transform

RompfTiark,; MaierIngo,; OderskyMartin,

doi:10.1145/1631687.1596596

Cited by 26 publications

(26 citation statements)

References 43 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Providing syntactic support for these encodings may provide an interesting alternative to our encoding using computation builder. Interestingly, our Run operation seems related to reset of delimited continuations [19] and our Delay is similar to the reify operation of Filinsky [4].…”

Section: Related Workmentioning

confidence: 65%

The F# Computation Expression Zoo

Petříček

Syme

2014

Practical Aspects of Declarative Languages

View full text Add to dashboard Cite

Abstract. Many computations can be structured using abstract computation types such as monoids, monad transformers or applicative functors. Functional programmers use those abstractions directly while mainstream languages often integrate concrete instances as language features -e.g. generators in Python or asynchronous computations in C# 5.0. The question is, is there a sweet spot between convenient, hardwired language features, and an inconvenient but flexible libraries?F# computation expressions answer this question in the affirmative. Unlike the "do" notation in Haskell, computation expressions are not tied to a single kind of abstraction. They support a wide range of computations, depending on what operations are available. They also provide greater syntactic flexibility leading to a more intuitive syntax, without resorting to full macro-based meta-programming.We show that computation expressions can structure well-known computations including monoidal list comprehensions, monadic parsers, applicative formlets and asynchronous sequences based on the list monad transformer. We also present typing rules for computation expressions that are capable of capturing all these applications.

show abstract

Section: Related Workmentioning

confidence: 65%

The F# Computation Expression Zoo

Petříček

Syme

2014

Practical Aspects of Declarative Languages

View full text Add to dashboard Cite

show abstract

“…Still, the most important feature for the LDL transformation is allowing plugins to extend the vanilla subtyping logic in the Scala compiler by providing custom and phase-dependent rules for annotated types. Using this framework, Rytz created a purity and effects checker [60] that uses annotations to track side-effecting code, while Rompf implemented a type-driven continuation-passing style (CPS) transformation [56].…”

Section: Scala Compiler Plug-insmentioning

confidence: 99%

“…In the context of Java, type annotations have been used to selectively add reified type argument information to erased generics [27]. In the context of Scala, annotated types have been used to track and limit the side-effects of expressions [60,61], to designate macro expansions [18] and to trigger continuation-passing-style transformations [56].…”

Section: Related Workmentioning

confidence: 99%

Late data layout

Ureche

Burmako

Odersky

2014

Proceedings of the 2014 ACM International Conference on Object Oriented Programming Systems Languages &Amp; Applications

Self Cite

View full text Add to dashboard Cite

“…Fortunately, we can map the let-insertion monad into direct style using Filinski's monadic reflection [17,18]. Implementing the corresponding reflect and reify operators would be straightforward using Scala's support for delimited continuations [41]. But it turns out we do not even need delimited control, since we can model the desired behavior directly using mutable state and a by-name parameter for reify (see Section 6.2).…”

Section: Deep Reuse Of Bindings and Statement Ordermentioning

confidence: 99%

Scala-Virtualized: linguistic reuse for deep embeddings

Rompf

Amin

Moors

et al. 2012

Higher-Order Symb Comput

Self Cite

View full text Add to dashboard Cite

Scala-Virtualized extends the Scala language to better support hosting embedded DSLs. Scala is an expressive language that provides a flexible syntax, type-level computation using implicits, and other features that facilitate the development of embedded DSLs. However, many of these features work well only for shallow embeddings, i.e. DSLs which are implemented as plain libraries. Shallow embeddings automatically profit from features of the host language through linguistic reuse: any DSL expression is just as a regular Scala expression. But in many cases, directly executing DSL programs within the host language is not enough and deep embeddings are needed, which reify DSL programs into a data structure representation that can be analyzed, optimized, or further translated. For deep embeddings, linguistic reuse is no longer automatic.Scala-Virtualized defines many of the language's built-in constructs as method calls, which enables DSLs to redefine the built-in semantics using familiar language mechanisms like overloading and overriding. This in turn enables an easier progression from shallow to deep embeddings, as core language constructs such as conditionals or pattern matching can be redefined to build a reified representation of the operation itself.While this facility brings shallow, syntactic, reuse to deep embeddings, we also present examples of what we call deep linguistic reuse: combining shallow and deep components in a single DSL in such a way that certain features are fully implemented in the shallow embedding part and do not need to be reified at the deep embedding level.

show abstract

Implementing first-class polymorphic delimited continuations by a type-directed selective CPS-transform

Cited by 26 publications

References 43 publications

The F# Computation Expression Zoo

The F# Computation Expression Zoo

Late data layout

Scala-Virtualized: linguistic reuse for deep embeddings

Contact Info

Product

Resources

About