[phd-thesis.git] / other.bib

@mastersthesis{crooijmans_reducing_2021,
        address = {Nijmegen},
        title = {Reducing the {Power} {Consumption} of {IoT} {Devices} in {Task}-{Oriented} {Programming}},
        language = {en},
        school = {Radboud University},
        author = {Crooijmans, Sjoerd},
        month = jul,
        year = {2021},
        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},
}

@inproceedings{plasmeijer_task-oriented_2012,
        address = {New York, NY, USA},
        series = {{PPDP} '12},
        title = {Task-{Oriented} {Programming} in a {Pure} {Functional} {Language}},
        isbn = {978-1-4503-1522-7},
        url = {https://doi.org/10.1145/2370776.2370801},
        doi = {10.1145/2370776.2370801},
        abstract = {Task-Oriented Programming (TOP) is a novel programming paradigm for the construction of distributed systems where users work together on the internet. When multiple users collaborate, they need to interact with each other frequently. TOP supports the definition of tasks that react to the progress made by others. With TOP, complex multi-user interactions can be programmed in a declarative style just by defining the tasks that have to be accomplished, thus eliminating the need to worry about the implementation detail that commonly frustrates the development of applications for this domain. TOP builds on four core concepts: tasks that represent computations or work to do which have an observable value that may change over time, data sharing enabling tasks to observe each other while the work is in progress, generic type driven generation of user interaction, and special combinators for sequential and parallel task composition. The semantics of these core concepts is defined in this paper. As an example we present the iTask3 framework, which embeds TOP in the functional programming language Clean.},
        booktitle = {Proceedings of the 14th {Symposium} on {Principles} and {Practice} of {Declarative} {Programming}},
        publisher = {Association for Computing Machinery},
        author = {Plasmeijer, Rinus and Lijnse, Bas and Michels, Steffen and Achten, Peter and Koopman, Pieter},
        year = {2012},
        note = {event-place: Leuven, Belgium},
        keywords = {clean, task-oriented programming},
        pages = {195--206},
        file = {103802.pdf:/home/mrl/.local/share/zotero/storage/ZE6A65AW/103802.pdf:application/pdf},
}

@inproceedings{brus_clean_1987,
        address = {Berlin, Heidelberg},
        title = {Clean — {A} language for functional graph rewriting},
        isbn = {978-3-540-47879-9},
        abstract = {Clean is an experimental language for specifying functional computations in terms of graph rewriting. It is based on an extension of Term Rewriting Systems (TRS) in which the terms are replaced by graphs. Such a Graph Rewriting System (GRS) consists of a, possibly cyclic, directed graph, called the data graph and graph rewrite rules which specify how this data graph may be rewritten. Clean is designed to provide a firm base for functional programming. In particular, Clean is suitable as an intermediate language between functional languages and (parallel) target machine architectures. A sequential implementation of Clean on a conventional machine is described and its performance is compared with other systems. The results show that Clean can be efficiently implemented.},
        booktitle = {Functional {Programming} {Languages} and {Computer} {Architecture}},
        publisher = {Springer Berlin Heidelberg},
        author = {Brus, T. H. and van Eekelen, M. C. J. D. and van Leer, M. O. and Plasmeijer, M. J.},
        editor = {Kahn, Gilles},
        year = {1987},
        pages = {364--384},
        file = {brut87-Clean.ps.gz:/home/mrl/.local/share/zotero/storage/T2QATWIE/brut87-Clean.ps.gz:application/gzip},
}

@misc{bolingbroke_constraint_2011,
        title = {Constraint {Kinds} for {GHC}},
        url = {http://blog.omega-prime.co.uk/2011/09/10/constraint-kinds-for-ghc/},
        urldate = {2021-06-09},
        journal = {:: (Bloggable a) ={\textgreater} a -{\textgreater} IO ()},
        author = {Bolingbroke, Max},
        month = sep,
        year = {2011},
        file = {Constraint Kinds for GHC:/home/mrl/.local/share/zotero/storage/R6RL79K7/constraint-kinds-for-ghc.html:text/html},
}

@inproceedings{fegaras_revisiting_1996,
        address = {New York, NY, USA},
        series = {{POPL} '96},
        title = {Revisiting {Catamorphisms} over {Datatypes} with {Embedded} {Functions} (or, {Programs} from {Outer} {Space})},
        isbn = {0-89791-769-3},
        url = {https://doi.org/10.1145/237721.237792},
        doi = {10.1145/237721.237792},
        abstract = {We revisit the work of Paterson and of Meijer \& Hutton, which describes how to construct catamorphisms for recursive datatype definitions that embed contravariant occurrences of the type being defined. Their construction requires, for each catamorphism, the definition of an anamorphism that has an inverse-like relationship to that catamorphism. We present an alternative construction, which replaces the stringent requirement that an inverse anamorphism be defined for each catamorphism with a more lenient restriction. The resulting construction has a more efficient implementation than that of Paterson, Meijer, and Hutton and the relevant restriction can be enforced by a Hindley-Milner type inference algorithm. We provide numerous examples illustrating our method.},
        booktitle = {Proceedings of the 23rd {ACM} {SIGPLAN}-{SIGACT} {Symposium} on {Principles} of {Programming} {Languages}},
        publisher = {Association for Computing Machinery},
        author = {Fegaras, Leonidas and Sheard, Tim},
        year = {1996},
        note = {event-place: St. Petersburg Beach, Florida, USA},
        pages = {284--294},
        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},
}

@inproceedings{pfenning_higher-order_1988,
        address = {New York, NY, USA},
        series = {{PLDI} '88},
        title = {Higher-{Order} {Abstract} {Syntax}},
        isbn = {0-89791-269-1},
        url = {https://doi.org/10.1145/53990.54010},
        doi = {10.1145/53990.54010},
        abstract = {We describe motivation, design, use, and implementation of higher-order abstract syntax as a central representation for programs, formulas, rules, and other syntactic objects in program manipulation and other formal systems where matching and substitution or unification are central operations. Higher-order abstract syntax incorporates name binding information in a uniform and language generic way. Thus it acts as a powerful link integrating diverse tools in such formal environments. We have implemented higher-order abstract syntax, a supporting matching and unification algorithm, and some clients in Common Lisp in the framework of the Ergo project at Carnegie Mellon University.},
        booktitle = {Proceedings of the {ACM} {SIGPLAN} 1988 {Conference} on {Programming} {Language} {Design} and {Implementation}},
        publisher = {Association for Computing Machinery},
        author = {Pfenning, F. and Elliott, C.},
        year = {1988},
        note = {event-place: Atlanta, Georgia, USA},
        pages = {199--208},
        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},
}

@inproceedings{chlipala_parametric_2008,
        address = {New York, NY, USA},
        series = {{ICFP} '08},
        title = {Parametric {Higher}-{Order} {Abstract} {Syntax} for {Mechanized} {Semantics}},
        isbn = {978-1-59593-919-7},
        url = {https://doi.org/10.1145/1411204.1411226},
        doi = {10.1145/1411204.1411226},
        abstract = {We present parametric higher-order abstract syntax (PHOAS), a new approach to formalizing the syntax of programming languages in computer proof assistants based on type theory. Like higher-order abstract syntax (HOAS), PHOAS uses the meta language's binding constructs to represent the object language's binding constructs. Unlike HOAS, PHOAS types are definable in general-purpose type theories that support traditional functional programming, like Coq's Calculus of Inductive Constructions. We walk through how Coq can be used to develop certified, executable program transformations over several statically-typed functional programming languages formalized with PHOAS; that is, each transformation has a machine-checked proof of type preservation and semantic preservation. Our examples include CPS translation and closure conversion for simply-typed lambda calculus, CPS translation for System F, and translation from a language with ML-style pattern matching to a simpler language with no variable-arity binding constructs. By avoiding the syntactic hassle associated with first-order representation techniques, we achieve a very high degree of proof automation.},
        booktitle = {Proceedings of the 13th {ACM} {SIGPLAN} {International} {Conference} on {Functional} {Programming}},
        publisher = {Association for Computing Machinery},
        author = {Chlipala, Adam},
        year = {2008},
        note = {event-place: Victoria, BC, Canada},
        keywords = {compiler verification, dependent types, interactive proof assistants, type-theoretic semantics},
        pages = {143--156},
        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},
}

@incollection{reynolds_user-defined_1978,
        address = {New York, NY},
        title = {User-{Defined} {Types} and {Procedural} {Data} {Structures} as {Complementary} {Approaches} to {Data} {Abstraction}},
        isbn = {978-1-4612-6315-9},
        url = {https://doi.org/10.1007/978-1-4612-6315-9_22},
        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.},
        booktitle = {Programming {Methodology}: {A} {Collection} of {Articles} by {Members} of {IFIP} {WG2}.3},
        publisher = {Springer New York},
        author = {Reynolds, John C.},
        editor = {Gries, David},
        year = {1978},
        doi = {10.1007/978-1-4612-6315-9_22},
        pages = {309--317},
        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},
}

@misc{ghc_team_ghc_2021,
        title = {{GHC} {User}’s {Guide} {Documentation}},
        url = {https://downloads.haskell.org/~ghc/latest/docs/users_guide.pdf},
        language = {English},
        urldate = {2021-02-24},
        publisher = {Release},
        author = {GHC Team},
        year = {2021},
        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},
}

@misc{ghc_team_datadynamic_2021,
        title = {Data.{Dynamic}},
        url = {https://hackage.haskell.org/package/base-4.14.1.0/docs/Data-Dynamic.html},
        language = {English},
        urldate = {2021-02-24},
        publisher = {Release},
        author = {GHC Team},
        year = {2021},
}

@inproceedings{jeuring_polytypic_1996,
        address = {Berlin, Heidelberg},
        title = {Polytypic programming},
        isbn = {978-3-540-70639-7},
        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.},
        booktitle = {Advanced {Functional} {Programming}},
        publisher = {Springer Berlin Heidelberg},
        author = {Jeuring, Johan and Jansson, Patrik},
        editor = {Launchbury, John and Meijer, Erik and Sheard, Tim},
        year = {1996},
        pages = {68--114},
        file = {Jeuring and Jansson - 1996 - Polytypic programming.pdf:/home/mrl/.local/share/zotero/storage/SLC4G2IT/Jeuring and Jansson - 1996 - Polytypic programming.pdf:application/pdf},
}

@book{peyton_jones_haskell_2003,
        address = {Cambridge},
        title = {Haskell 98 language and libraries: the revised report},
        isbn = {0-521 826144},
        publisher = {Cambridge University Press},
        editor = {Peyton Jones, Simon},
        year = {2003},
        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},
}

@inproceedings{laufer_combining_1994,
        title = {Combining type classes and existential types},
        booktitle = {Proceedings of the {Latin} {American} {Informatic} {Conference} ({PANEL})},
        publisher = {ITESM-CEM},
        author = {Läufer, Konstantin},
        year = {1994},
        note = {event-place: Monterrey, Mexico},
        file = {Läufer - COMBINING TYPE CLASSES AND EXISTENTIAL TYPES.pdf:/home/mrl/.local/share/zotero/storage/KR4P9EHS/Läufer - COMBINING TYPE CLASSES AND EXISTENTIAL TYPES.pdf:application/pdf},
}

@techreport{hughes_restricted_1999,
        address = {Paris},
        title = {Restricted data types in {Haskell}},
        number = {UU-CS-1999-28},
        institution = {Department of Information and Computing Sciences, Utrecht University},
        author = {Hughes, John},
        year = {1999},
        pages = {16},
        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},
}

@article{najd_trees_2017,
        title = {Trees that {Grow}},
        volume = {23},
        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.},
        number = {1},
        journal = {Journal of Universal Computer Science},
        author = {Najd, Shayan and Peyton Jones, Simon},
        month = jan,
        year = {2017},
        pages = {42--62},
        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},
}

@inproceedings{loh_open_2006,
        address = {New York, NY, USA},
        series = {{PPDP} '06},
        title = {Open {Data} {Types} and {Open} {Functions}},
        isbn = {1-59593-388-3},
        url = {https://doi.org/10.1145/1140335.1140352},
        doi = {10.1145/1140335.1140352},
        abstract = {The problem of supporting the modular extensibility of both data and functions in one programming language at the same time is known as the expression problem. Functional languages traditionally make it easy to add new functions, but extending data (adding new data constructors) requires modifying existing code. We present a semantically and syntactically lightweight variant of open data types and open functions as a solution to the expression problem in the Haskell language. Constructors of open data types and equations of open functions may appear scattered throughout a program with several modules. The intended semantics is as follows: the program should behave as if the data types and functions were closed, defined in one place. The order of function equations is determined by best-fit pattern matching, where a specific pattern takes precedence over an unspecific one. We show that our solution is applicable to the expression problem, generic programming, and exceptions. We sketch two implementations: a direct implementation of the semantics, and a scheme based on mutually recursive modules that permits separate compilation},
        booktitle = {Proceedings of the 8th {ACM} {SIGPLAN} {International} {Conference} on {Principles} and {Practice} of {Declarative} {Programming}},
        publisher = {Association for Computing Machinery},
        author = {Löh, Andres and Hinze, Ralf},
        year = {2006},
        note = {event-place: Venice, Italy},
        keywords = {functional programming, Haskell, expression problem, extensible data types, extensible exceptions, extensible functions, generic programming, mutually recursive modules},
        pages = {133--144},
        file = {OpenDatatypes.pdf:/home/mrl/.local/share/zotero/storage/NEP9GZ9N/OpenDatatypes.pdf:application/pdf},
}

@inproceedings{hutton_fold_1998,
        address = {New York, NY, USA},
        series = {{ICFP} '98},
        title = {Fold and {Unfold} for {Program} {Semantics}},
        isbn = {1-58113-024-4},
        url = {https://doi.org/10.1145/289423.289457},
        doi = {10.1145/289423.289457},
        abstract = {In this paper we explain how recursion operators can be used to structure and reason about program semantics within a functional language. In particular, we show how the recursion operator fold can be used to structure denotational semantics, how the dual recursion operator unfold can be used to structure operational semantics, and how algebraic properties of these operators can be used to reason about program semantics. The techniques are explained with the aid of two main examples, the first concerning arithmetic expressions, and the second concerning Milner's concurrent language CCS. The aim of the paper is to give functional programmers new insights into recursion operators, program semantics, and the relationships between them.},
        booktitle = {Proceedings of the {Third} {ACM} {SIGPLAN} {International} {Conference} on {Functional} {Programming}},
        publisher = {Association for Computing Machinery},
        author = {Hutton, Graham},
        year = {1998},
        note = {event-place: Baltimore, Maryland, USA},
        pages = {280--288},
        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},
}

@article{abadi_dynamic_1991,
        title = {Dynamic {Typing} in a {Statically} {Typed} {Language}},
        volume = {13},
        issn = {0164-0925},
        url = {https://doi.org/10.1145/103135.103138},
        doi = {10.1145/103135.103138},
        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.},
        number = {2},
        journal = {ACM Trans. Program. Lang. Syst.},
        author = {Abadi, Martín and Cardelli, Luca and Pierce, Benjamin and Plotkin, Gordon},
        month = apr,
        year = {1991},
        note = {Place: New York, NY, USA
Publisher: Association for Computing Machinery},
        keywords = {theory},
        pages = {237--268},
        file = {Abadi et al. - 1991 - Dynamic typing in a statically typed language.pdf:/home/mrl/.local/share/zotero/storage/CJSBG6X7/Abadi et al. - 1991 - Dynamic typing in a statically typed language.pdf:application/pdf},
}

@inproceedings{svenningsson_combining_2013,
        address = {Berlin, Heidelberg},
        title = {Combining {Deep} and {Shallow} {Embedding} for {EDSL}},
        isbn = {978-3-642-40447-4},
        doi = {10.1007/978-3-642-40447-4_2},
        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.},
        booktitle = {Trends in {Functional} {Programming}},
        publisher = {Springer Berlin Heidelberg},
        author = {Svenningsson, Josef and Axelsson, Emil},
        editor = {Loidl, Hans-Wolfgang and Peña, Ricardo},
        year = {2013},
        pages = {21--36},
        file = {svenningsson2013combining.pdf:/home/mrl/.local/share/zotero/storage/NFBGZCZT/svenningsson2013combining.pdf:application/pdf},
}

@article{mitchell_abstract_1988,
        title = {Abstract {Types} {Have} {Existential} {Type}},
        volume = {10},
        issn = {0164-0925},
        url = {https://doi.org/10.1145/44501.45065},
        doi = {10.1145/44501.45065},
        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.},
        number = {3},
        journal = {ACM Trans. Program. Lang. Syst.},
        author = {Mitchell, John C. and Plotkin, Gordon D.},
        month = jul,
        year = {1988},
        note = {Place: New York, NY, USA
Publisher: Association for Computing Machinery},
        pages = {470--502},
        file = {Mitchell and Plotkin - 1988 - Abstract types have existential type.pdf:/home/mrl/.local/share/zotero/storage/QXDE5H7C/Mitchell and Plotkin - 1988 - Abstract types have existential type.pdf:application/pdf},
}

@inproceedings{yorgey_giving_2012,
        address = {New York, NY, USA},
        series = {{TLDI} '12},
        title = {Giving {Haskell} a {Promotion}},
        isbn = {978-1-4503-1120-5},
        url = {https://doi.org/10.1145/2103786.2103795},
        doi = {10.1145/2103786.2103795},
        abstract = {Static type systems strive to be richly expressive while still being simple enough for programmers to use. We describe an experiment that enriches Haskell's kind system with two features promoted from its type system: data types and polymorphism. The new system has a very good power-to-weight ratio: it offers a significant improvement in expressiveness, but, by re-using concepts that programmers are already familiar with, the system is easy to understand and implement.},
        booktitle = {Proceedings of the 8th {ACM} {SIGPLAN} {Workshop} on {Types} in {Language} {Design} and {Implementation}},
        publisher = {Association for Computing Machinery},
        author = {Yorgey, Brent A. and Weirich, Stephanie and Cretin, Julien and Peyton Jones, Simon and Vytiniotis, Dimitrios and Magalhães, José Pedro},
        year = {2012},
        note = {event-place: Philadelphia, Pennsylvania, USA},
        keywords = {haskell, kinds, polymorphism, promotion},
        pages = {53--66},
        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},
}

@inproceedings{atkey_unembedding_2009,
        address = {New York, NY, USA},
        series = {Haskell '09},
        title = {Unembedding {Domain}-{Specific} {Languages}},
        isbn = {978-1-60558-508-6},
        url = {https://doi.org/10.1145/1596638.1596644},
        doi = {10.1145/1596638.1596644},
        abstract = {Higher-order abstract syntax provides a convenient way of embedding domain-specific languages, but is awkward to analyse and manipulate directly. We explore the boundaries of higher-order abstract syntax. Our key tool is the unembedding of embedded terms as de Bruijn terms, enabling intensional analysis. As part of our solution we present techniques for separating the definition of an embedded program from its interpretation, giving modular extensions of the embedded language, and different ways to encode the types of the embedded language.},
        booktitle = {Proceedings of the 2nd {ACM} {SIGPLAN} {Symposium} on {Haskell}},
        publisher = {Association for Computing Machinery},
        author = {Atkey, Robert and Lindley, Sam and Yallop, Jeremy},
        year = {2009},
        note = {event-place: Edinburgh, Scotland},
        keywords = {domain-specific languages, higher-order abstract syntax, type classes, unembedding},
        pages = {37--48},
        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},
}

@inproceedings{krishnamurthi_synthesizing_1998,
        address = {Berlin, Heidelberg},
        title = {Synthesizing object-oriented and functional design to promote re-use},
        isbn = {978-3-540-69064-1},
        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.},
        booktitle = {{ECOOP}'98 — {Object}-{Oriented} {Programming}},
        publisher = {Springer Berlin Heidelberg},
        author = {Krishnamurthi, Shriram and Felleisen, Matthias and Friedman, Daniel P.},
        editor = {Jul, Eric},
        year = {1998},
        note = {event-place: Brussels, Belgium},
        pages = {91--113},
        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},
}

@incollection{gibbons_functional_2015,
        address = {Cham},
        title = {Functional {Programming} for {Domain}-{Specific} {Languages}},
        isbn = {978-3-319-15940-9},
        url = {https://doi.org/10.1007/978-3-319-15940-9_1},
        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.},
        booktitle = {Central {European} {Functional} {Programming} {School}: 5th {Summer} {School}, {CEFP} 2013, {Cluj}-{Napoca}, {Romania}, {July} 8-20, 2013, {Revised} {Selected} {Papers}},
        publisher = {Springer International Publishing},
        author = {Gibbons, Jeremy},
        editor = {Zsók, Viktória and Horváth, Zoltán and Csató, Lehel},
        year = {2015},
        doi = {10.1007/978-3-319-15940-9_1},
        pages = {1--28},
        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},
}

@phdthesis{alimarine_generic_2005,
        address = {Nijmegen},
        type = {{PhD}},
        title = {Generic {Functional} {Programming}},
        language = {en},
        school = {Radboud University},
        author = {Alimarine, Artem},
        year = {2005},
        file = {Alimarine - Generic Functional Programming.pdf:/home/mrl/.local/share/zotero/storage/PDTS3SGX/Alimarine - Generic Functional Programming.pdf:application/pdf},
}

@inproceedings{barendregt_towards_1987,
        title = {Towards an intermediate language for graph rewriting},
        volume = {1},
        booktitle = {{PARLE}, {Parallel} {Architectures} and {Languages} {Europe}},
        publisher = {Springer Verlag},
        author = {Barendregt, HP and van Eekelen, MCJD and Glauert, JRW and Kennaway, JR and Plasmeijer, MJ and Sleep, MR},
        year = {1987},
        pages = {159--174},
        file = {barh87-Lean.ps.gz:/home/mrl/.local/share/zotero/storage/63FBHND7/barh87-Lean.ps.gz:application/gzip},
}

@incollection{wang_maintaining_2018,
        address = {Cham},
        title = {Maintaining {Separation} of {Concerns} {Through} {Task} {Oriented} {Software} {Development}},
        volume = {10788},
        isbn = {978-3-319-89718-9 978-3-319-89719-6},
        url = {http://link.springer.com/10.1007/978-3-319-89719-6_2},
        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.},
        language = {en},
        urldate = {2019-01-14},
        booktitle = {Trends in {Functional} {Programming}},
        publisher = {Springer International Publishing},
        author = {Stutterheim, Jurriën and Achten, Peter and Plasmeijer, Rinus},
        editor = {Wang, Meng and Owens, Scott},
        year = {2018},
        doi = {10.1007/978-3-319-89719-6},
        pages = {19--38},
        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},
}

@mastersthesis{bohm_asynchronous_2019,
        address = {Nijmegen},
        title = {Asynchronous {Actions} in a {Synchronous} {World}},
        abstract = {This thesis introduces a system for asynchronous communication in the iTasks framework. The
framework is written in Clean, a pure, lazy, functional language. Tasks need to be able to access
data in the system and retrieve data from all kinds of data sources. The share system allows
tasks to read arbitrary data sources and provides a simple interface that allows composition of
different data sources. This system allows tasks to share and store data in an efficient, re-usable
way.
A disadvantage of the share system is that it does not allow asynchronous evaluation. When
one task is using a share, other tasks have to wait for the full evaluation of this share before they
can be evaluated. This has the effect that users in the iTasks framework must wait on other
users. This results in poor user experience.
We implement a share system which, by way of share rewriting, allows asynchronous evalua-
tion. The system can be used to communicate with arbitrary services on the internet, as well as
to communicate between different iTasks servers in a distributed context.
We show how asynchronous shares are implemented and what the limitations are. We also
show multiple practical examples of using asynchronous shares. The new system can be effectively
used to consume services on the internet. It fits nicely into existing iTasks programs and requires
few changes in existing programs.},
        language = {en},
        school = {Radboud University},
        author = {Böhm, Haye},
        month = jan,
        year = {2019},
        file = {Bohm - Asynchronous Actions in a Synchronous World.pdf:/home/mrl/.local/share/zotero/storage/D3IYPAM5/Bohm - Asynchronous Actions in a Synchronous World.pdf:application/pdf},
}

@inproceedings{hentschel_supersensors:_2016,
        address = {Vienna, Austria},
        title = {Supersensors: {Raspberry} {Pi} {Devices} for {Smart} {Campus} {Infrastructure}},
        isbn = {978-1-5090-4052-0},
        shorttitle = {Supersensors},
        url = {http://ieeexplore.ieee.org/document/7575844/},
        doi = {10.1109/FiCloud.2016.16},
        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 significant compute capability—enable more flexible 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.},
        language = {en},
        urldate = {2019-09-04},
        booktitle = {2016 {IEEE} 4th {International} {Conference} on {Future} {Internet} of {Things} and {Cloud} ({FiCloud})},
        publisher = {IEEE},
        author = {Hentschel, Kristian and Jacob, Dejice and Singer, Jeremy and Chalmers, Matthew},
        month = aug,
        year = {2016},
        pages = {58--62},
        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},
}

@misc{achten_clean_2007,
        title = {Clean for {Haskell98} {Programmers}},
        url = {https://www.mbsd.cs.ru.nl/publications/papers/2007/achp2007-CleanHaskellQuickGuide.pdf},
        language = {en},
        author = {Achten, Peter},
        month = jul,
        year = {2007},
        file = {Achten - Clean for Haskell98 Programmers.pdf:/home/mrl/.local/share/zotero/storage/69WWSGLF/Achten - Clean for Haskell98 Programmers.pdf:application/pdf},
}

@inproceedings{baccelli_reprogramming_2018,
        title = {Reprogramming {Low}-end {IoT} {Devices} from the {Cloud}},
        booktitle = {2018 3rd {Cloudification} of the {Internet} of {Things} ({CIoT})},
        publisher = {IEEE},
        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},
        year = {2018},
        pages = {1--6},
        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},
}

@inproceedings{baccelli_scripting_2018,
        title = {Scripting {Over}-{The}-{Air}: {Towards} {Containers} on {Low}-end {Devices} in the {Internet} of {Things}},
        booktitle = {{IEEE} {PerCom} 2018},
        author = {Baccelli, Emmanuel and Doerr, Joerg and Kikuchi, Shinji and Padilla, Francisco and Schleiser, Kaspar and Thomas, Ian},
        year = {2018},
        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},
}

@mastersthesis{amazonas_cabral_de_andrade_developing_2018,
        address = {Nijmegen},
        title = {Developing {Real} {Life}, {Task} {Oriented} {Applications} for the {Internet} of {Things}},
        shorttitle = {Developing {Real} {Life}, {TOP} {Applications} for the {IOT}},
        language = {en},
        school = {Radboud University},
        author = {Amazonas Cabral De Andrade, Matheus},
        year = {2018},
        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},
}

@article{swierstra_data_2008,
        title = {Data types à la carte},
        volume = {18},
        doi = {10.1017/S0956796808006758},
        number = {4},
        journal = {Journal of functional programming},
        author = {Swierstra, Wouter},
        year = {2008},
        pages = {423--436},
        file = {swierstra2008.pdf:/home/mrl/.local/share/zotero/storage/BEQKBXWP/swierstra2008.pdf:application/pdf},
}

@article{groningen_exchanging_2010,
        title = {Exchanging sources between {Clean} and {Haskell}: {A} double-edged front end for the {Clean} compiler},
        volume = {45},
        shorttitle = {Exchanging sources between {Clean} and {Haskell}},
        number = {11},
        journal = {ACM Sigplan Notices},
        author = {Groningen, John van and Noort, Thomas van and Achten, Peter and Koopman, Pieter and Plasmeijer, Rinus},
        year = {2010},
        pages = {49--60},
        file = {groj10-Haskell_front_end_Clean.pdf:/home/mrl/.local/share/zotero/storage/WVZWX8WT/groj10-Haskell_front_end_Clean.pdf:application/pdf},
}

@inproceedings{cheney_lightweight_2002,
        title = {A lightweight implementation of generics and dynamics},
        url = {http://dl.acm.org/citation.cfm?id=581698},
        doi = {10.1145/581690.581698},
        urldate = {2017-05-15},
        booktitle = {Proceedings of the 2002 {ACM} {SIGPLAN} workshop on {Haskell}},
        publisher = {ACM},
        author = {Cheney, James and Hinze, Ralf},
        year = {2002},
        note = {event-place: Pittsburgh Pennsylvania, USA},
        keywords = {dynamic typing, generic programming, type representations},
        pages = {90--104},
        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},
}

@article{tratt_domain_2008,
        title = {Domain {Specific} {Language} {Implementation} via {Compile}-{Time} {Meta}-{Programming}},
        volume = {30},
        issn = {0164-0925},
        url = {https://doi.org/10.1145/1391956.1391958},
        doi = {10.1145/1391956.1391958},
        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.},
        number = {6},
        journal = {ACM Trans. Program. Lang. Syst.},
        author = {Tratt, Laurence},
        month = oct,
        year = {2008},
        note = {Place: New York, NY, USA
Publisher: Association for Computing Machinery},
        keywords = {domain specific languages, compile-time meta-programming, Syntax extension},
        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},
}

