-
+@PREAMBLE{ {\providecommand{\noopsort}[2]{#2} } }
@inproceedings{suchocki_microscheme:_2015,
address = {Washington DC, USA},
series = {{CS} {Techreport} 718},
doi = {10.1145/2370776.2370801},
abstract = {Task-Oriented Programming (TOP) is a novel programming paradigm for the construction of distributed systems where users work together on the internet. When multiple users collaborate, they need to interact with each other frequently. TOP supports the definition of tasks that react to the progress made by others. With TOP, complex multi-user interactions can be programmed in a declarative style just by defining the tasks that have to be accomplished, thus eliminating the need to worry about the implementation detail that commonly frustrates the development of applications for this domain. TOP builds on four core concepts: tasks that represent computations or work to do which have an observable value that may change over time, data sharing enabling tasks to observe each other while the work is in progress, generic type driven generation of user interaction, and special combinators for sequential and parallel task composition. The semantics of these core concepts is defined in this paper. As an example we present the iTask3 framework, which embeds TOP in the functional programming language Clean.},
booktitle = {Proceedings of the 14th {Symposium} on {Principles} and {Practice} of {Declarative} {Programming}},
- publisher = {Association for Computing Machinery},
+ publisher = {ACM},
author = {Plasmeijer, Rinus and Lijnse, Bas and Michels, Steffen and Achten, Peter and Koopman, Pieter},
year = {2012},
note = {event-place: Leuven, Belgium},
abstract = {Clean is an experimental language for specifying functional computations in terms of graph rewriting. It is based on an extension of Term Rewriting Systems (TRS) in which the terms are replaced by graphs. Such a Graph Rewriting System (GRS) consists of a, possibly cyclic, directed graph, called the data graph and graph rewrite rules which specify how this data graph may be rewritten. Clean is designed to provide a firm base for functional programming. In particular, Clean is suitable as an intermediate language between functional languages and (parallel) target machine architectures. A sequential implementation of Clean on a conventional machine is described and its performance is compared with other systems. The results show that Clean can be efficiently implemented.},
booktitle = {Functional {Programming} {Languages} and {Computer} {Architecture}},
publisher = {Springer Berlin Heidelberg},
- author = {Brus, T. H. and van Eekelen, M. C. J. D. and van Leer, M. O. and Plasmeijer, M. J.},
+ author = {Brus, T. H. and \noopsort{Eekelen}{van Eekelen}, M. C. J. D. and \noopsort{Leer}{van Leer}, M. O. and Plasmeijer, M. J.},
editor = {Kahn, Gilles},
year = {1987},
pages = {364--384},
doi = {10.1145/237721.237792},
abstract = {We revisit the work of Paterson and of Meijer \& Hutton, which describes how to construct catamorphisms for recursive datatype definitions that embed contravariant occurrences of the type being defined. Their construction requires, for each catamorphism, the definition of an anamorphism that has an inverse-like relationship to that catamorphism. We present an alternative construction, which replaces the stringent requirement that an inverse anamorphism be defined for each catamorphism with a more lenient restriction. The resulting construction has a more efficient implementation than that of Paterson, Meijer, and Hutton and the relevant restriction can be enforced by a Hindley-Milner type inference algorithm. We provide numerous examples illustrating our method.},
booktitle = {Proceedings of the 23rd {ACM} {SIGPLAN}-{SIGACT} {Symposium} on {Principles} of {Programming} {Languages}},
- publisher = {Association for Computing Machinery},
+ publisher = {ACM},
author = {Fegaras, Leonidas and Sheard, Tim},
year = {1996},
note = {event-place: St. Petersburg Beach, Florida, USA},
doi = {10.1145/53990.54010},
abstract = {We describe motivation, design, use, and implementation of higher-order abstract syntax as a central representation for programs, formulas, rules, and other syntactic objects in program manipulation and other formal systems where matching and substitution or unification are central operations. Higher-order abstract syntax incorporates name binding information in a uniform and language generic way. Thus it acts as a powerful link integrating diverse tools in such formal environments. We have implemented higher-order abstract syntax, a supporting matching and unification algorithm, and some clients in Common Lisp in the framework of the Ergo project at Carnegie Mellon University.},
booktitle = {Proceedings of the {ACM} {SIGPLAN} 1988 {Conference} on {Programming} {Language} {Design} and {Implementation}},
- publisher = {Association for Computing Machinery},
+ publisher = {ACM},
author = {Pfenning, F. and Elliott, C.},
year = {1988},
note = {event-place: Atlanta, Georgia, USA},
doi = {10.1145/1411204.1411226},
abstract = {We present parametric higher-order abstract syntax (PHOAS), a new approach to formalizing the syntax of programming languages in computer proof assistants based on type theory. Like higher-order abstract syntax (HOAS), PHOAS uses the meta language's binding constructs to represent the object language's binding constructs. Unlike HOAS, PHOAS types are definable in general-purpose type theories that support traditional functional programming, like Coq's Calculus of Inductive Constructions. We walk through how Coq can be used to develop certified, executable program transformations over several statically-typed functional programming languages formalized with PHOAS; that is, each transformation has a machine-checked proof of type preservation and semantic preservation. Our examples include CPS translation and closure conversion for simply-typed lambda calculus, CPS translation for System F, and translation from a language with ML-style pattern matching to a simpler language with no variable-arity binding constructs. By avoiding the syntactic hassle associated with first-order representation techniques, we achieve a very high degree of proof automation.},
booktitle = {Proceedings of the 13th {ACM} {SIGPLAN} {International} {Conference} on {Functional} {Programming}},
- publisher = {Association for Computing Machinery},
+ publisher = {ACM},
author = {Chlipala, Adam},
year = {2008},
note = {event-place: Victoria, BC, Canada},
title = {Combining type classes and existential types},
booktitle = {Proceedings of the {Latin} {American} {Informatic} {Conference} ({PANEL})},
publisher = {ITESM-CEM},
- author = {Läufer, Konstantin},
+ author = {L\"{a}ufer, Konstantin},
year = {1994},
note = {event-place: Monterrey, Mexico},
- file = {Läufer - COMBINING TYPE CLASSES AND EXISTENTIAL TYPES.pdf:/home/mrl/.local/share/zotero/storage/KR4P9EHS/Läufer - COMBINING TYPE CLASSES AND EXISTENTIAL TYPES.pdf:application/pdf},
}
@techreport{hughes_restricted_1999,
doi = {10.1145/1140335.1140352},
abstract = {The problem of supporting the modular extensibility of both data and functions in one programming language at the same time is known as the expression problem. Functional languages traditionally make it easy to add new functions, but extending data (adding new data constructors) requires modifying existing code. We present a semantically and syntactically lightweight variant of open data types and open functions as a solution to the expression problem in the Haskell language. Constructors of open data types and equations of open functions may appear scattered throughout a program with several modules. The intended semantics is as follows: the program should behave as if the data types and functions were closed, defined in one place. The order of function equations is determined by best-fit pattern matching, where a specific pattern takes precedence over an unspecific one. We show that our solution is applicable to the expression problem, generic programming, and exceptions. We sketch two implementations: a direct implementation of the semantics, and a scheme based on mutually recursive modules that permits separate compilation},
booktitle = {Proceedings of the 8th {ACM} {SIGPLAN} {International} {Conference} on {Principles} and {Practice} of {Declarative} {Programming}},
- publisher = {Association for Computing Machinery},
- author = {Löh, Andres and Hinze, Ralf},
+ publisher = {ACM},
+ author = {L\"{o}h, Andres and Hinze, Ralf},
year = {2006},
note = {event-place: Venice, Italy},
- keywords = {functional programming, Haskell, expression problem, extensible data types, extensible exceptions, extensible functions, generic programming, mutually recursive modules},
+ keywords = {expression problem, extensible data types, extensible exceptions, extensible functions, functional programming, generic programming, Haskell, mutually recursive modules},
pages = {133--144},
file = {OpenDatatypes.pdf:/home/mrl/.local/share/zotero/storage/NEP9GZ9N/OpenDatatypes.pdf:application/pdf},
}
doi = {10.1145/289423.289457},
abstract = {In this paper we explain how recursion operators can be used to structure and reason about program semantics within a functional language. In particular, we show how the recursion operator fold can be used to structure denotational semantics, how the dual recursion operator unfold can be used to structure operational semantics, and how algebraic properties of these operators can be used to reason about program semantics. The techniques are explained with the aid of two main examples, the first concerning arithmetic expressions, and the second concerning Milner's concurrent language CCS. The aim of the paper is to give functional programmers new insights into recursion operators, program semantics, and the relationships between them.},
booktitle = {Proceedings of the {Third} {ACM} {SIGPLAN} {International} {Conference} on {Functional} {Programming}},
- publisher = {Association for Computing Machinery},
+ publisher = {ACM},
author = {Hutton, Graham},
year = {1998},
note = {event-place: Baltimore, Maryland, USA},
month = apr,
year = {1991},
note = {Place: New York, NY, USA
-Publisher: Association for Computing Machinery},
+Publisher: ACM},
keywords = {theory},
pages = {237--268},
file = {Abadi et al. - 1991 - Dynamic typing in a statically typed language.pdf:/home/mrl/.local/share/zotero/storage/CJSBG6X7/Abadi et al. - 1991 - Dynamic typing in a statically typed language.pdf:application/pdf},
doi = {10.1145/2103786.2103795},
abstract = {Static type systems strive to be richly expressive while still being simple enough for programmers to use. We describe an experiment that enriches Haskell's kind system with two features promoted from its type system: data types and polymorphism. The new system has a very good power-to-weight ratio: it offers a significant improvement in expressiveness, but, by re-using concepts that programmers are already familiar with, the system is easy to understand and implement.},
booktitle = {Proceedings of the 8th {ACM} {SIGPLAN} {Workshop} on {Types} in {Language} {Design} and {Implementation}},
- publisher = {Association for Computing Machinery},
- author = {Yorgey, Brent A. and Weirich, Stephanie and Cretin, Julien and Peyton Jones, Simon and Vytiniotis, Dimitrios and Magalhães, José Pedro},
+ publisher = {ACM},
+ author = {Yorgey, Brent A. and Weirich, Stephanie and Cretin, Julien and Peyton Jones, Simon and Vytiniotis, Dimitrios and Magalh\~{a}es, Jos\'{e} Pedro},
year = {2012},
note = {event-place: Philadelphia, Pennsylvania, USA},
keywords = {haskell, kinds, polymorphism, promotion},
doi = {10.1145/1596638.1596644},
abstract = {Higher-order abstract syntax provides a convenient way of embedding domain-specific languages, but is awkward to analyse and manipulate directly. We explore the boundaries of higher-order abstract syntax. Our key tool is the unembedding of embedded terms as de Bruijn terms, enabling intensional analysis. As part of our solution we present techniques for separating the definition of an embedded program from its interpretation, giving modular extensions of the embedded language, and different ways to encode the types of the embedded language.},
booktitle = {Proceedings of the 2nd {ACM} {SIGPLAN} {Symposium} on {Haskell}},
- publisher = {Association for Computing Machinery},
+ publisher = {ACM},
author = {Atkey, Robert and Lindley, Sam and Yallop, Jeremy},
year = {2009},
note = {event-place: Edinburgh, Scotland},
booktitle = {Central {European} {Functional} {Programming} {School}: 5th {Summer} {School}, {CEFP} 2013, {Cluj}-{Napoca}, {Romania}, {July} 8-20, 2013, {Revised} {Selected} {Papers}},
publisher = {Springer International Publishing},
author = {Gibbons, Jeremy},
- editor = {Zsók, Viktória and Horváth, Zoltán and Csató, Lehel},
+ editor = {Zs\'{o}k, Vikt\'{o}ria and Horv\'{a}th, Zolt\'{a}n and Csat\'{o}, Lehel},
year = {2015},
doi = {10.1007/978-3-319-15940-9_1},
pages = {1--28},
file = {thesis_final.pdf:/home/mrl/.local/share/zotero/storage/Y9QWGGB9/thesis_final.pdf:application/pdf},
}
-@phdthesis{alimarine_generic_2005,
- address = {Nijmegen},
- type = {{PhD}},
- title = {Generic {Functional} {Programming}},
- language = {en},
- school = {Radboud University},
- author = {Alimarine, Artem},
- year = {2005},
- file = {Alimarine - Generic Functional Programming.pdf:/home/mrl/.local/share/zotero/storage/PDTS3SGX/Alimarine - Generic Functional Programming.pdf:application/pdf},
-}
-
@phdthesis{de_boer_secure_2020,
address = {Nijmegen},
type = {Bachelor's {Thesis}},
volume = {1},
booktitle = {{PARLE}, {Parallel} {Architectures} and {Languages} {Europe}},
publisher = {Springer Verlag},
- author = {Barendregt, HP and van Eekelen, MCJD and Glauert, JRW and Kennaway, JR and Plasmeijer, MJ and Sleep, MR},
+ author = {Barendregt, H.P. and \noopsort{Eekelen}{van Eekelen}, M.C.J.D and Glauert, J.R.W. and Kennaway, J.R. and Plasmeijer, M.J. and Sleep, M.R.},
year = {1987},
pages = {159--174},
file = {barh87-Lean.ps.gz:/home/mrl/.local/share/zotero/storage/63FBHND7/barh87-Lean.ps.gz:application/gzip;barh87-Lean.ps.gz:/home/mrl/.local/share/zotero/storage/6H2UKQGZ/barh87-Lean.ps.gz:application/gzip},
@article{dube_bit:_2000,
title = {{BIT}: {A} very compact {Scheme} system for embedded applications},
journal = {Proceedings of the Fourth Workshop on Scheme and Functional Programming},
- author = {Dubé, Danny},
+ author = {Dub\'{e}, Danny},
year = {2000},
file = {dube.ps:/home/mrl/.local/share/zotero/storage/RNG6V7HT/dube.ps:application/postscript},
}
title = {{PICBIT}: {A} {Scheme} system for the {PIC} microcontroller},
booktitle = {Proceedings of the {Fourth} {Workshop} on {Scheme} and {Functional} {Programming}},
publisher = {Citeseer},
- author = {Feeley, Marc and Dubé, Danny},
+ author = {Feeley, Marc and Dub\'{e}, Danny},
year = {2003},
pages = {7--15},
- file = {Feeley and Dubé - 2003 - PICBIT A Scheme system for the PIC microcontrolle.pdf:/home/mrl/.local/share/zotero/storage/EAEJSKNR/Feeley and Dubé - 2003 - PICBIT A Scheme system for the PIC microcontrolle.pdf:application/pdf},
}
@inproceedings{st-amour_picobit:_2009,
few changes in existing programs.},
language = {en},
school = {Radboud University},
- author = {Böhm, Haye},
+ author = {B\"{o}hm, Haye},
month = jan,
year = {2019},
file = {Bohm - Asynchronous Actions in a Synchronous World.pdf:/home/mrl/.local/share/zotero/storage/D3IYPAM5/Bohm - Asynchronous Actions in a Synchronous World.pdf:application/pdf},
file = {Baccelli et al. - 2018 - Reprogramming Low-end IoT Devices from the Cloud.pdf:/home/mrl/.local/share/zotero/storage/M6LX5ZJN/Baccelli et al. - 2018 - Reprogramming Low-end IoT Devices from the Cloud.pdf:application/pdf},
}
+@phdthesis{alimarine_generic_2005,
+ address = {Nijmegen},
+ type = {{PhD} {Thesis}},
+ title = {Generic {Functional} {Programming}},
+ language = {en},
+ school = {Radboud University},
+ author = {Alimarine, Artem},
+ year = {2005},
+ file = {Alimarine - Generic Functional Programming.pdf:/home/mrl/.local/share/zotero/storage/L4THNJHB/Alimarine - Generic Functional Programming.pdf:application/pdf},
+}
+
@inproceedings{wand_continuation-based_1980,
address = {Stanford University, California, United States},
title = {Continuation-based multiprocessing},
- url = {http://portal.acm.org/citation.cfm?doid=800087.802786},
doi = {10.1145/800087.802786},
abstract = {Any multiprocessing facility must include three features: elementary exclusion, data protection, and process saving. While elementary exclusion must rest on some hardware facility (e.g., a test-and-set instruction), the other two requirements are fulfilled by features already present in applicative languages. Data protection may be obtained through the use of procedures (closures or funargs), and process saving may be obtained through the use of the catch operator. The use of catch, in particular, allows an elegant treatment of process saving.},
language = {en},
shorttitle = {Exchanging sources between {Clean} and {Haskell}},
number = {11},
journal = {ACM Sigplan Notices},
- author = {van Groningen, John and van Noort, Thomas and Achten, Peter and Koopman, Pieter and Plasmeijer, Rinus},
+ author = {\noopsort{Groningen}{van Groningen}, John and \noopsort{Noort}{van Noort}, Thomas and Achten, Peter and Koopman, Pieter and Plasmeijer, Rinus},
year = {2010},
pages = {49--60},
file = {groj10-Haskell_front_end_Clean.pdf:/home/mrl/.local/share/zotero/storage/WVZWX8WT/groj10-Haskell_front_end_Clean.pdf:application/pdf},
month = oct,
year = {2019},
note = {Place: New York, NY, USA
-Publisher: Association for Computing Machinery},
+Publisher: ACM},
keywords = {aspect-oriented programming, generative programming, macro systems, meta-object protocols, Metaprogramming, multistage languages, reflection},
file = {Lilis and Savidis - 2019 - A Survey of Metaprogramming Languages.pdf:/home/mrl/.local/share/zotero/storage/9MS6TUNR/Lilis and Savidis - 2019 - A Survey of Metaprogramming Languages.pdf:application/pdf},
}
doi = {10.1145/1291201.1291211},
abstract = {Quasiquoting allows programmers to use domain specific syntax to construct program fragments. By providing concrete syntax for complex data types, programs become easier to read, easier to write, and easier to reason about and maintain. Haskell is an excellent host language for embedded domain specific languages, and quasiquoting ideally complements the language features that make Haskell perform so well in this area. Unfortunately, until now no Haskell compiler has provided support for quasiquoting. We present an implementation in GHC and demonstrate that by leveraging existing compiler capabilities, building a full quasiquoter requires little more work than writing a parser. Furthermore, we provide a compile-time guarantee that all quasiquoted data is type-correct.},
booktitle = {Proceedings of the {ACM} {SIGPLAN} {Workshop} on {Haskell} {Workshop}},
- publisher = {Association for Computing Machinery},
+ publisher = {ACM},
author = {Mainland, Geoffrey},
year = {2007},
note = {event-place: Freiburg, Germany},
month = oct,
year = {2008},
note = {Place: New York, NY, USA
-Publisher: Association for Computing Machinery},
- keywords = {domain specific languages, compile-time meta-programming, Syntax extension},
+Publisher: ACM},
+ keywords = {compile-time meta-programming, domain specific languages, Syntax extension},
file = {Tratt - 2008 - Domain Specific Language Implementation via Compil.pdf:/home/mrl/.local/share/zotero/storage/HHGYJK4H/Tratt - 2008 - Domain Specific Language Implementation via Compil.pdf:application/pdf},
}
doi = {10.1145/1411286.1411300},
abstract = {Monads as an organizing principle for programming and semantics are notoriously difficult to grasp, yet they are a central and powerful abstraction in Haskell. This paper introduces a domain-specific language, MonadLab, that simplifies the construction of monads, and describes its implementation in Template Haskell. MonadLab makes monad construction truly first class, meaning that arcane theoretical issues with respect to monad transformers are completely hidden from the programmer. The motivation behind the design of MonadLab is to make monadic programming in Haskell simpler while providing a tool for non-Haskell experts that will assist them in understanding this powerful abstraction.},
booktitle = {Proceedings of the {First} {ACM} {SIGPLAN} {Symposium} on {Haskell}},
- publisher = {Association for Computing Machinery},
+ publisher = {ACM},
author = {Kariotis, Pericles S. and Procter, Adam M. and Harrison, William L.},
year = {2008},
note = {event-place: Victoria, BC, Canada},
doi = {10.1145/581690.581691},
abstract = {We propose a new extension to the purely functional programming language Haskell that supports compile-time meta-programming. The purpose of the system is to support the algorithmic construction of programs at compile-time.The ability to generate code at compile time allows the programmer to implement such features as polytypic programs, macro-like expansion, user directed optimization (such as inlining), and the generation of supporting data structures and functions from existing data structures and functions.Our design is being implemented in the Glasgow Haskell Compiler, ghc.},
booktitle = {Proceedings of the 2002 {ACM} {SIGPLAN} {Workshop} on {Haskell}},
- publisher = {Association for Computing Machinery},
+ publisher = {ACM},
author = {Sheard, Tim and Peyton Jones, Simon},
year = {2002},
note = {event-place: Pittsburgh, Pennsylvania},
doi = {10.1145/2364506.2364509},
abstract = {Generic programming allows the concise expression of algorithms that would otherwise require large amounts of handwritten code. A number of such systems have been developed over the years, but a common drawback of these systems is poor runtime performance relative to handwritten, non-generic code. Generic-programming systems vary significantly in this regard, but few consistently match the performance of handwritten code. This poses a dilemma for developers. Generic-programming systems offer concision but cost performance. Handwritten code offers performance but costs concision.This paper explores the use of Template Haskell to achieve the best of both worlds. It presents a generic-programming system for Haskell that provides both the concision of other generic-programming systems and the efficiency of handwritten code. Our system gives the programmer a high-level, generic-programming interface, but uses Template Haskell to generate efficient, non-generic code that outperforms existing generic-programming systems for Haskell.This paper presents the results of benchmarking our system against both handwritten code and several other generic-programming systems. In these benchmarks, our system matches the performance of handwritten code while other systems average anywhere from two to twenty times slower.},
booktitle = {Proceedings of the 2012 {Haskell} {Symposium}},
- publisher = {Association for Computing Machinery},
+ publisher = {ACM},
author = {Adams, Michael D. and DuBuisson, Thomas M.},
year = {2012},
note = {event-place: Copenhagen, Denmark},
doi = {10.1017/S0956796802004574},
number = {3},
journal = {Journal of Functional Programming},
- author = {Elliott, Conal and Finne, Sigbjørn and de Moor, Oege},
+ author = {Elliott, Conal and Finne, Sigbjørn and \noopsort{Moor}{de Moor}, Oege},
year = {2003},
note = {Publisher: Cambridge University Press},
pages = {455--481},
abstract = {A wide range of domain-specific languages (DSLs) has been implemented successfully by embedding them in general purpose languages. This paper reviews embedding, and summarizes how two alternative techniques – staged interpreters and templates – can be used to overcome the limitations of embedding. Both techniques involve a form of generative programming. The paper reviews and compares three programming languages that have special support for generative programming. Two of these languages (MetaOCaml and Template Haskell) are research languages, while the third (C++) is already in wide industrial use. The paper identifies several dimensions that can serve as a basis for comparing generative languages.},
booktitle = {Domain-{Specific} {Program} {Generation}: {International} {Seminar}, {Dagstuhl} {Castle}, {Germany}, {March} 23-28, 2003. {Revised} {Papers}},
publisher = {Springer Berlin Heidelberg},
- author = {Czarnecki, Krzysztof and O'Donnell, John T. and Striegnitz, Jörg and Taha, Walid},
+ author = {Czarnecki, Krzysztof and O'Donnell, John T. and Striegnitz, J\"{o}rg and Taha, Walid},
editor = {Lengauer, Christian and Batory, Don and Consel, Charles and Odersky, Martin},
year = {2004},
doi = {10.1007/978-3-540-25935-0_4},
isbn = {0-89791-200-4},
doi = {10.1145/319838.319859},
booktitle = {Proceedings of the 1986 {ACM} {Conference} on {LISP} and {Functional} {Programming}},
- publisher = {Association for Computing Machinery},
+ publisher = {ACM},
author = {Kohlbecker, Eugene and Friedman, Daniel P. and Felleisen, Matthias and Duba, Bruce},
year = {1986},
note = {event-place: Cambridge, Massachusetts, USA},
doi = {10.1145/604174.604179},
abstract = {We describe a design pattern for writing programs that traverse data structures built from rich mutually-recursive data types. Such programs often have a great deal of "boilerplate" code that simply walks the structure, hiding a small amount of "real" code that constitutes the reason for the traversal.Our technique allows most of this boilerplate to be written once and for all, or even generated mechanically, leaving the programmer free to concentrate on the important part of the algorithm. These generic programs are much more adaptive when faced with data structure evolution because they contain many fewer lines of type-specific code.Our approach is simple to understand, reasonably efficient, and it handles all the data types found in conventional functional programming languages. It makes essential use of rank-2 polymorphism, an extension found in some implementations of Haskell. Further it relies on a simple type-safe cast operator.},
booktitle = {Proceedings of the 2003 {ACM} {SIGPLAN} {International} {Workshop} on {Types} in {Languages} {Design} and {Implementation}},
- publisher = {Association for Computing Machinery},
- author = {Lämmel, Ralf and Peyton Jones, Simon},
+ publisher = {ACM},
+ author = {L\"{a}mmel, Ralf and Peyton Jones, Simon},
year = {2003},
note = {event-place: New Orleans, Louisiana, USA},
keywords = {generic programming, rank-2 types, traversal, type cast},
pages = {26--37},
- file = {Lämmel and Jones - 2003 - Scrap Your Boilerplate A Practical Design Pattern.pdf:/home/mrl/.local/share/zotero/storage/P2PJYYY3/Lämmel and Jones - 2003 - Scrap Your Boilerplate A Practical Design Pattern.pdf:application/pdf},
}
@inproceedings{bawden_quasiquotation_1999,
doi = {10.1145/2658761.2658770},
abstract = {This paper presents a library called LibDSL that helps the implementer of an embedded domain specific language (EDSL) effectively develop it in D language. The LibDSL library accepts as input some kinds of “specifications” of the EDSL that the implementer is going to develop and a D program within which an EDSL source program written by the user is embedded. It produces the front-end code of an LALR parser for the EDSL program and back-end code of the execution engine. LibDSL is able to produce two kinds of execution engines, namely compiler-based and interpreter-based engines, either of which the user can properly choose depending on whether an EDSL program is known at compile time or not. We have implemented the LibDSL system by using template metaprogramming and other advanced facilities such as compile-time function execution of D language. EDSL programs developed by means of LibDSL have a nice integrativeness with the host language.},
booktitle = {Proceedings of the 2014 {International} {Conference} on {Generative} {Programming}: {Concepts} and {Experiences}},
- publisher = {Association for Computing Machinery},
+ publisher = {ACM},
author = {Shioda, Masato and Iwasaki, Hideya and Sato, Shigeyuki},
year = {2014},
- note = {event-place: Västerås, Sweden},
- keywords = {Metaprogramming, D language, Embedded domain specific languages, Library},
+ note = {event-place: V\"{a}ster\r{a}s, Sweden},
+ keywords = {D language, Embedded domain specific languages, Library, Metaprogramming},
pages = {63--72},
file = {Shioda et al. - 2014 - LibDSL A Library for Developing Embedded Domain S.pdf:/home/mrl/.local/share/zotero/storage/3WFYJPFR/Shioda et al. - 2014 - LibDSL A Library for Developing Embedded Domain S.pdf:application/pdf},
}
doi = {10.1145/2034675.2034689},
abstract = {We present a novel method of embedding context-free grammars in Haskell, and to automatically generate parsers and pretty-printers from them. We have implemented this method in a library called BNFC-meta (from the BNF Converter, which it is built on). The library builds compiler front ends using metaprogramming instead of conventional code generation. Parsers are built from labelled BNF grammars that are defined directly in Haskell modules. Our solution combines features of parser generators (static grammar checks, a highly specialised grammar DSL) and adds several features that are otherwise exclusive to combinatory libraries such as the ability to reuse, parameterise and generate grammars inside Haskell.To allow writing grammars in concrete syntax, BNFC-meta provides a quasi-quoter that can parse grammars (embedded in Haskell files) at compile time and use metaprogramming to replace them with their abstract syntax. We also generate quasi-quoters so that the languages we define with BNFC-meta can be embedded in the same way. With a minimal change to the grammar, we support adding anti-quotation to the generated quasi-quoters, which allows users of the defined language to mix concrete and abstract syntax almost seamlessly. Unlike previous methods of achieving anti-quotation, the method used by BNFC-meta is simple, efficient and avoids polluting the abstract syntax types.},
booktitle = {Proceedings of the 4th {ACM} {Symposium} on {Haskell}},
- publisher = {Association for Computing Machinery},
- author = {Duregård, Jonas and Jansson, Patrik},
+ publisher = {ACM},
+ author = {Dureg\r{a}rd, Jonas and Jansson, Patrik},
year = {2011},
note = {event-place: Tokyo, Japan},
keywords = {domain specific languages, metaprogramming},
pages = {107--117},
- file = {Duregård and Jansson - 2011 - Embedded Parser Generators.pdf:/home/mrl/.local/share/zotero/storage/H5A8TPWV/Duregård and Jansson - 2011 - Embedded Parser Generators.pdf:application/pdf},
}
@inproceedings{eisenberg_promoting_2014,
doi = {10.1145/2633357.2633361},
abstract = {Haskell, as implemented in the Glasgow Haskell Compiler (GHC), is enriched with many extensions that support type-level programming, such as promoted datatypes, kind polymorphism, and type families. Yet, the expressiveness of the type-level language remains limited. It is missing many features present at the term level, including case expressions, anonymous functions, partially-applied functions, and let expressions. In this paper, we present an algorithm - with a proof of correctness - to encode these term-level constructs at the type level. Our approach is automated and capable of promoting a wide array of functions to type families. We also highlight and discuss those term-level features that are not promotable. In so doing, we offer a critique on GHC's existing type system, showing what it is already capable of and where it may want improvement.We believe that delineating the mismatch between GHC's term level and its type level is a key step toward supporting dependently typed programming.},
booktitle = {Proceedings of the 2014 {ACM} {SIGPLAN} {Symposium} on {Haskell}},
- publisher = {Association for Computing Machinery},
+ publisher = {ACM},
author = {Eisenberg, Richard A. and Stolarek, Jan},
year = {2014},
note = {event-place: Gothenburg, Sweden},
- keywords = {Haskell, defunctionalization, type-level programming},
+ keywords = {defunctionalization, Haskell, type-level programming},
pages = {95--106},
file = {Eisenberg and Stolarek - 2014 - Promoting Functions to Type Families in Haskell.pdf:/home/mrl/.local/share/zotero/storage/PQXGBM6M/Eisenberg and Stolarek - 2014 - Promoting Functions to Type Families in Haskell.pdf:application/pdf},
}
doi = {10.1145/3310232.3310235},
abstract = {In this paper, we present an embedding of attribute grammars in Haskell, that is both modular and type-safe, while providing the user with domain specific error messages.Our approach involves to delay part of the safety checks to runtime. When a grammar is correct, we are able to extract a function that can be run without expecting any runtime error related to the EDSL.},
booktitle = {Proceedings of the 30th {Symposium} on {Implementation} and {Application} of {Functional} {Languages}},
- publisher = {Association for Computing Machinery},
+ publisher = {ACM},
author = {Viera, Marcos and Balestrieri, Florent and Pardo, Alberto},
year = {2018},
note = {event-place: Lowell, MA, USA},
- keywords = {Haskell, EDSL, Attribute Grammars, Dynamics, Staging},
+ keywords = {Attribute Grammars, Dynamics, EDSL, Haskell, Staging},
pages = {95--106},
file = {Viera et al. - 2018 - A Staged Embedding of Attribute Grammars in Haskel.pdf:/home/mrl/.local/share/zotero/storage/53D4HT9C/Viera et al. - 2018 - A Staged Embedding of Attribute Grammars in Haskel.pdf:application/pdf},
}
doi = {10.1017/S0956796800001817},
number = {3},
journal = {Journal of Functional Programming},
- author = {Läufer, Konstantin},
+ author = {L\"{a}ufer, Konstantin},
year = {1996},
note = {Publisher: Cambridge University Press},
pages = {485--518},
- file = {Läufer - 1996 - Type classes with existential types.pdf:/home/mrl/.local/share/zotero/storage/FG73PZJE/Läufer - 1996 - Type classes with existential types.pdf:application/pdf},
}
@incollection{hinze_fun_2003,
doi = {10.1145/2364506.2364524},
abstract = {Though Haskell is predominantly type-safe, implementations contain a few loopholes through which code can bypass typing and module encapsulation. This paper presents Safe Haskell, a language extension that closes these loopholes. Safe Haskell makes it possible to confine and safely execute untrusted, possibly malicious code. By strictly enforcing types, Safe Haskell allows a variety of different policies from API sandboxing to information-flow control to be implemented easily as monads. Safe Haskell is aimed to be as unobtrusive as possible. It enforces properties that programmers tend to meet already by convention. We describe the design of Safe Haskell and an implementation (currently shipping with GHC) that infers safety for code that lies in a safe subset of the language. We use Safe Haskell to implement an online Haskell interpreter that can securely execute arbitrary untrusted code with no overhead. The use of Safe Haskell greatly simplifies this task and allows the use of a large body of existing code and tools.},
booktitle = {Proceedings of the 2012 {Haskell} {Symposium}},
- publisher = {Association for Computing Machinery},
+ publisher = {ACM},
author = {Terei, David and Marlow, Simon and Peyton Jones, Simon and Mazières, David},
year = {2012},
note = {event-place: Copenhagen, Denmark},
doi = {10.1145/2628136.2628138},
abstract = {A domain-specific language can be implemented by embedding within a general-purpose host language. This embedding may be deep or shallow, depending on whether terms in the language construct syntactic or semantic representations. The deep and shallow styles are closely related, and intimately connected to folds; in this paper, we explore that connection.},
booktitle = {Proceedings of the 19th {ACM} {SIGPLAN} {International} {Conference} on {Functional} {Programming}},
- publisher = {Association for Computing Machinery},
+ publisher = {ACM},
author = {Gibbons, Jeremy and Wu, Nicolas},
year = {2014},
note = {event-place: Gothenburg, Sweden},
- keywords = {domain-specific languages, deep and shallow embedding, folds},
+ keywords = {deep and shallow embedding, domain-specific languages, folds},
pages = {339--347},
file = {Gibbons and Wu - 2014 - Folding Domain-Specific Languages Deep and Shallo.pdf:/home/mrl/.local/share/zotero/storage/6WNWSLFJ/Gibbons and Wu - 2014 - Folding Domain-Specific Languages Deep and Shallo.pdf:application/pdf},
}
doi = {10.1145/1088348.1088358},
abstract = {A type-indexed function is a function that is defined for each member of some family of types. Haskell's type class mechanism provides collections of open type-indexed functions, in which the indexing family can be extended by defining a new type class instance but the collection of functions is fixed. The purpose of this paper is to present TypeCase: a design pattern that allows the definition of closed type-indexed functions, in which the index family is fixed but the collection of functions is extensible. It is inspired by Cheney and Hinze's work on lightweight approaches to generic programming. We generalise their techniques as a design pattern. Furthermore, we show that type-indexed functions with type-indexed types, and consequently generic functions with generic types, can also be encoded in a lightweight manner, thereby overcoming one of the main limitations of the lightweight approaches.},
booktitle = {Proceedings of the 2005 {ACM} {SIGPLAN} {Workshop} on {Haskell}},
- publisher = {Association for Computing Machinery},
+ publisher = {ACM},
author = {Oliveira, Bruno C. d. S. and Gibbons, Jeremy},
year = {2005},
note = {event-place: Tallinn, Estonia},
doi = {10.1145/237721.237729},
abstract = {We study an extension of the Hindley/Milner system with explicit type scheme annotations and type declarations. The system can express polymorphic function arguments, user-defined data types with abstract components, and structure types with polymorphic fields. More generally, all programs of the polymorphic lambda calculus can be encoded by a translation between typing derivations. We show that type reconstruction in this system can be reduced to the decidable problem of first-order unification under a mixed prefix.},
booktitle = {Proceedings of the 23rd {ACM} {SIGPLAN}-{SIGACT} {Symposium} on {Principles} of {Programming} {Languages}},
- publisher = {Association for Computing Machinery},
- author = {Odersky, Martin and Läufer, Konstantin},
+ publisher = {ACM},
+ author = {Odersky, Martin and L\"{a}ufer, Konstantin},
year = {1996},
note = {event-place: St. Petersburg Beach, Florida, USA},
pages = {54--67},
- file = {Odersky and Läufer - 1996 - Putting Type Annotations to Work.pdf:/home/mrl/.local/share/zotero/storage/WC37TU5H/Odersky and Läufer - 1996 - Putting Type Annotations to Work.pdf:application/pdf},
}
@inproceedings{najd_everything_2016,
doi = {10.1145/2847538.2847541},
abstract = {We describe a new approach to implementing Domain-Specific Languages(DSLs), called Quoted DSLs (QDSLs), that is inspired by two old ideas:quasi-quotation, from McCarthy's Lisp of 1960, and the subformula principle of normal proofs, from Gentzen's natural deduction of 1935. QDSLs reuse facilities provided for the host language, since host and quoted terms share the same syntax, type system, and normalisation rules. QDSL terms are normalised to a canonical form, inspired by the subformula principle, which guarantees that one can use higher-order types in the source while guaranteeing first-order types in the target, and enables using types to guide fusion. We test our ideas by re-implementing Feldspar, which was originally implemented as an Embedded DSL (EDSL), as a QDSL; and we compare the QDSL and EDSL variants. The two variants produce identical code.},
booktitle = {Proceedings of the 2016 {ACM} {SIGPLAN} {Workshop} on {Partial} {Evaluation} and {Program} {Manipulation}},
- publisher = {Association for Computing Machinery},
+ publisher = {ACM},
author = {Najd, Shayan and Lindley, Sam and Svenningsson, Josef and Wadler, Philip},
year = {2016},
note = {event-place: St. Petersburg, FL, USA},
- keywords = {EDSL, domain-specific language, DSL, embedded language, normalisation, QDSL, quotation, subformula principle},
+ keywords = {domain-specific language, DSL, EDSL, embedded language, normalisation, QDSL, quotation, subformula principle},
pages = {25--36},
file = {Najd et al. - 2016 - Everything Old is New Again Quoted Domain-Specifi.pdf:/home/mrl/.local/share/zotero/storage/NZJW5ZVF/Najd et al. - 2016 - Everything Old is New Again Quoted Domain-Specifi.pdf:application/pdf},
}
doi = {10.1145/331960.331977},
abstract = {Domain-specific embedded languages (DSELs) expressed in higher-order, typed (HOT) languages provide a composable framework for domain-specific abstractions. Such a framework is of greater utility than a collection of stand-alone domain-specific languages. Usually, embedded domain specific languages are build on top of a set of domain specific primitive functions that are ultimately implemented using some form of foreign function call. We sketch a general design pattern/or embedding client-server style services into Haskell using a domain specific embedded compiler for the server's source language. In particular we apply this idea to implement Haskell/DB, a domain specific embdedded compiler that dynamically generates of SQL queries from monad comprehensions, which are then executed on an arbitrary ODBC database server.},
booktitle = {Proceedings of the 2nd {Conference} on {Domain}-{Specific} {Languages}},
- publisher = {Association for Computing Machinery},
+ publisher = {ACM},
author = {Leijen, Daan and Meijer, Erik},
year = {2000},
note = {event-place: Austin, Texas, USA},
title = {Clean {Language} {Report} version 3.1},
urldate = {2021-12-22},
institution = {Institute for Computing and Information Sciences},
- author = {Plasmeijer, Rinus and van Eekelen, Marko and van Groningen, John},
+ author = {Plasmeijer, Rinus and \noopsort{Eekelen}{van Eekelen}, Marko and \noopsort{Groningen}{van Groningen}, John},
month = dec,
year = {2021},
pages = {127},
abstract = {Concurrent Clean is an experimental, lazy, higher-order parallel functional programming language based on term graph rewriting. An important difference with other languages is that in Clean graphs are manipulated and not terms. This can be used by the programmer to control communication and sharing of computation. Cyclic structures can be defined. Concurrent Clean furthermore allows to control the (parallel) order of evaluation to make efficient evaluation possible. With help of sequential annotations the default lazy evaluation can be locally changed into eager evaluation. The language enables the definition of partially strict data structures which make a whole new class of algorithms feasible in a functional language. A powerful and fast strictness analyser is incorporated in the system. The quality of the code generated by the Clean compiler has been greatly improved such that it is one of the best code generators for a lazy functional language. Two very powerful parallel annotations enable the programmer to define concurrent functional programs with arbitrary process topologies. Concurrent Clean is set up in such a way that the efficiency achieved for the sequential case can largely be maintained for a parallel implementation on loosely coupled parallel machine architectures.},
booktitle = {{PARLE} '91 {Parallel} {Architectures} and {Languages} {Europe}},
publisher = {Springer Berlin Heidelberg},
- author = {Nöcker, E. G. J. M. H. and Smetsers, J. E. W. and van Eekelen, M. C. J. D. and Plasmeijer, M. J.},
+ author = {N\"{o}cker, E. G. J. M. H. and Smetsers, J. E. W. and \noopsort{Eekelen}{van Eekelen}, M. C. J. D. and Plasmeijer, M. J.},
editor = {Aarts, Emile H. L. and van Leeuwen, Jan and Rem, Martin},
year = {1991},
pages = {202--219},
- file = {Nöcker et al. - 1991 - Concurrent clean.pdf:/home/mrl/.local/share/zotero/storage/XHTNR7BR/Nöcker et al. - 1991 - Concurrent clean.pdf:application/pdf},
}
@inproceedings{staps_lazy_2019,
doi = {10.1145/3412932.3412941},
abstract = {More and more applications rely on the safe execution of code unknown at compile-time, for example in the implementation of web browsers and plugin systems. Furthermore, these applications usually require some form of communication between the added code and its embedder, and hence a communication channel must be set up in which values are serialized and deserialized. This paper shows that in a functional programming language we can solve these two problems at once, if we realize that the execution of extra code is nothing more than the deserialization of a value which happens to be a function. To demonstrate this, we describe the implementation of a serialization library for the language Clean, which internally uses an interpreter to evaluate added code in a separate, sandboxed environment. Remarkable is that despite the conceptual asymmetry between "host" and "interpreter", lazy interworking must be implemented in a highly symmetric fashion, much akin to distributed systems. The library interworks on a low level with the native Clean program, but has been implemented without any changes to the native runtime system. It can therefore easily be ported to other programming languages.We can use the same technique in the context of the web, where we want to be able to share possibly lazy values between a server and a client. In this case the interpreter runs in WebAssembly in the browser and communicates seamlessly with the server, written in Clean. We use this in the iTasks web framework to handle communication and offload computations to the client to reduce stress on the server-side. Previously, this framework cross-compiled the Clean source code to JavaScript and used JSON for communication. The interpreter has a more predictable and better performance, and integration is much simpler because it interworks on a lower level with the web server.},
booktitle = {Proceedings of the 31st {Symposium} on {Implementation} and {Application} of {Functional} {Languages}},
- publisher = {Association for Computing Machinery},
- author = {Staps, Camil and van Groningen, John and Plasmeijer, Rinus},
+ publisher = {ACM},
+ author = {Staps, Camil and \noopsort{Groningen}{van Groningen}, John and Plasmeijer, Rinus},
year = {2019},
note = {event-place: Singapore, Singapore},
keywords = {functional programming, interpreters, laziness, sandboxing, web-assembly},
doi = {10.1145/3354166.3354182},
abstract = {Software that models how people work is omnipresent in today's society. Current languages and frameworks often focus on usability by non-programmers, sacrificing flexibility and high level abstraction. Task-oriented programming (TOP) is a programming paradigm that aims to provide the desired level of abstraction while still being expressive enough to describe real world collaboration. It prescribes a declarative programming style to specify multi-user workflows. Workflows can be higher-order. They communicate through typed values on a local and global level. Such specifications can be turned into interactive applications for different platforms, supporting collaboration during execution. TOP has been around for more than a decade, in the forms of iTasks and mTasks, which are tailored for real-world usability. So far, it has not been given a formalisation which is suitable for formal reasoning.In this paper we give a description of the TOP paradigm and then decompose its rich features into elementary language elements, which makes them suitable for formal treatment. We use the simply typed lambda-calculus, extended with pairs and references, as a base language. On top of this language, we develop TopHat, a language for modular interactive workflows. We describe TopHat by means of a layered semantics. These layers consist of multiple big-step evaluations on expressions, and two labelled transition systems, handling user inputs.With TopHat we prepare a way to formally reason about TOP languages and programs. This approach allows for comparison with other work in the field. We have implemented the semantic rules of TopHat in Haskell, and the task layer on top of the iTasks framework. This shows that our approach is feasible, and lets us demonstrate the concepts by means of illustrative case studies. TOP has been applied in projects with the Dutch coast guard, tax office, and navy. Our work matters because formal program verification is important for mission-critical software, especially for systems with concurrency.},
booktitle = {Proceedings of the 21st {International} {Symposium} on {Principles} and {Practice} of {Declarative} {Programming}},
- publisher = {Association for Computing Machinery},
+ publisher = {ACM},
author = {Steenvoorden, Tim and Naus, Nico and Klinik, Markus},
year = {2019},
note = {event-place: Porto, Portugal},
booktitle = {Central {European} {Functional} {Programming} {School}: 6th {Summer} {School}, {CEFP} 2015, {Budapest}, {Hungary}, {July} 6–10, 2015, {Revised} {Selected} {Papers}},
publisher = {Springer International Publishing},
author = {Koopman, Pieter and Plasmeijer, Rinus},
- editor = {Zsók, Viktória and Porkoláb, Zoltán and Horváth, Zoltán},
+ editor = {Zs\'{o}k, Vikt\'{o}ria and Porkol\'{a}b, Zolt\'{a}n and Horv\'{a}th, Zolt\'{a}n},
year = {2019},
doi = {10.1007/978-3-030-28346-9_8},
pages = {283--340},
month = jul,
year = {1988},
note = {Place: New York, NY, USA
-Publisher: Association for Computing Machinery},
+Publisher: ACM},
pages = {470--502},
file = {Mitchell and Plotkin - 1988 - Abstract types have existential type.pdf:/home/mrl/.local/share/zotero/storage/QXDE5H7C/Mitchell and Plotkin - 1988 - Abstract types have existential type.pdf:application/pdf},
}
doi = {10.1145/581478.581494},
abstract = {Even when programming in a statically typed language we every now and then encounter statically untypable values; such values result from interpreting values or from communicating with the outside world. To cope with this problem most languages include some form of dynamic types. It may be that the core language has been explicitly extended with such a type, or that one is allowed to live dangerously by using functions like unsafeCoerce. We show how, by a careful use of existentially and universally quantified types, one may achievem the same effect, without extending the language with new or unsafe features. The techniques explained are universally applicable, provided the core language is expressive enough; this is the case for the common implementations of Haskell. The techniques are used in the description of a type checking compiler that, starting from an expression term, constructs a typed function representing the semantics of that expression. In this function the overhead associated with the type checking is only once being paid for; in this sense we have thus achieved static type checking.},
booktitle = {Proceedings of the {Seventh} {ACM} {SIGPLAN} {International} {Conference} on {Functional} {Programming}},
- publisher = {Association for Computing Machinery},
+ publisher = {ACM},
author = {Baars, Arthur I. and Swierstra, S. Doaitse},
year = {2002},
note = {event-place: Pittsburgh, PA, USA},
month = feb,
year = {2021},
note = {Place: New York, NY, USA
-Publisher: Association for Computing Machinery},
- keywords = {Internet of Things, design principles, non functional requirements, notation, software design tools, software engineering},
+Publisher: ACM},
+ keywords = {design principles, Internet of Things, non functional requirements, notation, software design tools, software engineering},
file = {Alhirabi et al. - 2021 - Security and Privacy Requirements for the Internet.pdf:/home/mrl/.local/share/zotero/storage/7UN4IF62/Alhirabi et al. - 2021 - Security and Privacy Requirements for the Internet.pdf:text/html},
}
author = {Wadler, Philip},
month = nov,
year = {1998},
- note = {e-mail message, accessed on 2021-02-24},
+ note = {e-mail message, accessed-on: 2021-02-24},
}
@misc{margaret_deuter_rhapsody_2015,
doi = {10.1145/158511.158524},
abstract = {We present a new model, based on monads, for performing input/output in a non-strict, purely functional language. It is composable, extensible, efficient, requires no extensions to the type system, and extends smoothly to incorporate mixed-language working and in-place array updates.},
booktitle = {Proceedings of the 20th {ACM} {SIGPLAN}-{SIGACT} {Symposium} on {Principles} of {Programming} {Languages}},
- publisher = {Association for Computing Machinery},
+ publisher = {ACM},
author = {Peyton Jones, Simon and Wadler, Philip},
year = {1993},
note = {event-place: Charleston, South Carolina, USA},
abstract = {The interface with the outside world has always been one of the weakest points of functional languages. It is not easy to incorporate I/O without being allowed to do side-effects. Furthermore, functional languages allow redexes to be evaluated in any order while I/O generally has to be performed in a very specific order. In this paper we present a new solution for the I/O problem which we have incorporated in the language Concurrent Clean. Concurrent Clean offers a linear type system called Unique Types. It makes it possible to define functions with side-effects without violating the functional semantics. Now it is possible to change any object in the world in the way we wanted: e.g. arrays can be updated in-situ, arbitrary file manipulation is possible. We have used this powerful tool among others to create a library for window based I/O. Using an explicit environment passing scheme provides a high-level and elegant functional specification method for I/O, called Event I/O. Now the specification of I/O has become one of the strengths of functional languages: interactive programs written in Concurrent Clean are concise, easy to write and comprehend as well as efficient. The presented solution can in principle be applied for any other functional language as well provided that it actually uses graph rewriting semantics in the implementation.},
booktitle = {Functional {Programming}, {Glasgow} 1992},
publisher = {Springer London},
- author = {Achten, Peter and van Groningen, John and Plasmeijer, Rinus},
+ author = {Achten, Peter and \noopsort{Groningen}{van Groningen}, John and Plasmeijer, Rinus},
editor = {Launchbury, John and Sansom, Patrick},
year = {1993},
pages = {1--17},
doi = {10.1145/3406088.3409021},
abstract = {Generic programming libraries have historically traded efficiency in return for convenience, and the generics-sop library is no exception. It offers a simple, uniform, representation of all datatypes precisely as a sum of products, making it easy to write generic functions. We show how to finally make generics-sop fast through the use of staging with Typed Template Haskell.},
booktitle = {Proceedings of the 13th {ACM} {SIGPLAN} {International} {Symposium} on {Haskell}},
- publisher = {Association for Computing Machinery},
- author = {Pickering, Matthew and Löh, Andres and Wu, Nicolas},
+ publisher = {ACM},
+ author = {Pickering, Matthew and L\"{o}h, Andres and Wu, Nicolas},
year = {2020},
note = {event-place: Virtual Event, USA},
keywords = {generic programming, staging},
abstract = {Multi-stage programming using typed code quotation is an established technique for writing optimizing code generators with strong type-safety guarantees. Unfortunately, quotation in Haskell interacts poorly with type classes, making it difficult to write robust multi-stage programs. We study this unsound interaction and propose a resolution, staged type class constraints, which we formalize in a source calculus $\lambda$⇒ that elaborates into an explicit core calculus F. We show type soundness of both calculi, establishing that well-typed, well-staged source programs always elaborate to well-typed, well-staged core programs, and prove beta and eta rules for code quotations. Our design allows programmers to incorporate type classes into multi-stage programs with confidence. Although motivated by Haskell, it is also suitable as a foundation for other languages that support both overloading and quotation.},
number = {POPL},
journal = {Proc. ACM Program. Lang.},
- author = {Xie, Ningning and Pickering, Matthew and Löh, Andres and Wu, Nicolas and Yallop, Jeremy and Wang, Meng},
+ author = {Xie, Ningning and Pickering, Matthew and L\"{o}h, Andres and Wu, Nicolas and Yallop, Jeremy and Wang, Meng},
month = jan,
year = {2022},
note = {Place: New York, NY, USA
-Publisher: Association for Computing Machinery},
+Publisher: ACM},
keywords = {Staging, Type Classes, Typed Template Haskell},
file = {Xie et al. - 2022 - Staging with Class A Specification for Typed Temp.pdf:/home/mrl/.local/share/zotero/storage/QGDB5YHR/Xie et al. - 2022 - Staging with Class A Specification for Typed Temp.pdf:application/pdf},
}
doi = {10.1145/2633628.2633634},
abstract = {We introduce the sum-of-products (SOP) view for datatype-generic programming (in Haskell). While many of the libraries that are commonly in use today represent datatypes as arbitrary combinations of binary sums and products, SOP reflects the structure of datatypes more faithfully: each datatype is a single n-ary sum, where each component of the sum is a single n-ary product. This representation turns out to be expressible accurately in GHC with today's extensions. The resulting list-like structure of datatypes allows for the definition of powerful high-level traversal combinators, which in turn encourage the definition of generic functions in a compositional and concise style. A major plus of the SOP view is that it allows to separate function-specific metadata from the main structural representation and recombining this information later.},
booktitle = {Proceedings of the 10th {ACM} {SIGPLAN} {Workshop} on {Generic} {Programming}},
- publisher = {Association for Computing Machinery},
- author = {de Vries, Edsko and Löh, Andres},
+ publisher = {ACM},
+ author = {de Vries, Edsko and L\"{o}h, Andres},
year = {2014},
note = {event-place: Gothenburg, Sweden},
- keywords = {lenses, datatype-generic programming, generic views, json, metadata, sums of products, universes},
+ keywords = {datatype-generic programming, generic views, json, lenses, metadata, sums of products, universes},
pages = {83--94},
- file = {de Vries and Löh - 2014 - True Sums of Products.pdf:/home/mrl/.local/share/zotero/storage/QHT5IPQA/de Vries and Löh - 2014 - True Sums of Products.pdf:application/pdf},
}
@article{willis_staged_2020,
month = aug,
year = {2020},
note = {Place: New York, NY, USA
-Publisher: Association for Computing Machinery},
+Publisher: ACM},
keywords = {combinators, meta-programming, parsers},
file = {Willis et al. - 2020 - Staged Selective Parser Combinators.pdf:/home/mrl/.local/share/zotero/storage/RCD842QK/Willis et al. - 2020 - Staged Selective Parser Combinators.pdf:application/pdf},
}
doi = {10.1145/3331545.3342597},
abstract = {Cross-stage persistence is an essential aspect of multi-stage programming that allows a value defined in one stage to be available in another. However, difficulty arises when implicit information held in types, type classes and implicit parameters needs to be persisted. Without a careful treatment of such implicit information—which are pervasive in Haskell—subtle yet avoidable bugs lurk beneath the surface. This paper demonstrates that in multi-stage programming care must be taken when representing quoted terms so that important implicit information is kept in context and not discarded. The approach is formalised with a type-system, and an implementation in GHC is presented that fixes problems of the previous incarnation.},
booktitle = {Proceedings of the 12th {ACM} {SIGPLAN} {International} {Symposium} on {Haskell}},
- publisher = {Association for Computing Machinery},
+ publisher = {ACM},
author = {Pickering, Matthew and Wu, Nicolas and Kiss, Csongor},
year = {2019},
note = {event-place: Berlin, Germany},
- keywords = {metaprogramming, staging, implicits},
+ keywords = {implicits, metaprogramming, staging},
pages = {71--84},
file = {Pickering et al. - 2019 - Multi-Stage Programs in Context.pdf:/home/mrl/.local/share/zotero/storage/3EW7FM44/Pickering et al. - 2019 - Multi-Stage Programs in Context.pdf:application/pdf},
}
volume = {abs/2112.03653},
doi = {10.48550/arXiv.2112.03653},
journal = {CoRR},
- author = {Pickering, Matthew and Löh, Andres and Wu, Nicolas},
+ author = {Pickering, Matthew and L\"{o}h, Andres and Wu, Nicolas},
year = {2021},
note = {arXiv: 2112.03653},
file = {Pickering et al. - 2021 - A Specification for Typed Template Haskell.pdf:/home/mrl/.local/share/zotero/storage/YBTN4DLK/Pickering et al. - 2021 - A Specification for Typed Template Haskell.pdf:application/pdf},
month = aug,
year = {2022},
note = {Place: New York, NY, USA
-Publisher: Association for Computing Machinery},
+Publisher: ACM},
keywords = {circuit synthesis, generators, hardware description languages},
file = {Materzok - 2022 - Generating Circuits with Generators.pdf:/home/mrl/.local/share/zotero/storage/LH4Q8J73/Materzok - 2022 - Generating Circuits with Generators.pdf:application/pdf},
}
doi = {10.1145/3546189.3549921},
abstract = {Liquid Haskell is a popular verifier for Haskell programs, leveraging the power of SMT solvers to ease users' burden of proof. However, this power does not come without a price: convincing Liquid Haskell that a program is correct often necessitates giving hints to the underlying solver, which can be a tedious and verbose process that sometimes requires intricate knowledge of Liquid Haskell's inner workings. In this paper, we present Liquid Proof Macros, an extensible metaprogramming technique and framework for simplifying the development of Liquid Haskell proofs. We describe how to leverage Template Haskell to generate Liquid Haskell proof terms, via a tactic-inspired DSL interface for more concise and user-friendly proofs, and we demonstrate the capabilities of this framework by automating a wide variety of proofs from an existing Liquid Haskell benchmark.},
booktitle = {Proceedings of the 15th {ACM} {SIGPLAN} {International} {Haskell} {Symposium}},
- publisher = {Association for Computing Machinery},
+ publisher = {ACM},
author = {Blanchette, Henry and Vazou, Niki and Lampropoulos, Leonidas},
year = {2022},
note = {event-place: Ljubljana, Slovenia},
doi = {10.1145/3546189.3549917},
abstract = {Haskell is a popular choice for hosting deeply embedded languages. A recurring challenge for these embeddings is how to seamlessly integrate user defined algebraic data types. In particular, one important, convenient, and expressive feature for creating and inspecting data—pattern matching—is not directly available on embedded terms. We present a novel technique, embedded pattern matching, which enables a natural and user friendly embedding of user defined algebraic data types into the embedded language, and allows programmers to pattern match on terms in the embedded language in much the same way they would in the host language.},
booktitle = {Proceedings of the 15th {ACM} {SIGPLAN} {International} {Haskell} {Symposium}},
- publisher = {Association for Computing Machinery},
+ publisher = {ACM},
author = {McDonell, Trevor L. and Meredith, Joshua D. and Keller, Gabriele},
year = {2022},
note = {event-place: Ljubljana, Slovenia},
- keywords = {Haskell, algebraic data types, embedded languages, pattern matching},
+ keywords = {algebraic data types, embedded languages, Haskell, pattern matching},
pages = {123--136},
file = {2108.13114.pdf:/home/mrl/.local/share/zotero/storage/AJAT8AXI/2108.13114.pdf:application/pdf},
}
@misc{lubbers_htask_2022,
title = {{hTask}},
- url = {https://gitlab.com/mlubbers/acsds},
+ url = {https://gitlab.com/mlubbers/hTask},
urldate = {2022-10-07},
author = {Lubbers, Mart},
year = {2022},
doi = {https://doi.org/10.1016/j.jclepro.2020.122877},
abstract = {The rapid development and implementation of smart and IoT (Internet of Things) based technologies have allowed for various possibilities in technological advancements for different aspects of life. The main goal of IoT technologies is to simplify processes in different fields, to ensure a better efficiency of systems (technologies or specific processes) and finally to improve life quality. Sustainability has become a key issue for population where the dynamic development of IoT technologies is bringing different useful benefits, but this fast development must be carefully monitored and evaluated from an environmental point of view to limit the presence of harmful impacts and ensure the smart utilization of limited global resources. Significant research efforts are needed in the previous sense to carefully investigate the pros and cons of IoT technologies. This review editorial is partially directed on the research contributions presented at the 4th International Conference on Smart and Sustainable Technologies held in Split and Bol, Croatia, in 2019 (SpliTech 2019) as well as on recent findings from literature. The SpliTech2019 conference was a valuable event that successfully linked different engineering professions, industrial experts and finally researchers from academia. The focus of the conference was directed towards key conference tracks such as Smart City, Energy/Environment, e-Health and Engineering Modelling. The research presented and discussed at the SpliTech2019 conference helped to understand the complex and intertwined effects of IoT technologies on societies and their potential effects on sustainability in general. Various application areas of IoT technologies were discussed as well as the progress made. Four main topical areas were discussed in the herein editorial, i.e. latest advancements in the further fields: (i) IoT technologies in Sustainable Energy and Environment, (ii) IoT enabled Smart City, (iii) E-health – Ambient assisted living systems (iv) IoT technologies in Transportation and Low Carbon Products. The main outcomes of the review introductory article contributed to the better understanding of current technological progress in IoT application areas as well as the environmental implications linked with the increased application of IoT products.},
journal = {Journal of Cleaner Production},
- author = {Nižetić, Sandro and Šolić, Petar and González-de-Artaza, Diego López-de-Ipiña and Patrono, Luigi},
+ author = {Ni\v{z}eti\'{c}, Sandro and \v{S}oli\'{c}, Petar and Gonz\'{a}lez-de-Artaza, Diego L\'{o}pez-de-Ipiña and Patrono, Luigi},
year = {2020},
keywords = {IoT, Energy, Environment, Smart city, SpliTech2020, Sustainability},
pages = {122877},
booktitle = {Trends in {Functional} {Programming}},
publisher = {Springer International Publishing},
author = {Koopman, Pieter and Michels, Steffen and Plasmeijer, Rinus},
- editor = {Zsók, Viktória and Hughes, John},
+ editor = {Zs\'{o}k, Vikt\'{o}ria and Hughes, John},
year = {2021},
pages = {44--66},
file = {978-3-030-83978-9_3.pdf:/home/mrl/.local/share/zotero/storage/6654TJL7/978-3-030-83978-9_3.pdf:application/pdf},
doi = {10.1145/3009837.3009900},
abstract = {Structure editors allow programmers to edit the tree structure of a program directly. This can have cognitive benefits, particularly for novice and end-user programmers. It also simplifies matters for tool designers, because they do not need to contend with malformed program text. This paper introduces Hazelnut, a structure editor based on a small bidirectionally typed lambda calculus extended with holes and a cursor. Hazelnut goes one step beyond syntactic well-formedness: its edit actions operate over statically meaningful incomplete terms. Naïvely, this would force the programmer to construct terms in a rigid "outside-in" manner. To avoid this problem, the action semantics automatically places terms assigned a type that is inconsistent with the expected type inside a hole. This meaningfully defers the type consistency check until the term inside the hole is finished. Hazelnut is not intended as an end-user tool itself. Instead, it serves as a foundational account of typed structure editing. To that end, we describe how Hazelnut's rich metatheory, which we have mechanized using the Agda proof assistant, serves as a guide when we extend the calculus to include binary sum types. We also discuss various interpretations of holes, and in so doing reveal connections with gradual typing and contextual modal type theory, the Curry-Howard interpretation of contextual modal logic. Finally, we discuss how Hazelnut's semantics lends itself to implementation as an event-based functional reactive program. Our simple reference implementation is written using js\_of\_ocaml.},
booktitle = {Proceedings of the 44th {ACM} {SIGPLAN} {Symposium} on {Principles} of {Programming} {Languages}},
- publisher = {Association for Computing Machinery},
+ publisher = {ACM},
author = {Omar, Cyrus and Voysey, Ian and Hilton, Michael and Aldrich, Jonathan and Hammer, Matthew A.},
year = {2017},
note = {event-place: Paris, France},
month = sep,
year = {2019},
note = {Place: New York, NY, USA
-Publisher: Association for Computing Machinery},
+Publisher: ACM},
pages = {23--27},
file = {Hester and Sorber - 2019 - Batteries Not Included.pdf:/home/mrl/.local/share/zotero/storage/LT53WV8K/Hester and Sorber - 2019 - Batteries Not Included.pdf:application/pdf},
}
abstract = {Domain-Specific Languages (DSLs) can be regarded as User Interfaces (UIs) because they bridge the gap between the domain experts and the computation platforms. Usability of DSLs by domain experts is a key factor for their successful adoption. The few reports supporting improvement claims are persuasive, but mostly anecdotal. Systematic literature reviews show that evidences on the effects of the introduction of DSLs are actually very scarce. In particular, the evaluation of usability is often skipped, relaxed, or at least omitted from papers reporting the development of DSLs. The few exceptions mostly take place at the end of the development process, when fixing problems is already too expensive. A systematic approach, based on techniques for the experimental evaluation of UIs, should be used to assess suitability of new DSLs. This chapter presents a general experimental evaluation model, tailored for DSLs’ experimental evaluation, and instantiates it in several DSL’s evaluation examples.},
booktitle = {Software {Design} and {Development}: {Concepts}, {Methodologies}, {Tools}, and {Applications}},
publisher = {IGI Global},
- author = {Barišic, Ankica and Amaral, Vasco and Goulão, Miguel and Barroca, Bruno},
+ author = {Bari\v{s}ic, Ankica and Amaral, Vasco and Goul\~{a}o, Miguel and Barroca, Bruno},
editor = {Management Association, Information Resources},
year = {2014},
doi = {10.4018/978-1-4666-4301-7.ch098},
pages = {2120--2141},
- file = {Barišic et al. - 2014 - Evaluating the Usability of Domain-Specific Langua.pdf:/home/mrl/.local/share/zotero/storage/ARTGSHZK/Barišic et al. - 2014 - Evaluating the Usability of Domain-Specific Langua.pdf:application/pdf},
}
@article{van_der_aalst_workflow_2003,
abstract = {Differences in features supported by the various contemporary commercial workflow management systems point to different insights of suitability and different levels of expressive power. The challenge, which we undertake in this paper, is to systematically address workflow requirements, from basic to complex. Many of the more complex requirements identified, recur quite frequently in the analysis phases of workflow projects, however their implementation is uncertain in current products. Requirements for workflow languages are indicated through workflow patterns. In this context, patterns address business requirements in an imperative workflow style expression, but are removed from specific workflow languages. The paper describes a number of workflow patterns addressing what we believe identify comprehensive workflow functionality. These patterns provide the basis for an in-depth comparison of a number of commercially availablework flow management systems. As such, this paper can be seen as the academic response to evaluations made by prestigious consulting companies. Typically, these evaluations hardly consider the workflow modeling language and routing capabilities, and focus more on the purely technical and commercial aspects.},
number = {1},
journal = {Distributed and Parallel Databases},
- author = {van der Aalst, W.M.P. and ter Hofstede, A.H.M. and Kiepuszewski, B. and Barros, A.P.},
+ author = {\noopsort{Aalst}{van der Aalst}, W.M.P. and \noopsort{Hofstede}{ter Hofstede}, A.H.M. and Kiepuszewski, B. and Barros, A.P.},
month = jul,
year = {2003},
pages = {5--51},
doi = {10.1145/2513228.2513271},
abstract = {In this paper, we consider how energy consumption can be reduced in the Priority-based Functional Reactive Programming (P-FRP) execution model through the implementation of Dynamic Voltage and Frequency Scaling (DVFS), a technique for modifying circuit delays and altering the operating frequency of the CPU. Use of DVFS can have an impact on task execution time, which adversely affects the temporal guarantees required from the real-time scheduler. Most of the existing studies provide solutions which are suitable for the classical model of preemptive task scheduling. Tasks which are schedulable in the preemptive model cannot be guaranteed to be schedulable in P-FRP, since the abort-based preemptive approach often creates additional costs in terms of response times.},
booktitle = {Proceedings of the 2013 {Research} in {Adaptive} and {Convergent} {Systems}},
- publisher = {Association for Computing Machinery},
+ publisher = {ACM},
author = {Belwal, Chaitanya and Cheng, Albert M. K. and Ras, J. and Wen, Yuanfeng},
year = {2013},
note = {event-place: Montreal, Quebec, Canada},
title = {Derivable {Type} {Classes}},
volume = {41},
issn = {1571-0661},
- url = {https://www.sciencedirect.com/science/article/pii/S1571066105805420},
doi = {https://doi.org/10.1016/S1571-0661(05)80542-0},
abstract = {Generic programming allows you to write a function once, and use it many times at different types. A lot of good foundational work on generic programming has been done. The goal of this paper is to propose a practical way of supporting generic programming within the Haskell language, without radically changing the language or its type system. The key idea is to present generic programming as a richer language in which to write default method definitions in a class declaration. On the way, we came across a separate issue, concerning type-class overloading where higher kinds are involved. We propose a simple type-class system extension to allow the programmer to write richer contexts than is currently possible.},
number = {1},
journal = {Electronic Notes in Theoretical Computer Science},
- author = {Hinze, Ralf and Jones, Simon Peyton},
+ author = {Hinze, Ralf and Peyton Jones, Simon},
year = {2001},
pages = {5--35},
file = {Hinze and Jones - 2001 - Derivable Type Classes.pdf:/home/mrl/.local/share/zotero/storage/33IF2HMZ/Hinze and Jones - 2001 - Derivable Type Classes.pdf:application/pdf},
repositories / phd-thesis.git / blobdiff