other.bib

   1
   2 @mastersthesis{crooijmans_reducing_2021,
   3         address = {Nijmegen},
   4         title = {Reducing the {Power} {Consumption} of {IoT} {Devices} in {Task}-{Oriented} {Programming}},
   5         language = {en},
   6         school = {Radboud University},
   7         author = {Crooijmans, Sjoerd},
   8         month = jul,
   9         year = {2021},
  10         file = {Crooijmans - 2021 - Reducing the Power Consumption of IoT Devices in T.pdf:/home/mrl/.local/share/zotero/storage/98LY9YHH/Crooijmans - 2021 - Reducing the Power Consumption of IoT Devices in T.pdf:application/pdf},
  11 }
  12
  13 @inproceedings{plasmeijer_task-oriented_2012,
  14         address = {New York, NY, USA},
  15         series = {{PPDP} '12},
  16         title = {Task-{Oriented} {Programming} in a {Pure} {Functional} {Language}},
  17         isbn = {978-1-4503-1522-7},
  18         doi = {10.1145/2370776.2370801},
  19         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.},
  20         booktitle = {Proceedings of the 14th {Symposium} on {Principles} and {Practice} of {Declarative} {Programming}},
  21         publisher = {Association for Computing Machinery},
  22         author = {Plasmeijer, Rinus and Lijnse, Bas and Michels, Steffen and Achten, Peter and Koopman, Pieter},
  23         year = {2012},
  24         note = {event-place: Leuven, Belgium},
  25         keywords = {clean, task-oriented programming},
  26         pages = {195--206},
  27         file = {103802.pdf:/home/mrl/.local/share/zotero/storage/ZE6A65AW/103802.pdf:application/pdf},
  28 }
  29
  30 @inproceedings{brus_clean_1987,
  31         address = {Berlin, Heidelberg},
  32         title = {Clean — {A} language for functional graph rewriting},
  33         isbn = {978-3-540-47879-9},
  34         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.},
  35         booktitle = {Functional {Programming} {Languages} and {Computer} {Architecture}},
  36         publisher = {Springer Berlin Heidelberg},
  37         author = {Brus, T. H. and van Eekelen, M. C. J. D. and van Leer, M. O. and Plasmeijer, M. J.},
  38         editor = {Kahn, Gilles},
  39         year = {1987},
  40         pages = {364--384},
  41         file = {brut87-Clean.ps.gz:/home/mrl/.local/share/zotero/storage/T2QATWIE/brut87-Clean.ps.gz:application/gzip},
  42 }
  43
  44 @misc{bolingbroke_constraint_2011,
  45         title = {Constraint {Kinds} for {GHC}},
  46         url = {http://blog.omega-prime.co.uk/2011/09/10/constraint-kinds-for-ghc/},
  47         urldate = {2021-06-09},
  48         journal = {:: (Bloggable a) ={\textgreater} a -{\textgreater} IO ()},
  49         author = {Bolingbroke, Max},
  50         month = sep,
  51         year = {2011},
  52         file = {Constraint Kinds for GHC:/home/mrl/.local/share/zotero/storage/R6RL79K7/constraint-kinds-for-ghc.html:text/html},
  53 }
  54
  55 @inproceedings{fegaras_revisiting_1996,
  56         address = {New York, NY, USA},
  57         series = {{POPL} '96},
  58         title = {Revisiting {Catamorphisms} over {Datatypes} with {Embedded} {Functions} (or, {Programs} from {Outer} {Space})},
  59         isbn = {0-89791-769-3},
  60         doi = {10.1145/237721.237792},
  61         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.},
  62         booktitle = {Proceedings of the 23rd {ACM} {SIGPLAN}-{SIGACT} {Symposium} on {Principles} of {Programming} {Languages}},
  63         publisher = {Association for Computing Machinery},
  64         author = {Fegaras, Leonidas and Sheard, Tim},
  65         year = {1996},
  66         note = {event-place: St. Petersburg Beach, Florida, USA},
  67         pages = {284--294},
  68         file = {Fegaras and Sheard - 1996 - Revisiting Catamorphisms over Datatypes with Embed.pdf:/home/mrl/.local/share/zotero/storage/WCSRVWGC/Fegaras and Sheard - 1996 - Revisiting Catamorphisms over Datatypes with Embed.pdf:application/pdf},
  69 }
  70
  71 @inproceedings{pfenning_higher-order_1988,
  72         address = {New York, NY, USA},
  73         series = {{PLDI} '88},
  74         title = {Higher-{Order} {Abstract} {Syntax}},
  75         isbn = {0-89791-269-1},
  76         doi = {10.1145/53990.54010},
  77         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.},
  78         booktitle = {Proceedings of the {ACM} {SIGPLAN} 1988 {Conference} on {Programming} {Language} {Design} and {Implementation}},
  79         publisher = {Association for Computing Machinery},
  80         author = {Pfenning, F. and Elliott, C.},
  81         year = {1988},
  82         note = {event-place: Atlanta, Georgia, USA},
  83         pages = {199--208},
  84         file = {Pfenning and Elliott - 1988 - Higher-Order Abstract Syntax.pdf:/home/mrl/.local/share/zotero/storage/2HSRWURK/Pfenning and Elliott - 1988 - Higher-Order Abstract Syntax.pdf:application/pdf},
  85 }
  86
  87 @inproceedings{chlipala_parametric_2008,
  88         address = {New York, NY, USA},
  89         series = {{ICFP} '08},
  90         title = {Parametric {Higher}-{Order} {Abstract} {Syntax} for {Mechanized} {Semantics}},
  91         isbn = {978-1-59593-919-7},
  92         doi = {10.1145/1411204.1411226},
  93         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.},
  94         booktitle = {Proceedings of the 13th {ACM} {SIGPLAN} {International} {Conference} on {Functional} {Programming}},
  95         publisher = {Association for Computing Machinery},
  96         author = {Chlipala, Adam},
  97         year = {2008},
  98         note = {event-place: Victoria, BC, Canada},
  99         keywords = {compiler verification, dependent types, interactive proof assistants, type-theoretic semantics},
 100         pages = {143--156},
 101         file = {Chlipala - 2008 - Parametric Higher-Order Abstract Syntax for Mechan.pdf:/home/mrl/.local/share/zotero/storage/DZ33DAMU/Chlipala - 2008 - Parametric Higher-Order Abstract Syntax for Mechan.pdf:application/pdf},
 102 }
 103
 104 @incollection{reynolds_user-defined_1978,
 105         address = {New York, NY},
 106         title = {User-{Defined} {Types} and {Procedural} {Data} {Structures} as {Complementary} {Approaches} to {Data} {Abstraction}},
 107         isbn = {978-1-4612-6315-9},
 108         abstract = {User-defined types (or modes) and procedural (or functional) data structures are complementary methods for data abstraction, each providing a capability lacked by the other. With user-defined types, all information about the representation of a particular kind of data is centralized in a type definition and hidden from the rest of the program. With procedural data structures, each part of the program which creates data can specify its own representation, independently of any representations used elsewhere for the same kind of data. However, this decentralization of the description of data is achieved at the cost of prohibiting primitive operations from accessing the representations of more than one data item. The contrast between these approaches is illustrated by a simple example.},
 109         booktitle = {Programming {Methodology}: {A} {Collection} of {Articles} by {Members} of {IFIP} {WG2}.3},
 110         publisher = {Springer New York},
 111         author = {Reynolds, John C.},
 112         editor = {Gries, David},
 113         year = {1978},
 114         doi = {10.1007/978-1-4612-6315-9_22},
 115         pages = {309--317},
 116         file = {Reynolds - 1978 - User-Defined Types and Procedural Data Structures .pdf:/home/mrl/.local/share/zotero/storage/ASXE73U2/Reynolds - 1978 - User-Defined Types and Procedural Data Structures .pdf:application/pdf},
 117 }
 118
 119 @misc{ghc_team_ghc_2021,
 120         title = {{GHC} {User}’s {Guide} {Documentation}},
 121         url = {https://downloads.haskell.org/~ghc/latest/docs/users_guide.pdf},
 122         language = {English},
 123         urldate = {2021-02-24},
 124         publisher = {Release},
 125         author = {GHC Team},
 126         year = {2021},
 127         file = {GHC Team - 2021 - GHC User’s Guide Documentation.pdf:/home/mrl/.local/share/zotero/storage/87ZT5VXL/GHC Team - 2021 - GHC User’s Guide Documentation.pdf:application/pdf},
 128 }
 129
 130 @misc{ghc_team_datadynamic_2021,
 131         title = {Data.{Dynamic}},
 132         url = {https://hackage.haskell.org/package/base-4.14.1.0/docs/Data-Dynamic.html},
 133         language = {English},
 134         urldate = {2021-02-24},
 135         publisher = {Release},
 136         author = {GHC Team},
 137         year = {2021},
 138 }
 139
 140 @inproceedings{jeuring_polytypic_1996,
 141         address = {Berlin, Heidelberg},
 142         title = {Polytypic programming},
 143         isbn = {978-3-540-70639-7},
 144         abstract = {Many functions have to be written over and over again for different datatypes, either because datatypes change during the development of programs, or because functions with similar functionality are needed on different datatypes. Examples of such functions are pretty printers, debuggers, equality functions, unifiers, pattern matchers, rewriting functions, etc. Such functions are called polytypic functions. A polytypic function is a function that is defined by induction on the structure of user-defined datatypes. This paper introduces polytypic functions, and shows how to construct and reason about polytypic functions. A larger example is studied in detail: polytypic functions for term rewriting and for determining whether a collection of rewrite rules is normalising.},
 145         booktitle = {Advanced {Functional} {Programming}},
 146         publisher = {Springer Berlin Heidelberg},
 147         author = {Jeuring, Johan and Jansson, Patrik},
 148         editor = {Launchbury, John and Meijer, Erik and Sheard, Tim},
 149         year = {1996},
 150         pages = {68--114},
 151         file = {Jeuring and Jansson - 1996 - Polytypic programming.pdf:/home/mrl/.local/share/zotero/storage/SLC4G2IT/Jeuring and Jansson - 1996 - Polytypic programming.pdf:application/pdf},
 152 }
 153
 154 @book{peyton_jones_haskell_2003,
 155         address = {Cambridge},
 156         title = {Haskell 98 language and libraries: the revised report},
 157         isbn = {0-521 826144},
 158         publisher = {Cambridge University Press},
 159         editor = {Peyton Jones, Simon},
 160         year = {2003},
 161         file = {Peyton Jones - 2003 - Haskell 98 language and libraries the revised rep.pdf:/home/mrl/.local/share/zotero/storage/UXEJT89I/Peyton Jones - 2003 - Haskell 98 language and libraries the revised rep.pdf:application/pdf},
 162 }
 163
 164 @inproceedings{laufer_combining_1994,
 165         title = {Combining type classes and existential types},
 166         booktitle = {Proceedings of the {Latin} {American} {Informatic} {Conference} ({PANEL})},
 167         publisher = {ITESM-CEM},
 168         author = {Läufer, Konstantin},
 169         year = {1994},
 170         note = {event-place: Monterrey, Mexico},
 171         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},
 172 }
 173
 174 @techreport{hughes_restricted_1999,
 175         address = {Paris},
 176         title = {Restricted data types in {Haskell}},
 177         number = {UU-CS-1999-28},
 178         institution = {Department of Information and Computing Sciences, Utrecht University},
 179         author = {Hughes, John},
 180         year = {1999},
 181         pages = {16},
 182         file = {Hughes - 1999 - Restricted data types in Haskell.pdf:/home/mrl/.local/share/zotero/storage/7ZE2MYWE/Hughes - 1999 - Restricted data types in Haskell.pdf:application/pdf},
 183 }
 184
 185 @article{najd_trees_2017,
 186         title = {Trees that {Grow}},
 187         volume = {23},
 188         abstract = {We study the notion of extensibility in functional data types, as a new approach to the problem of decorating abstract syntax trees with additional information. We observed the need for such extensibility while redesigning the data types representing Haskell abstract syntax inside Glasgow Haskell Compiler (GHC). Specifically, we describe a programming idiom that exploits type-level functions to allow a particular form of extensibility. The approach scales to support existentials and generalised algebraic data types, and we can use pattern synonyms to make it convenient in practice.},
 189         number = {1},
 190         journal = {Journal of Universal Computer Science},
 191         author = {Najd, Shayan and Peyton Jones, Simon},
 192         month = jan,
 193         year = {2017},
 194         pages = {42--62},
 195         file = {Najd and Jones - 2017 - Trees that Grow.pdf:/home/mrl/.local/share/zotero/storage/HYQFTWZP/Najd and Jones - 2017 - Trees that Grow.pdf:application/pdf},
 196 }
 197
 198 @inproceedings{loh_open_2006,
 199         address = {New York, NY, USA},
 200         series = {{PPDP} '06},
 201         title = {Open {Data} {Types} and {Open} {Functions}},
 202         isbn = {1-59593-388-3},
 203         doi = {10.1145/1140335.1140352},
 204         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},
 205         booktitle = {Proceedings of the 8th {ACM} {SIGPLAN} {International} {Conference} on {Principles} and {Practice} of {Declarative} {Programming}},
 206         publisher = {Association for Computing Machinery},
 207         author = {Löh, Andres and Hinze, Ralf},
 208         year = {2006},
 209         note = {event-place: Venice, Italy},
 210         keywords = {functional programming, Haskell, expression problem, extensible data types, extensible exceptions, extensible functions, generic programming, mutually recursive modules},
 211         pages = {133--144},
 212         file = {OpenDatatypes.pdf:/home/mrl/.local/share/zotero/storage/NEP9GZ9N/OpenDatatypes.pdf:application/pdf},
 213 }
 214
 215 @inproceedings{hutton_fold_1998,
 216         address = {New York, NY, USA},
 217         series = {{ICFP} '98},
 218         title = {Fold and {Unfold} for {Program} {Semantics}},
 219         isbn = {1-58113-024-4},
 220         doi = {10.1145/289423.289457},
 221         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.},
 222         booktitle = {Proceedings of the {Third} {ACM} {SIGPLAN} {International} {Conference} on {Functional} {Programming}},
 223         publisher = {Association for Computing Machinery},
 224         author = {Hutton, Graham},
 225         year = {1998},
 226         note = {event-place: Baltimore, Maryland, USA},
 227         pages = {280--288},
 228         file = {Hutton - 1998 - Fold and unfold for program semantics.pdf:/home/mrl/.local/share/zotero/storage/YEB9K2TP/Hutton - 1998 - Fold and unfold for program semantics.pdf:application/pdf},
 229 }
 230
 231 @article{abadi_dynamic_1991,
 232         title = {Dynamic {Typing} in a {Statically} {Typed} {Language}},
 233         volume = {13},
 234         issn = {0164-0925},
 235         doi = {10.1145/103135.103138},
 236         abstract = {Statically typed programming languages allow earlier error checking, better enforcement of diciplined programming styles, and the generation of more efficient object code than languages where all type consistency checks are performed at run time. However, even in statically typed languages, there is often the need to deal with datawhose type cannot be determined at compile time. To handle such situations safely, we propose to add a type Dynamic whose values are pairs of a value v and a type tag T where v has the type denoted by T. Instances of Dynamic are built with an explicit tagging construct and inspected with a type safe typecase construct.This paper explores the syntax, operational semantics, and denotational semantics of a simple language that includes the type Dynamic. We give examples of how dynamically typed values can be used in programming. Then we discuss an operational semantics for our language and obtain a soundness theorem. We present two formulations of the denotational semantics of this language and relate them to the operational semantics. Finally, we consider the implications of polymorphism and some implementation issues.},
 237         number = {2},
 238         journal = {ACM Trans. Program. Lang. Syst.},
 239         author = {Abadi, Martín and Cardelli, Luca and Pierce, Benjamin and Plotkin, Gordon},
 240         month = apr,
 241         year = {1991},
 242         note = {Place: New York, NY, USA
 243 Publisher: Association for Computing Machinery},
 244         keywords = {theory},
 245         pages = {237--268},
 246         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},
 247 }
 248
 249 @inproceedings{svenningsson_combining_2013,
 250         address = {Berlin, Heidelberg},
 251         title = {Combining {Deep} and {Shallow} {Embedding} for {EDSL}},
 252         isbn = {978-3-642-40447-4},
 253         doi = {10.1007/978-3-642-40447-4_2},
 254         abstract = {When compiling embedded languages it is natural to use an abstract syntax tree to represent programs. This is known as a deep embedding and it is a rather cumbersome technique compared to other forms of embedding, typically leading to more code and being harder to extend. In shallow embeddings, language constructs are mapped directly to their semantics which yields more flexible and succinct implementations. But shallow embeddings are not well-suited for compiling embedded languages. We present a technique to combine deep and shallow embedding in the context of compiling embedded languages in order to provide the benefits of both techniques. In particular it helps keeping the deep embedding small and it makes extending the embedded language much easier. Our technique also has some unexpected but welcome knock-on effects. It provides fusion of functions to remove intermediate results for free without any additional effort. It also helps to give the embedded language a more natural programming interface.},
 255         booktitle = {Trends in {Functional} {Programming}},
 256         publisher = {Springer Berlin Heidelberg},
 257         author = {Svenningsson, Josef and Axelsson, Emil},
 258         editor = {Loidl, Hans-Wolfgang and Peña, Ricardo},
 259         year = {2013},
 260         pages = {21--36},
 261         file = {svenningsson2013combining.pdf:/home/mrl/.local/share/zotero/storage/NFBGZCZT/svenningsson2013combining.pdf:application/pdf},
 262 }
 263
 264 @article{mitchell_abstract_1988,
 265         title = {Abstract {Types} {Have} {Existential} {Type}},
 266         volume = {10},
 267         issn = {0164-0925},
 268         doi = {10.1145/44501.45065},
 269         abstract = {Abstract data type declarations appear in typed programming languages like Ada, Alphard, CLU and ML. This form of declaration binds a list of identifiers to a type with associated operations, a composite “value” we call a data algebra. We use a second-order typed lambda calculus SOL to show how data algebras may be given types, passed as parameters, and returned as results of function calls. In the process, we discuss the semantics of abstract data type declarations and review a connection between typed programming languages and constructive logic.},
 270         number = {3},
 271         journal = {ACM Trans. Program. Lang. Syst.},
 272         author = {Mitchell, John C. and Plotkin, Gordon D.},
 273         month = jul,
 274         year = {1988},
 275         note = {Place: New York, NY, USA
 276 Publisher: Association for Computing Machinery},
 277         pages = {470--502},
 278         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},
 279 }
 280
 281 @inproceedings{yorgey_giving_2012,
 282         address = {New York, NY, USA},
 283         series = {{TLDI} '12},
 284         title = {Giving {Haskell} a {Promotion}},
 285         isbn = {978-1-4503-1120-5},
 286         doi = {10.1145/2103786.2103795},
 287         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.},
 288         booktitle = {Proceedings of the 8th {ACM} {SIGPLAN} {Workshop} on {Types} in {Language} {Design} and {Implementation}},
 289         publisher = {Association for Computing Machinery},
 290         author = {Yorgey, Brent A. and Weirich, Stephanie and Cretin, Julien and Peyton Jones, Simon and Vytiniotis, Dimitrios and Magalhães, José Pedro},
 291         year = {2012},
 292         note = {event-place: Philadelphia, Pennsylvania, USA},
 293         keywords = {haskell, kinds, polymorphism, promotion},
 294         pages = {53--66},
 295         file = {Yorgey et al. - 2012 - Giving Haskell a Promotion.pdf:/home/mrl/.local/share/zotero/storage/7GTDGQ3I/Yorgey et al. - 2012 - Giving Haskell a Promotion.pdf:application/pdf},
 296 }
 297
 298 @inproceedings{atkey_unembedding_2009,
 299         address = {New York, NY, USA},
 300         series = {Haskell '09},
 301         title = {Unembedding {Domain}-{Specific} {Languages}},
 302         isbn = {978-1-60558-508-6},
 303         doi = {10.1145/1596638.1596644},
 304         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.},
 305         booktitle = {Proceedings of the 2nd {ACM} {SIGPLAN} {Symposium} on {Haskell}},
 306         publisher = {Association for Computing Machinery},
 307         author = {Atkey, Robert and Lindley, Sam and Yallop, Jeremy},
 308         year = {2009},
 309         note = {event-place: Edinburgh, Scotland},
 310         keywords = {domain-specific languages, higher-order abstract syntax, type classes, unembedding},
 311         pages = {37--48},
 312         file = {Atkey et al. - 2009 - Unembedding Domain-Specific Languages.pdf:/home/mrl/.local/share/zotero/storage/GVFRIDUG/Atkey et al. - 2009 - Unembedding Domain-Specific Languages.pdf:application/pdf},
 313 }
 314
 315 @inproceedings{krishnamurthi_synthesizing_1998,
 316         address = {Berlin, Heidelberg},
 317         title = {Synthesizing object-oriented and functional design to promote re-use},
 318         isbn = {978-3-540-69064-1},
 319         abstract = {Many problems require recursively specified types of data and a collection of tools that operate on those data. Over time, these problems evolve so that the programmer must extend the toolkit or extend the types and adjust the existing tools accordingly. Ideally, this should be done without modifying existing code. Unfortunately, the prevailing program design strategies do not support both forms of extensibility: functional programming accommodates the addition of tools, while object-oriented programming supports either adding new tools or extending the data set, but not both. In this paper, we present a composite design pattern that synthesizes the best of both approaches and in the process resolves the tension between the two design strategies. We also show how this protocol suggests a new set of linguistic facilities for languages that support class systems.},
 320         booktitle = {{ECOOP}'98 — {Object}-{Oriented} {Programming}},
 321         publisher = {Springer Berlin Heidelberg},
 322         author = {Krishnamurthi, Shriram and Felleisen, Matthias and Friedman, Daniel P.},
 323         editor = {Jul, Eric},
 324         year = {1998},
 325         note = {event-place: Brussels, Belgium},
 326         pages = {91--113},
 327         file = {Krishnamurthi et al. - 1998 - Synthesizing object-oriented and functional design.pdf:/home/mrl/.local/share/zotero/storage/AMMULPPT/Krishnamurthi et al. - 1998 - Synthesizing object-oriented and functional design.pdf:application/pdf},
 328 }
 329
 330 @incollection{gibbons_functional_2015,
 331         address = {Cham},
 332         title = {Functional {Programming} for {Domain}-{Specific} {Languages}},
 333         isbn = {978-3-319-15940-9},
 334         abstract = {Domain-specific languages are a popular application area for functional programming; and conversely, functional programming is a popular implementation vehicle for domain-specific languages—at least, for embedded ones. Why is this? The appeal of embedded domain-specific languages is greatly enhanced by the presence of convenient lightweight tools for defining, implementing, and optimising new languages; such tools represent one of functional programming's strengths. In these lectures we discuss functional programming techniques for embedded domain-specific languages; we focus especially on algebraic datatypes and higher-order functions, and their influence on deep and shallow embeddings.},
 335         booktitle = {Central {European} {Functional} {Programming} {School}: 5th {Summer} {School}, {CEFP} 2013, {Cluj}-{Napoca}, {Romania}, {July} 8-20, 2013, {Revised} {Selected} {Papers}},
 336         publisher = {Springer International Publishing},
 337         author = {Gibbons, Jeremy},
 338         editor = {Zsók, Viktória and Horváth, Zoltán and Csató, Lehel},
 339         year = {2015},
 340         doi = {10.1007/978-3-319-15940-9_1},
 341         pages = {1--28},
 342         file = {Gibbons - 2015 - Functional Programming for Domain-Specific Languag.pdf:/home/mrl/.local/share/zotero/storage/ARUBLFU6/Gibbons - 2015 - Functional Programming for Domain-Specific Languag.pdf:application/pdf},
 343 }
 344
 345 @mastersthesis{van_der_veen_mutable_2020,
 346         address = {Nijmegen},
 347         title = {Mutable {Collection} {Types} in {Shallow} {Embedded} {DSLs}},
 348         language = {en},
 349         school = {Radboud University},
 350         author = {van der Veen, Erin},
 351         month = jun,
 352         year = {2020},
 353         file = {thesis_final.pdf:/home/mrl/.local/share/zotero/storage/Y9QWGGB9/thesis_final.pdf:application/pdf},
 354 }
 355
 356 @phdthesis{alimarine_generic_2005,
 357         address = {Nijmegen},
 358         type = {{PhD}},
 359         title = {Generic {Functional} {Programming}},
 360         language = {en},
 361         school = {Radboud University},
 362         author = {Alimarine, Artem},
 363         year = {2005},
 364         file = {Alimarine - Generic Functional Programming.pdf:/home/mrl/.local/share/zotero/storage/PDTS3SGX/Alimarine - Generic Functional Programming.pdf:application/pdf},
 365 }
 366
 367 @phdthesis{de_boer_secure_2020,
 368         address = {Nijmegen},
 369         type = {Bachelor's {Thesis}},
 370         title = {Secure {Communication} {Channels} for the {mTask} {System}.},
 371         language = {en},
 372         school = {Radboud University},
 373         author = {de Boer, Michel},
 374         month = jun,
 375         year = {2020},
 376         file = {Boer, de - 2020 - Secure Communication Channels for the mTask System.pdf:/home/mrl/.local/share/zotero/storage/C46E3FBF/Boer, de - 2020 - Secure Communication Channels for the mTask System.pdf:application/pdf},
 377 }
 378
 379 @inproceedings{barendregt_towards_1987,
 380         title = {Towards an intermediate language for graph rewriting},
 381         volume = {1},
 382         booktitle = {{PARLE}, {Parallel} {Architectures} and {Languages} {Europe}},
 383         publisher = {Springer Verlag},
 384         author = {Barendregt, HP and van Eekelen, MCJD and Glauert, JRW and Kennaway, JR and Plasmeijer, MJ and Sleep, MR},
 385         year = {1987},
 386         pages = {159--174},
 387         file = {barh87-Lean.ps.gz:/home/mrl/.local/share/zotero/storage/63FBHND7/barh87-Lean.ps.gz:application/gzip},
 388 }
 389
 390 @incollection{wang_maintaining_2018,
 391         address = {Cham},
 392         title = {Maintaining {Separation} of {Concerns} {Through} {Task} {Oriented} {Software} {Development}},
 393         volume = {10788},
 394         isbn = {978-3-319-89718-9 978-3-319-89719-6},
 395         abstract = {Task Oriented Programming is a programming paradigm that enhances ‘classic’ functional programming with means to express the coordination of work among people and computer systems, the distribution and control of data sources, and the human-machine interfaces. To make the creation process of such applications feasible, it is important to have separation of concerns. In this paper we demonstrate how this is achieved within the Task Oriented Software Development process and illustrate the approach by means of a case study.},
 396         language = {en},
 397         urldate = {2019-01-14},
 398         booktitle = {Trends in {Functional} {Programming}},
 399         publisher = {Springer International Publishing},
 400         author = {Stutterheim, Jurriën and Achten, Peter and Plasmeijer, Rinus},
 401         editor = {Wang, Meng and Owens, Scott},
 402         year = {2018},
 403         doi = {10.1007/978-3-319-89719-6},
 404         pages = {19--38},
 405         file = {Stutterheim et al. - 2018 - Maintaining Separation of Concerns Through Task Or.pdf:/home/mrl/.local/share/zotero/storage/4GXJEM2U/Stutterheim et al. - 2018 - Maintaining Separation of Concerns Through Task Or.pdf:application/pdf},
 406 }
 407
 408 @article{barendsen_uniqueness_1996,
 409         title = {Uniqueness typing for functional languages with graph rewriting semantics},
 410         volume = {6},
 411         number = {6},
 412         journal = {Mathematical structures in computer science},
 413         author = {Barendsen, Erik and Smetsers, Sjaak},
 414         year = {1996},
 415         pages = {579--612},
 416         file = {Barendsen and Smetsers - 1996 - Uniqueness typing for functional languages with gr.pdf:/home/mrl/.local/share/zotero/storage/BPRC6KJK/Barendsen and Smetsers - 1996 - Uniqueness typing for functional languages with gr.pdf:application/pdf},
 417 }
 418
 419 @inproceedings{lijnse_itasks_2009,
 420         title = {{iTasks} 2: {iTasks} for {End}-users},
 421         booktitle = {International {Symposium} on {Implementation} and {Application} of {Functional} {Languages}},
 422         publisher = {Springer},
 423         author = {Lijnse, Bas and Plasmeijer, Rinus},
 424         year = {2009},
 425         pages = {36--54},
 426         file = {Lijnse and Plasmeijer - 2009 - iTasks 2 iTasks for End-users.pdf:/home/mrl/.local/share/zotero/storage/KACEWKXY/Lijnse and Plasmeijer - 2009 - iTasks 2 iTasks for End-users.pdf:application/pdf},
 427 }
 428
 429 @mastersthesis{bohm_asynchronous_2019,
 430         address = {Nijmegen},
 431         title = {Asynchronous {Actions} in a {Synchronous} {World}},
 432         abstract = {This thesis introduces a system for asynchronous communication in the iTasks framework. The
 433 framework is written in Clean, a pure, lazy, functional language. Tasks need to be able to access
 434 data in the system and retrieve data from all kinds of data sources. The share system allows
 435 tasks to read arbitrary data sources and provides a simple interface that allows composition of
 436 different data sources. This system allows tasks to share and store data in an efficient, re-usable
 437 way.
 438 A disadvantage of the share system is that it does not allow asynchronous evaluation. When
 439 one task is using a share, other tasks have to wait for the full evaluation of this share before they
 440 can be evaluated. This has the effect that users in the iTasks framework must wait on other
 441 users. This results in poor user experience.
 442 We implement a share system which, by way of share rewriting, allows asynchronous evalua-
 443 tion. The system can be used to communicate with arbitrary services on the internet, as well as
 444 to communicate between different iTasks servers in a distributed context.
 445 We show how asynchronous shares are implemented and what the limitations are. We also
 446 show multiple practical examples of using asynchronous shares. The new system can be effectively
 447 used to consume services on the internet. It fits nicely into existing iTasks programs and requires
 448 few changes in existing programs.},
 449         language = {en},
 450         school = {Radboud University},
 451         author = {Böhm, Haye},
 452         month = jan,
 453         year = {2019},
 454         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},
 455 }
 456
 457 @inproceedings{hentschel_supersensors:_2016,
 458         address = {Vienna, Austria},
 459         title = {Supersensors: {Raspberry} {Pi} {Devices} for {Smart} {Campus} {Infrastructure}},
 460         isbn = {978-1-5090-4052-0},
 461         shorttitle = {Supersensors},
 462         doi = {10.1109/FiCloud.2016.16},
 463         abstract = {We describe an approach for developing a campuswide sensor network using commodity single board computers. We sketch various use cases for environmental sensor data, for different university stakeholders. Our key premise is that supersensors—sensors with signiﬁcant compute capability—enable more ﬂexible data collection, processing and reaction. In this paper, we describe the initial prototype deployment of our supersensor system in a single department at the University of Glasgow.},
 464         language = {en},
 465         urldate = {2019-09-04},
 466         booktitle = {2016 {IEEE} 4th {International} {Conference} on {Future} {Internet} of {Things} and {Cloud} ({FiCloud})},
 467         publisher = {IEEE},
 468         author = {Hentschel, Kristian and Jacob, Dejice and Singer, Jeremy and Chalmers, Matthew},
 469         month = aug,
 470         year = {2016},
 471         pages = {58--62},
 472         file = {Hentschel et al. - 2016 - Supersensors Raspberry Pi Devices for Smart Campu.pdf:/home/mrl/.local/share/zotero/storage/ATK53FN2/Hentschel et al. - 2016 - Supersensors Raspberry Pi Devices for Smart Campu.pdf:application/pdf},
 473 }
 474
 475 @inproceedings{feijs_multi-tasking_2013,
 476         address = {Wuxi, China},
 477         title = {Multi-tasking and {Arduino} : why and how?},
 478         isbn = {978-90-386-3462-3},
 479         abstract = {In this article I argue that it is important to develop experiential prototypes which have multi-tasking capabilities. At the same time I show that for embedded prototype software based on the popular Arduino platform this is not too difficult. The approach is explained and illustrated using technical examples – practical and hands-on, down to the code level. At the same time a few helpful notations for designing and documenting the software are introduced and illustrated by the same examples. Finally a few case studies of the technical approach are listed.},
 480         language = {English},
 481         booktitle = {Design and semantics of form and movement. 8th {International} {Conference} on {Design} and {Semantics} of {Form} and {Movement} ({DeSForM} 2013)},
 482         author = {Feijs, Loe},
 483         editor = {Chen, L. L. and Djajadiningrat, T. and Feijs, L. M. G. and Fraser, S. and Hu, J. and Kyffin, S. and Steffen, D.},
 484         year = {2013},
 485         pages = {119--127},
 486         file = {Feijs - 2013 - Multi-tasking and Arduino why and how.pdf:/home/mrl/.local/share/zotero/storage/8A3Q8LHA/Feijs - 2013 - Multi-tasking and Arduino why and how.pdf:application/pdf},
 487 }
 488
 489 @misc{achten_clean_2007,
 490         title = {Clean for {Haskell98} {Programmers}},
 491         url = {https://www.mbsd.cs.ru.nl/publications/papers/2007/achp2007-CleanHaskellQuickGuide.pdf},
 492         language = {en},
 493         author = {Achten, Peter},
 494         month = jul,
 495         year = {2007},
 496         file = {Achten - Clean for Haskell98 Programmers.pdf:/home/mrl/.local/share/zotero/storage/69WWSGLF/Achten - Clean for Haskell98 Programmers.pdf:application/pdf},
 497 }
 498
 499 @inproceedings{baccelli_reprogramming_2018,
 500         title = {Reprogramming {Low}-end {IoT} {Devices} from the {Cloud}},
 501         booktitle = {2018 3rd {Cloudification} of the {Internet} of {Things} ({CIoT})},
 502         publisher = {IEEE},
 503         author = {Baccelli, Emmanuel and Doerr, Joerg and Jallouli, Ons and Kikuchi, Shinji and Morgenstern, Andreas and Padilla, Francisco Acosta and Schleiser, Kaspar and Thomas, Ian},
 504         year = {2018},
 505         pages = {1--6},
 506         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},
 507 }
 508
 509 @mastersthesis{piers_task-oriented_2016,
 510         address = {Nijmegen},
 511         title = {Task-{Oriented} {Programming} for developing non-distributed interruptible embedded systems},
 512         language = {en},
 513         school = {Radboud University},
 514         author = {Piers, Jasper},
 515         year = {2016},
 516         file = {Piers - Task-Oriented Programming for developing non-distr.pdf:/home/mrl/.local/share/zotero/storage/X8BZM9D4/Piers - Task-Oriented Programming for developing non-distr.pdf:application/pdf},
 517 }
 518
 519 @inproceedings{baccelli_scripting_2018,
 520         title = {Scripting {Over}-{The}-{Air}: {Towards} {Containers} on {Low}-end {Devices} in the {Internet} of {Things}},
 521         booktitle = {{IEEE} {PerCom} 2018},
 522         author = {Baccelli, Emmanuel and Doerr, Joerg and Kikuchi, Shinji and Padilla, Francisco and Schleiser, Kaspar and Thomas, Ian},
 523         year = {2018},
 524         file = {Baccelli et al. - Scripting Over-The-Air Towards Containers on Low-.pdf:/home/mrl/.local/share/zotero/storage/98UTMFAC/Baccelli et al. - Scripting Over-The-Air Towards Containers on Low-.pdf:application/pdf},
 525 }
 526
 527 @mastersthesis{amazonas_cabral_de_andrade_developing_2018,
 528         address = {Nijmegen},
 529         title = {Developing {Real} {Life}, {Task} {Oriented} {Applications} for the {Internet} of {Things}},
 530         shorttitle = {Developing {Real} {Life}, {TOP} {Applications} for the {IOT}},
 531         language = {en},
 532         school = {Radboud University},
 533         author = {Amazonas Cabral de Andrade, Matheus},
 534         year = {2018},
 535         file = {Lubbers - prof. dr. dr.h.c. ir. M.J. Plasmeijer.pdf:/home/mrl/.local/share/zotero/storage/JXPEWS85/Lubbers - prof. dr. dr.h.c. ir. M.J. Plasmeijer.pdf:application/pdf},
 536 }
 537
 538 @article{swierstra_data_2008,
 539         title = {Data types à la carte},
 540         volume = {18},
 541         doi = {10.1017/S0956796808006758},
 542         number = {4},
 543         journal = {Journal of functional programming},
 544         author = {Swierstra, Wouter},
 545         year = {2008},
 546         pages = {423--436},
 547         file = {swierstra2008.pdf:/home/mrl/.local/share/zotero/storage/BEQKBXWP/swierstra2008.pdf:application/pdf},
 548 }
 549
 550 @article{groningen_exchanging_2010,
 551         title = {Exchanging sources between {Clean} and {Haskell}: {A} double-edged front end for the {Clean} compiler},
 552         volume = {45},
 553         shorttitle = {Exchanging sources between {Clean} and {Haskell}},
 554         number = {11},
 555         journal = {ACM Sigplan Notices},
 556         author = {Groningen, John van and Noort, Thomas van and Achten, Peter and Koopman, Pieter and Plasmeijer, Rinus},
 557         year = {2010},
 558         pages = {49--60},
 559         file = {groj10-Haskell_front_end_Clean.pdf:/home/mrl/.local/share/zotero/storage/WVZWX8WT/groj10-Haskell_front_end_Clean.pdf:application/pdf},
 560 }
 561
 562 @article{plasmeijer_itasks:_2007,
 563         title = {{iTasks}: executable specifications of interactive work flow systems for the web},
 564         volume = {42},
 565         number = {9},
 566         journal = {ACM SIGPLAN Notices},
 567         author = {Plasmeijer, Rinus and Achten, Peter and Koopman, Pieter},
 568         year = {2007},
 569         pages = {141--152},
 570         file = {plar2007-ICFP07-iTasks.pdf:/home/mrl/.local/share/zotero/storage/N8EUZP7D/plar2007-ICFP07-iTasks.pdf:application/pdf},
 571 }
 572
 573 @incollection{plasmeijer_shallow_2016,
 574         address = {Cham},
 575         series = {Lecture {Notes} in {Computer} {Science}},
 576         title = {A {Shallow} {Embedded} {Type} {Safe} {Extendable} {DSL} for the {Arduino}},
 577         volume = {9547},
 578         isbn = {978-3-319-39110-6},
 579         urldate = {2017-02-22},
 580         booktitle = {Trends in {Functional} {Programming}},
 581         publisher = {Springer International Publishing},
 582         author = {Plasmeijer, Rinus and Koopman, Pieter},
 583         year = {2016},
 584         doi = {10.1007/978-3-319-39110-6},
 585         file = {chp%3A10.1007%2F978-3-319-39110-6_6.pdf:/home/mrl/.local/share/zotero/storage/TJVP6FHF/chp%3A10.1007%2F978-3-319-39110-6_6.pdf:application/pdf},
 586 }
 587
 588 @inproceedings{cheney_lightweight_2002,
 589         title = {A lightweight implementation of generics and dynamics},
 590         doi = {10.1145/581690.581698},
 591         urldate = {2017-05-15},
 592         booktitle = {Proceedings of the 2002 {ACM} {SIGPLAN} workshop on {Haskell}},
 593         publisher = {ACM},
 594         author = {Cheney, James and Hinze, Ralf},
 595         year = {2002},
 596         note = {event-place: Pittsburgh Pennsylvania, USA},
 597         keywords = {dynamic typing, generic programming, type representations},
 598         pages = {90--104},
 599         file = {Cheney and Hinze - 2002 - A lightweight implementation of generics and dynam.pdf:/home/mrl/.local/share/zotero/storage/FZ6EGJRJ/Cheney and Hinze - 2002 - A lightweight implementation of generics and dynam.pdf:application/pdf;HW02.pdf:/home/mrl/.local/share/zotero/storage/A8Z49NK6/HW02.pdf:application/pdf},
 600 }
 601
 602 @article{lilis_survey_2019,
 603         title = {A {Survey} of {Metaprogramming} {Languages}},
 604         volume = {52},
 605         issn = {0360-0300},
 606         doi = {10.1145/3354584},
 607         abstract = {Metaprogramming is the process of writing computer programs that treat programs as data, enabling them to analyze or transform existing programs or generate new ones. While the concept of metaprogramming has existed for several decades, activities focusing on metaprogramming have been increasing rapidly over the past few years, with most languages offering some metaprogramming support and the amount of metacode being developed growing exponentially. In this article, we introduce a taxonomy of metaprogramming languages and present a survey of metaprogramming languages and systems based on the taxonomy. Our classification is based on the metaprogramming model adopted by the language, the phase of the metaprogram evaluation, the metaprogram source location, and the relation between the metalanguage and the object language.},
 608         number = {6},
 609         journal = {ACM Comput. Surv.},
 610         author = {Lilis, Yannis and Savidis, Anthony},
 611         month = oct,
 612         year = {2019},
 613         note = {Place: New York, NY, USA
 614 Publisher: Association for Computing Machinery},
 615         keywords = {aspect-oriented programming, generative programming, macro systems, meta-object protocols, Metaprogramming, multistage languages, reflection},
 616         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},
 617 }
 618
 619 @inproceedings{mainland_why_2007,
 620         address = {New York, NY, USA},
 621         series = {Haskell '07},
 622         title = {Why {It}'s {Nice} to {Be} {Quoted}: {Quasiquoting} for {Haskell}},
 623         isbn = {978-1-59593-674-5},
 624         doi = {10.1145/1291201.1291211},
 625         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.},
 626         booktitle = {Proceedings of the {ACM} {SIGPLAN} {Workshop} on {Haskell} {Workshop}},
 627         publisher = {Association for Computing Machinery},
 628         author = {Mainland, Geoffrey},
 629         year = {2007},
 630         note = {event-place: Freiburg, Germany},
 631         keywords = {meta programming, quasiquoting},
 632         pages = {73--82},
 633         file = {Mainland - 2007 - Why It's Nice to Be Quoted Quasiquoting for Haske.pdf:/home/mrl/.local/share/zotero/storage/PSJ59GY2/Mainland - 2007 - Why It's Nice to Be Quoted Quasiquoting for Haske.pdf:application/pdf},
 634 }
 635
 636 @article{tratt_domain_2008,
 637         title = {Domain {Specific} {Language} {Implementation} via {Compile}-{Time} {Meta}-{Programming}},
 638         volume = {30},
 639         issn = {0164-0925},
 640         doi = {10.1145/1391956.1391958},
 641         abstract = {Domain specific languages (DSLs) are mini-languages that are increasingly seen as being a valuable tool for software developers and non-developers alike. DSLs must currently be created in an ad-hoc fashion, often leading to high development costs and implementations of variable quality. In this article, I show how expressive DSLs can be hygienically embedded in the Converge programming language using its compile-time meta-programming facility, the concept of DSL blocks, and specialised error reporting techniques. By making use of pre-existing facilities, and following a simple methodology, DSL implementation costs can be significantly reduced whilst leading to higher quality DSL implementations.},
 642         number = {6},
 643         journal = {ACM Trans. Program. Lang. Syst.},
 644         author = {Tratt, Laurence},
 645         month = oct,
 646         year = {2008},
 647         note = {Place: New York, NY, USA
 648 Publisher: Association for Computing Machinery},
 649         keywords = {domain specific languages, compile-time meta-programming, Syntax extension},
 650         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},
 651 }
 652
 653 @inproceedings{kariotis_making_2008,
 654         address = {New York, NY, USA},
 655         series = {Haskell '08},
 656         title = {Making {Monads} {First}-{Class} with {Template} {Haskell}},
 657         isbn = {978-1-60558-064-7},
 658         doi = {10.1145/1411286.1411300},
 659         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.},
 660         booktitle = {Proceedings of the {First} {ACM} {SIGPLAN} {Symposium} on {Haskell}},
 661         publisher = {Association for Computing Machinery},
 662         author = {Kariotis, Pericles S. and Procter, Adam M. and Harrison, William L.},
 663         year = {2008},
 664         note = {event-place: Victoria, BC, Canada},
 665         keywords = {domain-specific languages, monads, staged programming},
 666         pages = {99--110},
 667         file = {Kariotis et al. - 2008 - Making Monads First-Class with Template Haskell.pdf:/home/mrl/.local/share/zotero/storage/ZLX24WE8/Kariotis et al. - 2008 - Making Monads First-Class with Template Haskell.pdf:application/pdf},
 668 }
 669
 670 @inproceedings{gill_haskell_2009,
 671         address = {Berlin, Heidelberg},
 672         title = {A {Haskell} {Hosted} {DSL} for {Writing} {Transformation} {Systems}},
 673         isbn = {978-3-642-03034-5},
 674         abstract = {KURE is a Haskell hosted Domain Specific Language (DSL) for writing transformation systems based on rewrite strategies. When writing transformation systems, a significant amount of engineering effort goes into setting up plumbing to make sure that specific rewrite rules can fire. Systems like Stratego and Strafunski provide most of this plumbing as infrastructure, allowing the DSL user to focus on the rewrite rules. KURE is a strongly typed strategy control language in the tradition of Stratego and Strafunski. It is intended for writing reasonably efficient rewrite systems, makes use of type families to provide a delimited generic mechanism for tree rewriting, and provides support for efficient identity rewrite detection.},
 675         booktitle = {Domain-{Specific} {Languages}},
 676         publisher = {Springer Berlin Heidelberg},
 677         author = {Gill, Andy},
 678         editor = {Taha, Walid Mohamed},
 679         year = {2009},
 680         pages = {285--309},
 681         file = {Gill2009_Chapter_AHaskellHostedDSLForWritingTra.pdf:/home/mrl/.local/share/zotero/storage/I9RJNDYR/Gill2009_Chapter_AHaskellHostedDSLForWritingTra.pdf:application/pdf},
 682 }
 683
 684 @book{peyton_jones_implementation_1987,
 685         address = {Hertfordshire},
 686         title = {The {Implementation} of {Functional} {Programming} {Languages}},
 687         url = {https://www.microsoft.com/en-us/research/publication/the-implementation-of-functional-programming-languages/},
 688         abstract = {My 1987 book is now out of print, but it is available here in its entirety in PDF form, in one of two formats: single-page portrait double-page landscape Both are fully searchable, thanks to OCR and Norman Ramsey. Errata Section 5.2.4, p87. We need an extra rule match us [] E = E This accounts for the possibility that in the constructor rule (Section 5.2.4) there may be some non-nullary constructors for which there are no equations. P168, line 2, "VAR" should be "TVAR".},
 689         publisher = {Prentice Hall},
 690         author = {Peyton Jones, Simon},
 691         month = jan,
 692         year = {1987},
 693         file = {Peyton Jones - 1987 - The Implementation of Functional Programming Langu.pdf:/home/mrl/.local/share/zotero/storage/9RIR6KGD/Peyton Jones - 1987 - The Implementation of Functional Programming Langu.pdf:application/pdf},
 694 }
 695
 696 @inproceedings{sheard_template_2002,
 697         address = {New York, NY, USA},
 698         series = {Haskell '02},
 699         title = {Template {Meta}-{Programming} for {Haskell}},
 700         isbn = {1-58113-605-6},
 701         doi = {10.1145/581690.581691},
 702         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.},
 703         booktitle = {Proceedings of the 2002 {ACM} {SIGPLAN} {Workshop} on {Haskell}},
 704         publisher = {Association for Computing Machinery},
 705         author = {Sheard, Tim and Jones, Simon Peyton},
 706         year = {2002},
 707         note = {event-place: Pittsburgh, Pennsylvania},
 708         keywords = {meta programming, templates},
 709         pages = {1--16},
 710         file = {Sheard and Jones - 2002 - Template Meta-Programming for Haskell.pdf:/home/mrl/.local/share/zotero/storage/2GSK6DSF/Sheard and Jones - 2002 - Template Meta-Programming for Haskell.pdf:application/pdf},
 711 }
 712
 713 @inproceedings{seefried_optimising_2004,
 714         address = {Berlin, Heidelberg},
 715         title = {Optimising {Embedded} {DSLs} {Using} {Template} {Haskell}},
 716         isbn = {978-3-540-30175-2},
 717         abstract = {Embedded domain specific languages (EDSLs) provide a specialised language for a particular application area while harnessing the infrastructure of an existing general purpose programming language. The reduction in implementation costs that results from this approach comes at a price: the EDSL often compiles to inefficient code since the host language's compiler only optimises at the level of host language constructs. The paper presents an approach to solving this problem based on compile-time meta-programming which retains the simplicity of the embedded approach. We use PanTHeon, our implementation of an existing EDSL for image synthesis to demonstrate the benefits and drawbacks of this approach. Furthermore, we suggest potential improvements to Template Haskell, the meta-programming framework we are using, which would greatly improve its applicability to this kind of task.},
 718         booktitle = {Generative {Programming} and {Component} {Engineering}},
 719         publisher = {Springer Berlin Heidelberg},
 720         author = {Seefried, Sean and Chakravarty, Manuel and Keller, Gabriele},
 721         editor = {Karsai, Gabor and Visser, Eelco},
 722         year = {2004},
 723         pages = {186--205},
 724         file = {Seefried et al. - 2004 - Optimising Embedded DSLs Using Template Haskell.pdf:/home/mrl/.local/share/zotero/storage/ZRKQ9AH6/Seefried et al. - 2004 - Optimising Embedded DSLs Using Template Haskell.pdf:application/pdf},
 725 }
 726
 727 @article{hammond_automatic_2003,
 728         title = {{AUTOMATIC} {SKELETONS} {IN} {TEMPLATE} {HASKELL}},
 729         volume = {13},
 730         doi = {10.1142/S0129626403001380},
 731         abstract = {This paper uses Template Haskell to automatically select appropriate skeleton implementations in the Eden parallel dialect of Haskell. The approach allows implementation parameters to be statically tuned according to architectural cost models based on source analyses. This permits us to target a range of parallel architecture classes from a single source specification. A major advantage of the approach is that cost models are user-definable and can be readily extended to new data or computation structures etc.},
 732         number = {03},
 733         journal = {Parallel Processing Letters},
 734         author = {Hammond, Kevin and Berthold, Jost and Loogen, Rita},
 735         year = {2003},
 736         pages = {413--424},
 737         file = {Hammond et al. - 2003 - AUTOMATIC SKELETONS IN TEMPLATE HASKELL.pdf:/home/mrl/.local/share/zotero/storage/HBQ8UXY3/Hammond et al. - 2003 - AUTOMATIC SKELETONS IN TEMPLATE HASKELL.pdf:application/pdf},
 738 }
 739
 740 @inproceedings{adams_template_2012,
 741         address = {New York, NY, USA},
 742         series = {Haskell '12},
 743         title = {Template {Your} {Boilerplate}: {Using} {Template} {Haskell} for {Efficient} {Generic} {Programming}},
 744         isbn = {978-1-4503-1574-6},
 745         doi = {10.1145/2364506.2364509},
 746         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.},
 747         booktitle = {Proceedings of the 2012 {Haskell} {Symposium}},
 748         publisher = {Association for Computing Machinery},
 749         author = {Adams, Michael D. and DuBuisson, Thomas M.},
 750         year = {2012},
 751         note = {event-place: Copenhagen, Denmark},
 752         keywords = {generic programming, scrap your boilerplate, template haskell},
 753         pages = {13--24},
 754         file = {Adams and DuBuisson - 2012 - Template Your Boilerplate Using Template Haskell .pdf:/home/mrl/.local/share/zotero/storage/ANAHWLB5/Adams and DuBuisson - 2012 - Template Your Boilerplate Using Template Haskell .pdf:application/pdf},
 755 }
 756
 757 @inproceedings{norell_prototyping_2004,
 758         address = {Berlin, Heidelberg},
 759         title = {Prototyping {Generic} {Programming} in {Template} {Haskell}},
 760         isbn = {978-3-540-27764-4},
 761         abstract = {Generic Programming deals with the construction of programs that can be applied to many different datatypes. This is achieved by parameterizing the generic programs by the structure of the datatypes on which they are to be applied. Programs that can be defined generically range from simple map functions through pretty printers to complex XML tools.},
 762         booktitle = {Mathematics of {Program} {Construction}},
 763         publisher = {Springer Berlin Heidelberg},
 764         author = {Norell, Ulf and Jansson, Patrik},
 765         editor = {Kozen, Dexter},
 766         year = {2004},
 767         pages = {314--333},
 768         file = {Norell and Jansson - 2004 - Prototyping Generic Programming in Template Haskel.pdf:/home/mrl/.local/share/zotero/storage/S3EXD65Z/Norell and Jansson - 2004 - Prototyping Generic Programming in Template Haskel.pdf:application/pdf},
 769 }
 770
 771 @incollection{odonnell_embedding_2004,
 772         address = {Berlin, Heidelberg},
 773         title = {Embedding a {Hardware} {Description} {Language} in {Template} {Haskell}},
 774         isbn = {978-3-540-25935-0},
 775         abstract = {Hydra is a domain-specific language for designing digital circuits, which is implemented by embedding within Haskell. Many features required for hardware specification fit well within functional languages, leading in many cases to a perfect embedding. There are some situations, including netlist generation and software logic probes, where the DSL does not fit exactly within the host functional language. A new solution to these problems is based on program transformations performed automatically by metaprograms in Template Haskell.},
 776         booktitle = {Domain-{Specific} {Program} {Generation}: {International} {Seminar}, {Dagstuhl} {Castle}, {Germany}, {March} 23-28, 2003. {Revised} {Papers}},
 777         publisher = {Springer Berlin Heidelberg},
 778         author = {O'Donnell, John T.},
 779         editor = {Lengauer, Christian and Batory, Don and Consel, Charles and Odersky, Martin},
 780         year = {2004},
 781         doi = {10.1007/978-3-540-25935-0_9},
 782         pages = {143--164},
 783         file = {O'Donnell - 2004 - Embedding a Hardware Description Language in Templ.pdf:/home/mrl/.local/share/zotero/storage/Z2XT7SM3/O'Donnell - 2004 - Embedding a Hardware Description Language in Templ.pdf:application/pdf},
 784 }
 785
 786 @misc{lynagh_unrolling_2003,
 787         title = {Unrolling and {Simplifying} {Expressions} with {Template} {Haskell}},
 788         url = {http://web.comlab.ox.ac.uk/oucl/work/ian.lynagh/papers/},
 789         urldate = {2021-09-07},
 790         author = {Lynagh, Ian},
 791         month = may,
 792         year = {2003},
 793         file = {10.1.1.5.9813.pdf:/home/mrl/.local/share/zotero/storage/G4AFM8XZ/10.1.1.5.9813.pdf:application/pdf},
 794 }
 795
 796 @article{elliott_compiling_2003,
 797         title = {Compiling embedded languages},
 798         volume = {13},
 799         doi = {10.1017/S0956796802004574},
 800         number = {3},
 801         journal = {Journal of Functional Programming},
 802         author = {Elliott, Conal and Finne, Sigbjørn and de Moor, Oege},
 803         year = {2003},
 804         note = {Publisher: Cambridge University Press},
 805         pages = {455--481},
 806         file = {Elliott et al. - 2003 - Compiling embedded languages.pdf:/home/mrl/.local/share/zotero/storage/3X4Z6AKB/Elliott et al. - 2003 - Compiling embedded languages.pdf:application/pdf},
 807 }
 808
 809 @incollection{czarnecki_dsl_2004,
 810         address = {Berlin, Heidelberg},
 811         title = {{DSL} {Implementation} in {MetaOCaml}, {Template} {Haskell}, and {C}++},
 812         isbn = {978-3-540-25935-0},
 813         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.},
 814         booktitle = {Domain-{Specific} {Program} {Generation}: {International} {Seminar}, {Dagstuhl} {Castle}, {Germany}, {March} 23-28, 2003. {Revised} {Papers}},
 815         publisher = {Springer Berlin Heidelberg},
 816         author = {Czarnecki, Krzysztof and O'Donnell, John T. and Striegnitz, Jörg and Taha, Walid},
 817         editor = {Lengauer, Christian and Batory, Don and Consel, Charles and Odersky, Martin},
 818         year = {2004},
 819         doi = {10.1007/978-3-540-25935-0_4},
 820         pages = {51--72},
 821         file = {Czarnecki et al. - 2004 - DSL Implementation in MetaOCaml, Template Haskell,.pdf:/home/mrl/.local/share/zotero/storage/U6E3325Q/Czarnecki et al. - 2004 - DSL Implementation in MetaOCaml, Template Haskell,.pdf:application/pdf},
 822 }
 823
 824 @inproceedings{sheard_accomplishments_2001,
 825         address = {Berlin, Heidelberg},
 826         title = {Accomplishments and {Research} {Challenges} in {Meta}-programming},
 827         isbn = {978-3-540-44806-8},
 828         abstract = {In the last ten years the study of meta-programming systems, as formal systems worthy of study in their own right, has vastly accelerated. In that time a lot has been accomplished, yet much remains to be done. In this invited talk I wish to review recent accomplishments and future research challenges in hopes that this will spur interest in meta-programming in general and lead to new and better meta-programming systems.},
 829         booktitle = {Semantics, {Applications}, and {Implementation} of {Program} {Generation}},
 830         publisher = {Springer Berlin Heidelberg},
 831         author = {Sheard, Tim},
 832         editor = {Taha, Walid},
 833         year = {2001},
 834         pages = {2--44},
 835         file = {Sheard - 2001 - Accomplishments and Research Challenges in Meta-pr.pdf:/home/mrl/.local/share/zotero/storage/M7NT6USA/Sheard - 2001 - Accomplishments and Research Challenges in Meta-pr.pdf:application/pdf},
 836 }
 837
 838 @inproceedings{kohlbecker_hygienic_1986,
 839         address = {New York, NY, USA},
 840         series = {{LFP} '86},
 841         title = {Hygienic {Macro} {Expansion}},
 842         isbn = {0-89791-200-4},
 843         doi = {10.1145/319838.319859},
 844         booktitle = {Proceedings of the 1986 {ACM} {Conference} on {LISP} and {Functional} {Programming}},
 845         publisher = {Association for Computing Machinery},
 846         author = {Kohlbecker, Eugene and Friedman, Daniel P. and Felleisen, Matthias and Duba, Bruce},
 847         year = {1986},
 848         note = {event-place: Cambridge, Massachusetts, USA},
 849         pages = {151--161},
 850         file = {Kohlbecker et al. - 1986 - Hygienic Macro Expansion.pdf:/home/mrl/.local/share/zotero/storage/MFH642JU/Kohlbecker et al. - 1986 - Hygienic Macro Expansion.pdf:application/pdf},
 851 }
 852
 853 @inproceedings{lammel_scrap_2003,
 854         address = {New York, NY, USA},
 855         series = {{TLDI} '03},
 856         title = {Scrap {Your} {Boilerplate}: {A} {Practical} {Design} {Pattern} for {Generic} {Programming}},
 857         isbn = {1-58113-649-8},
 858         doi = {10.1145/604174.604179},
 859         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.},
 860         booktitle = {Proceedings of the 2003 {ACM} {SIGPLAN} {International} {Workshop} on {Types} in {Languages} {Design} and {Implementation}},
 861         publisher = {Association for Computing Machinery},
 862         author = {Lämmel, Ralf and Jones, Simon Peyton},
 863         year = {2003},
 864         note = {event-place: New Orleans, Louisiana, USA},
 865         keywords = {generic programming, rank-2 types, traversal, type cast},
 866         pages = {26--37},
 867         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},
 868 }
 869
 870 @inproceedings{bawden_quasiquotation_1999,
 871         address = {Aarhus, Denmark},
 872         series = {{BRICS} {Notes} {Series}},
 873         title = {Quasiquotation in {Lisp}},
 874         volume = {NS-99-1},
 875         doi = {10.1.1.22.1290},
 876         booktitle = {O. {Danvy}, {Ed}., {University} of {Aarhus}, {Dept}. of {Computer} {Science}},
 877         publisher = {BRICS},
 878         author = {Bawden, Alan},
 879         year = {1999},
 880         pages = {88--99},
 881         file = {Bawden - 1999 - Quasiquotation in Lisp.pdf:/home/mrl/.local/share/zotero/storage/CIFANZAW/Bawden - 1999 - Quasiquotation in Lisp.pdf:application/pdf},
 882 }
 883
 884 @inproceedings{clifton-everest_embedding_2014,
 885         address = {Cham},
 886         title = {Embedding {Foreign} {Code}},
 887         isbn = {978-3-319-04132-2},
 888         abstract = {Special purpose embedded languages facilitate generating high-performance code from purely functional high-level code; for example, we want to program highly parallel GPUs without the usual high barrier to entry and the time-consuming development process. We previously demonstrated the feasibility of a skeleton-based, generative approach to compiling such embedded languages.},
 889         booktitle = {Practical {Aspects} of {Declarative} {Languages}},
 890         publisher = {Springer International Publishing},
 891         author = {Clifton-Everest, Robert and McDonell, Trevor L. and Chakravarty, Manuel M. T. and Keller, Gabriele},
 892         editor = {Flatt, Matthew and Guo, Hai-Feng},
 893         year = {2014},
 894         pages = {136--151},
 895         file = {Clifton-Everest et al. - 2014 - Embedding Foreign Code.pdf:/home/mrl/.local/share/zotero/storage/JTJGK5BX/Clifton-Everest et al. - 2014 - Embedding Foreign Code.pdf:application/pdf},
 896 }
 897
 898 @inproceedings{shioda_libdsl_2014,
 899         address = {New York, NY, USA},
 900         series = {{GPCE} 2014},
 901         title = {{LibDSL}: {A} {Library} for {Developing} {Embedded} {Domain} {Specific} {Languages} in d via {Template} {Metaprogramming}},
 902         isbn = {978-1-4503-3161-6},
 903         doi = {10.1145/2658761.2658770},
 904         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.},
 905         booktitle = {Proceedings of the 2014 {International} {Conference} on {Generative} {Programming}: {Concepts} and {Experiences}},
 906         publisher = {Association for Computing Machinery},
 907         author = {Shioda, Masato and Iwasaki, Hideya and Sato, Shigeyuki},
 908         year = {2014},
 909         note = {event-place: Västerås, Sweden},
 910         keywords = {Metaprogramming, D language, Embedded domain specific languages, Library},
 911         pages = {63--72},
 912         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},
 913 }
 914
 915 @inproceedings{duregard_embedded_2011,
 916         address = {New York, NY, USA},
 917         series = {Haskell '11},
 918         title = {Embedded {Parser} {Generators}},
 919         isbn = {978-1-4503-0860-1},
 920         doi = {10.1145/2034675.2034689},
 921         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.},
 922         booktitle = {Proceedings of the 4th {ACM} {Symposium} on {Haskell}},
 923         publisher = {Association for Computing Machinery},
 924         author = {Duregård, Jonas and Jansson, Patrik},
 925         year = {2011},
 926         note = {event-place: Tokyo, Japan},
 927         keywords = {domain specific languages, metaprogramming},
 928         pages = {107--117},
 929         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},
 930 }
 931
 932 @inproceedings{eisenberg_promoting_2014,
 933         address = {New York, NY, USA},
 934         series = {Haskell '14},
 935         title = {Promoting {Functions} to {Type} {Families} in {Haskell}},
 936         isbn = {978-1-4503-3041-1},
 937         doi = {10.1145/2633357.2633361},
 938         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.},
 939         booktitle = {Proceedings of the 2014 {ACM} {SIGPLAN} {Symposium} on {Haskell}},
 940         publisher = {Association for Computing Machinery},
 941         author = {Eisenberg, Richard A. and Stolarek, Jan},
 942         year = {2014},
 943         note = {event-place: Gothenburg, Sweden},
 944         keywords = {Haskell, defunctionalization, type-level programming},
 945         pages = {95--106},
 946         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},
 947 }
 948
 949 @inproceedings{viera_staged_2018,
 950         address = {New York, NY, USA},
 951         series = {{IFL} 2018},
 952         title = {A {Staged} {Embedding} of {Attribute} {Grammars} in {Haskell}},
 953         isbn = {978-1-4503-7143-8},
 954         doi = {10.1145/3310232.3310235},
 955         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.},
 956         booktitle = {Proceedings of the 30th {Symposium} on {Implementation} and {Application} of {Functional} {Languages}},
 957         publisher = {Association for Computing Machinery},
 958         author = {Viera, Marcos and Balestrieri, Florent and Pardo, Alberto},
 959         year = {2018},
 960         note = {event-place: Lowell, MA, USA},
 961         keywords = {Haskell, EDSL, Attribute Grammars, Dynamics, Staging},
 962         pages = {95--106},
 963         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},
 964 }
 965
 966 @incollection{kiselyov_typed_2012,
 967         address = {Berlin, Heidelberg},
 968         title = {Typed {Tagless} {Final} {Interpreters}},
 969         isbn = {978-3-642-32202-0},
 970         abstract = {The so-called `typed tagless final' approach of [6] has collected and polished a number of techniques for representing typed higher-order languages in a typed metalanguage, along with type-preserving interpretation, compilation and partial evaluation. The approach is an alternative to the traditional, or `initial' encoding of an object language as a (generalized) algebraic data type. Both approaches permit multiple interpretations of an expression, to evaluate it, pretty-print, etc. The final encoding represents all and only typed object terms without resorting to generalized algebraic data types, dependent or other fancy types. The final encoding lets us add new language forms and interpretations without breaking the existing terms and interpreters.},
 971         booktitle = {Generic and {Indexed} {Programming}: {International} {Spring} {School}, {SSGIP} 2010, {Oxford}, {UK}, {March} 22-26, 2010, {Revised} {Lectures}},
 972         publisher = {Springer Berlin Heidelberg},
 973         author = {Kiselyov, Oleg},
 974         editor = {Gibbons, Jeremy},
 975         year = {2012},
 976         doi = {10.1007/978-3-642-32202-0_3},
 977         pages = {130--174},
 978         file = {Kiselyov - 2012 - Typed Tagless Final Interpreters.pdf:/home/mrl/.local/share/zotero/storage/9NBYZLRP/Kiselyov - 2012 - Typed Tagless Final Interpreters.pdf:application/pdf},
 979 }
 980
 981 @article{laufer_type_1996,
 982         title = {Type classes with existential types},
 983         volume = {6},
 984         doi = {10.1017/S0956796800001817},
 985         number = {3},
 986         journal = {Journal of Functional Programming},
 987         author = {Läufer, Konstantin},
 988         year = {1996},
 989         note = {Publisher: Cambridge University Press},
 990         pages = {485--518},
 991         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},
 992 }
 993
 994 @incollection{hinze_fun_2003,
 995         address = {Palgrave},
 996         series = {Cornerstones of {Computing}},
 997         title = {Fun {With} {Phantom} {Types}},
 998         isbn = {978-0-333-99285-2},
 999         booktitle = {The {Fun} of {Programming}},
1000         publisher = {Bloomsbury Publishing},
1001         author = {Hinze, Ralf},
1002         editor = {Gibbons, Jeremy and de Moor, Oege},
1003         year = {2003},
1004         pages = {245--262},
1005 }
1006
1007 @inproceedings{boulton_experience_1992,
1008         address = {North-Holland},
1009         title = {Experience with embedding hardware description languages in {HOL}},
1010         volume = {10},
1011         isbn = {0-444-89686-4},
1012         abstract = {The semantics of hardware description languages can be represented in higher order logic. This provides a formal de nition that is suitable for machine processing. Experiments are in progress at Cambridge to see whether this method can be the basis of practical tools based on the HOL theorem-proving assistant. Three languages are being investigated: ELLA, Silage and VHDL. The approaches taken for these languages are compared and current progress on building semantically-based theorem-proving tools is discussed.},
1013         language = {en},
1014         booktitle = {{IFIP} {TC10}/{WG}},
1015         publisher = {Elsevier},
1016         author = {Boulton, Richard and Gordon, Andrew and Gordon, Mike and Harrison, John and Herbert, John and Tassel, John Van},
1017         editor = {Stavridou, Victoria and Melham, Thomas F. and Boute, Raymond T.},
1018         year = {1992},
1019         note = {event-place: Nijmegen, NL},
1020         pages = {129--156},
1021         file = {Boulton et al. - Experience with embedding hardware description lan.pdf:/home/mrl/.local/share/zotero/storage/USAAA6WM/Boulton et al. - Experience with embedding hardware description lan.pdf:application/pdf},
1022 }
1023
1024 @inproceedings{terei_safe_2012,
1025         address = {New York, NY, USA},
1026         series = {Haskell '12},
1027         title = {Safe {Haskell}},
1028         isbn = {978-1-4503-1574-6},
1029         doi = {10.1145/2364506.2364524},
1030         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.},
1031         booktitle = {Proceedings of the 2012 {Haskell} {Symposium}},
1032         publisher = {Association for Computing Machinery},
1033         author = {Terei, David and Marlow, Simon and Peyton Jones, Simon and Mazières, David},
1034         year = {2012},
1035         note = {event-place: Copenhagen, Denmark},
1036         keywords = {haskell, security, type safety},
1037         pages = {137--148},
1038         file = {2364506.2364524.pdf:/home/mrl/.local/share/zotero/storage/5SMB272R/2364506.2364524.pdf:application/pdf},
1039 }
1040
1041 @techreport{leijen_parsec_2001,
1042         address = {Utrecht},
1043         title = {Parsec: {Direct} {Style} {Monadic} {Parser} {Combinators} {For} {The} {Real} {World}},
1044         language = {en},
1045         number = {UU-CS-2001-27},
1046         institution = {Universiteit Utrecht},
1047         author = {Leijen, Daan and Meijer, Erik},
1048         year = {2001},
1049         pages = {22},
1050         file = {Leijen - Parsec Direct Style Monadic Parser Combinators Fo.pdf:/home/mrl/.local/share/zotero/storage/J78G3FZ2/Leijen - Parsec Direct Style Monadic Parser Combinators Fo.pdf:application/pdf},
1051 }
1052
1053 @inproceedings{gibbons_folding_2014,
1054         address = {New York, NY, USA},
1055         series = {{ICFP} '14},
1056         title = {Folding {Domain}-{Specific} {Languages}: {Deep} and {Shallow} {Embeddings} ({Functional} {Pearl})},
1057         isbn = {978-1-4503-2873-9},
1058         doi = {10.1145/2628136.2628138},
1059         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.},
1060         booktitle = {Proceedings of the 19th {ACM} {SIGPLAN} {International} {Conference} on {Functional} {Programming}},
1061         publisher = {Association for Computing Machinery},
1062         author = {Gibbons, Jeremy and Wu, Nicolas},
1063         year = {2014},
1064         note = {event-place: Gothenburg, Sweden},
1065         keywords = {domain-specific languages, deep and shallow embedding, folds},
1066         pages = {339--347},
1067         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},
1068 }
1069
1070 @inproceedings{oliveira_typecase_2005,
1071         address = {New York, NY, USA},
1072         series = {Haskell '05},
1073         title = {{TypeCase}: {A} {Design} {Pattern} for {Type}-{Indexed} {Functions}},
1074         isbn = {1-59593-071-X},
1075         doi = {10.1145/1088348.1088358},
1076         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.},
1077         booktitle = {Proceedings of the 2005 {ACM} {SIGPLAN} {Workshop} on {Haskell}},
1078         publisher = {Association for Computing Machinery},
1079         author = {Oliveira, Bruno C. d. S. and Gibbons, Jeremy},
1080         year = {2005},
1081         note = {event-place: Tallinn, Estonia},
1082         keywords = {generic programming, type classes, type-indexed functions},
1083         pages = {98--109},
1084         file = {Oliveira and Gibbons - 2005 - TypeCase A Design Pattern for Type-Indexed Functi.pdf:/home/mrl/.local/share/zotero/storage/RBKEZKHN/Oliveira and Gibbons - 2005 - TypeCase A Design Pattern for Type-Indexed Functi.pdf:application/pdf},
1085 }
1086
1087 @inproceedings{odersky_putting_1996,
1088         address = {New York, NY, USA},
1089         series = {{POPL} '96},
1090         title = {Putting {Type} {Annotations} to {Work}},
1091         isbn = {0-89791-769-3},
1092         doi = {10.1145/237721.237729},
1093         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.},
1094         booktitle = {Proceedings of the 23rd {ACM} {SIGPLAN}-{SIGACT} {Symposium} on {Principles} of {Programming} {Languages}},
1095         publisher = {Association for Computing Machinery},
1096         author = {Odersky, Martin and Läufer, Konstantin},
1097         year = {1996},
1098         note = {event-place: St. Petersburg Beach, Florida, USA},
1099         pages = {54--67},
1100         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},
1101 }
1102
1103 @inproceedings{najd_everything_2016,
1104         address = {New York, NY, USA},
1105         series = {{PEPM} '16},
1106         title = {Everything {Old} is {New} {Again}: {Quoted} {Domain}-{Specific} {Languages}},
1107         isbn = {978-1-4503-4097-7},
1108         doi = {10.1145/2847538.2847541},
1109         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.},
1110         booktitle = {Proceedings of the 2016 {ACM} {SIGPLAN} {Workshop} on {Partial} {Evaluation} and {Program} {Manipulation}},
1111         publisher = {Association for Computing Machinery},
1112         author = {Najd, Shayan and Lindley, Sam and Svenningsson, Josef and Wadler, Philip},
1113         year = {2016},
1114         note = {event-place: St. Petersburg, FL, USA},
1115         keywords = {EDSL, domain-specific language, DSL, embedded language, normalisation, QDSL, quotation, subformula principle},
1116         pages = {25--36},
1117         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},
1118 }
1119
1120 @article{carette_finally_2009,
1121         title = {Finally tagless, partially evaluated: {Tagless} staged interpreters for simpler typed languages},
1122         volume = {19},
1123         doi = {10.1017/S0956796809007205},
1124         number = {5},
1125         journal = {Journal of Functional Programming},
1126         author = {Carette, Jacques and Kiselyov, Oleg and Shan, Chung-Chieh},
1127         year = {2009},
1128         note = {Publisher: Cambridge University Press},
1129         pages = {509--543},
1130         file = {CARETTE et al. - 2009 - Finally tagless, partially evaluated Tagless stag.pdf:/home/mrl/.local/share/zotero/storage/T8C8VMHP/CARETTE et al. - 2009 - Finally tagless, partially evaluated Tagless stag.pdf:application/pdf},
1131 }
1132
1133 @inproceedings{leijen_domain_2000,
1134         address = {New York, NY, USA},
1135         series = {{DSL} '99},
1136         title = {Domain {Specific} {Embedded} {Compilers}},
1137         isbn = {1-58113-255-7},
1138         doi = {10.1145/331960.331977},
1139         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.},
1140         booktitle = {Proceedings of the 2nd {Conference} on {Domain}-{Specific} {Languages}},
1141         publisher = {Association for Computing Machinery},
1142         author = {Leijen, Daan and Meijer, Erik},
1143         year = {2000},
1144         note = {event-place: Austin, Texas, USA},
1145         pages = {109--122},
1146         file = {Leijen and Meijer - 2000 - Domain Specific Embedded Compilers.pdf:/home/mrl/.local/share/zotero/storage/YHPF2VZ6/Leijen and Meijer - 2000 - Domain Specific Embedded Compilers.pdf:application/pdf},
1147 }
1148
1149 @techreport{plasmeijer_clean_2021,
1150         address = {Nijmegen},
1151         title = {Clean {Language} {Report} version 3.1},
1152         urldate = {2021-12-22},
1153         institution = {Institute for Computing and Information Sciences},
1154         author = {Plasmeijer, Rinus and van Eekelen, Marko and van Groningen, John},
1155         month = dec,
1156         year = {2021},
1157         pages = {127},
1158         file = {CleanLanguageReport.pdf:/home/mrl/.local/share/zotero/storage/I2SDRIH6/CleanLanguageReport.pdf:application/pdf},
1159 }
1160
1161 @inproceedings{nocker_concurrent_1991,
1162         address = {Berlin, Heidelberg},
1163         title = {Concurrent clean},
1164         isbn = {978-3-540-47472-2},
1165         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.},
1166         booktitle = {{PARLE} '91 {Parallel} {Architectures} and {Languages} {Europe}},
1167         publisher = {Springer Berlin Heidelberg},
1168         author = {Nöcker, E. G. J. M. H. and Smetsers, J. E. W. and van Eekelen, M. C. J. D. and Plasmeijer, M. J.},
1169         editor = {Aarts, Emile H. L. and van Leeuwen, Jan and Rem, Martin},
1170         year = {1991},
1171         pages = {202--219},
1172         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},
1173 }
1174
1175 @incollection{mernik_extensible_2013,
1176         address = {Hershey, PA, USA},
1177         title = {Extensible {Languages}: {Blurring} the {Distinction} between {DSL} and {GPL}},
1178         isbn = {978-1-4666-2092-6},
1179         abstract = {Out of a concern for focus and concision, domain-specific languages (DSLs) are usually very different from general purpose programming languages (GPLs), both at the syntactic and the semantic levels. One approach to DSL implementation is to write a full language infrastructure, including parser, interpreter, or even compiler. Another approach however, is to ground the DSL into an extensible GPL, giving you control over its own syntax and semantics. The DSL may then be designed merely as an extension to the original GPL, and its implementation may boil down to expressing only the differences with it. The task of DSL implementation is hence considerably eased. The purpose of this chapter is to provide a tour of the features that make a GPL extensible, and to demonstrate how, in this context, the distinction between DSL and GPL can blur, sometimes to the point of complete disappearance.},
1180         booktitle = {Formal and {Practical} {Aspects} of {Domain}-{Specific} {Languages}: {Recent} {Developments}},
1181         publisher = {IGI Global},
1182         author = {Verna, Didier},
1183         editor = {Mernik, Marjan},
1184         year = {2013},
1185         doi = {10.4018/978-1-4666-2092-6.ch001},
1186         pages = {1--31},
1187 }
1188
1189 @inproceedings{hudak_modular_1998,
1190         title = {Modular domain specific languages and tools},
1191         doi = {10.1109/ICSR.1998.685738},
1192         booktitle = {Proceedings. {Fifth} {International} {Conference} on {Software} {Reuse} ({Cat}. {No}.{98TB100203})},
1193         author = {Hudak, P.},
1194         year = {1998},
1195         pages = {134--142},
1196         file = {Hudak - 1998 - Modular domain specific languages and tools.pdf:/home/mrl/.local/share/zotero/storage/JX7KZ2ST/Hudak - 1998 - Modular domain specific languages and tools.pdf:application/pdf},
1197 }
1198
1199 @book{fowler_domain_2010,
1200         edition = {1st},
1201         title = {Domain {Specific} {Languages}},
1202         isbn = {0-321-71294-3},
1203         abstract = {Designed as a wide-ranging guide to Domain Specific Languages (DSLs) and how to approach building them, this book covers a variety of different techniques available for DSLs. The goal is to provide readers with enough information to make an informed choice about whether or not to use a DSL and what kinds of DSL techniques to employ. Part I is a 150-page narrative overview that gives you a broad understanding of general principles. The reference material in Parts II through VI provides the details and examples you willneed to get started using the various techniques discussed. Both internal and external DSL topics are covered, in addition to alternative computational models and code generation. Although the general principles and patterns presented can be used with whatever programming language you happen to be using, most of the examples are in Java or C\#.},
1204         publisher = {Addison-Wesley Professional},
1205         author = {Fowler, Martin},
1206         year = {2010},
1207         file = {Fowler - 2010 - Domain-specific languages.pdf:/home/mrl/.local/share/zotero/storage/YYMYXTZ5/Fowler - 2010 - Domain-specific languages.pdf:application/pdf},
1208 }
1209
1210 @misc{peter_t_lewis_speech_1985,
1211         address = {Washington, D.C.},
1212         type = {Speech},
1213         title = {Speech},
1214         url = {http://www.chetansharma.com/correcting-the-iot-history/},
1215         author = {{Peter T. Lewis}},
1216         month = sep,
1217         year = {1985},
1218 }
1219
1220 @article{weiser_computer_1991,
1221         title = {The {Computer} for the 21 st {Century}},
1222         volume = {265},
1223         language = {en},
1224         number = {3},
1225         journal = {Scientific American},
1226         author = {Weiser, Mark},
1227         month = sep,
1228         year = {1991},
1229         pages = {94--105},
1230         file = {Weiser - 1991 - The Computer for the 21 st Century.pdf:/home/mrl/.local/share/zotero/storage/N5456M2M/Weiser - 1991 - The Computer for the 21 st Century.pdf:application/pdf},
1231 }
1232
1233 @misc{evans_internet_2011,
1234         title = {The {Internet} of {Things}: {How} the {Next} {Evolution} of the {Internet} {Is} {Changing} {Everything}},
1235         url = {https://www.cisco.com/c/dam/en_us/about/ac79/docs/innov/IoT_IBSG_0411FINAL.pdf},
1236         language = {en},
1237         publisher = {Cisco Internet Business Solutions Group (IBSG)},
1238         author = {Evans, Dave},
1239         month = apr,
1240         year = {2011},
1241         file = {Evans - 2011 - How the Next Evolution of the Internet Is Changing.pdf:/home/mrl/.local/share/zotero/storage/32YXCM6P/Evans - 2011 - How the Next Evolution of the Internet Is Changing.pdf:application/pdf},
1242 }
1243
1244 @inproceedings{ireland_classification_2009,
1245         address = {Cancun, Mexico},
1246         title = {A {Classification} of {Object}-{Relational} {Impedance} {Mismatch}},
1247         isbn = {978-0-7695-3550-0},
1248         doi = {10.1109/DBKDA.2009.11},
1249         booktitle = {First {International} {Conference} on {Advances} in {Databases}, {Knowledge}, and {Data} {Applications}},
1250         publisher = {IEEE},
1251         author = {Ireland, Christopher and Bowers, David and Newton, Michael and Waugh, Kevin},
1252         year = {2009},
1253         pages = {36--43},
1254 }
1255
1256 @inproceedings{steenvoorden_tophat_2019,
1257         address = {New York, NY, USA},
1258         series = {{PPDP} '19},
1259         title = {{TopHat}: {A} {Formal} {Foundation} for {Task}-{Oriented} {Programming}},
1260         isbn = {978-1-4503-7249-7},
1261         doi = {10.1145/3354166.3354182},
1262         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.},
1263         booktitle = {Proceedings of the 21st {International} {Symposium} on {Principles} and {Practice} of {Declarative} {Programming}},
1264         publisher = {Association for Computing Machinery},
1265         author = {Steenvoorden, Tim and Naus, Nico and Klinik, Markus},
1266         year = {2019},
1267         note = {event-place: Porto, Portugal},
1268         file = {Steenvoorden et al. - 2019 - TopHat A Formal Foundation for Task-Oriented Prog.pdf:/home/mrl/.local/share/zotero/storage/E9W4WKZC/Steenvoorden et al. - 2019 - TopHat A Formal Foundation for Task-Oriented Prog.pdf:application/pdf},
1269 }
1270
1271 @incollection{koopman_type-safe_2019,
1272         address = {Cham},
1273         title = {Type-{Safe} {Functions} and {Tasks} in a {Shallow} {Embedded} {DSL} for {Microprocessors}},
1274         isbn = {978-3-030-28346-9},
1275         abstract = {The Internet of Things, IoT, brings us large amounts of connected computing devices that are equipped with dedicated sensors and actuators. These computing devices are typically driven by a cheap microprocessor system with a relatively slow processor and a very limited amount of memory. Due to the special input-output capabilities of IoT devices and their connections it is very attractive to execute (parts of) programs on these microcomputers.},
1276         booktitle = {Central {European} {Functional} {Programming} {School}: 6th {Summer} {School}, {CEFP} 2015, {Budapest}, {Hungary}, {July} 6–10, 2015, {Revised} {Selected} {Papers}},
1277         publisher = {Springer International Publishing},
1278         author = {Koopman, Pieter and Plasmeijer, Rinus},
1279         editor = {Zsók, Viktória and Porkoláb, Zoltán and Horváth, Zoltán},
1280         year = {2019},
1281         doi = {10.1007/978-3-030-28346-9_8},
1282         pages = {283--340},
1283         file = {Koopman and Plasmeijer - 2019 - Type-Safe Functions and Tasks in a Shallow Embedde.pdf:/home/mrl/.local/share/zotero/storage/UY2DY4EJ/Koopman and Plasmeijer - 2019 - Type-Safe Functions and Tasks in a Shallow Embedde.pdf:application/pdf},
1284 }
1285
1286 @techreport{cheney_first-class_2003,
1287         title = {First-class phantom types},
1288         url = {https://ecommons.cornell.edu/handle/1813/5614},
1289         number = {TR2003-1901},
1290         urldate = {2017-05-15},
1291         institution = {Cornell University},
1292         author = {Cheney, James and Hinze, Ralf},
1293         year = {2003},
1294         file = {Cheney and Hinze - 2003 - First-class phantom types.pdf:/home/mrl/.local/share/zotero/storage/IBKGCFG2/Cheney and Hinze - 2003 - First-class phantom types.pdf:application/pdf},
1295 }
1296
1297 @inproceedings{baars_typing_2002,
1298         address = {New York, NY, USA},
1299         series = {{ICFP} '02},
1300         title = {Typing {Dynamic} {Typing}},
1301         isbn = {1-58113-487-8},
1302         doi = {10.1145/581478.581494},
1303         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.},
1304         booktitle = {Proceedings of the {Seventh} {ACM} {SIGPLAN} {International} {Conference} on {Functional} {Programming}},
1305         publisher = {Association for Computing Machinery},
1306         author = {Baars, Arthur I. and Swierstra, S. Doaitse},
1307         year = {2002},
1308         note = {event-place: Pittsburgh, PA, USA},
1309         keywords = {coercions, dynamic typing, Haskell, Leibnitz' rule, quantified types, static typing, type equality, typed interpreters},
1310         pages = {157--166},
1311         file = {Baars and Swierstra - 2002 - Typing dynamic typing.pdf:/home/mrl/.local/share/zotero/storage/QSGVSTM4/Baars and Swierstra - 2002 - Typing dynamic typing.pdf:application/pdf},
1312 }
1313
1314 @inproceedings{young_adding_2021,
1315         address = {Berlin, Heidelberg},
1316         title = {On {Adding} {Pattern} {Matching} to {Haskell}-{Based} {Deeply} {Embedded} {Domain} {Specific} {Languages}},
1317         isbn = {978-3-030-67437-3},
1318         doi = {10.1007/978-3-030-67438-0_2},
1319         abstract = {Capturing control flow is the Achilles heel of Haskell-based deeply embedded domain specific languages. Rather than use the builtin control flow mechanisms, artificial control flow combinators are used instead. However, capturing traditional control flow in a deeply embedded domain specific language would support the writing of programs in a natural style by allowing the programmer to use the constructs that are already builtin to the base language, such as pattern matching and recursion. In this paper, we expand the capabilities of Haskell-based deep embeddings with a compiler extension for reifying conditionals and pattern matching. With this new support, the subset of Haskell that we use for expressing deeply embedded domain specific languages can be cleaner, Haskell-idiomatic, and more declarative in nature.},
1320         booktitle = {Practical {Aspects} of {Declarative} {Languages}: 23rd {International} {Symposium}, {PADL} 2021, {Copenhagen}, {Denmark}, {January} 18-19, 2021, {Proceedings}},
1321         publisher = {Springer-Verlag},
1322         author = {Young, David and Grebe, Mark and Gill, Andy},
1323         year = {2021},
1324         note = {event-place: Copenhagen, Denmark},
1325         pages = {20--36},
1326 }
1327
1328 @incollection{hinze_generic_2003,
1329         address = {Berlin, Heidelberg},
1330         title = {Generic {Haskell}: {Practice} and {Theory}},
1331         isbn = {978-3-540-45191-4},
1332         abstract = {Generic Haskell is an extension of Haskell that supports the construction of generic programs. These lecture notes describe the basic constructs of Generic Haskell and highlight the underlying theory.},
1333         booktitle = {Generic {Programming}: {Advanced} {Lectures}},
1334         publisher = {Springer Berlin Heidelberg},
1335         author = {Hinze, Ralf and Jeuring, Johan},
1336         editor = {Backhouse, Roland and Gibbons, Jeremy},
1337         year = {2003},
1338         doi = {10.1007/978-3-540-45191-4_1},
1339         pages = {1--56},
1340         file = {Hinze and Jeuring - Generic Haskell practice and theory.pdf:/home/mrl/.local/share/zotero/storage/QDRNI5VB/Hinze and Jeuring - Generic Haskell practice and theory.pdf:application/pdf},
1341 }
1342
1343 @inproceedings{torrano_strictness_2005,
1344         address = {Bristol, UK},
1345         series = {Trends in {Functional} {Programming}},
1346         title = {Strictness {Analysis} and let-to-case {Transformation} using {Template} {Haskell}},
1347         volume = {6},
1348         isbn = {978-1-84150-176-5},
1349         booktitle = {Revised {Selected} {Papers} from the {Sixth} {Symposium} on {Trends} in {Functional} {Programming}, {TFP} 2005, {Tallinn}, {Estonia}, 23-24 {September} 2005},
1350         publisher = {Intellect},
1351         author = {Torrano, Carmen and Segura, Clara},
1352         editor = {Eekelen, Marko C. J. D. van},
1353         year = {2005},
1354         note = {event-place: Talinn, Estonia},
1355         pages = {429--442},
1356         file = {Torrano and Segura - Strictness Analysis and let-to-case Transformation.pdf:/home/mrl/.local/share/zotero/storage/RIYW9WFT/Torrano and Segura - Strictness Analysis and let-to-case Transformation.pdf:application/pdf},
1357 }
1358
1359 @inproceedings{polak_automatic_2006,
1360         address = {Bristol, UK},
1361         series = {Trends in {Functional} {Programming}},
1362         title = {Automatic {Graphical} {User} {Interface} {Form} {Generation} {Using} {Template} {Haskell}},
1363         volume = {7},
1364         isbn = {978-1-84150-188-8},
1365         booktitle = {Revised {Selected} {Papers} from the {Seventh} {Symposium} on {Trends} in {Functional} {Programming}, {TFP} 2006, {Nottingham}, {United} {Kingdom}, 19-21 {April} 2006},
1366         publisher = {Intellect},
1367         author = {Polak, Gracjan and Jarosz, Janusz},
1368         editor = {Nilsson, Henrik},
1369         year = {2006},
1370         note = {event-place: Nottingham, UK},
1371         pages = {1--11},
1372         file = {Polak and Jarosz - Automatic Graphical User Interface Form Generation.pdf:/home/mrl/.local/share/zotero/storage/8VK3D8JQ/Polak and Jarosz - Automatic Graphical User Interface Form Generation.pdf:application/pdf},
1373 }
1374
1375 @phdthesis{antonova_mtask_2022,
1376         address = {Nijmegen},
1377         type = {Bachelor's {Thesis}},
1378         title = {{mTask} {Semantics} and its {Comparison} to {TopHat}},
1379         language = {en},
1380         school = {Radboud University},
1381         author = {Antonova, Elina},
1382         year = {2022},
1383         file = {Crooijmans - 2021 - Reducing the Power Consumption of IoT Devices in T.pdf:/home/mrl/.local/share/zotero/storage/YIEQ97KK/Crooijmans - 2021 - Reducing the Power Consumption of IoT Devices in T.pdf:application/pdf},
1384 }
1385
1386 @misc{wadler_expression_1998,
1387         title = {The expression problem},
1388         url = {https://homepages.inf.ed.ac.uk/wadler/papers/expression/expression.txt},
1389         language = {en},
1390         urldate = {2021-02-24},
1391         author = {Wadler, Philip},
1392         month = nov,
1393         year = {1998},
1394         note = {e-mail message, accessed on 2021-02-24},
1395 }
1396
1397 @misc{margaret_deuter_rhapsody_2015,
1398         address = {Oxford},
1399         edition = {Ninth edition},
1400         title = {Rhapsody},
1401         journal = {Oxford Advanced Learner's Dictionary of Current English},
1402         publisher = {Oxford University Press},
1403         author = {{A S Hornby}},
1404         editor = {{Margaret Deuter} and {Jennifer Bradbery} and {Joanna Turnbull}},
1405         year = {2015},
1406 }
1407
1408 @misc{wikipedia_contributors_rhapsody_2022,
1409         title = {Rhapsody (music) — {Wikipedia}, {The} {Free} {Encyclopedia}},
1410         url = {https://en.wikipedia.org/w/index.php?title=Rhapsody_(music)\&oldid=1068385257},
1411         urldate = {2022-09-06},
1412         journal = {Wikipedia},
1413         author = {{Wikipedia contributors}},
1414         year = {2022},
1415         note = {accessed on: 2022-09-06},
1416 }
1417
1418 @incollection{backus_introduction_1990,
1419         address = {USA},
1420         title = {An {Introduction} to the {Programming} {Language} {FL}},
1421         isbn = {0-201-17236-4},
1422         booktitle = {Research {Topics} in {Functional} {Programming}},
1423         publisher = {Addison-Wesley Longman Publishing Co., Inc.},
1424         author = {Backus, John and Williams, John H. and Wimmers, Edward L.},
1425         year = {1990},
1426         pages = {219--247},
1427 }
1428
1429 @article{achten_ins_1995,
1430         title = {The ins and outs of {Clean} {I}/{O}},
1431         volume = {5},
1432         doi = {10.1017/S0956796800001258},
1433         number = {1},
1434         journal = {Journal of Functional Programming},
1435         author = {Achten, Peter and Plasmeijer, Rinus},
1436         year = {1995},
1437         note = {Publisher: Cambridge University Press},
1438         pages = {81--110},
1439 }
1440
1441 @inproceedings{peyton_jones_imperative_1993,
1442         address = {New York, NY, USA},
1443         series = {{POPL} '93},
1444         title = {Imperative {Functional} {Programming}},
1445         isbn = {0-89791-560-7},
1446         doi = {10.1145/158511.158524},
1447         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.},
1448         booktitle = {Proceedings of the 20th {ACM} {SIGPLAN}-{SIGACT} {Symposium} on {Principles} of {Programming} {Languages}},
1449         publisher = {Association for Computing Machinery},
1450         author = {Peyton Jones, Simon L. and Wadler, Philip},
1451         year = {1993},
1452         note = {event-place: Charleston, South Carolina, USA},
1453         pages = {71--84},
1454         file = {Peyton Jones and Wadler - 1993 - Imperative Functional Programming.pdf:/home/mrl/.local/share/zotero/storage/9DQ5V3N3/Peyton Jones and Wadler - 1993 - Imperative Functional Programming.pdf:application/pdf},
1455 }
1456
1457 @inproceedings{achten_high_1993,
1458         address = {London},
1459         title = {High {Level} {Specification} of {I}/{O} in {Functional} {Languages}},
1460         isbn = {978-1-4471-3215-8},
1461         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.},
1462         booktitle = {Functional {Programming}, {Glasgow} 1992},
1463         publisher = {Springer London},
1464         author = {Achten, Peter and van Groningen, John and Plasmeijer, Rinus},
1465         editor = {Launchbury, John and Sansom, Patrick},
1466         year = {1993},
1467         pages = {1--17},
1468         file = {Achten et al. - 1993 - High Level Specification of IO in Functional Lang.pdf:/home/mrl/.local/share/zotero/storage/4QVH7AYC/Achten et al. - 1993 - High Level Specification of IO in Functional Lang.pdf:application/pdf},
1469 }
1470
1471 @inproceedings{pickering_staged_2020,
1472         address = {New York, NY, USA},
1473         series = {Haskell 2020},
1474         title = {Staged {Sums} of {Products}},
1475         isbn = {978-1-4503-8050-8},
1476         doi = {10.1145/3406088.3409021},
1477         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.},
1478         booktitle = {Proceedings of the 13th {ACM} {SIGPLAN} {International} {Symposium} on {Haskell}},
1479         publisher = {Association for Computing Machinery},
1480         author = {Pickering, Matthew and Löh, Andres and Wu, Nicolas},
1481         year = {2020},
1482         note = {event-place: Virtual Event, USA},
1483         keywords = {generic programming, staging},
1484         pages = {122--135},
1485         file = {Pickering et al. - 2020 - Staged Sums of Products.pdf:/home/mrl/.local/share/zotero/storage/Q6ZWX4YP/Pickering et al. - 2020 - Staged Sums of Products.pdf:application/pdf},
1486 }
1487
1488 @article{xie_staging_2022,
1489         title = {Staging with {Class}: {A} {Specification} for {Typed} {Template} {Haskell}},
1490         volume = {6},
1491         doi = {10.1145/3498723},
1492         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 λ⇒ 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.},
1493         number = {POPL},
1494         journal = {Proc. ACM Program. Lang.},
1495         author = {Xie, Ningning and Pickering, Matthew and Löh, Andres and Wu, Nicolas and Yallop, Jeremy and Wang, Meng},
1496         month = jan,
1497         year = {2022},
1498         note = {Place: New York, NY, USA
1499 Publisher: Association for Computing Machinery},
1500         keywords = {Staging, Type Classes, Typed Template Haskell},
1501         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},
1502 }
1503
1504 @article{rhiger_type-safe_2009,
1505         title = {Type-safe pattern combinators},
1506         volume = {19},
1507         doi = {10.1017/S0956796808007089},
1508         number = {2},
1509         journal = {Journal of Functional Programming},
1510         author = {Rhiger, Morten},
1511         year = {2009},
1512         note = {Publisher: Cambridge University Press},
1513         pages = {145--156},
1514         file = {RHIGER - 2009 - Type-safe pattern combinators.pdf:/home/mrl/.local/share/zotero/storage/D4N7PGBS/RHIGER - 2009 - Type-safe pattern combinators.pdf:application/pdf},
1515 }
1516
1517 @inproceedings{de_vries_true_2014,
1518         address = {New York, NY, USA},
1519         series = {{WGP} '14},
1520         title = {True {Sums} of {Products}},
1521         isbn = {978-1-4503-3042-8},
1522         doi = {10.1145/2633628.2633634},
1523         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.},
1524         booktitle = {Proceedings of the 10th {ACM} {SIGPLAN} {Workshop} on {Generic} {Programming}},
1525         publisher = {Association for Computing Machinery},
1526         author = {de Vries, Edsko and Löh, Andres},
1527         year = {2014},
1528         note = {event-place: Gothenburg, Sweden},
1529         keywords = {lenses, datatype-generic programming, generic views, json, metadata, sums of products, universes},
1530         pages = {83--94},
1531         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},
1532 }
1533
1534 @article{willis_staged_2020,
1535         title = {Staged {Selective} {Parser} {Combinators}},
1536         volume = {4},
1537         doi = {10.1145/3409002},
1538         abstract = {Parser combinators are a middle ground between the fine control of hand-rolled parsers and the high-level almost grammar-like appearance of parsers created via parser generators. They also promote a cleaner, compositional design for parsers. Historically, however, they cannot match the performance of their counterparts. This paper describes how to compile parser combinators into parsers of hand-written quality. This is done by leveraging the static information present in the grammar by representing it as a tree. However, in order to exploit this information, it will be necessary to drop support for monadic computation since this generates dynamic structure. Selective functors can help recover lost functionality in the absence of monads, and the parser tree can be partially evaluated with staging. This is implemented in a library called Parsley.},
1539         number = {ICFP},
1540         journal = {Proc. ACM Program. Lang.},
1541         author = {Willis, Jamie and Wu, Nicolas and Pickering, Matthew},
1542         month = aug,
1543         year = {2020},
1544         note = {Place: New York, NY, USA
1545 Publisher: Association for Computing Machinery},
1546         keywords = {combinators, meta-programming, parsers},
1547         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},
1548 }
1549
1550 @inproceedings{pickering_multi-stage_2019,
1551         address = {New York, NY, USA},
1552         series = {Haskell 2019},
1553         title = {Multi-{Stage} {Programs} in {Context}},
1554         isbn = {978-1-4503-6813-1},
1555         doi = {10.1145/3331545.3342597},
1556         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.},
1557         booktitle = {Proceedings of the 12th {ACM} {SIGPLAN} {International} {Symposium} on {Haskell}},
1558         publisher = {Association for Computing Machinery},
1559         author = {Pickering, Matthew and Wu, Nicolas and Kiss, Csongor},
1560         year = {2019},
1561         note = {event-place: Berlin, Germany},
1562         keywords = {metaprogramming, staging, implicits},
1563         pages = {71--84},
1564         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},
1565 }
1566
1567 @article{pickering_specification_2021,
1568         title = {A {Specification} for {Typed} {Template} {Haskell}},
1569         volume = {abs/2112.03653},
1570         doi = {10.48550/arXiv.2112.03653},
1571         journal = {CoRR},
1572         author = {Pickering, Matthew and Löh, Andres and Wu, Nicolas},
1573         year = {2021},
1574         note = {arXiv: 2112.03653},
1575         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},
1576 }
1577
1578 @book{steenvoorden_tophat_2022,
1579         address = {Nijmegen},
1580         title = {{TopHat}: {Task}-{Oriented} {Programming} with {Style}},
1581         isbn = {978-94-6458-595-7},
1582         shorttitle = {{TopHat}: {TOP} with {Style}},
1583         language = {English},
1584         publisher = {UB Nijmegen},
1585         author = {Steenvoorden, Tim},
1586         year = {2022},
1587         file = {Steenvoorden - 2022 - TopHat Task-Oriented Programming with Style.pdf:/home/mrl/.local/share/zotero/storage/ZV8IT9J5/Steenvoorden - 2022 - TopHat Task-Oriented Programming with Style.pdf:application/pdf},
1588 }
1589
1590 @inproceedings{folmer_high-level_2022,
1591         address = {Cham},
1592         title = {High-{Level} {Synthesis} of {Digital} {Circuits} from {Template} {Haskell} and {SDF}-{AP}},
1593         isbn = {978-3-031-15074-6},
1594         abstract = {Functional languages as input specifications for HLS-tools allow to specify data dependencies but do not contain a notion of time nor execution order. In this paper, we propose a method to add this notion to the functional description using the dataflow model SDF-AP. SDF-AP consists of patterns that express consumption and production that we can use to enforce resource usage. We created an HLS-tool that can synthesize parallel hardware, both data and control path, based on the repetition, expressed in Higher-Order Functions, combined with specified SDF-AP patterns.},
1595         booktitle = {Embedded {Computer} {Systems}: {Architectures}, {Modeling}, and {Simulation}},
1596         publisher = {Springer International Publishing},
1597         author = {Folmer, H. H. and Groote, R. de and Bekooij, M. J. G.},
1598         editor = {Orailoglu, Alex and Reichenbach, Marc and Jung, Matthias},
1599         year = {2022},
1600         pages = {3--27},
1601         file = {Folmer et al. - 2022 - High-Level Synthesis of Digital Circuits from Temp.pdf:/home/mrl/.local/share/zotero/storage/5JSW6MAL/Folmer et al. - 2022 - High-Level Synthesis of Digital Circuits from Temp.pdf:application/pdf},
1602 }
1603
1604 @article{materzok_generating_2022,
1605         title = {Generating {Circuits} with {Generators}},
1606         volume = {6},
1607         doi = {10.1145/3549821},
1608         abstract = {The most widely used languages and methods used for designing digital hardware fall into two rough categories. One of them, register transfer level (RTL), requires specifying each and every component in the designed circuit. This gives the designer full control, but burdens the designer with many trivial details. The other, the high-level synthesis (HLS) method, allows the designer to abstract the details of hardware away and focus on the problem being solved. This method however cannot be used for a class of hardware design problems because the circuit's clock is also abstracted away. We present YieldFSM, a hardware description language that uses the generator abstraction to represent clock-level timing in a digital circuit. It represents a middle ground between the RTL and HLS approaches: the abstraction level is higher than in RTL, but thanks to explicit information about clock-level timing, it can be used in applications where RTL is traditionally used. We also present the YieldFSM compiler, which uses methods developed by the functional programming community – including continuation-passsing style translation and defunctionalization – to translate YieldFSM programs to Mealy machines. It is implemented using Template Haskell and the Clash functional hardware description language. We show that this approach leads to short and conceptually simple hardware descriptions.},
1609         number = {ICFP},
1610         journal = {Proc. ACM Program. Lang.},
1611         author = {Materzok, Marek},
1612         month = aug,
1613         year = {2022},
1614         note = {Place: New York, NY, USA
1615 Publisher: Association for Computing Machinery},
1616         keywords = {circuit synthesis, generators, hardware description languages},
1617         file = {Materzok - 2022 - Generating Circuits with Generators.pdf:/home/mrl/.local/share/zotero/storage/LH4Q8J73/Materzok - 2022 - Generating Circuits with Generators.pdf:application/pdf},
1618 }
1619
1620 @article{egi_embedding_2022,
1621         title = {Embedding {Non}-linear {Pattern} {Matching} with {Backtracking} for {Non}-free {Data} {Types} into {Haskell}},
1622         volume = {40},
1623         issn = {1882-7055},
1624         doi = {10.1007/s00354-022-00177-z},
1625         abstract = {Pattern matching is an important language construct for data abstraction. Many pattern-match extensions have been developed for extending the range of data types to which pattern matching is applicable. Among them, the pattern-match system proposed by Egi and Nishiwaki features practical pattern matching for non-free data types by providing a user-customizable non-linear pattern-match facility with backtracking. However, they implemented their proposal only in dynamically typed programming languages, and there were no proposals that allow programmers to benefit from both static type systems and expressive pattern matching. This paper proposes a method for implementing this pattern-match facility by meta-programming in Haskell. There are two technical challenges: (i) we need to design a set of typing rules for the pattern-match facility; (ii) we need to embed these typing rules in Haskell to make types of the pattern-match expressions inferable by the Haskell type system. We propose a set of typing rules and show that several GHC extensions, such as multi-parameter type classes, datatype promotion, GADTs, existential types, and view patterns, play essential roles for embedding these typing rules into Haskell. The implementation has already been distributed as a Haskell library miniEgison via Hackage.},
1626         number = {2},
1627         journal = {New Generation Computing},
1628         author = {Egi, Satoshi and Kawata, Akira and Kori, Mayuko and Ogawa, Hiromi},
1629         month = jul,
1630         year = {2022},
1631         pages = {481--506},
1632         file = {Egi et al. - 2022 - Embedding Non-linear Pattern Matching with Backtra.pdf:/home/mrl/.local/share/zotero/storage/PXT9L9Z4/Egi et al. - 2022 - Embedding Non-linear Pattern Matching with Backtra.pdf:application/pdf},
1633 }
1634
1635 @inproceedings{blanchette_liquid_2022,
1636         address = {New York, NY, USA},
1637         series = {Haskell 2022},
1638         title = {Liquid {Proof} {Macros}},
1639         isbn = {978-1-4503-9438-3},
1640         doi = {10.1145/3546189.3549921},
1641         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.},
1642         booktitle = {Proceedings of the 15th {ACM} {SIGPLAN} {International} {Haskell} {Symposium}},
1643         publisher = {Association for Computing Machinery},
1644         author = {Blanchette, Henry and Vazou, Niki and Lampropoulos, Leonidas},
1645         year = {2022},
1646         note = {event-place: Ljubljana, Slovenia},
1647         keywords = {Liquid Haskell, Proof Macros, Tactics},
1648         pages = {27--38},
1649         file = {Blanchette et al. - 2022 - Liquid Proof Macros.pdf:/home/mrl/.local/share/zotero/storage/YXPCWQNI/Blanchette et al. - 2022 - Liquid Proof Macros.pdf:application/pdf},
1650 }
1651
1652 @phdthesis{baaij_digital_2015,
1653         address = {Netherlands},
1654         type = {{PhD} {Thesis}},
1655         title = {Digital circuit in {C}\${\textbackslash}lambda\${aSH}: functional specifications and type-directed synthesis},
1656         abstract = {Over the last three decades, the number of transistors used in microchips has increased by three orders of magnitude, from millions to billions. The productivity of the designers, however, lags behind. Managing to implement complex algorithms, while keeping non-functional properties within desired bounds, and thoroughly verifying the design against its specification, are the main difficulties in circuit design. As a motivation for our work we make a qualitative analysis of the tools available to circuit designers. Here we see that progress has been slow, and that the same techniques have been used for over 20 years. We claim that functional languages can be used to raise the abstraction level in circuit design. Especially higher-order functional languages, where functions are first-class and can be manipulated by other functions, offer a single abstraction mechanism that can capture many design patterns. This thesis explores the idea of using the functional language Haskell directly as a hardware specification language, and move beyond the limitations of embedded languages. Additionally, we can use normal functions from existing Haskell libraries to model the behaviour of our circuits. This thesis describes the inner workings of our CλaSH compiler, which translates the aforementioned circuit descriptions written in Haskell to low-level descriptions in VHDL. The challenge then becomes the reduction of the higher-level abstractions in the descriptions to a form where synthesis is feasible. This thesis describes a term rewrite system (with bound variables) to achieve this reduction. We prove that this term rewrite system always reduces a polymorphic, higher-order circuit description to a synthesisable variant. Even when descriptions use high-level abstractions, the CλaSH compiler can synthesize efficient circuits. Case studies show that circuits designed in Haskell, and synthesized with the C?aSH compiler, are on par with hand-written VHDL, in both area and gate propagation delay. This thesis thus shows the merits of using a modern functional language for circuit design. The advanced type system and higher-order functions allow us to design circuits that have the desired property of being correct-by-construction. Finally, our synthesis approach enables us to derive efficient circuits from descriptions that use high-level abstractions.},
1657         language = {Undefined},
1658         school = {University of Twente},
1659         author = {Baaij, C. P. R.},
1660         month = jan,
1661         year = {2015},
1662         doi = {10.3990/1.9789036538039},
1663         note = {ISBN: 978-90-365-3803-9},
1664         keywords = {Haskell, Digital Circuits, EC Grant Agreement nr.: FP7/248465, EC Grant Agreement nr.: FP7/610686, EWI-23939, FPGA, Functional Programming, Hardware, IR-93962, Lambda calculus, METIS-308711, Rewrite Systems},
1665         file = {Baaij - 2015 - Digital circuit in CλaSH functional specification.pdf:/home/mrl/.local/share/zotero/storage/MYJ33ISL/Baaij - 2015 - Digital circuit in CλaSH functional specification.pdf:application/pdf},
1666 }
1667
1668 @inproceedings{mcdonell_embedded_2022,
1669         address = {New York, NY, USA},
1670         series = {Haskell 2022},
1671         title = {Embedded {Pattern} {Matching}},
1672         isbn = {978-1-4503-9438-3},
1673         doi = {10.1145/3546189.3549917},
1674         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.},
1675         booktitle = {Proceedings of the 15th {ACM} {SIGPLAN} {International} {Haskell} {Symposium}},
1676         publisher = {Association for Computing Machinery},
1677         author = {McDonell, Trevor L. and Meredith, Joshua D. and Keller, Gabriele},
1678         year = {2022},
1679         note = {event-place: Ljubljana, Slovenia},
1680         keywords = {Haskell, algebraic data types, embedded languages, pattern matching},
1681         pages = {123--136},
1682         file = {2108.13114.pdf:/home/mrl/.local/share/zotero/storage/AJAT8AXI/2108.13114.pdf:application/pdf},
1683 }
1684
1685 @phdthesis{krishnamurthi_linguistic_2001,
1686         address = {Houston, USA},
1687         type = {{PhD} {Thesis}},
1688         title = {Linguistic reuse},
1689         school = {Rice University},
1690         author = {Krishnamurthi, Shriram},
1691         year = {2001},
1692         file = {Krishnamurthi - 2001 - Linguistic reuse.PDF:/home/mrl/.local/share/zotero/storage/LSKHFPIS/Krishnamurthi - 2001 - Linguistic reuse.PDF:application/pdf},
1693 }
1694
1695 @misc{ashton_internet_1999,
1696         address = {London, UK},
1697         type = {Presentation},
1698         title = {Internet of {Things}},
1699         author = {Ashton, Kevin},
1700         year = {1999},
1701         note = {Presentation at Proctor \& Gamble},
1702 }
1703
1704 @article{ashton_that_2009,
1705         title = {That ‘{Internet} of {Things}’ {Thing}},
1706         volume = {22},
1707         number = {7},
1708         journal = {RFID journal},
1709         author = {Ashton, Kevin},
1710         year = {2009},
1711         note = {Publisher: Hauppauge, New York},
1712         pages = {97--114},
1713         file = {Ashton - 2009 - That ‘Internet of Things’ Thing.pdf:/home/mrl/.local/share/zotero/storage/SJ33G6VR/Ashton - 2009 - That ‘Internet of Things’ Thing.pdf:application/pdf},
1714 }
1715
1716 @phdthesis{van_gemert_task_2022,
1717         address = {Nijmegen},
1718         type = {Bachelor's {Thesis}},
1719         title = {Task {Oriented} {Programming} in {LUA}},
1720         language = {en},
1721         school = {Radboud University},
1722         author = {van Gemert, Dante},
1723         year = {2022},
1724         file = {van Gemert - 2022 - Task Oriented Programming in LUA.pdf:/home/mrl/.local/share/zotero/storage/UQHAWT83/van Gemert - 2022 - Task Oriented Programming in LUA.pdf:application/pdf},
1725 }
1726
1727 @misc{lijnse_toppyt_2022,
1728         title = {Toppyt},
1729         url = {https://gitlab.com/baslijnse/toppyt},
1730         urldate = {2022-10-07},
1731         author = {Lijnse, Bas},
1732         year = {2022},
1733 }
1734
1735 @article{sun_compositional_2022,
1736         title = {Compositional {Embeddings} of {Domain}-{Specific} {Languages}},
1737         volume = {6},
1738         doi = {10.1145/3563294},
1739         language = {en},
1740         number = {OOPSLA2},
1741         journal = {Proc. ACM Program. Lang.},
1742         author = {Sun, Yaozhu and Dhandhania, Utkarsh and Oliveira, Bruno C. d. S.},
1743         year = {2022},
1744         pages = {34},
1745         file = {Sun and Dhandhania - Compositional Embeddings of Domain-Specific Langua.pdf:/home/mrl/.local/share/zotero/storage/Y4GADQFP/Sun and Dhandhania - Compositional Embeddings of Domain-Specific Langua.pdf:application/pdf},
1746 }
1747
1748 @misc{lubbers_htask_2022,
1749         title = {{hTask}},
1750         url = {https://gitlab.com/mlubbers/acsds},
1751         urldate = {2022-10-07},
1752         author = {Lubbers, Mart},
1753         year = {2022},
1754 }
1755
1756 @article{nizetic_internet_2020,
1757         title = {Internet of {Things} ({IoT}): {Opportunities}, issues and challenges towards a smart and sustainable future},
1758         volume = {274},
1759         issn = {0959-6526},
1760         doi = {https://doi.org/10.1016/j.jclepro.2020.122877},
1761         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.},
1762         journal = {Journal of Cleaner Production},
1763         author = {Nižetić, Sandro and Šolić, Petar and González-de-Artaza, Diego López-de-Ipiña and Patrono, Luigi},
1764         year = {2020},
1765         keywords = {Energy, Environment, IoT, Smart city, SpliTech2020, Sustainability},
1766         pages = {122877},
1767 }