@book{peyton_jones_implementation_1987,
        title = {The {Implementation} of {Functional} {Programming} {Languages}},
        url = {https://www.microsoft.com/en-us/research/publication/the-implementation-of-functional-programming-languages/},
        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".},
        publisher = {Prentice Hall},
        author = {Peyton Jones, Simon},
        month = jan,
        year = {1987},
        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},
}

@article{elliott_compiling_2003,
        title = {Compiling embedded languages},
        volume = {13},
        doi = {10.1017/S0956796802004574},
        number = {3},
        journal = {Journal of Functional Programming},
        author = {Elliott, Conal and Finne, Sigbjørn and de Moor, Oege},
        year = {2003},
        note = {Publisher: Cambridge University Press},
        pages = {455--481},
        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},
}

@inproceedings{sheard_accomplishments_2001,
        address = {Berlin, Heidelberg},
        title = {Accomplishments and {Research} {Challenges} in {Meta}-programming},
        isbn = {978-3-540-44806-8},
        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.},
        booktitle = {Semantics, {Applications}, and {Implementation} of {Program} {Generation}},
        publisher = {Springer Berlin Heidelberg},
        author = {Sheard, Tim},
        editor = {Taha, Walid},
        year = {2001},
        pages = {2--44},
        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},
}

@incollection{kiselyov_typed_2012,
        address = {Berlin, Heidelberg},
        title = {Typed {Tagless} {Final} {Interpreters}},
        isbn = {978-3-642-32202-0},
        url = {https://doi.org/10.1007/978-3-642-32202-0_3},
        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.},
        booktitle = {Generic and {Indexed} {Programming}: {International} {Spring} {School}, {SSGIP} 2010, {Oxford}, {UK}, {March} 22-26, 2010, {Revised} {Lectures}},
        publisher = {Springer Berlin Heidelberg},
        author = {Kiselyov, Oleg},
        editor = {Gibbons, Jeremy},
        year = {2012},
        doi = {10.1007/978-3-642-32202-0_3},
        pages = {130--174},
        file = {Kiselyov - 2012 - Typed Tagless Final Interpreters.pdf:/home/mrl/.local/share/zotero/storage/9NBYZLRP/Kiselyov - 2012 - Typed Tagless Final Interpreters.pdf:application/pdf},
}

