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         url = {https://doi.org/10.1145/2370776.2370801},
  19         doi = {10.1145/2370776.2370801},
  20         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.},
  21         booktitle = {Proceedings of the 14th {Symposium} on {Principles} and {Practice} of {Declarative} {Programming}},
  22         publisher = {Association for Computing Machinery},
  23         author = {Plasmeijer, Rinus and Lijnse, Bas and Michels, Steffen and Achten, Peter and Koopman, Pieter},
  24         year = {2012},
  25         note = {event-place: Leuven, Belgium},
  26         keywords = {clean, task-oriented programming},
  27         pages = {195--206},
  28         file = {103802.pdf:/home/mrl/.local/share/zotero/storage/ZE6A65AW/103802.pdf:application/pdf},
  29 }
  30
  31 @inproceedings{brus_clean_1987,
  32         address = {Berlin, Heidelberg},
  33         title = {Clean — {A} language for functional graph rewriting},
  34         isbn = {978-3-540-47879-9},
  35         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.},
  36         booktitle = {Functional {Programming} {Languages} and {Computer} {Architecture}},
  37         publisher = {Springer Berlin Heidelberg},
  38         author = {Brus, T. H. and van Eekelen, M. C. J. D. and van Leer, M. O. and Plasmeijer, M. J.},
  39         editor = {Kahn, Gilles},
  40         year = {1987},
  41         pages = {364--384},
  42         file = {brut87-Clean.ps.gz:/home/mrl/.local/share/zotero/storage/T2QATWIE/brut87-Clean.ps.gz:application/gzip},
  43 }
  44
  45 @misc{bolingbroke_constraint_2011,
  46         title = {Constraint {Kinds} for {GHC}},
  47         url = {http://blog.omega-prime.co.uk/2011/09/10/constraint-kinds-for-ghc/},
  48         urldate = {2021-06-09},
  49         journal = {:: (Bloggable a) ={\textgreater} a -{\textgreater} IO ()},
  50         author = {Bolingbroke, Max},
  51         month = sep,
  52         year = {2011},
  53         file = {Constraint Kinds for GHC:/home/mrl/.local/share/zotero/storage/R6RL79K7/constraint-kinds-for-ghc.html:text/html},
  54 }
  55
  56 @inproceedings{fegaras_revisiting_1996,
  57         address = {New York, NY, USA},
  58         series = {{POPL} '96},
  59         title = {Revisiting {Catamorphisms} over {Datatypes} with {Embedded} {Functions} (or, {Programs} from {Outer} {Space})},
  60         isbn = {0-89791-769-3},
  61         url = {https://doi.org/10.1145/237721.237792},
  62         doi = {10.1145/237721.237792},
  63         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.},
  64         booktitle = {Proceedings of the 23rd {ACM} {SIGPLAN}-{SIGACT} {Symposium} on {Principles} of {Programming} {Languages}},
  65         publisher = {Association for Computing Machinery},
  66         author = {Fegaras, Leonidas and Sheard, Tim},
  67         year = {1996},
  68         note = {event-place: St. Petersburg Beach, Florida, USA},
  69         pages = {284--294},
  70         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},
  71 }
  72
  73 @inproceedings{pfenning_higher-order_1988,
  74         address = {New York, NY, USA},
  75         series = {{PLDI} '88},
  76         title = {Higher-{Order} {Abstract} {Syntax}},
  77         isbn = {0-89791-269-1},
  78         url = {https://doi.org/10.1145/53990.54010},
  79         doi = {10.1145/53990.54010},
  80         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.},
  81         booktitle = {Proceedings of the {ACM} {SIGPLAN} 1988 {Conference} on {Programming} {Language} {Design} and {Implementation}},
  82         publisher = {Association for Computing Machinery},
  83         author = {Pfenning, F. and Elliott, C.},
  84         year = {1988},
  85         note = {event-place: Atlanta, Georgia, USA},
  86         pages = {199--208},
  87         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},
  88 }
  89
  90 @inproceedings{chlipala_parametric_2008,
  91         address = {New York, NY, USA},
  92         series = {{ICFP} '08},
  93         title = {Parametric {Higher}-{Order} {Abstract} {Syntax} for {Mechanized} {Semantics}},
  94         isbn = {978-1-59593-919-7},
  95         url = {https://doi.org/10.1145/1411204.1411226},
  96         doi = {10.1145/1411204.1411226},
  97         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.},
  98         booktitle = {Proceedings of the 13th {ACM} {SIGPLAN} {International} {Conference} on {Functional} {Programming}},
  99         publisher = {Association for Computing Machinery},
 100         author = {Chlipala, Adam},
 101         year = {2008},
 102         note = {event-place: Victoria, BC, Canada},
 103         keywords = {compiler verification, dependent types, interactive proof assistants, type-theoretic semantics},
 104         pages = {143--156},
 105         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},
 106 }
 107
 108 @incollection{reynolds_user-defined_1978,
 109         address = {New York, NY},
 110         title = {User-{Defined} {Types} and {Procedural} {Data} {Structures} as {Complementary} {Approaches} to {Data} {Abstraction}},
 111         isbn = {978-1-4612-6315-9},
 112         url = {https://doi.org/10.1007/978-1-4612-6315-9_22},
 113         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.},
 114         booktitle = {Programming {Methodology}: {A} {Collection} of {Articles} by {Members} of {IFIP} {WG2}.3},
 115         publisher = {Springer New York},
 116         author = {Reynolds, John C.},
 117         editor = {Gries, David},
 118         year = {1978},
 119         doi = {10.1007/978-1-4612-6315-9_22},
 120         pages = {309--317},
 121         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},
 122 }
 123
 124 @misc{ghc_team_ghc_2021,
 125         title = {{GHC} {User}’s {Guide} {Documentation}},
 126         url = {https://downloads.haskell.org/~ghc/latest/docs/users_guide.pdf},
 127         language = {English},
 128         urldate = {2021-02-24},
 129         publisher = {Release},
 130         author = {GHC Team},
 131         year = {2021},
 132         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},
 133 }
 134
 135 @misc{ghc_team_datadynamic_2021,
 136         title = {Data.{Dynamic}},
 137         url = {https://hackage.haskell.org/package/base-4.14.1.0/docs/Data-Dynamic.html},
 138         language = {English},
 139         urldate = {2021-02-24},
 140         publisher = {Release},
 141         author = {GHC Team},
 142         year = {2021},
 143 }
 144
 145 @inproceedings{jeuring_polytypic_1996,
 146         address = {Berlin, Heidelberg},
 147         title = {Polytypic programming},
 148         isbn = {978-3-540-70639-7},
 149         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.},
 150         booktitle = {Advanced {Functional} {Programming}},
 151         publisher = {Springer Berlin Heidelberg},
 152         author = {Jeuring, Johan and Jansson, Patrik},
 153         editor = {Launchbury, John and Meijer, Erik and Sheard, Tim},
 154         year = {1996},
 155         pages = {68--114},
 156         file = {Jeuring and Jansson - 1996 - Polytypic programming.pdf:/home/mrl/.local/share/zotero/storage/SLC4G2IT/Jeuring and Jansson - 1996 - Polytypic programming.pdf:application/pdf},
 157 }
 158
 159 @book{peyton_jones_haskell_2003,
 160         address = {Cambridge},
 161         title = {Haskell 98 language and libraries: the revised report},
 162         isbn = {0-521 826144},
 163         publisher = {Cambridge University Press},
 164         editor = {Peyton Jones, Simon},
 165         year = {2003},
 166         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},
 167 }
 168
 169 @inproceedings{laufer_combining_1994,
 170         title = {Combining type classes and existential types},
 171         booktitle = {Proceedings of the {Latin} {American} {Informatic} {Conference} ({PANEL})},
 172         publisher = {ITESM-CEM},
 173         author = {Läufer, Konstantin},
 174         year = {1994},
 175         note = {event-place: Monterrey, Mexico},
 176         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},
 177 }
 178
 179 @techreport{hughes_restricted_1999,
 180         address = {Paris},
 181         title = {Restricted data types in {Haskell}},
 182         number = {UU-CS-1999-28},
 183         institution = {Department of Information and Computing Sciences, Utrecht University},
 184         author = {Hughes, John},
 185         year = {1999},
 186         pages = {16},
 187         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},
 188 }
 189
 190 @article{najd_trees_2017,
 191         title = {Trees that {Grow}},
 192         volume = {23},
 193         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.},
 194         number = {1},
 195         journal = {Journal of Universal Computer Science},
 196         author = {Najd, Shayan and Peyton Jones, Simon},
 197         month = jan,
 198         year = {2017},
 199         pages = {42--62},
 200         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},
 201 }
 202
 203 @inproceedings{loh_open_2006,
 204         address = {New York, NY, USA},
 205         series = {{PPDP} '06},
 206         title = {Open {Data} {Types} and {Open} {Functions}},
 207         isbn = {1-59593-388-3},
 208         url = {https://doi.org/10.1145/1140335.1140352},
 209         doi = {10.1145/1140335.1140352},
 210         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},
 211         booktitle = {Proceedings of the 8th {ACM} {SIGPLAN} {International} {Conference} on {Principles} and {Practice} of {Declarative} {Programming}},
 212         publisher = {Association for Computing Machinery},
 213         author = {Löh, Andres and Hinze, Ralf},
 214         year = {2006},
 215         note = {event-place: Venice, Italy},
 216         keywords = {functional programming, Haskell, expression problem, extensible data types, extensible exceptions, extensible functions, generic programming, mutually recursive modules},
 217         pages = {133--144},
 218         file = {OpenDatatypes.pdf:/home/mrl/.local/share/zotero/storage/NEP9GZ9N/OpenDatatypes.pdf:application/pdf},
 219 }
 220
 221 @inproceedings{hutton_fold_1998,
 222         address = {New York, NY, USA},
 223         series = {{ICFP} '98},
 224         title = {Fold and {Unfold} for {Program} {Semantics}},
 225         isbn = {1-58113-024-4},
 226         url = {https://doi.org/10.1145/289423.289457},
 227         doi = {10.1145/289423.289457},
 228         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.},
 229         booktitle = {Proceedings of the {Third} {ACM} {SIGPLAN} {International} {Conference} on {Functional} {Programming}},
 230         publisher = {Association for Computing Machinery},
 231         author = {Hutton, Graham},
 232         year = {1998},
 233         note = {event-place: Baltimore, Maryland, USA},
 234         pages = {280--288},
 235         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},
 236 }
 237
 238 @article{abadi_dynamic_1991,
 239         title = {Dynamic {Typing} in a {Statically} {Typed} {Language}},
 240         volume = {13},
 241         issn = {0164-0925},
 242         url = {https://doi.org/10.1145/103135.103138},
 243         doi = {10.1145/103135.103138},
 244         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.},
 245         number = {2},
 246         journal = {ACM Trans. Program. Lang. Syst.},
 247         author = {Abadi, Martín and Cardelli, Luca and Pierce, Benjamin and Plotkin, Gordon},
 248         month = apr,
 249         year = {1991},
 250         note = {Place: New York, NY, USA
 251 Publisher: Association for Computing Machinery},
 252         keywords = {theory},
 253         pages = {237--268},
 254         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},
 255 }
 256
 257 @inproceedings{svenningsson_combining_2013,
 258         address = {Berlin, Heidelberg},
 259         title = {Combining {Deep} and {Shallow} {Embedding} for {EDSL}},
 260         isbn = {978-3-642-40447-4},
 261         doi = {10.1007/978-3-642-40447-4_2},
 262         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.},
 263         booktitle = {Trends in {Functional} {Programming}},
 264         publisher = {Springer Berlin Heidelberg},
 265         author = {Svenningsson, Josef and Axelsson, Emil},
 266         editor = {Loidl, Hans-Wolfgang and Peña, Ricardo},
 267         year = {2013},
 268         pages = {21--36},
 269         file = {svenningsson2013combining.pdf:/home/mrl/.local/share/zotero/storage/NFBGZCZT/svenningsson2013combining.pdf:application/pdf},
 270 }
 271
 272 @article{mitchell_abstract_1988,
 273         title = {Abstract {Types} {Have} {Existential} {Type}},
 274         volume = {10},
 275         issn = {0164-0925},
 276         url = {https://doi.org/10.1145/44501.45065},
 277         doi = {10.1145/44501.45065},
 278         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.},
 279         number = {3},
 280         journal = {ACM Trans. Program. Lang. Syst.},
 281         author = {Mitchell, John C. and Plotkin, Gordon D.},
 282         month = jul,
 283         year = {1988},
 284         note = {Place: New York, NY, USA
 285 Publisher: Association for Computing Machinery},
 286         pages = {470--502},
 287         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},
 288 }
 289
 290 @inproceedings{yorgey_giving_2012,
 291         address = {New York, NY, USA},
 292         series = {{TLDI} '12},
 293         title = {Giving {Haskell} a {Promotion}},
 294         isbn = {978-1-4503-1120-5},
 295         url = {https://doi.org/10.1145/2103786.2103795},
 296         doi = {10.1145/2103786.2103795},
 297         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.},
 298         booktitle = {Proceedings of the 8th {ACM} {SIGPLAN} {Workshop} on {Types} in {Language} {Design} and {Implementation}},
 299         publisher = {Association for Computing Machinery},
 300         author = {Yorgey, Brent A. and Weirich, Stephanie and Cretin, Julien and Peyton Jones, Simon and Vytiniotis, Dimitrios and Magalhães, José Pedro},
 301         year = {2012},
 302         note = {event-place: Philadelphia, Pennsylvania, USA},
 303         keywords = {haskell, kinds, polymorphism, promotion},
 304         pages = {53--66},
 305         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},
 306 }
 307
 308 @inproceedings{atkey_unembedding_2009,
 309         address = {New York, NY, USA},
 310         series = {Haskell '09},
 311         title = {Unembedding {Domain}-{Specific} {Languages}},
 312         isbn = {978-1-60558-508-6},
 313         url = {https://doi.org/10.1145/1596638.1596644},
 314         doi = {10.1145/1596638.1596644},
 315         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.},
 316         booktitle = {Proceedings of the 2nd {ACM} {SIGPLAN} {Symposium} on {Haskell}},
 317         publisher = {Association for Computing Machinery},
 318         author = {Atkey, Robert and Lindley, Sam and Yallop, Jeremy},
 319         year = {2009},
 320         note = {event-place: Edinburgh, Scotland},
 321         keywords = {domain-specific languages, higher-order abstract syntax, type classes, unembedding},
 322         pages = {37--48},
 323         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},
 324 }
 325
 326 @inproceedings{krishnamurthi_synthesizing_1998,
 327         address = {Berlin, Heidelberg},
 328         title = {Synthesizing object-oriented and functional design to promote re-use},
 329         isbn = {978-3-540-69064-1},
 330         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.},
 331         booktitle = {{ECOOP}'98 — {Object}-{Oriented} {Programming}},
 332         publisher = {Springer Berlin Heidelberg},
 333         author = {Krishnamurthi, Shriram and Felleisen, Matthias and Friedman, Daniel P.},
 334         editor = {Jul, Eric},
 335         year = {1998},
 336         note = {event-place: Brussels, Belgium},
 337         pages = {91--113},
 338         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},
 339 }
 340
 341 @incollection{gibbons_functional_2015,
 342         address = {Cham},
 343         title = {Functional {Programming} for {Domain}-{Specific} {Languages}},
 344         isbn = {978-3-319-15940-9},
 345         url = {https://doi.org/10.1007/978-3-319-15940-9_1},
 346         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.},
 347         booktitle = {Central {European} {Functional} {Programming} {School}: 5th {Summer} {School}, {CEFP} 2013, {Cluj}-{Napoca}, {Romania}, {July} 8-20, 2013, {Revised} {Selected} {Papers}},
 348         publisher = {Springer International Publishing},
 349         author = {Gibbons, Jeremy},
 350         editor = {Zsók, Viktória and Horváth, Zoltán and Csató, Lehel},
 351         year = {2015},
 352         doi = {10.1007/978-3-319-15940-9_1},
 353         pages = {1--28},
 354         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},
 355 }
 356
 357 @incollection{lubbers_writing_2019,
 358         address = {Cham},
 359         title = {Writing {Internet} of {Things} applications with {Task} {Oriented} {Programming}},
 360         abstract = {The Internet of Things (IOT) is growing fast. In 2018, there was approximately one connected device per person on earth and the number has been growing ever since. The devices interact with the environment via diﬀerent modalities at the same time using sensors and actuators making the programs parallel. Yet, writing this type of programs is diﬃcult because the devices have little computation power and memory, the platforms are heterogeneous and the languages are low level. Task Oriented Programming (TOP) is a novel declarative programming language paradigm that is used to express coordination of work, collaboration of users and systems, the distribution of shared data and the human computer interaction. The mTask language is a specialized, yet full-ﬂedged, multi-backend TOP language for IOT devices. With the bytecode interpretation backend and the integration with iTasks, tasks can be executed on the device dynamically. This means that —according to the current state of aﬀairs— tasks can be tailor-made at run time, compiled to device-agnostic bytecode and shipped to the device for interpretation. Tasks sent to the device are fully integrated in iTasks to allow every form of interaction with the tasks such as observation of the task value and interaction with Shared Data Sources (SDSs). The application is —server and devices— are programmed in a single language, albeit using two embedded Domain Speciﬁc Languages (EDSLs).},
 361         language = {en},
 362         booktitle = {Central {European} {Functional} {Programming} {School}: 8th {Summer} {School}, {CEFP} 2019, {Budapest}, {Hungary}, {July} 17–21, 2019, {Revised} {Selected} {Papers}},
 363         publisher = {Springer International Publishing},
 364         author = {Lubbers, Mart and Koopman, Pieter and Plasmeijer, Rinus},
 365         year = {2019},
 366         pages = {51},
 367         file = {Lubbers - Writing Internet of Things applications with Task .pdf:/home/mrl/.local/share/zotero/storage/ILZIBYW5/Lubbers - Writing Internet of Things applications with Task .pdf:application/pdf},
 368 }
 369
 370 @mastersthesis{veen_van_der_mutable_2020,
 371         address = {Nijmegen},
 372         title = {Mutable {Collection} {Types} in {Shallow} {Embedded} {DSLs}},
 373         language = {en},
 374         school = {Radboud University},
 375         author = {Veen, van der, Erin},
 376         month = jun,
 377         year = {2020},
 378         file = {thesis_final.pdf:/home/mrl/.local/share/zotero/storage/Y9QWGGB9/thesis_final.pdf:application/pdf},
 379 }
 380
 381 @phdthesis{alimarine_generic_2005,
 382         address = {Nijmegen},
 383         type = {{PhD}},
 384         title = {Generic {Functional} {Programming}},
 385         language = {en},
 386         school = {Radboud University},
 387         author = {Alimarine, Artem},
 388         year = {2005},
 389         file = {Alimarine - Generic Functional Programming.pdf:/home/mrl/.local/share/zotero/storage/PDTS3SGX/Alimarine - Generic Functional Programming.pdf:application/pdf},
 390 }
 391
 392 @phdthesis{boer_de_secure_2020,
 393         address = {Nijmegen},
 394         type = {Bachelor's {Thesis}},
 395         title = {Secure {Communication} {Channels} for the {mTask} {System}.},
 396         language = {en},
 397         school = {Radboud University},
 398         author = {Boer, de, Michel},
 399         month = jun,
 400         year = {2020},
 401         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},
 402 }
 403
 404 @inproceedings{barendregt_towards_1987,
 405         title = {Towards an intermediate language for graph rewriting},
 406         volume = {1},
 407         booktitle = {{PARLE}, {Parallel} {Architectures} and {Languages} {Europe}},
 408         publisher = {Springer Verlag},
 409         author = {Barendregt, HP and van Eekelen, MCJD and Glauert, JRW and Kennaway, JR and Plasmeijer, MJ and Sleep, MR},
 410         year = {1987},
 411         pages = {159--174},
 412         file = {barh87-Lean.ps.gz:/home/mrl/.local/share/zotero/storage/63FBHND7/barh87-Lean.ps.gz:application/gzip},
 413 }
 414
 415 @incollection{wang_maintaining_2018,
 416         address = {Cham},
 417         title = {Maintaining {Separation} of {Concerns} {Through} {Task} {Oriented} {Software} {Development}},
 418         volume = {10788},
 419         isbn = {978-3-319-89718-9 978-3-319-89719-6},
 420         url = {http://link.springer.com/10.1007/978-3-319-89719-6_2},
 421         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.},
 422         language = {en},
 423         urldate = {2019-01-14},
 424         booktitle = {Trends in {Functional} {Programming}},
 425         publisher = {Springer International Publishing},
 426         author = {Stutterheim, Jurriën and Achten, Peter and Plasmeijer, Rinus},
 427         editor = {Wang, Meng and Owens, Scott},
 428         year = {2018},
 429         doi = {10.1007/978-3-319-89719-6},
 430         pages = {19--38},
 431         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},
 432 }
 433
 434 @article{barendsen_uniqueness_1996,
 435         title = {Uniqueness typing for functional languages with graph rewriting semantics},
 436         volume = {6},
 437         number = {6},
 438         journal = {Mathematical structures in computer science},
 439         author = {Barendsen, Erik and Smetsers, Sjaak},
 440         year = {1996},
 441         pages = {579--612},
 442         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},
 443 }
 444
 445 @mastersthesis{bohm_asynchronous_2019,
 446         address = {Nijmegen},
 447         title = {Asynchronous {Actions} in a {Synchronous} {World}},
 448         abstract = {This thesis introduces a system for asynchronous communication in the iTasks framework. The
 449 framework is written in Clean, a pure, lazy, functional language. Tasks need to be able to access
 450 data in the system and retrieve data from all kinds of data sources. The share system allows
 451 tasks to read arbitrary data sources and provides a simple interface that allows composition of
 452 different data sources. This system allows tasks to share and store data in an efficient, re-usable
 453 way.
 454 A disadvantage of the share system is that it does not allow asynchronous evaluation. When
 455 one task is using a share, other tasks have to wait for the full evaluation of this share before they
 456 can be evaluated. This has the effect that users in the iTasks framework must wait on other
 457 users. This results in poor user experience.
 458 We implement a share system which, by way of share rewriting, allows asynchronous evalua-
 459 tion. The system can be used to communicate with arbitrary services on the internet, as well as
 460 to communicate between different iTasks servers in a distributed context.
 461 We show how asynchronous shares are implemented and what the limitations are. We also
 462 show multiple practical examples of using asynchronous shares. The new system can be effectively
 463 used to consume services on the internet. It fits nicely into existing iTasks programs and requires
 464 few changes in existing programs.},
 465         language = {en},
 466         school = {Radboud University},
 467         author = {Böhm, Haye},
 468         month = jan,
 469         year = {2019},
 470         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},
 471 }
 472
 473 @inproceedings{hentschel_supersensors:_2016,
 474         address = {Vienna, Austria},
 475         title = {Supersensors: {Raspberry} {Pi} {Devices} for {Smart} {Campus} {Infrastructure}},
 476         isbn = {978-1-5090-4052-0},
 477         shorttitle = {Supersensors},
 478         url = {http://ieeexplore.ieee.org/document/7575844/},
 479         doi = {10.1109/FiCloud.2016.16},
 480         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.},
 481         language = {en},
 482         urldate = {2019-09-04},
 483         booktitle = {2016 {IEEE} 4th {International} {Conference} on {Future} {Internet} of {Things} and {Cloud} ({FiCloud})},
 484         publisher = {IEEE},
 485         author = {Hentschel, Kristian and Jacob, Dejice and Singer, Jeremy and Chalmers, Matthew},
 486         month = aug,
 487         year = {2016},
 488         pages = {58--62},
 489         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},
 490 }
 491
 492 @inproceedings{feijs_multi-tasking_2013,
 493         address = {Wuxi, China},
 494         title = {Multi-tasking and {Arduino} : why and how?},
 495         isbn = {978-90-386-3462-3},
 496         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.},
 497         language = {English},
 498         booktitle = {Design and semantics of form and movement. 8th {International} {Conference} on {Design} and {Semantics} of {Form} and {Movement} ({DeSForM} 2013)},
 499         author = {Feijs, Loe},
 500         editor = {Chen, L. L. and Djajadiningrat, T. and Feijs, L. M. G. and Fraser, S. and Hu, J. and Kyffin, S. and Steffen, D.},
 501         year = {2013},
 502         pages = {119--127},
 503         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},
 504 }
 505
 506 @misc{achten_clean_2007,
 507         title = {Clean for {Haskell98} {Programmers}},
 508         url = {https://www.mbsd.cs.ru.nl/publications/papers/2007/achp2007-CleanHaskellQuickGuide.pdf},
 509         language = {en},
 510         author = {Achten, Peter},
 511         month = jul,
 512         year = {2007},
 513         file = {Achten - Clean for Haskell98 Programmers.pdf:/home/mrl/.local/share/zotero/storage/69WWSGLF/Achten - Clean for Haskell98 Programmers.pdf:application/pdf},
 514 }
 515
 516 @inproceedings{baccelli_reprogramming_2018,
 517         title = {Reprogramming {Low}-end {IoT} {Devices} from the {Cloud}},
 518         booktitle = {2018 3rd {Cloudification} of the {Internet} of {Things} ({CIoT})},
 519         publisher = {IEEE},
 520         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},
 521         year = {2018},
 522         pages = {1--6},
 523         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},
 524 }
 525
 526 @inproceedings{baccelli_scripting_2018,
 527         title = {Scripting {Over}-{The}-{Air}: {Towards} {Containers} on {Low}-end {Devices} in the {Internet} of {Things}},
 528         booktitle = {{IEEE} {PerCom} 2018},
 529         author = {Baccelli, Emmanuel and Doerr, Joerg and Kikuchi, Shinji and Padilla, Francisco and Schleiser, Kaspar and Thomas, Ian},
 530         year = {2018},
 531         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},
 532 }
 533
 534 @mastersthesis{amazonas_cabral_de_andrade_developing_2018,
 535         address = {Nijmegen},
 536         title = {Developing {Real} {Life}, {Task} {Oriented} {Applications} for the {Internet} of {Things}},
 537         shorttitle = {Developing {Real} {Life}, {TOP} {Applications} for the {IOT}},
 538         language = {en},
 539         school = {Radboud University},
 540         author = {Amazonas Cabral De Andrade, Matheus},
 541         year = {2018},
 542         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},
 543 }
 544
 545 @article{swierstra_data_2008,
 546         title = {Data types à la carte},
 547         volume = {18},
 548         doi = {10.1017/S0956796808006758},
 549         number = {4},
 550         journal = {Journal of functional programming},
 551         author = {Swierstra, Wouter},
 552         year = {2008},
 553         pages = {423--436},
 554         file = {swierstra2008.pdf:/home/mrl/.local/share/zotero/storage/BEQKBXWP/swierstra2008.pdf:application/pdf},
 555 }
 556
 557 @article{groningen_exchanging_2010,
 558         title = {Exchanging sources between {Clean} and {Haskell}: {A} double-edged front end for the {Clean} compiler},
 559         volume = {45},
 560         shorttitle = {Exchanging sources between {Clean} and {Haskell}},
 561         number = {11},
 562         journal = {ACM Sigplan Notices},
 563         author = {Groningen, John van and Noort, Thomas van and Achten, Peter and Koopman, Pieter and Plasmeijer, Rinus},
 564         year = {2010},
 565         pages = {49--60},
 566         file = {groj10-Haskell_front_end_Clean.pdf:/home/mrl/.local/share/zotero/storage/WVZWX8WT/groj10-Haskell_front_end_Clean.pdf:application/pdf},
 567 }
 568
 569 @incollection{plasmeijer_shallow_2016,
 570         address = {Cham},
 571         series = {Lecture {Notes} in {Computer} {Science}},
 572         title = {A {Shallow} {Embedded} {Type} {Safe} {Extendable} {DSL} for the {Arduino}},
 573         volume = {9547},
 574         isbn = {978-3-319-39109-0 978-3-319-39110-6},
 575         url = {http://link.springer.com/10.1007/978-3-319-39110-6},
 576         urldate = {2017-02-22},
 577         booktitle = {Trends in {Functional} {Programming}},
 578         publisher = {Springer International Publishing},
 579         author = {Plasmeijer, Rinus and Koopman, Pieter},
 580         year = {2016},
 581         doi = {10.1007/978-3-319-39110-6},
 582         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},
 583 }
 584
 585 @inproceedings{cheney_lightweight_2002,
 586         title = {A lightweight implementation of generics and dynamics},
 587         url = {http://dl.acm.org/citation.cfm?id=581698},
 588         doi = {10.1145/581690.581698},
 589         urldate = {2017-05-15},
 590         booktitle = {Proceedings of the 2002 {ACM} {SIGPLAN} workshop on {Haskell}},
 591         publisher = {ACM},
 592         author = {Cheney, James and Hinze, Ralf},
 593         year = {2002},
 594         note = {event-place: Pittsburgh Pennsylvania, USA},
 595         keywords = {dynamic typing, generic programming, type representations},
 596         pages = {90--104},
 597         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},
 598 }
 599
 600 @article{tratt_domain_2008,
 601         title = {Domain {Specific} {Language} {Implementation} via {Compile}-{Time} {Meta}-{Programming}},
 602         volume = {30},
 603         issn = {0164-0925},
 604         url = {https://doi.org/10.1145/1391956.1391958},
 605         doi = {10.1145/1391956.1391958},
 606         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.},
 607         number = {6},
 608         journal = {ACM Trans. Program. Lang. Syst.},
 609         author = {Tratt, Laurence},
 610         month = oct,
 611         year = {2008},
 612         note = {Place: New York, NY, USA
 613 Publisher: Association for Computing Machinery},
 614         keywords = {domain specific languages, compile-time meta-programming, Syntax extension},
 615         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},
 616 }
 617
 618 @book{peyton_jones_implementation_1987,
 619         title = {The {Implementation} of {Functional} {Programming} {Languages}},
 620         url = {https://www.microsoft.com/en-us/research/publication/the-implementation-of-functional-programming-languages/},
 621         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".},
 622         publisher = {Prentice Hall},
 623         author = {Peyton Jones, Simon},
 624         month = jan,
 625         year = {1987},
 626         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},
 627 }
 628
 629 @article{elliott_compiling_2003,
 630         title = {Compiling embedded languages},
 631         volume = {13},
 632         doi = {10.1017/S0956796802004574},
 633         number = {3},
 634         journal = {Journal of Functional Programming},
 635         author = {Elliott, Conal and Finne, Sigbjørn and de Moor, Oege},
 636         year = {2003},
 637         note = {Publisher: Cambridge University Press},
 638         pages = {455--481},
 639         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},
 640 }
 641
 642 @inproceedings{sheard_accomplishments_2001,
 643         address = {Berlin, Heidelberg},
 644         title = {Accomplishments and {Research} {Challenges} in {Meta}-programming},
 645         isbn = {978-3-540-44806-8},
 646         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.},
 647         booktitle = {Semantics, {Applications}, and {Implementation} of {Program} {Generation}},
 648         publisher = {Springer Berlin Heidelberg},
 649         author = {Sheard, Tim},
 650         editor = {Taha, Walid},
 651         year = {2001},
 652         pages = {2--44},
 653         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},
 654 }
 655
 656 @incollection{kiselyov_typed_2012,
 657         address = {Berlin, Heidelberg},
 658         title = {Typed {Tagless} {Final} {Interpreters}},
 659         isbn = {978-3-642-32202-0},
 660         url = {https://doi.org/10.1007/978-3-642-32202-0_3},
 661         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.},
 662         booktitle = {Generic and {Indexed} {Programming}: {International} {Spring} {School}, {SSGIP} 2010, {Oxford}, {UK}, {March} 22-26, 2010, {Revised} {Lectures}},
 663         publisher = {Springer Berlin Heidelberg},
 664         author = {Kiselyov, Oleg},
 665         editor = {Gibbons, Jeremy},
 666         year = {2012},
 667         doi = {10.1007/978-3-642-32202-0_3},
 668         pages = {130--174},
 669         file = {Kiselyov - 2012 - Typed Tagless Final Interpreters.pdf:/home/mrl/.local/share/zotero/storage/9NBYZLRP/Kiselyov - 2012 - Typed Tagless Final Interpreters.pdf:application/pdf},
 670 }
 671
 672 @article{laufer_type_1996,
 673         title = {Type classes with existential types},
 674         volume = {6},
 675         doi = {10.1017/S0956796800001817},
 676         number = {3},
 677         journal = {Journal of Functional Programming},
 678         author = {Läufer, Konstantin},
 679         year = {1996},
 680         note = {Publisher: Cambridge University Press},
 681         pages = {485--518},
 682         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},
 683 }
 684
 685 @incollection{hinze_fun_2003,
 686         address = {Palgrave},
 687         series = {Cornerstones of {Computing}},
 688         title = {Fun {With} {Phantom} {Types}},
 689         isbn = {978-0-333-99285-2},
 690         booktitle = {The {Fun} of {Programming}},
 691         publisher = {Bloomsbury Publishing},
 692         author = {Hinze, Ralf},
 693         editor = {Gibbons, Jeremy and de Moor, Oege},
 694         year = {2003},
 695         pages = {245--262},
 696 }
 697
 698 @inproceedings{boulton_experience_1992,
 699         address = {North-Holland},
 700         title = {Experience with embedding hardware description languages in {HOL}},
 701         volume = {10},
 702         isbn = {0-444-89686-4},
 703         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.},
 704         language = {en},
 705         booktitle = {{IFIP} {TC10}/{WG}},
 706         publisher = {Elsevier},
 707         author = {Boulton, Richard and Gordon, Andrew and Gordon, Mike and Harrison, John and Herbert, John and Tassel, John Van},
 708         editor = {Stavridou, Victoria and Melham, Thomas F. and Boute, Raymond T.},
 709         year = {1992},
 710         note = {event-place: Nijmegen, NL},
 711         pages = {129--156},
 712         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},
 713 }
 714
 715 @inproceedings{gibbons_folding_2014,
 716         address = {New York, NY, USA},
 717         series = {{ICFP} '14},
 718         title = {Folding {Domain}-{Specific} {Languages}: {Deep} and {Shallow} {Embeddings} ({Functional} {Pearl})},
 719         isbn = {978-1-4503-2873-9},
 720         url = {https://doi.org/10.1145/2628136.2628138},
 721         doi = {10.1145/2628136.2628138},
 722         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.},
 723         booktitle = {Proceedings of the 19th {ACM} {SIGPLAN} {International} {Conference} on {Functional} {Programming}},
 724         publisher = {Association for Computing Machinery},
 725         author = {Gibbons, Jeremy and Wu, Nicolas},
 726         year = {2014},
 727         note = {event-place: Gothenburg, Sweden},
 728         keywords = {domain-specific languages, deep and shallow embedding, folds},
 729         pages = {339--347},
 730         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},
 731 }
 732
 733 @inproceedings{oliveira_typecase_2005,
 734         address = {New York, NY, USA},
 735         series = {Haskell '05},
 736         title = {{TypeCase}: {A} {Design} {Pattern} for {Type}-{Indexed} {Functions}},
 737         isbn = {1-59593-071-X},
 738         url = {https://doi.org/10.1145/1088348.1088358},
 739         doi = {10.1145/1088348.1088358},
 740         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.},
 741         booktitle = {Proceedings of the 2005 {ACM} {SIGPLAN} {Workshop} on {Haskell}},
 742         publisher = {Association for Computing Machinery},
 743         author = {Oliveira, Bruno C. d. S. and Gibbons, Jeremy},
 744         year = {2005},
 745         note = {event-place: Tallinn, Estonia},
 746         keywords = {generic programming, type classes, type-indexed functions},
 747         pages = {98--109},
 748         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},
 749 }
 750
 751 @inproceedings{odersky_putting_1996,
 752         address = {New York, NY, USA},
 753         series = {{POPL} '96},
 754         title = {Putting {Type} {Annotations} to {Work}},
 755         isbn = {0-89791-769-3},
 756         url = {https://doi.org/10.1145/237721.237729},
 757         doi = {10.1145/237721.237729},
 758         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.},
 759         booktitle = {Proceedings of the 23rd {ACM} {SIGPLAN}-{SIGACT} {Symposium} on {Principles} of {Programming} {Languages}},
 760         publisher = {Association for Computing Machinery},
 761         author = {Odersky, Martin and Läufer, Konstantin},
 762         year = {1996},
 763         note = {event-place: St. Petersburg Beach, Florida, USA},
 764         pages = {54--67},
 765         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},
 766 }
 767
 768 @article{carette_finally_2009,
 769         title = {Finally tagless, partially evaluated: {Tagless} staged interpreters for simpler typed languages},
 770         volume = {19},
 771         doi = {10.1017/S0956796809007205},
 772         number = {5},
 773         journal = {Journal of Functional Programming},
 774         author = {Carette, Jacques and Kiselyov, Oleg and Shan, Chung-Chieh},
 775         year = {2009},
 776         note = {Publisher: Cambridge University Press},
 777         pages = {509--543},
 778         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},
 779 }
 780
 781 @incollection{koopman_simulation_2018,
 782         address = {Cham},
 783         title = {Simulation of a {Task}-{Based} {Embedded} {Domain} {Specific} {Language} for the {Internet} of {Things}},
 784         language = {en},
 785         booktitle = {Central {European} {Functional} {Programming} {School}: 7th {Summer} {School}, {CEFP} 2018, {Košice}, {Slovakia}, {January} 22–26, 2018, {Revised} {Selected} {Papers}},
 786         publisher = {Springer International Publishing},
 787         author = {Koopman, Pieter and Lubbers, Mart and Plasmeijer, Rinus},
 788         year = {2018},
 789         pages = {51},
 790 }
 791
 792 @techreport{plasmeijer_clean_2021,
 793         address = {Nijmegen},
 794         title = {Clean {Language} {Report} version 3.1},
 795         urldate = {2021-12-22},
 796         institution = {Institute for Computing and Information Sciences},
 797         author = {Plasmeijer, Rinus and van Eekelen, Marko and van Groningen, John},
 798         month = dec,
 799         year = {2021},
 800         pages = {127},
 801         file = {CleanLanguageReport.pdf:/home/mrl/.local/share/zotero/storage/I2SDRIH6/CleanLanguageReport.pdf:application/pdf},
 802 }
 803
 804 @inproceedings{nocker_concurrent_1991,
 805         address = {Berlin, Heidelberg},
 806         title = {Concurrent clean},
 807         isbn = {978-3-540-47472-2},
 808         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.},
 809         booktitle = {{PARLE} '91 {Parallel} {Architectures} and {Languages} {Europe}},
 810         publisher = {Springer Berlin Heidelberg},
 811         author = {Nöcker, E. G. J. M. H. and Smetsers, J. E. W. and van Eekelen, M. C. J. D. and Plasmeijer, M. J.},
 812         editor = {Aarts, Emile H. L. and van Leeuwen, Jan and Rem, Martin},
 813         year = {1991},
 814         pages = {202--219},
 815         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},
 816 }
 817
 818 @incollection{mernik_extensible_2013,
 819         address = {Hershey, PA, USA},
 820         title = {Extensible {Languages}: {Blurring} the {Distinction} between {DSL} and {GPL}},
 821         isbn = {978-1-4666-2092-6},
 822         url = {https://services.igi-global.com/resolvedoi/resolve.aspx?doi=10.4018/978-1-4666-2092-6.ch001},
 823         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.},
 824         booktitle = {Formal and {Practical} {Aspects} of {Domain}-{Specific} {Languages}: {Recent} {Developments}},
 825         publisher = {IGI Global},
 826         author = {Verna, Didier},
 827         editor = {Mernik, Marjan},
 828         year = {2013},
 829         doi = {10.4018/978-1-4666-2092-6.ch001},
 830         pages = {1--31},
 831 }
 832
 833 @inproceedings{hudak_modular_1998,
 834         title = {Modular domain specific languages and tools},
 835         doi = {10.1109/ICSR.1998.685738},
 836         booktitle = {Proceedings. {Fifth} {International} {Conference} on {Software} {Reuse} ({Cat}. {No}.{98TB100203})},
 837         author = {Hudak, P.},
 838         year = {1998},
 839         pages = {134--142},
 840         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},
 841 }
 842
 843 @book{fowler_domain_2010,
 844         edition = {1st},
 845         title = {Domain {Specific} {Languages}},
 846         isbn = {0-321-71294-3},
 847         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\#.},
 848         publisher = {Addison-Wesley Professional},
 849         author = {Fowler, Martin},
 850         year = {2010},
 851         file = {Fowler - 2010 - Domain-specific languages.pdf:/home/mrl/.local/share/zotero/storage/YYMYXTZ5/Fowler - 2010 - Domain-specific languages.pdf:application/pdf},
 852 }
 853
 854 @misc{peter_t_lewis_speech_1985,
 855         address = {Washington, D.C.},
 856         type = {Speech},
 857         title = {Speech},
 858         url = {http://www.chetansharma.com/correcting-the-iot-history/},
 859         author = {{Peter T. Lewis}},
 860         month = sep,
 861         year = {1985},
 862 }
 863
 864 @article{weiser_computer_1991,
 865         title = {The {Computer} for the 21 st {Century}},
 866         volume = {265},
 867         language = {en},
 868         number = {3},
 869         journal = {Scientific American},
 870         author = {Weiser, Mark},
 871         month = sep,
 872         year = {1991},
 873         pages = {94--105},
 874         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},
 875 }
 876
 877 @misc{evans_internet_2011,
 878         title = {The {Internet} of {Things}: {How} the {Next} {Evolution} of the {Internet} {Is} {Changing} {Everything}},
 879         url = {https://www.cisco.com/c/dam/en_us/about/ac79/docs/innov/IoT_IBSG_0411FINAL.pdf},
 880         language = {en},
 881         publisher = {Cisco Internet Business Solutions Group (IBSG)},
 882         author = {Evans, Dave},
 883         month = apr,
 884         year = {2011},
 885         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},
 886 }
 887
 888 @inproceedings{ireland_classification_2009,
 889         address = {Cancun, Mexico},
 890         title = {A {Classification} of {Object}-{Relational} {Impedance} {Mismatch}},
 891         isbn = {978-0-7695-3550-0},
 892         doi = {10.1109/DBKDA.2009.11},
 893         booktitle = {First {International} {Conference} on {Advances} in {Databases}, {Knowledge}, and {Data} {Applications}},
 894         publisher = {IEEE},
 895         author = {Ireland, Christopher and Bowers, David and Newton, Michael and Waugh, Kevin},
 896         year = {2009},
 897         pages = {36--43},
 898 }
 899
 900 @incollection{koopman_type-safe_2019,
 901         address = {Cham},
 902         title = {Type-{Safe} {Functions} and {Tasks} in a {Shallow} {Embedded} {DSL} for {Microprocessors}},
 903         isbn = {978-3-030-28346-9},
 904         url = {https://doi.org/10.1007/978-3-030-28346-9_8},
 905         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.},
 906         booktitle = {Central {European} {Functional} {Programming} {School}: 6th {Summer} {School}, {CEFP} 2015, {Budapest}, {Hungary}, {July} 6–10, 2015, {Revised} {Selected} {Papers}},
 907         publisher = {Springer International Publishing},
 908         author = {Koopman, Pieter and Plasmeijer, Rinus},
 909         editor = {Zsók, Viktória and Porkoláb, Zoltán and Horváth, Zoltán},
 910         year = {2019},
 911         doi = {10.1007/978-3-030-28346-9_8},
 912         pages = {283--340},
 913         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},
 914 }
 915
 916 @techreport{cheney_first-class_2003,
 917         title = {First-class phantom types},
 918         url = {https://ecommons.cornell.edu/handle/1813/5614},
 919         number = {TR2003-1901},
 920         urldate = {2017-05-15},
 921         institution = {Cornell University},
 922         author = {Cheney, James and Hinze, Ralf},
 923         year = {2003},
 924         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},
 925 }
 926
 927 @inproceedings{baars_typing_2002,
 928         address = {New York, NY, USA},
 929         series = {{ICFP} '02},
 930         title = {Typing {Dynamic} {Typing}},
 931         isbn = {1-58113-487-8},
 932         url = {https://doi.org/10.1145/581478.581494},
 933         doi = {10.1145/581478.581494},
 934         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.},
 935         booktitle = {Proceedings of the {Seventh} {ACM} {SIGPLAN} {International} {Conference} on {Functional} {Programming}},
 936         publisher = {Association for Computing Machinery},
 937         author = {Baars, Arthur I. and Swierstra, S. Doaitse},
 938         year = {2002},
 939         note = {event-place: Pittsburgh, PA, USA},
 940         keywords = {coercions, dynamic typing, Haskell, Leibnitz' rule, quantified types, static typing, type equality, typed interpreters},
 941         pages = {157--166},
 942         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},
 943 }
 944
 945 @incollection{hinze_generic_2003,
 946         address = {Berlin, Heidelberg},
 947         title = {Generic {Haskell}: {Practice} and {Theory}},
 948         isbn = {978-3-540-45191-4},
 949         url = {https://doi.org/10.1007/978-3-540-45191-4_1},
 950         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.},
 951         booktitle = {Generic {Programming}: {Advanced} {Lectures}},
 952         publisher = {Springer Berlin Heidelberg},
 953         author = {Hinze, Ralf and Jeuring, Johan},
 954         editor = {Backhouse, Roland and Gibbons, Jeremy},
 955         year = {2003},
 956         doi = {10.1007/978-3-540-45191-4_1},
 957         pages = {1--56},
 958         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},
 959 }
 960
 961 @phdthesis{antonova_mtask_2022,
 962         address = {Nijmegen},
 963         type = {Bachelor's {Thesis}},
 964         title = {{mTask} {Semantics} and its {Comparison} to {TopHat}},
 965         language = {en},
 966         school = {Radboud University},
 967         author = {Antonova, Elina},
 968         year = {2022},
 969         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},
 970 }
 971
 972 @misc{wadler_expression_1998,
 973         title = {The expression problem},
 974         url = {https://homepages.inf.ed.ac.uk/wadler/papers/expression/expression.txt},
 975         language = {en},
 976         urldate = {2021-02-24},
 977         author = {Wadler, Philip},
 978         month = nov,
 979         year = {1998},
 980         note = {e-mail message, accessed on 2021-02-24},
 981 }
 982
 983 @misc{margaret_deuter_rhapsody_2015,
 984         address = {Oxford},
 985         edition = {Ninth edition},
 986         title = {Rhapsody},
 987         journal = {Oxford Advanced Learner's Dictionary of Current English},
 988         publisher = {Oxford University Press},
 989         author = {{A S Hornby}},
 990         editor = {{Margaret Deuter} and {Jennifer Bradbery} and {Joanna Turnbull}},
 991         year = {2015},
 992 }
 993
 994 @misc{wikipedia_contributors_rhapsody_2022,
 995         title = {Rhapsody (music) — {Wikipedia}, {The} {Free} {Encyclopedia}},
 996         url = {https://en.wikipedia.org/w/index.php?title=Rhapsody_(music)&oldid=1068385257},
 997         urldate = {2022-09-06},
 998         journal = {Wikipedia},
 999         author = {{Wikipedia contributors}},
1000         year = {2022},
1001         note = {accessed on: 2022-09-06},
1002 }
1003
1004 @incollection{backus_introduction_1990,
1005         address = {USA},
1006         title = {An {Introduction} to the {Programming} {Language} {FL}},
1007         isbn = {0-201-17236-4},
1008         booktitle = {Research {Topics} in {Functional} {Programming}},
1009         publisher = {Addison-Wesley Longman Publishing Co., Inc.},
1010         author = {Backus, John and Williams, John H. and Wimmers, Edward L.},
1011         year = {1990},
1012         pages = {219--247},
1013 }
1014
1015 @inproceedings{peyton_jones_imperative_1993,
1016         address = {New York, NY, USA},
1017         series = {{POPL} '93},
1018         title = {Imperative {Functional} {Programming}},
1019         isbn = {0-89791-560-7},
1020         url = {https://doi.org/10.1145/158511.158524},
1021         doi = {10.1145/158511.158524},
1022         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.},
1023         booktitle = {Proceedings of the 20th {ACM} {SIGPLAN}-{SIGACT} {Symposium} on {Principles} of {Programming} {Languages}},
1024         publisher = {Association for Computing Machinery},
1025         author = {Peyton Jones, Simon L. and Wadler, Philip},
1026         year = {1993},
1027         note = {event-place: Charleston, South Carolina, USA},
1028         pages = {71--84},
1029         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},
1030 }