2 @mastersthesis
{crooijmans_reducing_2021
,
4 title = {Reducing the
{Power
} {Consumption
} of
{IoT
} {Devices
} in
{Task
}-{Oriented
} {Programming
}},
6 school = {Radboud University
},
7 author = {Crooijmans
, Sjoerd
},
10 file
= {Crooijmans
- 2021 - Reducing the Power Consumption of IoT Devices in T.pdf
:/home
/mrl
/.local
/share
/zotero
/storage
/98LY
9YHH
/Crooijmans
- 2021 - Reducing the Power Consumption of IoT Devices in T.pdf
:application
/pdf
},
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
},
25 note = {event
-place
: Leuven
, Belgium
},
26 keywords = {clean
, task
-oriented programming
},
28 file
= {103802.pdf
:/home
/mrl
/.local
/share
/zotero
/storage
/ZE6A65AW
/103802.pdf
:application
/pdf
},
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
},
42 file
= {brut87
-Clean.ps.gz
:/home
/mrl
/.local
/share
/zotero
/storage
/T2QATWIE
/brut87
-Clean.ps.gz
:application
/gzip
},
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
},
53 file
= {Constraint Kinds for GHC
:/home
/mrl
/.local
/share
/zotero
/storage
/R6RL79K7
/constraint
-kinds
-for
-ghc.html
:text
/html
},
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
},
68 note = {event
-place
: St. Petersburg Beach
, Florida
, USA
},
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
},
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.
},
85 note = {event
-place
: Atlanta
, Georgia
, USA
},
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
},
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
},
102 note = {event
-place
: Victoria
, BC
, Canada
},
103 keywords = {compiler verification
, dependent types
, interactive proof assistants
, type-theoretic semantics
},
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
},
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
},
119 doi
= {10.1007/978-1-4612-6315-9_22
},
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
},
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
},
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
},
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
},
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
},
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
},
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
},
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
},
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
},
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
},
179 @techreport
{hughes_restricted_1999
,
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
},
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
},
190 @article
{najd_trees_2017
,
191 title = {Trees that
{Grow
}},
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.
},
195 journal = {Journal of Universal Computer Science
},
196 author = {Najd
, Shayan and Peyton Jones
, Simon
},
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
},
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
},
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
},
218 file
= {OpenDatatypes.pdf
:/home
/mrl
/.local
/share
/zotero
/storage
/NEP9GZ9N
/OpenDatatypes.pdf
:application
/pdf
},
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
},
233 note = {event
-place
: Baltimore
, Maryland
, USA
},
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
},
238 @article
{abadi_dynamic_1991
,
239 title = {Dynamic
{Typing
} in a
{Statically
} {Typed
} {Language
}},
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.
},
246 journal = {ACM Trans. Program. Lang. Syst.
},
247 author = {Abadi
, Martín and Cardelli
, Luca and Pierce
, Benjamin and Plotkin
, Gordon
},
250 note = {Place
: New York
, NY
, USA
251 Publisher
: Association for Computing Machinery
},
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
},
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
},
269 file
= {svenningsson2013combining.pdf
:/home
/mrl
/.local
/share
/zotero
/storage
/NFBGZCZT
/svenningsson2013combining.pdf
:application
/pdf
},
272 @article
{mitchell_abstract_1988
,
273 title = {Abstract
{Types
} {Have
} {Existential
} {Type
}},
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.
},
280 journal = {ACM Trans. Program. Lang. Syst.
},
281 author = {Mitchell
, John C. and Plotkin
, Gordon D.
},
284 note = {Place
: New York
, NY
, USA
285 Publisher
: Association for Computing Machinery
},
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
},
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
},
302 note = {event
-place
: Philadelphia
, Pennsylvania
, USA
},
303 keywords = {haskell
, kinds
, polymorphism
, promotion
},
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
},
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
},
320 note = {event
-place
: Edinburgh
, Scotland
},
321 keywords = {domain
-specific languages
, higher
-order
abstract syntax
, type classes
, unembedding
},
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
},
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
},
336 note = {event
-place
: Brussels
, Belgium
},
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
},
341 @incollection
{gibbons_functional_2015
,
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
},
352 doi
= {10.1007/978-3-319-15940-9_1
},
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
},
357 @phdthesis
{alimarine_generic_2005
,
358 address = {Nijmegen
},
360 title = {Generic
{Functional
} {Programming
}},
362 school = {Radboud University
},
363 author = {Alimarine
, Artem
},
365 file
= {Alimarine
- Generic Functional Programming.pdf
:/home
/mrl
/.local
/share
/zotero
/storage
/PDTS3SGX
/Alimarine
- Generic Functional Programming.pdf
:application
/pdf
},
368 @inproceedings
{barendregt_towards_1987
,
369 title = {Towards an intermediate language for graph rewriting
},
371 booktitle = {{PARLE
}, {Parallel
} {Architectures
} and
{Languages
} {Europe
}},
372 publisher = {Springer Verlag
},
373 author = {Barendregt
, HP and van Eekelen
, MCJD and Glauert
, JRW and Kennaway
, JR and Plasmeijer
, MJ and Sleep
, MR
},
376 file
= {barh87
-Lean.ps.gz
:/home
/mrl
/.local
/share
/zotero
/storage
/63FBHND7
/barh87
-Lean.ps.gz
:application
/gzip
},
379 @incollection
{wang_maintaining_2018
,
381 title = {Maintaining
{Separation
} of
{Concerns
} {Through
} {Task
} {Oriented
} {Software
} {Development
}},
383 isbn
= {978-3-319-89718-9 978-3-319-89719-6},
384 url
= {http
://link.springer.com
/10.1007/978-3-319-89719-6_2
},
385 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.
},
387 urldate
= {2019-01-14},
388 booktitle = {Trends in
{Functional
} {Programming
}},
389 publisher = {Springer International Publishing
},
390 author = {Stutterheim
, Jurriën and Achten
, Peter and Plasmeijer
, Rinus
},
391 editor = {Wang
, Meng and Owens
, Scott
},
393 doi
= {10.1007/978-3-319-89719-6},
395 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
},
398 @mastersthesis
{bohm_asynchronous_2019
,
399 address = {Nijmegen
},
400 title = {Asynchronous
{Actions
} in a
{Synchronous
} {World
}},
401 abstract = {This thesis introduces a system for asynchronous communication in the iTasks framework. The
402 framework is written in Clean
, a pure
, lazy
, functional language. Tasks need to be able to access
403 data in the system and retrieve data from all kinds of data sources. The share system allows
404 tasks to read arbitrary data sources and provides a simple interface that allows composition of
405 different data sources. This system allows tasks to share and store data in an efficient
, re
-usable
407 A disadvantage of the share system is that it does not allow asynchronous evaluation. When
408 one task is using a share
, other tasks have to wait for the full evaluation of this share before they
409 can be evaluated. This has the effect that users in the iTasks framework must wait on other
410 users. This results in poor user experience.
411 We implement a share system which
, by way of share rewriting
, allows asynchronous evalua
-
412 tion. The system can be used to communicate with arbitrary services on the internet
, as well as
413 to communicate between different iTasks servers in a distributed context.
414 We show how asynchronous shares are implemented and what the limitations are. We also
415 show multiple practical examples of using asynchronous shares. The new system can be effectively
416 used to consume services on the internet. It fits nicely into existing iTasks programs and requires
417 few changes in existing programs.
},
419 school = {Radboud University
},
420 author = {Böhm
, Haye
},
423 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
},
426 @inproceedings
{hentschel_supersensors
:_2016
,
427 address = {Vienna
, Austria
},
428 title = {Supersensors
: {Raspberry
} {Pi
} {Devices
} for
{Smart
} {Campus
} {Infrastructure
}},
429 isbn
= {978-1-5090-4052-0},
430 shorttitle
= {Supersensors
},
431 url
= {http
://ieeexplore.ieee.org
/document
/7575844/},
432 doi
= {10.1109/FiCloud
.2016.16},
433 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.
},
435 urldate
= {2019-09-04},
436 booktitle = {2016 {IEEE
} 4th
{International
} {Conference
} on
{Future
} {Internet
} of
{Things
} and
{Cloud
} ({FiCloud
})},
438 author = {Hentschel
, Kristian and Jacob
, Dejice and Singer
, Jeremy and Chalmers
, Matthew
},
442 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
},
445 @misc
{achten_clean_2007
,
446 title = {Clean for
{Haskell98
} {Programmers
}},
447 url
= {https
://www.mbsd.cs.ru.nl
/publications
/papers
/2007/achp2007
-CleanHaskellQuickGuide.pdf
},
449 author = {Achten
, Peter
},
452 file
= {Achten
- Clean for Haskell98 Programmers.pdf
:/home
/mrl
/.local
/share
/zotero
/storage
/69WWSGLF
/Achten
- Clean for Haskell98 Programmers.pdf
:application
/pdf
},
455 @inproceedings
{baccelli_reprogramming_2018
,
456 title = {Reprogramming
{Low
}-end
{IoT
} {Devices
} from the
{Cloud
}},
457 booktitle = {2018 3rd
{Cloudification
} of the
{Internet
} of
{Things
} ({CIoT
})},
459 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
},
462 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
},
465 @inproceedings
{baccelli_scripting_2018
,
466 title = {Scripting
{Over
}-{The
}-{Air
}: {Towards
} {Containers
} on
{Low
}-end
{Devices
} in the
{Internet
} of
{Things
}},
467 booktitle = {{IEEE
} {PerCom
} 2018},
468 author = {Baccelli
, Emmanuel and Doerr
, Joerg and Kikuchi
, Shinji and Padilla
, Francisco and Schleiser
, Kaspar and Thomas
, Ian
},
470 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
},
473 @mastersthesis
{amazonas_cabral_de_andrade_developing_2018
,
474 address = {Nijmegen
},
475 title = {Developing
{Real
} {Life
}, {Task
} {Oriented
} {Applications
} for the
{Internet
} of
{Things
}},
476 shorttitle
= {Developing
{Real
} {Life
}, {TOP
} {Applications
} for the
{IOT
}},
478 school = {Radboud University
},
479 author = {Amazonas Cabral De Andrade
, Matheus
},
481 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
},
484 @article
{swierstra_data_2008
,
485 title = {Data types à la carte
},
487 doi
= {10.1017/S0956796808006758
},
489 journal = {Journal of functional programming
},
490 author = {Swierstra
, Wouter
},
493 file
= {swierstra2008.pdf
:/home
/mrl
/.local
/share
/zotero
/storage
/BEQKBXWP
/swierstra2008.pdf
:application
/pdf
},
496 @article
{groningen_exchanging_2010
,
497 title = {Exchanging sources between
{Clean
} and
{Haskell
}: {A
} double
-edged front end for the
{Clean
} compiler
},
499 shorttitle
= {Exchanging sources between
{Clean
} and
{Haskell
}},
501 journal = {ACM Sigplan Notices
},
502 author = {Groningen
, John van and Noort
, Thomas van and Achten
, Peter and Koopman
, Pieter and Plasmeijer
, Rinus
},
505 file
= {groj10
-Haskell_front_end_Clean.pdf
:/home
/mrl
/.local
/share
/zotero
/storage
/WVZWX8WT
/groj10
-Haskell_front_end_Clean.pdf
:application
/pdf
},
508 @inproceedings
{cheney_lightweight_2002
,
509 title = {A lightweight implementation of generics and dynamics
},
510 url
= {http
://dl.acm.org
/citation.cfm?id
=581698},
511 doi
= {10.1145/581690.581698},
512 urldate
= {2017-05-15},
513 booktitle = {Proceedings of the
2002 {ACM
} {SIGPLAN
} workshop on
{Haskell
}},
515 author = {Cheney
, James and Hinze
, Ralf
},
517 note = {event
-place
: Pittsburgh Pennsylvania
, USA
},
518 keywords = {dynamic typing
, generic programming
, type representations
},
520 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
},
523 @article
{tratt_domain_2008
,
524 title = {Domain
{Specific
} {Language
} {Implementation
} via
{Compile
}-{Time
} {Meta
}-{Programming
}},
527 url
= {https
://doi.org
/10.1145/1391956.1391958},
528 doi
= {10.1145/1391956.1391958},
529 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.
},
531 journal = {ACM Trans. Program. Lang. Syst.
},
532 author = {Tratt
, Laurence
},
535 note = {Place
: New York
, NY
, USA
536 Publisher
: Association for Computing Machinery
},
537 keywords = {domain specific languages
, compile
-time meta
-programming
, Syntax extension
},
538 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
},
541 @book
{peyton_jones_implementation_1987
,
542 title = {The
{Implementation
} of
{Functional
} {Programming
} {Languages
}},
543 url
= {https
://www.microsoft.com
/en
-us
/research
/publication
/the
-implementation
-of
-functional
-programming
-languages
/},
544 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".
},
545 publisher = {Prentice Hall
},
546 author = {Peyton Jones
, Simon
},
549 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
},
552 @article
{elliott_compiling_2003
,
553 title = {Compiling embedded languages
},
555 doi
= {10.1017/S0956796802004574
},
557 journal = {Journal of Functional Programming
},
558 author = {Elliott
, Conal and Finne
, Sigbjørn and de Moor
, Oege
},
560 note = {Publisher
: Cambridge University Press
},
562 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
},
565 @inproceedings
{sheard_accomplishments_2001
,
566 address = {Berlin
, Heidelberg
},
567 title = {Accomplishments and
{Research
} {Challenges
} in
{Meta
}-programming
},
568 isbn
= {978-3-540-44806-8},
569 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.
},
570 booktitle = {Semantics
, {Applications
}, and
{Implementation
} of
{Program
} {Generation
}},
571 publisher = {Springer Berlin Heidelberg
},
572 author = {Sheard
, Tim
},
573 editor = {Taha
, Walid
},
576 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
},
579 @incollection
{kiselyov_typed_2012
,
580 address = {Berlin
, Heidelberg
},
581 title = {Typed
{Tagless
} {Final
} {Interpreters
}},
582 isbn
= {978-3-642-32202-0},
583 url
= {https
://doi.org
/10.1007/978-3-642-32202-0_3
},
584 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.
},
585 booktitle = {Generic and
{Indexed
} {Programming
}: {International
} {Spring
} {School
}, {SSGIP
} 2010, {Oxford
}, {UK
}, {March
} 22-26, 2010, {Revised
} {Lectures
}},
586 publisher = {Springer Berlin Heidelberg
},
587 author = {Kiselyov
, Oleg
},
588 editor = {Gibbons
, Jeremy
},
590 doi
= {10.1007/978-3-642-32202-0_3
},
592 file
= {Kiselyov
- 2012 - Typed Tagless Final Interpreters.pdf
:/home
/mrl
/.local
/share
/zotero
/storage
/9NBYZLRP
/Kiselyov
- 2012 - Typed Tagless Final Interpreters.pdf
:application
/pdf
},
595 @article
{laufer_type_1996
,
596 title = {Type classes with existential types
},
598 doi
= {10.1017/S0956796800001817
},
600 journal = {Journal of Functional Programming
},
601 author = {Läufer
, Konstantin
},
603 note = {Publisher
: Cambridge University Press
},
605 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
},
608 @incollection
{hinze_fun_2003
,
609 address = {Palgrave
},
610 series = {Cornerstones of
{Computing
}},
611 title = {Fun
{With
} {Phantom
} {Types
}},
612 isbn
= {978-0-333-99285-2},
613 booktitle = {The
{Fun
} of
{Programming
}},
614 publisher = {Bloomsbury Publishing
},
615 author = {Hinze
, Ralf
},
616 editor = {Gibbons
, Jeremy and de Moor
, Oege
},
621 @inproceedings
{boulton_experience_1992
,
622 address = {North
-Holland
},
623 title = {Experience with embedding hardware description languages in
{HOL
}},
625 isbn
= {0-444-89686-4},
626 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.
},
628 booktitle = {{IFIP
} {TC10
}/{WG
}},
629 publisher = {Elsevier
},
630 author = {Boulton
, Richard and Gordon
, Andrew and Gordon
, Mike and Harrison
, John and Herbert
, John and Tassel
, John Van
},
631 editor = {Stavridou
, Victoria and Melham
, Thomas F. and Boute
, Raymond T.
},
633 note = {event
-place
: Nijmegen
, NL
},
635 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
},
638 @inproceedings
{gibbons_folding_2014
,
639 address = {New York
, NY
, USA
},
640 series = {{ICFP
} '
14},
641 title = {Folding
{Domain
}-{Specific
} {Languages
}: {Deep
} and
{Shallow
} {Embeddings
} ({Functional
} {Pearl
})},
642 isbn
= {978-1-4503-2873-9},
643 url
= {https
://doi.org
/10.1145/2628136.2628138},
644 doi
= {10.1145/2628136.2628138},
645 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.
},
646 booktitle = {Proceedings of the
19th
{ACM
} {SIGPLAN
} {International
} {Conference
} on
{Functional
} {Programming
}},
647 publisher = {Association for Computing Machinery
},
648 author = {Gibbons
, Jeremy and Wu
, Nicolas
},
650 note = {event
-place
: Gothenburg
, Sweden
},
651 keywords = {domain
-specific languages
, deep and shallow embedding
, folds
},
653 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
},
656 @inproceedings
{oliveira_typecase_2005
,
657 address = {New York
, NY
, USA
},
658 series = {Haskell '
05},
659 title = {{TypeCase
}: {A
} {Design
} {Pattern
} for
{Type
}-{Indexed
} {Functions
}},
660 isbn
= {1-59593-071-X
},
661 url
= {https
://doi.org
/10.1145/1088348.1088358},
662 doi
= {10.1145/1088348.1088358},
663 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.
},
664 booktitle = {Proceedings of the
2005 {ACM
} {SIGPLAN
} {Workshop
} on
{Haskell
}},
665 publisher = {Association for Computing Machinery
},
666 author = {Oliveira
, Bruno C. d. S. and Gibbons
, Jeremy
},
668 note = {event
-place
: Tallinn
, Estonia
},
669 keywords = {generic programming
, type classes
, type-indexed functions
},
671 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
},
674 @inproceedings
{odersky_putting_1996
,
675 address = {New York
, NY
, USA
},
676 series = {{POPL
} '
96},
677 title = {Putting
{Type
} {Annotations
} to
{Work
}},
678 isbn
= {0-89791-769-3},
679 url
= {https
://doi.org
/10.1145/237721.237729},
680 doi
= {10.1145/237721.237729},
681 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.
},
682 booktitle = {Proceedings of the
23rd
{ACM
} {SIGPLAN
}-{SIGACT
} {Symposium
} on
{Principles
} of
{Programming
} {Languages
}},
683 publisher = {Association for Computing Machinery
},
684 author = {Odersky
, Martin and Läufer
, Konstantin
},
686 note = {event
-place
: St. Petersburg Beach
, Florida
, USA
},
688 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
},
691 @article
{carette_finally_2009
,
692 title = {Finally tagless
, partially evaluated
: {Tagless
} staged interpreters for simpler typed languages
},
694 doi
= {10.1017/S0956796809007205
},
696 journal = {Journal of Functional Programming
},
697 author = {Carette
, Jacques and Kiselyov
, Oleg and Shan
, Chung
-Chieh
},
699 note = {Publisher
: Cambridge University Press
},
701 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
},
704 @techreport
{plasmeijer_clean_2021
,
705 address = {Nijmegen
},
706 title = {Clean
{Language
} {Report
} version
3.1},
707 urldate
= {2021-12-22},
708 institution = {Institute for Computing and Information Sciences
},
709 author = {Plasmeijer
, Rinus and van Eekelen
, Marko and van Groningen
, John
},
713 file
= {CleanLanguageReport.pdf
:/home
/mrl
/.local
/share
/zotero
/storage
/I2SDRIH6
/CleanLanguageReport.pdf
:application
/pdf
},
716 @inproceedings
{nocker_concurrent_1991
,
717 address = {Berlin
, Heidelberg
},
718 title = {Concurrent clean
},
719 isbn
= {978-3-540-47472-2},
720 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.
},
721 booktitle = {{PARLE
} '
91 {Parallel
} {Architectures
} and
{Languages
} {Europe
}},
722 publisher = {Springer Berlin Heidelberg
},
723 author = {Nöcker
, E. G. J. M. H. and Smetsers
, J. E. W. and van Eekelen
, M. C. J. D. and Plasmeijer
, M. J.
},
724 editor = {Aarts
, Emile H. L. and van Leeuwen
, Jan and Rem
, Martin
},
727 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
},
730 @incollection
{mernik_extensible_2013
,
731 address = {Hershey
, PA
, USA
},
732 title = {Extensible
{Languages
}: {Blurring
} the
{Distinction
} between
{DSL
} and
{GPL
}},
733 isbn
= {978-1-4666-2092-6},
734 url
= {https
://services.igi
-global.com
/resolvedoi
/resolve.aspx?doi
=10.4018/978-1-4666-2092-6.ch001
},
735 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.
},
736 booktitle = {Formal and
{Practical
} {Aspects
} of
{Domain
}-{Specific
} {Languages
}: {Recent
} {Developments
}},
737 publisher = {IGI Global
},
738 author = {Verna
, Didier
},
739 editor = {Mernik
, Marjan
},
741 doi
= {10.4018/978-1-4666-2092-6.ch001
},
745 @inproceedings
{hudak_modular_1998
,
746 title = {Modular domain specific languages and tools
},
747 doi
= {10.1109/ICSR
.1998.685738},
748 booktitle = {Proceedings.
{Fifth
} {International
} {Conference
} on
{Software
} {Reuse
} ({Cat
}.
{No
}.
{98TB100203
})},
749 author = {Hudak
, P.
},
752 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
},
755 @book
{fowler_domain_2010
,
757 title = {Domain
{Specific
} {Languages
}},
758 isbn
= {0-321-71294-3},
759 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\#.
},
760 publisher = {Addison
-Wesley Professional
},
761 author = {Fowler
, Martin
},
763 file
= {Fowler
- 2010 - Domain
-specific languages.pdf
:/home
/mrl
/.local
/share
/zotero
/storage
/YYMYXTZ5
/Fowler
- 2010 - Domain
-specific languages.pdf
:application
/pdf
},
766 @misc
{peter_t_lewis_speech_1985
,
767 address = {Washington
, D.C.
},
770 url
= {http
://www.chetansharma.com
/correcting
-the
-iot
-history
/},
771 author = {{Peter T. Lewis
}},
776 @article
{weiser_computer_1991
,
777 title = {The
{Computer
} for the
21 st
{Century
}},
781 journal = {Scientific American
},
782 author = {Weiser
, Mark
},
786 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
},
789 @misc
{evans_internet_2011
,
790 title = {The
{Internet
} of
{Things
}: {How
} the
{Next
} {Evolution
} of the
{Internet
} {Is
} {Changing
} {Everything
}},
791 url
= {https
://www.cisco.com
/c
/dam
/en_us
/about
/ac79
/docs
/innov
/IoT_IBSG_0411FINAL.pdf
},
793 publisher = {Cisco Internet Business Solutions Group
(IBSG
)},
794 author = {Evans
, Dave
},
797 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
},
800 @inproceedings
{ireland_classification_2009
,
801 address = {Cancun
, Mexico
},
802 title = {A
{Classification
} of
{Object
}-{Relational
} {Impedance
} {Mismatch
}},
803 isbn
= {978-0-7695-3550-0},
804 doi
= {10.1109/DBKDA
.2009.11},
805 booktitle = {First
{International
} {Conference
} on
{Advances
} in
{Databases
}, {Knowledge
}, and
{Data
} {Applications
}},
807 author = {Ireland
, Christopher and Bowers
, David and Newton
, Michael and Waugh
, Kevin
},
812 @techreport
{cheney_first
-class_2003
,
813 title = {First
-class phantom types
},
814 url
= {https
://ecommons.cornell.edu
/handle
/1813/5614},
815 number = {TR2003
-1901},
816 urldate
= {2017-05-15},
817 institution = {Cornell University
},
818 author = {Cheney
, James and Hinze
, Ralf
},
820 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
},
823 @inproceedings
{baars_typing_2002
,
824 address = {New York
, NY
, USA
},
825 series = {{ICFP
} '
02},
826 title = {Typing
{Dynamic
} {Typing
}},
827 isbn
= {1-58113-487-8},
828 url
= {https
://doi.org
/10.1145/581478.581494},
829 doi
= {10.1145/581478.581494},
830 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.
},
831 booktitle = {Proceedings of the
{Seventh
} {ACM
} {SIGPLAN
} {International
} {Conference
} on
{Functional
} {Programming
}},
832 publisher = {Association for Computing Machinery
},
833 author = {Baars
, Arthur I. and Swierstra
, S. Doaitse
},
835 note = {event
-place
: Pittsburgh
, PA
, USA
},
836 keywords = {coercions
, dynamic typing
, Haskell
, Leibnitz' rule
, quantified types
, static typing
, type equality
, typed interpreters
},
838 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
},
841 @incollection
{hinze_generic_2003
,
842 address = {Berlin
, Heidelberg
},
843 title = {Generic
{Haskell
}: {Practice
} and
{Theory
}},
844 isbn
= {978-3-540-45191-4},
845 url
= {https
://doi.org
/10.1007/978-3-540-45191-4_1
},
846 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.
},
847 booktitle = {Generic
{Programming
}: {Advanced
} {Lectures
}},
848 publisher = {Springer Berlin Heidelberg
},
849 author = {Hinze
, Ralf and Jeuring
, Johan
},
850 editor = {Backhouse
, Roland and Gibbons
, Jeremy
},
852 doi
= {10.1007/978-3-540-45191-4_1
},
854 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
},
857 @misc
{wadler_expression_1998
,
858 title = {The expression problem
},
859 url
= {https
://homepages.inf.ed.ac.uk
/wadler
/papers
/expression
/expression.txt
},
861 urldate
= {2021-02-24},
862 author = {Wadler
, Philip
},
865 note = {e
-mail message
, accessed on
2021-02-24},
868 @misc
{margaret_deuter_rhapsody_2015
,
870 edition
= {Ninth edition
},
872 journal = {Oxford Advanced Learner's Dictionary of Current English
},
873 publisher = {Oxford University Press
},
874 author = {{A S Hornby
}},
875 editor = {{Margaret Deuter
} and
{Jennifer Bradbery
} and
{Joanna Turnbull
}},
879 @misc
{wikipedia_contributors_rhapsody_2022
,
880 title = {Rhapsody
(music
) —
{Wikipedia
}, {The
} {Free
} {Encyclopedia
}},
881 url
= {https
://en.wikipedia.org
/w
/index.php?
title=Rhapsody_
(music
)&oldid
=1068385257},
882 urldate
= {2022-09-06},
883 journal = {Wikipedia
},
884 author = {{Wikipedia contributors
}},
886 note = {accessed on
: 2022-09-06},
888 @article
{barendsen_uniqueness_1996
,
889 title = {Uniqueness typing for functional languages with graph rewriting semantics
},
892 journal = {Mathematical structures in computer science
},
893 author = {Barendsen
, Erik and Smetsers
, Sjaak
},
896 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
},
899 @incollection
{backus_introduction_1990
,
901 title = {An
{Introduction
} to the
{Programming
} {Language
} {FL
}},
902 isbn
= {0-201-17236-4},
903 booktitle = {Research
{Topics
} in
{Functional
} {Programming
}},
904 publisher = {Addison
-Wesley Longman Publishing Co.
, Inc.
},
905 author = {Backus
, John and Williams
, John H. and Wimmers
, Edward L.
},
910 @article
{achten_ins_1995
,
911 title = {The ins and outs of
{Clean
} {I
}/{O
}},
913 doi
= {10.1017/S0956796800001258
},
915 journal = {Journal of Functional Programming
},
916 author = {Achten
, Peter and Plasmeijer
, Rinus
},
918 note = {Publisher
: Cambridge University Press
},
922 @inproceedings
{peyton_jones_imperative_1993
,
923 address = {New York
, NY
, USA
},
924 series = {{POPL
} '
93},
925 title = {Imperative
{Functional
} {Programming
}},
926 isbn
= {0-89791-560-7},
927 url
= {https
://doi.org
/10.1145/158511.158524},
928 doi
= {10.1145/158511.158524},
929 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.
},
930 booktitle = {Proceedings of the
20th
{ACM
} {SIGPLAN
}-{SIGACT
} {Symposium
} on
{Principles
} of
{Programming
} {Languages
}},
931 publisher = {Association for Computing Machinery
},
932 author = {Peyton Jones
, Simon L. and Wadler
, Philip
},
934 note = {event
-place
: Charleston
, South Carolina
, USA
},
936 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
},
939 @inproceedings
{achten_high_1993
,
941 title = {High
{Level
} {Specification
} of
{I
}/{O
} in
{Functional
} {Languages
}},
942 isbn
= {978-1-4471-3215-8},
943 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.
},
944 booktitle = {Functional
{Programming
}, {Glasgow
} 1992},
945 publisher = {Springer London
},
946 author = {Achten
, Peter and van Groningen
, John and Plasmeijer
, Rinus
},
947 editor = {Launchbury
, John and Sansom
, Patrick
},
950 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
},