@article{laufer_type_1996,
        title = {Type classes with existential types},
        volume = {6},
        doi = {10.1017/S0956796800001817},
        number = {3},
        journal = {Journal of Functional Programming},
        author = {Läufer, Konstantin},
        year = {1996},
        note = {Publisher: Cambridge University Press},
        pages = {485--518},
        file = {Läufer - 1996 - Type classes with existential types.pdf:/home/mrl/.local/share/zotero/storage/FG73PZJE/Läufer - 1996 - Type classes with existential types.pdf:application/pdf},
}

@incollection{hinze_fun_2003,
        address = {Palgrave},
        series = {Cornerstones of {Computing}},
        title = {Fun {With} {Phantom} {Types}},
        isbn = {978-0-333-99285-2},
        booktitle = {The {Fun} of {Programming}},
        publisher = {Bloomsbury Publishing},
        author = {Hinze, Ralf},
        editor = {Gibbons, Jeremy and de Moor, Oege},
        year = {2003},
        pages = {245--262},
}

@inproceedings{boulton_experience_1992,
        address = {North-Holland},
        title = {Experience with embedding hardware description languages in {HOL}},
        volume = {10},
        isbn = {0-444-89686-4},
        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.},
        language = {en},
        booktitle = {{IFIP} {TC10}/{WG}},
        publisher = {Elsevier},
        author = {Boulton, Richard and Gordon, Andrew and Gordon, Mike and Harrison, John and Herbert, John and Tassel, John Van},
        editor = {Stavridou, Victoria and Melham, Thomas F. and Boute, Raymond T.},
        year = {1992},
        note = {event-place: Nijmegen, NL},
        pages = {129--156},
        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},
}

