2 @inproceedings
{plasmeijer_task
-oriented_2012
,
3 address = {New York
, NY
, USA
},
5 title = {Task
-{Oriented
} {Programming
} in a
{Pure
} {Functional
} {Language
}},
6 isbn
= {978-1-4503-1522-7},
7 url
= {https
://doi.org
/10.1145/2370776.2370801},
8 doi
= {10.1145/2370776.2370801},
9 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.
},
10 booktitle = {Proceedings of the
14th
{Symposium
} on
{Principles
} and
{Practice
} of
{Declarative
} {Programming
}},
11 publisher = {Association for Computing Machinery
},
12 author = {Plasmeijer
, Rinus and Lijnse
, Bas and Michels
, Steffen and Achten
, Peter and Koopman
, Pieter
},
14 note = {event
-place
: Leuven
, Belgium
},
15 keywords = {clean
, task
-oriented programming
},
17 file
= {103802.pdf
:/home
/mrl
/.local
/share
/zotero
/storage
/ZE6A65AW
/103802.pdf
:application
/pdf
},
20 @inproceedings
{brus_clean_1987
,
21 address = {Berlin
, Heidelberg
},
22 title = {Clean —
{A
} language for functional graph rewriting
},
23 isbn
= {978-3-540-47879-9},
24 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.
},
25 booktitle = {Functional
{Programming
} {Languages
} and
{Computer
} {Architecture
}},
26 publisher = {Springer Berlin Heidelberg
},
27 author = {Brus
, T. H. and van Eekelen
, M. C. J. D. and van Leer
, M. O. and Plasmeijer
, M. J.
},
28 editor = {Kahn
, Gilles
},
31 file
= {brut87
-Clean.ps.gz
:/home
/mrl
/.local
/share
/zotero
/storage
/T2QATWIE
/brut87
-Clean.ps.gz
:application
/gzip
},
34 @misc
{bolingbroke_constraint_2011
,
35 title = {Constraint
{Kinds
} for
{GHC
}},
36 url
= {http
://blog.omega
-prime.co.uk
/2011/09/10/constraint
-kinds
-for
-ghc
/},
37 urldate
= {2021-06-09},
38 journal = {:: (Bloggable a
) ={\textgreater
} a
-{\textgreater
} IO
()},
39 author = {Bolingbroke
, Max
},
42 file
= {Constraint Kinds for GHC
:/home
/mrl
/.local
/share
/zotero
/storage
/R6RL79K7
/constraint
-kinds
-for
-ghc.html
:text
/html
},
45 @inproceedings
{fegaras_revisiting_1996
,
46 address = {New York
, NY
, USA
},
47 series = {{POPL
} '
96},
48 title = {Revisiting
{Catamorphisms
} over
{Datatypes
} with
{Embedded
} {Functions
} (or
, {Programs
} from
{Outer
} {Space
})},
49 isbn
= {0-89791-769-3},
50 url
= {https
://doi.org
/10.1145/237721.237792},
51 doi
= {10.1145/237721.237792},
52 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.
},
53 booktitle = {Proceedings of the
23rd
{ACM
} {SIGPLAN
}-{SIGACT
} {Symposium
} on
{Principles
} of
{Programming
} {Languages
}},
54 publisher = {Association for Computing Machinery
},
55 author = {Fegaras
, Leonidas and Sheard
, Tim
},
57 note = {event
-place
: St. Petersburg Beach
, Florida
, USA
},
59 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
},
62 @inproceedings
{pfenning_higher
-order_1988
,
63 address = {New York
, NY
, USA
},
64 series = {{PLDI
} '
88},
65 title = {Higher
-{Order
} {Abstract
} {Syntax
}},
66 isbn
= {0-89791-269-1},
67 url
= {https
://doi.org
/10.1145/53990.54010},
68 doi
= {10.1145/53990.54010},
69 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.
},
70 booktitle = {Proceedings of the
{ACM
} {SIGPLAN
} 1988 {Conference
} on
{Programming
} {Language
} {Design
} and
{Implementation
}},
71 publisher = {Association for Computing Machinery
},
72 author = {Pfenning
, F. and Elliott
, C.
},
74 note = {event
-place
: Atlanta
, Georgia
, USA
},
76 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
},
79 @inproceedings
{chlipala_parametric_2008
,
80 address = {New York
, NY
, USA
},
81 series = {{ICFP
} '
08},
82 title = {Parametric
{Higher
}-{Order
} {Abstract
} {Syntax
} for
{Mechanized
} {Semantics
}},
83 isbn
= {978-1-59593-919-7},
84 url
= {https
://doi.org
/10.1145/1411204.1411226},
85 doi
= {10.1145/1411204.1411226},
86 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.
},
87 booktitle = {Proceedings of the
13th
{ACM
} {SIGPLAN
} {International
} {Conference
} on
{Functional
} {Programming
}},
88 publisher = {Association for Computing Machinery
},
89 author = {Chlipala
, Adam
},
91 note = {event
-place
: Victoria
, BC
, Canada
},
92 keywords = {compiler verification
, dependent types
, interactive proof assistants
, type-theoretic semantics
},
94 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
},
97 @incollection
{reynolds_user
-defined_1978
,
98 address = {New York
, NY
},
99 title = {User
-{Defined
} {Types
} and
{Procedural
} {Data
} {Structures
} as
{Complementary
} {Approaches
} to
{Data
} {Abstraction
}},
100 isbn
= {978-1-4612-6315-9},
101 url
= {https
://doi.org
/10.1007/978-1-4612-6315-9_22
},
102 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.
},
103 booktitle = {Programming
{Methodology
}: {A
} {Collection
} of
{Articles
} by
{Members
} of
{IFIP
} {WG2
}.3},
104 publisher = {Springer New York
},
105 author = {Reynolds
, John C.
},
106 editor = {Gries
, David
},
108 doi
= {10.1007/978-1-4612-6315-9_22
},
110 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
},
113 @misc
{ghc_team_ghc_2021
,
114 title = {{GHC
} {User
}’s
{Guide
} {Documentation
}},
115 url
= {https
://downloads.haskell.org
/~ghc
/latest
/docs
/users_guide.pdf
},
116 language
= {English
},
117 urldate
= {2021-02-24},
118 publisher = {Release
},
121 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
},
124 @misc
{ghc_team_datadynamic_2021
,
125 title = {Data.
{Dynamic
}},
126 url
= {https
://hackage.haskell.org
/package
/base
-4.14.1.0/docs
/Data
-Dynamic.html
},
127 language
= {English
},
128 urldate
= {2021-02-24},
129 publisher = {Release
},
134 @inproceedings
{jeuring_polytypic_1996
,
135 address = {Berlin
, Heidelberg
},
136 title = {Polytypic programming
},
137 isbn
= {978-3-540-70639-7},
138 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.
},
139 booktitle = {Advanced
{Functional
} {Programming
}},
140 publisher = {Springer Berlin Heidelberg
},
141 author = {Jeuring
, Johan and Jansson
, Patrik
},
142 editor = {Launchbury
, John and Meijer
, Erik and Sheard
, Tim
},
145 file
= {Jeuring and Jansson
- 1996 - Polytypic programming.pdf
:/home
/mrl
/.local
/share
/zotero
/storage
/SLC4G2IT
/Jeuring and Jansson
- 1996 - Polytypic programming.pdf
:application
/pdf
},
148 @book
{peyton_jones_haskell_2003
,
149 address = {Cambridge
},
150 title = {Haskell
98 language and libraries
: the revised report
},
151 isbn
= {0-521 826144},
152 publisher = {Cambridge University Press
},
153 editor = {Peyton Jones
, Simon
},
155 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
},
158 @inproceedings
{laufer_combining_1994
,
159 title = {Combining
type classes and existential types
},
160 booktitle = {Proceedings of the
{Latin
} {American
} {Informatic
} {Conference
} ({PANEL
})},
161 publisher = {ITESM
-CEM
},
162 author = {Läufer
, Konstantin
},
164 note = {event
-place
: Monterrey
, Mexico
},
165 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
},
168 @techreport
{hughes_restricted_1999
,
170 title = {Restricted data types in
{Haskell
}},
171 number = {UU
-CS
-1999-28},
172 institution = {Department of Information and Computing Sciences
, Utrecht University
},
173 author = {Hughes
, John
},
176 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
},
179 @article
{najd_trees_2017
,
180 title = {Trees that
{Grow
}},
182 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.
},
184 journal = {Journal of Universal Computer Science
},
185 author = {Najd
, Shayan and Peyton Jones
, Simon
},
189 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
},
192 @inproceedings
{loh_open_2006
,
193 address = {New York
, NY
, USA
},
194 series = {{PPDP
} '
06},
195 title = {Open
{Data
} {Types
} and
{Open
} {Functions
}},
196 isbn
= {1-59593-388-3},
197 url
= {https
://doi.org
/10.1145/1140335.1140352},
198 doi
= {10.1145/1140335.1140352},
199 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
},
200 booktitle = {Proceedings of the
8th
{ACM
} {SIGPLAN
} {International
} {Conference
} on
{Principles
} and
{Practice
} of
{Declarative
} {Programming
}},
201 publisher = {Association for Computing Machinery
},
202 author = {Löh
, Andres and Hinze
, Ralf
},
204 note = {event
-place
: Venice
, Italy
},
205 keywords = {expression problem
, extensible data types
, extensible exceptions
, extensible functions
, functional programming
, generic programming
, Haskell
, mutually recursive modules
},
207 file
= {OpenDatatypes.pdf
:/home
/mrl
/.local
/share
/zotero
/storage
/NEP9GZ9N
/OpenDatatypes.pdf
:application
/pdf
},
210 @inproceedings
{hutton_fold_1998
,
211 address = {New York
, NY
, USA
},
212 series = {{ICFP
} '
98},
213 title = {Fold and
{Unfold
} for
{Program
} {Semantics
}},
214 isbn
= {1-58113-024-4},
215 url
= {https
://doi.org
/10.1145/289423.289457},
216 doi
= {10.1145/289423.289457},
217 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.
},
218 booktitle = {Proceedings of the
{Third
} {ACM
} {SIGPLAN
} {International
} {Conference
} on
{Functional
} {Programming
}},
219 publisher = {Association for Computing Machinery
},
220 author = {Hutton
, Graham
},
222 note = {event
-place
: Baltimore
, Maryland
, USA
},
224 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
},
227 @article
{abadi_dynamic_1991
,
228 title = {Dynamic
{Typing
} in a
{Statically
} {Typed
} {Language
}},
231 url
= {https
://doi.org
/10.1145/103135.103138},
232 doi
= {10.1145/103135.103138},
233 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.
},
235 journal = {ACM Trans. Program. Lang. Syst.
},
236 author = {Abadi
, Martín and Cardelli
, Luca and Pierce
, Benjamin and Plotkin
, Gordon
},
239 note = {Place
: New York
, NY
, USA
240 Publisher
: Association for Computing Machinery
},
243 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
},
246 @inproceedings
{svenningsson_combining_2013
,
247 address = {Berlin
, Heidelberg
},
248 title = {Combining
{Deep
} and
{Shallow
} {Embedding
} for
{EDSL
}},
249 isbn
= {978-3-642-40447-4},
250 doi
= {10.1007/978-3-642-40447-4_2
},
251 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.
},
252 booktitle = {Trends in
{Functional
} {Programming
}},
253 publisher = {Springer Berlin Heidelberg
},
254 author = {Svenningsson
, Josef and Axelsson
, Emil
},
255 editor = {Loidl
, Hans
-Wolfgang and Peña
, Ricardo
},
258 file
= {svenningsson2013combining.pdf
:/home
/mrl
/.local
/share
/zotero
/storage
/NFBGZCZT
/svenningsson2013combining.pdf
:application
/pdf
},
261 @article
{mitchell_abstract_1988
,
262 title = {Abstract
{Types
} {Have
} {Existential
} {Type
}},
265 url
= {https
://doi.org
/10.1145/44501.45065},
266 doi
= {10.1145/44501.45065},
267 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.
},
269 journal = {ACM Trans. Program. Lang. Syst.
},
270 author = {Mitchell
, John C. and Plotkin
, Gordon D.
},
273 note = {Place
: New York
, NY
, USA
274 Publisher
: Association for Computing Machinery
},
276 file
= {Mitchell and Plotkin
- 1988 - Abstract types have existential
type.pdf
:/home
/mrl
/.local
/share
/zotero
/storage
/QXDE5H7C
/Mitchell and Plotkin
- 1988 - Abstract types have existential
type.pdf
:application
/pdf
},
279 @inproceedings
{yorgey_giving_2012
,
280 address = {New York
, NY
, USA
},
281 series = {{TLDI
} '
12},
282 title = {Giving
{Haskell
} a
{Promotion
}},
283 isbn
= {978-1-4503-1120-5},
284 url
= {https
://doi.org
/10.1145/2103786.2103795},
285 doi
= {10.1145/2103786.2103795},
286 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.
},
287 booktitle = {Proceedings of the
8th
{ACM
} {SIGPLAN
} {Workshop
} on
{Types
} in
{Language
} {Design
} and
{Implementation
}},
288 publisher = {Association for Computing Machinery
},
289 author = {Yorgey
, Brent A. and Weirich
, Stephanie and Cretin
, Julien and Peyton Jones
, Simon and Vytiniotis
, Dimitrios and Magalhães
, José Pedro
},
291 note = {event
-place
: Philadelphia
, Pennsylvania
, USA
},
292 keywords = {haskell
, kinds
, polymorphism
, promotion
},
294 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
},
297 @inproceedings
{atkey_unembedding_2009
,
298 address = {New York
, NY
, USA
},
299 series = {Haskell '
09},
300 title = {Unembedding
{Domain
}-{Specific
} {Languages
}},
301 isbn
= {978-1-60558-508-6},
302 url
= {https
://doi.org
/10.1145/1596638.1596644},
303 doi
= {10.1145/1596638.1596644},
304 abstract = {Higher
-order
abstract syntax provides a convenient way of embedding domain
-specific languages
, but is awkward to analyse and manipulate directly. We explore the boundaries of higher
-order
abstract syntax. Our
key tool is the unembedding of embedded terms as de Bruijn terms
, enabling intensional analysis. As part of our solution we present techniques for separating the definition of an embedded program from its interpretation
, giving modular extensions of the embedded language
, and different ways to encode the types of the embedded language.
},
305 booktitle = {Proceedings of the
2nd
{ACM
} {SIGPLAN
} {Symposium
} on
{Haskell
}},
306 publisher = {Association for Computing Machinery
},
307 author = {Atkey
, Robert and Lindley
, Sam and Yallop
, Jeremy
},
309 note = {event
-place
: Edinburgh
, Scotland
},
310 keywords = {domain
-specific languages
, higher
-order
abstract syntax
, type classes
, unembedding
},
312 file
= {Atkey et al.
- 2009 - Unembedding Domain
-Specific Languages.pdf
:/home
/mrl
/.local
/share
/zotero
/storage
/GVFRIDUG
/Atkey et al.
- 2009 - Unembedding Domain
-Specific Languages.pdf
:application
/pdf
},
315 @inproceedings
{krishnamurthi_synthesizing_1998
,
316 address = {Berlin
, Heidelberg
},
317 title = {Synthesizing object
-oriented and functional design to promote re
-use
},
318 isbn
= {978-3-540-69064-1},
319 abstract = {Many problems require recursively specified types of data and a collection of tools that operate on those data. Over time
, these problems evolve so that the programmer must extend the toolkit or extend the types and adjust the existing tools accordingly. Ideally
, this should be done without modifying existing code. Unfortunately
, the prevailing program design strategies do not support both forms of extensibility
: functional programming accommodates the addition of tools
, while object
-oriented programming supports either adding new tools or extending the data set
, but not both. In this paper
, we present a composite design pattern that synthesizes the best of both approaches and in the process resolves the tension between the two design strategies. We also show how this protocol suggests a new set of linguistic facilities for languages that support class systems.
},
320 booktitle = {{ECOOP
}'
98 —
{Object
}-{Oriented
} {Programming
}},
321 publisher = {Springer Berlin Heidelberg
},
322 author = {Krishnamurthi
, Shriram and Felleisen
, Matthias and Friedman
, Daniel P.
},
323 editor = {Jul
, Eric
},
325 note = {event
-place
: Brussels
, Belgium
},
327 file
= {Krishnamurthi et al.
- 1998 - Synthesizing object
-oriented and functional design.pdf
:/home
/mrl
/.local
/share
/zotero
/storage
/AMMULPPT
/Krishnamurthi et al.
- 1998 - Synthesizing object
-oriented and functional design.pdf
:application
/pdf
},
330 @incollection
{gibbons_functional_2015
,
332 title = {Functional
{Programming
} for
{Domain
}-{Specific
} {Languages
}},
333 isbn
= {978-3-319-15940-9},
334 url
= {https
://doi.org
/10.1007/978-3-319-15940-9_1
},
335 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.
},
336 booktitle = {Central
{European
} {Functional
} {Programming
} {School
}: 5th
{Summer
} {School
}, {CEFP
} 2013, {Cluj
}-{Napoca
}, {Romania
}, {July
} 8-20, 2013, {Revised
} {Selected
} {Papers
}},
337 publisher = {Springer International Publishing
},
338 author = {Gibbons
, Jeremy
},
339 editor = {Zsók
, Viktória and Horváth
, Zoltán and Csató
, Lehel
},
341 doi
= {10.1007/978-3-319-15940-9_1
},
343 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
},
346 @phdthesis
{alimarine_generic_2005
,
347 address = {Nijmegen
},
349 title = {Generic
{Functional
} {Programming
}},
351 school = {Radboud University
},
352 author = {Alimarine
, Artem
},
354 file
= {Alimarine
- Generic Functional Programming.pdf
:/home
/mrl
/.local
/share
/zotero
/storage
/PDTS3SGX
/Alimarine
- Generic Functional Programming.pdf
:application
/pdf
},
357 @inproceedings
{barendregt_towards_1987
,
358 title = {Towards an intermediate language for graph rewriting
},
360 booktitle = {{PARLE
}, {Parallel
} {Architectures
} and
{Languages
} {Europe
}},
361 publisher = {Springer Verlag
},
362 author = {Barendregt
, HP and van Eekelen
, MCJD and Glauert
, JRW and Kennaway
, JR and Plasmeijer
, MJ and Sleep
, MR
},
365 file
= {barh87
-Lean.ps.gz
:/home
/mrl
/.local
/share
/zotero
/storage
/63FBHND7
/barh87
-Lean.ps.gz
:application
/gzip
},
368 @incollection
{wang_maintaining_2018
,
370 title = {Maintaining
{Separation
} of
{Concerns
} {Through
} {Task
} {Oriented
} {Software
} {Development
}},
372 isbn
= {978-3-319-89718-9 978-3-319-89719-6},
373 url
= {http
://link.springer.com
/10.1007/978-3-319-89719-6_2
},
374 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.
},
376 urldate
= {2019-01-14},
377 booktitle = {Trends in
{Functional
} {Programming
}},
378 publisher = {Springer International Publishing
},
379 author = {Stutterheim
, Jurriën and Achten
, Peter and Plasmeijer
, Rinus
},
380 editor = {Wang
, Meng and Owens
, Scott
},
382 doi
= {10.1007/978-3-319-89719-6},
384 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
},
387 @misc
{achten_clean_2007
,
388 title = {Clean for
{Haskell98
} {Programmers
}},
389 url
= {https
://www.mbsd.cs.ru.nl
/publications
/papers
/2007/achp2007
-CleanHaskellQuickGuide.pdf
},
391 author = {Achten
, Peter
},
394 file
= {Achten
- Clean for Haskell98 Programmers.pdf
:/home
/mrl
/.local
/share
/zotero
/storage
/69WWSGLF
/Achten
- Clean for Haskell98 Programmers.pdf
:application
/pdf
},
397 @inproceedings
{baccelli_reprogramming_2018
,
398 title = {Reprogramming
{Low
}-end
{IoT
} {Devices
} from the
{Cloud
}},
399 booktitle = {2018 3rd
{Cloudification
} of the
{Internet
} of
{Things
} ({CIoT
})},
401 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
},
404 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
},
407 @inproceedings
{baccelli_scripting_2018
,
408 title = {Scripting
{Over
}-{The
}-{Air
}: {Towards
} {Containers
} on
{Low
}-end
{Devices
} in the
{Internet
} of
{Things
}},
409 booktitle = {{IEEE
} {PerCom
} 2018},
410 author = {Baccelli
, Emmanuel and Doerr
, Joerg and Kikuchi
, Shinji and Padilla
, Francisco and Schleiser
, Kaspar and Thomas
, Ian
},
412 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
},
415 @article
{swierstra_data_2008
,
416 title = {Data types à la carte
},
418 doi
= {10.1017/S0956796808006758
},
420 journal = {Journal of functional programming
},
421 author = {Swierstra
, Wouter
},
424 file
= {swierstra2008.pdf
:/home
/mrl
/.local
/share
/zotero
/storage
/BEQKBXWP
/swierstra2008.pdf
:application
/pdf
},
427 @article
{groningen_exchanging_2010
,
428 title = {Exchanging sources between
{Clean
} and
{Haskell
}: {A
} double
-edged front end for the
{Clean
} compiler
},
430 shorttitle
= {Exchanging sources between
{Clean
} and
{Haskell
}},
432 journal = {ACM Sigplan Notices
},
433 author = {Groningen
, John van and Noort
, Thomas van and Achten
, Peter and Koopman
, Pieter and Plasmeijer
, Rinus
},
436 file
= {groj10
-Haskell_front_end_Clean.pdf
:/home
/mrl
/.local
/share
/zotero
/storage
/WVZWX8WT
/groj10
-Haskell_front_end_Clean.pdf
:application
/pdf
},
439 @inproceedings
{cheney_lightweight_2002
,
440 title = {A lightweight implementation of generics and dynamics
},
441 url
= {http
://dl.acm.org
/citation.cfm?id
=581698},
442 doi
= {10.1145/581690.581698},
443 urldate
= {2017-05-15},
444 booktitle = {Proceedings of the
2002 {ACM
} {SIGPLAN
} workshop on
{Haskell
}},
446 author = {Cheney
, James and Hinze
, Ralf
},
448 note = {event
-place
: Pittsburgh Pennsylvania
, USA
},
449 keywords = {dynamic typing
, generic programming
, type representations
},
451 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
},
454 @article
{tratt_domain_2008
,
455 title = {Domain
{Specific
} {Language
} {Implementation
} via
{Compile
}-{Time
} {Meta
}-{Programming
}},
458 url
= {https
://doi.org
/10.1145/1391956.1391958},
459 doi
= {10.1145/1391956.1391958},
460 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.
},
462 journal = {ACM Trans. Program. Lang. Syst.
},
463 author = {Tratt
, Laurence
},
466 note = {Place
: New York
, NY
, USA
467 Publisher
: Association for Computing Machinery
},
468 keywords = {domain specific languages
, compile
-time meta
-programming
, Syntax extension
},
469 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
},
472 @book
{peyton_jones_implementation_1987
,
473 title = {The
{Implementation
} of
{Functional
} {Programming
} {Languages
}},
474 url
= {https
://www.microsoft.com
/en
-us
/research
/publication
/the
-implementation
-of
-functional
-programming
-languages
/},
475 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".
},
476 publisher = {Prentice Hall
},
477 author = {Peyton Jones
, Simon
},
480 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
},
483 @article
{elliott_compiling_2003
,
484 title = {Compiling embedded languages
},
486 doi
= {10.1017/S0956796802004574
},
488 journal = {Journal of Functional Programming
},
489 author = {Elliott
, Conal and Finne
, Sigbjørn and de Moor
, Oege
},
491 note = {Publisher
: Cambridge University Press
},
493 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
},
496 @inproceedings
{sheard_accomplishments_2001
,
497 address = {Berlin
, Heidelberg
},
498 title = {Accomplishments and
{Research
} {Challenges
} in
{Meta
}-programming
},
499 isbn
= {978-3-540-44806-8},
500 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.
},
501 booktitle = {Semantics
, {Applications
}, and
{Implementation
} of
{Program
} {Generation
}},
502 publisher = {Springer Berlin Heidelberg
},
503 author = {Sheard
, Tim
},
504 editor = {Taha
, Walid
},
507 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
},
510 @incollection
{kiselyov_typed_2012
,
511 address = {Berlin
, Heidelberg
},
512 title = {Typed
{Tagless
} {Final
} {Interpreters
}},
513 isbn
= {978-3-642-32202-0},
514 url
= {https
://doi.org
/10.1007/978-3-642-32202-0_3
},
515 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.
},
516 booktitle = {Generic and
{Indexed
} {Programming
}: {International
} {Spring
} {School
}, {SSGIP
} 2010, {Oxford
}, {UK
}, {March
} 22-26, 2010, {Revised
} {Lectures
}},
517 publisher = {Springer Berlin Heidelberg
},
518 author = {Kiselyov
, Oleg
},
519 editor = {Gibbons
, Jeremy
},
521 doi
= {10.1007/978-3-642-32202-0_3
},
523 file
= {Kiselyov
- 2012 - Typed Tagless Final Interpreters.pdf
:/home
/mrl
/.local
/share
/zotero
/storage
/9NBYZLRP
/Kiselyov
- 2012 - Typed Tagless Final Interpreters.pdf
:application
/pdf
},
526 @article
{laufer_type_1996
,
527 title = {Type classes with existential types
},
529 doi
= {10.1017/S0956796800001817
},
531 journal = {Journal of Functional Programming
},
532 author = {Läufer
, Konstantin
},
534 note = {Publisher
: Cambridge University Press
},
536 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
},
539 @incollection
{hinze_fun_2003
,
540 address = {Palgrave
},
541 series = {Cornerstones of
{Computing
}},
542 title = {Fun
{With
} {Phantom
} {Types
}},
543 isbn
= {978-0-333-99285-2},
544 booktitle = {The
{Fun
} of
{Programming
}},
545 publisher = {Bloomsbury Publishing
},
546 author = {Hinze
, Ralf
},
547 editor = {Gibbons
, Jeremy and de Moor
, Oege
},
552 @inproceedings
{boulton_experience_1992
,
553 address = {North
-Holland
},
554 title = {Experience with embedding hardware description languages in
{HOL
}},
556 isbn
= {0-444-89686-4},
557 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.
},
559 booktitle = {{IFIP
} {TC10
}/{WG
}},
560 publisher = {Elsevier
},
561 author = {Boulton
, Richard and Gordon
, Andrew and Gordon
, Mike and Harrison
, John and Herbert
, John and Tassel
, John Van
},
562 editor = {Stavridou
, Victoria and Melham
, Thomas F. and Boute
, Raymond T.
},
564 note = {event
-place
: Nijmegen
, NL
},
566 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
},
569 @inproceedings
{gibbons_folding_2014
,
570 address = {New York
, NY
, USA
},
571 series = {{ICFP
} '
14},
572 title = {Folding
{Domain
}-{Specific
} {Languages
}: {Deep
} and
{Shallow
} {Embeddings
} ({Functional
} {Pearl
})},
573 isbn
= {978-1-4503-2873-9},
574 url
= {https
://doi.org
/10.1145/2628136.2628138},
575 doi
= {10.1145/2628136.2628138},
576 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.
},
577 booktitle = {Proceedings of the
19th
{ACM
} {SIGPLAN
} {International
} {Conference
} on
{Functional
} {Programming
}},
578 publisher = {Association for Computing Machinery
},
579 author = {Gibbons
, Jeremy and Wu
, Nicolas
},
581 note = {event
-place
: Gothenburg
, Sweden
},
582 keywords = {deep and shallow embedding
, domain
-specific languages
, folds
},
584 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
},
587 @inproceedings
{oliveira_typecase_2005
,
588 address = {New York
, NY
, USA
},
589 series = {Haskell '
05},
590 title = {{TypeCase
}: {A
} {Design
} {Pattern
} for
{Type
}-{Indexed
} {Functions
}},
591 isbn
= {1-59593-071-X
},
592 url
= {https
://doi.org
/10.1145/1088348.1088358},
593 doi
= {10.1145/1088348.1088358},
594 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.
},
595 booktitle = {Proceedings of the
2005 {ACM
} {SIGPLAN
} {Workshop
} on
{Haskell
}},
596 publisher = {Association for Computing Machinery
},
597 author = {Oliveira
, Bruno C. d. S. and Gibbons
, Jeremy
},
599 note = {event
-place
: Tallinn
, Estonia
},
600 keywords = {generic programming
, type classes
, type-indexed functions
},
602 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
},
605 @inproceedings
{odersky_putting_1996
,
606 address = {New York
, NY
, USA
},
607 series = {{POPL
} '
96},
608 title = {Putting
{Type
} {Annotations
} to
{Work
}},
609 isbn
= {0-89791-769-3},
610 url
= {https
://doi.org
/10.1145/237721.237729},
611 doi
= {10.1145/237721.237729},
612 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.
},
613 booktitle = {Proceedings of the
23rd
{ACM
} {SIGPLAN
}-{SIGACT
} {Symposium
} on
{Principles
} of
{Programming
} {Languages
}},
614 publisher = {Association for Computing Machinery
},
615 author = {Odersky
, Martin and Läufer
, Konstantin
},
617 note = {event
-place
: St. Petersburg Beach
, Florida
, USA
},
619 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
},
622 @article
{carette_finally_2009
,
623 title = {Finally tagless
, partially evaluated
: {Tagless
} staged interpreters for simpler typed languages
},
625 doi
= {10.1017/S0956796809007205
},
627 journal = {Journal of Functional Programming
},
628 author = {Carette
, Jacques and Kiselyov
, Oleg and Shan
, Chung
-Chieh
},
630 note = {Publisher
: Cambridge University Press
},
632 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
},
635 @techreport
{plasmeijer_clean_2021
,
636 address = {Nijmegen
},
637 title = {Clean
{Language
} {Report
} version
3.1},
638 urldate
= {2021-12-22},
639 institution = {Institute for Computing and Information Sciences
},
640 author = {Plasmeijer
, Rinus and van Eekelen
, Marko and van Groningen
, John
},
644 file
= {CleanLanguageReport.pdf
:/home
/mrl
/.local
/share
/zotero
/storage
/I2SDRIH6
/CleanLanguageReport.pdf
:application
/pdf
},
647 @inproceedings
{nocker_concurrent_1991
,
648 address = {Berlin
, Heidelberg
},
649 title = {Concurrent clean
},
650 isbn
= {978-3-540-47472-2},
651 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.
},
652 booktitle = {{PARLE
} '
91 {Parallel
} {Architectures
} and
{Languages
} {Europe
}},
653 publisher = {Springer Berlin Heidelberg
},
654 author = {Nöcker
, E. G. J. M. H. and Smetsers
, J. E. W. and van Eekelen
, M. C. J. D. and Plasmeijer
, M. J.
},
655 editor = {Aarts
, Emile H. L. and van Leeuwen
, Jan and Rem
, Martin
},
658 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
},
661 @incollection
{mernik_extensible_2013
,
662 address = {Hershey
, PA
, USA
},
663 title = {Extensible
{Languages
}: {Blurring
} the
{Distinction
} between
{DSL
} and
{GPL
}},
664 isbn
= {978-1-4666-2092-6},
665 url
= {https
://services.igi
-global.com
/resolvedoi
/resolve.aspx?doi
=10.4018/978-1-4666-2092-6.ch001
},
666 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.
},
667 booktitle = {Formal and
{Practical
} {Aspects
} of
{Domain
}-{Specific
} {Languages
}: {Recent
} {Developments
}},
668 publisher = {IGI Global
},
669 author = {Verna
, Didier
},
670 editor = {Mernik
, Marjan
},
672 doi
= {10.4018/978-1-4666-2092-6.ch001
},
676 @inproceedings
{hudak_modular_1998
,
677 title = {Modular domain specific languages and tools
},
678 doi
= {10.1109/ICSR
.1998.685738},
679 booktitle = {Proceedings.
{Fifth
} {International
} {Conference
} on
{Software
} {Reuse
} ({Cat
}.
{No
}.
{98TB100203
})},
680 author = {Hudak
, P.
},
683 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
},
686 @book
{fowler_domain_2010
,
688 title = {Domain
{Specific
} {Languages
}},
689 isbn
= {0-321-71294-3},
690 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\#.
},
691 publisher = {Addison
-Wesley Professional
},
692 author = {Fowler
, Martin
},
694 file
= {Fowler
- 2010 - Domain
-specific languages.pdf
:/home
/mrl
/.local
/share
/zotero
/storage
/YYMYXTZ5
/Fowler
- 2010 - Domain
-specific languages.pdf
:application
/pdf
},
697 @misc
{peter_t_lewis_speech_1985
,
698 address = {Washington
, D.C.
},
701 url
= {http
://www.chetansharma.com
/correcting
-the
-iot
-history
/},
702 author = {{Peter T. Lewis
}},
707 @article
{weiser_computer_1991
,
708 title = {The
{Computer
} for the
21 st
{Century
}},
712 journal = {Scientific American
},
713 author = {Weiser
, Mark
},
717 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
},
720 @misc
{evans_internet_2011
,
721 title = {The
{Internet
} of
{Things
}: {How
} the
{Next
} {Evolution
} of the
{Internet
} {Is
} {Changing
} {Everything
}},
722 url
= {https
://www.cisco.com
/c
/dam
/en_us
/about
/ac79
/docs
/innov
/IoT_IBSG_0411FINAL.pdf
},
724 publisher = {Cisco Internet Business Solutions Group
(IBSG
)},
725 author = {Evans
, Dave
},
728 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
},
731 @inproceedings
{ireland_classification_2009
,
732 address = {Cancun
, Mexico
},
733 title = {A
{Classification
} of
{Object
}-{Relational
} {Impedance
} {Mismatch
}},
734 isbn
= {978-0-7695-3550-0},
735 doi
= {10.1109/DBKDA
.2009.11},
736 booktitle = {First
{International
} {Conference
} on
{Advances
} in
{Databases
}, {Knowledge
}, and
{Data
} {Applications
}},
738 author = {Ireland
, Christopher and Bowers
, David and Newton
, Michael and Waugh
, Kevin
},
743 @techreport
{cheney_first
-class_2003
,
744 title = {First
-class phantom types
},
745 url
= {https
://ecommons.cornell.edu
/handle
/1813/5614},
746 number = {TR2003
-1901},
747 urldate
= {2017-05-15},
748 institution = {Cornell University
},
749 author = {Cheney
, James and Hinze
, Ralf
},
751 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
},
754 @inproceedings
{baars_typing_2002
,
755 address = {New York
, NY
, USA
},
756 series = {{ICFP
} '
02},
757 title = {Typing
{Dynamic
} {Typing
}},
758 isbn
= {1-58113-487-8},
759 url
= {https
://doi.org
/10.1145/581478.581494},
760 doi
= {10.1145/581478.581494},
761 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.
},
762 booktitle = {Proceedings of the
{Seventh
} {ACM
} {SIGPLAN
} {International
} {Conference
} on
{Functional
} {Programming
}},
763 publisher = {Association for Computing Machinery
},
764 author = {Baars
, Arthur I. and Swierstra
, S. Doaitse
},
766 note = {event
-place
: Pittsburgh
, PA
, USA
},
767 keywords = {coercions
, dynamic typing
, Haskell
, Leibnitz' rule
, quantified types
, static typing
, type equality
, typed interpreters
},
769 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
},
772 @incollection
{hinze_generic_2003
,
773 address = {Berlin
, Heidelberg
},
774 title = {Generic
{Haskell
}: {Practice
} and
{Theory
}},
775 isbn
= {978-3-540-45191-4},
776 url
= {https
://doi.org
/10.1007/978-3-540-45191-4_1
},
777 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.
},
778 booktitle = {Generic
{Programming
}: {Advanced
} {Lectures
}},
779 publisher = {Springer Berlin Heidelberg
},
780 author = {Hinze
, Ralf and Jeuring
, Johan
},
781 editor = {Backhouse
, Roland and Gibbons
, Jeremy
},
783 doi
= {10.1007/978-3-540-45191-4_1
},
785 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
},
788 @misc
{wadler_expression_1998
,
789 title = {The expression problem
},
790 url
= {https
://homepages.inf.ed.ac.uk
/wadler
/papers
/expression
/expression.txt
},
792 urldate
= {2021-02-24},
793 author = {Wadler
, Philip
},
796 note = {e
-mail message
, accessed on
2021-02-24},
799 @misc
{margaret_deuter_rhapsody_2015
,
801 edition
= {Ninth edition
},
803 journal = {Oxford Advanced Learner's Dictionary of Current English
},
804 publisher = {Oxford University Press
},
805 author = {{A S Hornby
}},
806 editor = {{Margaret Deuter
} and
{Jennifer Bradbery
} and
{Joanna Turnbull
}},
810 @misc
{wikipedia_contributors_rhapsody_2022
,
811 title = {Rhapsody
(music
) —
{Wikipedia
}, {The
} {Free
} {Encyclopedia
}},
812 url
= {https
://en.wikipedia.org
/w
/index.php?
title=Rhapsody_
(music
)\
&oldid
=1068385257},
813 urldate
= {2022-09-06},
814 journal = {Wikipedia
},
815 author = {{Wikipedia contributors
}},
817 note = {accessed on
: 2022-09-06},
820 @mastersthesis
{crooijmans_reducing_2021
,
821 address = {Nijmegen
},
822 title = {Reducing the
{Power
} {Consumption
} of
{IoT
} {Devices
} in
{Task
}-{Oriented
} {Programming
}},
824 school = {Radboud University
},
825 author = {Crooijmans
, Sjoerd
},
828 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
},
831 @mastersthesis
{amazonas_cabral_de_andrade_developing_2018
,
832 address = {Nijmegen
},
833 title = {Developing
{Real
} {Life
}, {Task
} {Oriented
} {Applications
} for the
{Internet
} of
{Things
}},
834 shorttitle
= {Developing
{Real
} {Life
}, {TOP
} {Applications
} for the
{IOT
}},
836 school = {Radboud University
},
837 author = {Amazonas Cabral De Andrade
, Matheus
},
839 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
},