@inproceedings{gibbons_folding_2014,
        address = {New York, NY, USA},
        series = {{ICFP} '14},
        title = {Folding {Domain}-{Specific} {Languages}: {Deep} and {Shallow} {Embeddings} ({Functional} {Pearl})},
        isbn = {978-1-4503-2873-9},
        url = {https://doi.org/10.1145/2628136.2628138},
        doi = {10.1145/2628136.2628138},
        abstract = {A domain-specific language can be implemented by embedding within a general-purpose host language. This embedding may be deep or shallow, depending on whether terms in the language construct syntactic or semantic representations. The deep and shallow styles are closely related, and intimately connected to folds; in this paper, we explore that connection.},
        booktitle = {Proceedings of the 19th {ACM} {SIGPLAN} {International} {Conference} on {Functional} {Programming}},
        publisher = {Association for Computing Machinery},
        author = {Gibbons, Jeremy and Wu, Nicolas},
        year = {2014},
        note = {event-place: Gothenburg, Sweden},
        keywords = {domain-specific languages, deep and shallow embedding, folds},
        pages = {339--347},
        file = {Gibbons and Wu - 2014 - Folding Domain-Specific Languages Deep and Shallo.pdf:/home/mrl/.local/share/zotero/storage/6WNWSLFJ/Gibbons and Wu - 2014 - Folding Domain-Specific Languages Deep and Shallo.pdf:application/pdf},
}

@inproceedings{oliveira_typecase_2005,
        address = {New York, NY, USA},
        series = {Haskell '05},
        title = {{TypeCase}: {A} {Design} {Pattern} for {Type}-{Indexed} {Functions}},
        isbn = {1-59593-071-X},
        url = {https://doi.org/10.1145/1088348.1088358},
        doi = {10.1145/1088348.1088358},
        abstract = {A type-indexed function is a function that is defined for each member of some family of types. Haskell's type class mechanism provides collections of open type-indexed functions, in which the indexing family can be extended by defining a new type class instance but the collection of functions is fixed. The purpose of this paper is to present TypeCase: a design pattern that allows the definition of closed type-indexed functions, in which the index family is fixed but the collection of functions is extensible. It is inspired by Cheney and Hinze's work on lightweight approaches to generic programming. We generalise their techniques as a design pattern. Furthermore, we show that type-indexed functions with type-indexed types, and consequently generic functions with generic types, can also be encoded in a lightweight manner, thereby overcoming one of the main limitations of the lightweight approaches.},
        booktitle = {Proceedings of the 2005 {ACM} {SIGPLAN} {Workshop} on {Haskell}},
        publisher = {Association for Computing Machinery},
        author = {Oliveira, Bruno C. d. S. and Gibbons, Jeremy},
        year = {2005},
        note = {event-place: Tallinn, Estonia},
        keywords = {generic programming, type classes, type-indexed functions},
        pages = {98--109},
        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},
}

@inproceedings{odersky_putting_1996,
        address = {New York, NY, USA},
        series = {{POPL} '96},
        title = {Putting {Type} {Annotations} to {Work}},
        isbn = {0-89791-769-3},
        url = {https://doi.org/10.1145/237721.237729},
        doi = {10.1145/237721.237729},
        abstract = {We study an extension of the Hindley/Milner system with explicit type scheme annotations and type declarations. The system can express polymorphic function arguments, user-defined data types with abstract components, and structure types with polymorphic fields. More generally, all programs of the polymorphic lambda calculus can be encoded by a translation between typing derivations. We show that type reconstruction in this system can be reduced to the decidable problem of first-order unification under a mixed prefix.},
        booktitle = {Proceedings of the 23rd {ACM} {SIGPLAN}-{SIGACT} {Symposium} on {Principles} of {Programming} {Languages}},
        publisher = {Association for Computing Machinery},
        author = {Odersky, Martin and Läufer, Konstantin},
        year = {1996},
        note = {event-place: St. Petersburg Beach, Florida, USA},
        pages = {54--67},
        file = {Odersky and Läufer - 1996 - Putting Type Annotations to Work.pdf:/home/mrl/.local/share/zotero/storage/WC37TU5H/Odersky and Läufer - 1996 - Putting Type Annotations to Work.pdf:application/pdf},
}

@article{carette_finally_2009,
        title = {Finally tagless, partially evaluated: {Tagless} staged interpreters for simpler typed languages},
        volume = {19},
        doi = {10.1017/S0956796809007205},
        number = {5},
        journal = {Journal of Functional Programming},
        author = {Carette, Jacques and Kiselyov, Oleg and Shan, Chung-Chieh},
        year = {2009},
        note = {Publisher: Cambridge University Press},
        pages = {509--543},
        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},
}

@techreport{plasmeijer_clean_2021,
        address = {Nijmegen},
        title = {Clean {Language} {Report} version 3.1},
        urldate = {2021-12-22},
        institution = {Institute for Computing and Information Sciences},
        author = {Plasmeijer, Rinus and van Eekelen, Marko and van Groningen, John},
        month = dec,
        year = {2021},
        pages = {127},
        file = {CleanLanguageReport.pdf:/home/mrl/.local/share/zotero/storage/I2SDRIH6/CleanLanguageReport.pdf:application/pdf},
}

@inproceedings{nocker_concurrent_1991,
        address = {Berlin, Heidelberg},
        title = {Concurrent clean},
        isbn = {978-3-540-47472-2},
        abstract = {Concurrent Clean is an experimental, lazy, higher-order parallel functional programming language based on term graph rewriting. An important difference with other languages is that in Clean graphs are manipulated and not terms. This can be used by the programmer to control communication and sharing of computation. Cyclic structures can be defined. Concurrent Clean furthermore allows to control the (parallel) order of evaluation to make efficient evaluation possible. With help of sequential annotations the default lazy evaluation can be locally changed into eager evaluation. The language enables the definition of partially strict data structures which make a whole new class of algorithms feasible in a functional language. A powerful and fast strictness analyser is incorporated in the system. The quality of the code generated by the Clean compiler has been greatly improved such that it is one of the best code generators for a lazy functional language. Two very powerful parallel annotations enable the programmer to define concurrent functional programs with arbitrary process topologies. Concurrent Clean is set up in such a way that the efficiency achieved for the sequential case can largely be maintained for a parallel implementation on loosely coupled parallel machine architectures.},
        booktitle = {{PARLE} '91 {Parallel} {Architectures} and {Languages} {Europe}},
        publisher = {Springer Berlin Heidelberg},
        author = {Nöcker, E. G. J. M. H. and Smetsers, J. E. W. and van Eekelen, M. C. J. D. and Plasmeijer, M. J.},
        editor = {Aarts, Emile H. L. and van Leeuwen, Jan and Rem, Martin},
        year = {1991},
        pages = {202--219},
        file = {Nöcker et al. - 1991 - Concurrent clean.pdf:/home/mrl/.local/share/zotero/storage/XHTNR7BR/Nöcker et al. - 1991 - Concurrent clean.pdf:application/pdf},
}

@incollection{mernik_extensible_2013,
        address = {Hershey, PA, USA},
        title = {Extensible {Languages}: {Blurring} the {Distinction} between {DSL} and {GPL}},
        isbn = {978-1-4666-2092-6},
        url = {https://services.igi-global.com/resolvedoi/resolve.aspx?doi=10.4018/978-1-4666-2092-6.ch001},
        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.},
        booktitle = {Formal and {Practical} {Aspects} of {Domain}-{Specific} {Languages}: {Recent} {Developments}},
        publisher = {IGI Global},
        author = {Verna, Didier},
        editor = {Mernik, Marjan},
        year = {2013},
        doi = {10.4018/978-1-4666-2092-6.ch001},
        pages = {1--31},
}

@inproceedings{hudak_modular_1998,
        title = {Modular domain specific languages and tools},
        doi = {10.1109/ICSR.1998.685738},
        booktitle = {Proceedings. {Fifth} {International} {Conference} on {Software} {Reuse} ({Cat}. {No}.{98TB100203})},
        author = {Hudak, P.},
        year = {1998},
        pages = {134--142},
        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},
}

@book{fowler_domain_2010,
        edition = {1st},
        title = {Domain {Specific} {Languages}},
        isbn = {0-321-71294-3},
        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\#.},
        publisher = {Addison-Wesley Professional},
        author = {Fowler, Martin},
        year = {2010},
        file = {Fowler - 2010 - Domain-specific languages.pdf:/home/mrl/.local/share/zotero/storage/YYMYXTZ5/Fowler - 2010 - Domain-specific languages.pdf:application/pdf},
}

@misc{peter_t_lewis_speech_1985,
        address = {Washington, D.C.},
        type = {Speech},
        title = {Speech},
        url = {http://www.chetansharma.com/correcting-the-iot-history/},
        author = {{Peter T. Lewis}},
        month = sep,
        year = {1985},
}

@article{weiser_computer_1991,
        title = {The {Computer} for the 21 st {Century}},
        volume = {265},
        language = {en},
        number = {3},
        journal = {Scientific American},
        author = {Weiser, Mark},
        month = sep,
        year = {1991},
        pages = {94--105},
        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},
}

@misc{evans_internet_2011,
        title = {The {Internet} of {Things}: {How} the {Next} {Evolution} of the {Internet} {Is} {Changing} {Everything}},
        url = {https://www.cisco.com/c/dam/en_us/about/ac79/docs/innov/IoT_IBSG_0411FINAL.pdf},
        language = {en},
        publisher = {Cisco Internet Business Solutions Group (IBSG)},
        author = {Evans, Dave},
        month = apr,
        year = {2011},
        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},
}

@inproceedings{ireland_classification_2009,
        address = {Cancun, Mexico},
        title = {A {Classification} of {Object}-{Relational} {Impedance} {Mismatch}},
        isbn = {978-0-7695-3550-0},
        doi = {10.1109/DBKDA.2009.11},
        booktitle = {First {International} {Conference} on {Advances} in {Databases}, {Knowledge}, and {Data} {Applications}},
        publisher = {IEEE},
        author = {Ireland, Christopher and Bowers, David and Newton, Michael and Waugh, Kevin},
        year = {2009},
        pages = {36--43},
}

@techreport{cheney_first-class_2003,
        title = {First-class phantom types},
        url = {https://ecommons.cornell.edu/handle/1813/5614},
        number = {TR2003-1901},
        urldate = {2017-05-15},
        institution = {Cornell University},
        author = {Cheney, James and Hinze, Ralf},
        year = {2003},
        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},
}

@inproceedings{baars_typing_2002,
        address = {New York, NY, USA},
        series = {{ICFP} '02},
        title = {Typing {Dynamic} {Typing}},
        isbn = {1-58113-487-8},
        url = {https://doi.org/10.1145/581478.581494},
        doi = {10.1145/581478.581494},
        abstract = {Even when programming in a statically typed language we every now and then encounter statically untypable values; such values result from interpreting values or from communicating with the outside world. To cope with this problem most languages include some form of dynamic types. It may be that the core language has been explicitly extended with such a type, or that one is allowed to live dangerously by using functions like unsafeCoerce. We show how, by a careful use of existentially and universally quantified types, one may achievem the same effect, without extending the language with new or unsafe features. The techniques explained are universally applicable, provided the core language is expressive enough; this is the case for the common implementations of Haskell. The techniques are used in the description of a type checking compiler that, starting from an expression term, constructs a typed function representing the semantics of that expression. In this function the overhead associated with the type checking is only once being paid for; in this sense we have thus achieved static type checking.},
        booktitle = {Proceedings of the {Seventh} {ACM} {SIGPLAN} {International} {Conference} on {Functional} {Programming}},
        publisher = {Association for Computing Machinery},
        author = {Baars, Arthur I. and Swierstra, S. Doaitse},
        year = {2002},
        note = {event-place: Pittsburgh, PA, USA},
        keywords = {coercions, dynamic typing, Haskell, Leibnitz' rule, quantified types, static typing, type equality, typed interpreters},
        pages = {157--166},
        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},
}

@incollection{hinze_generic_2003,
        address = {Berlin, Heidelberg},
        title = {Generic {Haskell}: {Practice} and {Theory}},
        isbn = {978-3-540-45191-4},
        url = {https://doi.org/10.1007/978-3-540-45191-4_1},
        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.},
        booktitle = {Generic {Programming}: {Advanced} {Lectures}},
        publisher = {Springer Berlin Heidelberg},
        author = {Hinze, Ralf and Jeuring, Johan},
        editor = {Backhouse, Roland and Gibbons, Jeremy},
        year = {2003},
        doi = {10.1007/978-3-540-45191-4_1},
        pages = {1--56},
        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},
}

@misc{wadler_expression_1998,
        title = {The expression problem},
        url = {https://homepages.inf.ed.ac.uk/wadler/papers/expression/expression.txt},
        language = {en},
        urldate = {2021-02-24},
        author = {Wadler, Philip},
        month = nov,
        year = {1998},
        note = {e-mail message, accessed on 2021-02-24},
}

@misc{margaret_deuter_rhapsody_2015,
        address = {Oxford},
        edition = {Ninth edition},
        title = {Rhapsody},
        journal = {Oxford Advanced Learner's Dictionary of Current English},
        publisher = {Oxford University Press},
        author = {{A S Hornby}},
        editor = {{Margaret Deuter} and {Jennifer Bradbery} and {Joanna Turnbull}},
        year = {2015},
}

@misc{wikipedia_contributors_rhapsody_2022,
        title = {Rhapsody (music) — {Wikipedia}, {The} {Free} {Encyclopedia}},
        url = {https://en.wikipedia.org/w/index.php?title=Rhapsody_(music)&oldid=1068385257},
        urldate = {2022-09-06},
        journal = {Wikipedia},
        author = {{Wikipedia contributors}},
        year = {2022},
        note = {accessed on: 2022-09-06},
}
@article{barendsen_uniqueness_1996,
        title = {Uniqueness typing for functional languages with graph rewriting semantics},
        volume = {6},
        number = {6},
        journal = {Mathematical structures in computer science},
        author = {Barendsen, Erik and Smetsers, Sjaak},
        year = {1996},
        pages = {579--612},
        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},
}

@incollection{backus_introduction_1990,
        address = {USA},
        title = {An {Introduction} to the {Programming} {Language} {FL}},
        isbn = {0-201-17236-4},
        booktitle = {Research {Topics} in {Functional} {Programming}},
        publisher = {Addison-Wesley Longman Publishing Co., Inc.},
        author = {Backus, John and Williams, John H. and Wimmers, Edward L.},
        year = {1990},
        pages = {219--247},
}

@article{achten_ins_1995,
        title = {The ins and outs of {Clean} {I}/{O}},
        volume = {5},
        doi = {10.1017/S0956796800001258},
        number = {1},
        journal = {Journal of Functional Programming},
        author = {Achten, Peter and Plasmeijer, Rinus},
        year = {1995},
        note = {Publisher: Cambridge University Press},
        pages = {81--110},
}

@inproceedings{peyton_jones_imperative_1993,
        address = {New York, NY, USA},
        series = {{POPL} '93},
        title = {Imperative {Functional} {Programming}},
        isbn = {0-89791-560-7},
        url = {https://doi.org/10.1145/158511.158524},
        doi = {10.1145/158511.158524},
        abstract = {We present a new model, based on monads, for performing input/output in a non-strict, purely functional language. It is composable, extensible, efficient, requires no extensions to the type system, and extends smoothly to incorporate mixed-language working and in-place array updates.},
        booktitle = {Proceedings of the 20th {ACM} {SIGPLAN}-{SIGACT} {Symposium} on {Principles} of {Programming} {Languages}},
        publisher = {Association for Computing Machinery},
        author = {Peyton Jones, Simon L. and Wadler, Philip},
        year = {1993},
        note = {event-place: Charleston, South Carolina, USA},
        pages = {71--84},
        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},
}

@inproceedings{achten_high_1993,
        address = {London},
        title = {High {Level} {Specification} of {I}/{O} in {Functional} {Languages}},
        isbn = {978-1-4471-3215-8},
        abstract = {The interface with the outside world has always been one of the weakest points of functional languages. It is not easy to incorporate I/O without being allowed to do side-effects. Furthermore, functional languages allow redexes to be evaluated in any order while I/O generally has to be performed in a very specific order. In this paper we present a new solution for the I/O problem which we have incorporated in the language Concurrent Clean. Concurrent Clean offers a linear type system called Unique Types. It makes it possible to define functions with side-effects without violating the functional semantics. Now it is possible to change any object in the world in the way we wanted: e.g. arrays can be updated in-situ, arbitrary file manipulation is possible. We have used this powerful tool among others to create a library for window based I/O. Using an explicit environment passing scheme provides a high-level and elegant functional specification method for I/O, called Event I/O. Now the specification of I/O has become one of the strengths of functional languages: interactive programs written in Concurrent Clean are concise, easy to write and comprehend as well as efficient. The presented solution can in principle be applied for any other functional language as well provided that it actually uses graph rewriting semantics in the implementation.},
        booktitle = {Functional {Programming}, {Glasgow} 1992},
        publisher = {Springer London},
        author = {Achten, Peter and van Groningen, John and Plasmeijer, Rinus},
        editor = {Launchbury, John and Sansom, Patrick},
        year = {1993},
        pages = {1--17},
        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},
}