Filters








82 Hits in 1.9 sec

Lightweight Higher-Kinded Polymorphism [chapter]

Jeremy Yallop, Leo White
2014 Lecture Notes in Computer Science  
Yallop and Kiselyov [2010] show how first-class modules make it possible to define an OCaml type eq equivalent to Equal. A minimised version of eq and its core operations is given in Figure 3 .  ... 
doi:10.1007/978-3-319-07151-0_8 fatcat:duxnysgi5rb25oo2zwtl6v2zsu

The arrow calculus

SAM LINDLEY, PHILIP WADLER, JEREMY YALLOP
2010 Journal of functional programming  
Lindley, Wadler and Yallop [7] give forward and backward translations between variants of idioms, arrows, and monads, and only some turn out to be equational correspondences; we had to invent a more  ... 
doi:10.1017/s095679680999027x fatcat:u7wegk2ffvbsrcv3rga6crhdri

Staged generic programming

Jeremy Yallop
2017 Proceedings of the ACM on Programming Languages  
However, the query itself is typically supplied directly via a scheme such as listify, and so is left as static. 29:8 Jeremy Yallop The implementations of gmapQ for the Data_int and Data_list instances  ...  Enclosing 29:4 Jeremy Yallop type _ tyrep = .. module type TYPEABLE = sig type t val tyrep ȷ t tyrep lazy_t val eqty ȷ 's tyrep → ˘t˛'s¯eql option end The first, Data_int, defines gmapQ to return an  ... 
doi:10.1145/3110273 dblp:journals/pacmpl/Yallop17 fatcat:23a3xf5a7nc3ribcrvfnnkeeai

Links: Web Programming Without Tiers [chapter]

Ezra Cooper, Sam Lindley, Philip Wadler, Jeremy Yallop
2007 Lecture Notes in Computer Science  
Links is a programming language for web applications. Links generates code for all three tiers of a web application from a single source, compiling into JavaScript to run on the client and into SQL to run on the database. Links provides support for rich clients running in what has been dubbed 'Ajax' style. Links programs are scalable in the sense that session state is preserved in the client rather than the server, in contrast to other approaches such as Java Servlets or PLT Scheme. ¢ database
more » ... rogramming, as found in Kleisli and elsewhere, ¢ web interaction, as found in PLT Scheme and elsewhere, ¢ concurrency, as found in Erlang and elsewhere, and ¢ XML programming, as found in XDuce and elsewhere. A detailed description of these influences appears below. Links also supports a number of features not found elsewhere.
doi:10.1007/978-3-540-74792-5_12 fatcat:2ymqqlatzvamxaggzbgxybowue

A modular foreign function interface

Jeremy Yallop, David Sheets, Anil Madhavapeddy
2018 Science of Computer Programming  
Foreign function interfaces (FFIs) between high-level languages and system libraries typically intertwine the actions of describing the interface of a system library and selecting a binding strategy for linking to it. This tight coupling makes it difficult for programmers to switch between different binding strategies, and discourages the development of new approaches to binding, since more exotic approaches are unlikely to attract sufficient users to justify the cost of development. We present
more » ... Cmeleon, a replacement for the standard OCaml FFI that exposes typed constructors that correspond to the operations of the type algebra of C, and binding strategies that interpret this type structure as separate program stages. Cmeleon parameterises external calls across binding strategies, isolating interface descriptions from choices relating to call construction (code generation vs dynamic call frames), concurrency style (blocking, cooperatively or preemptively threaded), and separation (in-process, address space or a network connection). This flexibility enables significant code reuse of bindings in many different contexts, from rapid interactive development in a REPL to production deployments with generated code and privilege separation. Cmeleon has been used for the past two years to bind to a broad variety of real-world OCaml libraries, and entirely supplants the need for the low-level C FFI for the vast majority of applications.
doi:10.1016/j.scico.2017.04.002 fatcat:7vmukszpivck3kjoghrfsjtipa

Modular implicits

Leo White, Frédéric Bour, Jeremy Yallop
2015 Electronic Proceedings in Theoretical Computer Science  
We present modular implicits, an extension to the OCaml language for ad-hoc polymorphism inspired by Scala implicits and modular type classes. Modular implicits are based on type-directed implicit module parameters, and elaborate straightforwardly into OCaml's first-class functors. Basing the design on OCaml's modules leads to a system that naturally supports many features from other languages with systematic ad-hoc overloading, including inheritance, instance constraints, constructor classes and associated types.
doi:10.4204/eptcs.198.2 fatcat:fha5fyedfrd6phdrdsotd6omha

The Essence of Form Abstraction [chapter]

Ezra Cooper, Sam Lindley, Philip Wadler, Jeremy Yallop
2008 Lecture Notes in Computer Science  
Abstraction is the cornerstone of high-level programming; HTML forms are the principal medium of web interaction. However, most web programming environments do not support abstraction of form components, leading to a lack of compositionality. Using a semantics based on idioms, we show how to support compositional form construction and give a convenient syntax.
doi:10.1007/978-3-540-89330-1_15 fatcat:d3y4mcb5ojgvdnt5qo6lzkyutq

Declarative Foreign Function Binding Through Generic Programming [chapter]

Jeremy Yallop, David Sheets, Anil Madhavapeddy
2016 Lecture Notes in Computer Science  
Foreign function interfaces are typically organised monolithically, tying together the specification of each foreign function with the mechanism used to make the function available in the host language. This leads to inflexibile systems, where switching from one binding mechanism to another (say from dynamic binding to static code generation) often requires changing tools and rewriting large portions of code. In contrast, approaching the design of a foreign function interface as a generic
more » ... mming problem allows foreign function specifications to be written declaratively, with easy switching between a wide variety of binding mechanisms -static and dynamic, synchronous and asynchronous, etc. -with no changes to the specifications.
doi:10.1007/978-3-319-29604-3_13 fatcat:yuygfno4avhllcssapho5r7lmi

Programming Unikernels in the Large via Functor Driven Development [article]

Gabriel Radanne, Thomas Gazagnaire, Anil Madhavapeddy, Jeremy Yallop, Richard Mortier, Hannes Mehnert, Mindy Preston, David Scott
2019 arXiv   pre-print
Yallop, R. Mortier, H. Mehnert, M. Preston, and D. Scott response by adding the correct headers, before being returned to the client connection.  ...  Yallop, R. Mortier, H. Mehnert, M. Preston, and D. Scott the case of foreign devices, but arbitrary initialization code in general for more complex cases.  ... 
arXiv:1905.02529v1 fatcat:a6vmsxnmazgj7m3mjhll34qjey

Unembedding domain-specific languages

Robert Atkey, Sam Lindley, Jeremy Yallop
2009 Proceedings of the 2nd ACM SIGPLAN symposium on Haskell - Haskell '09  
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.
doi:10.1145/1596638.1596644 dblp:conf/haskell/AtkeyLY09 fatcat:5v2pqkdmtfbl3kpaf5v6wxzyrm

Staging generic programming

Jeremy Yallop
2016 Proceedings of the 2016 ACM SIGPLAN Workshop on Partial Evaluation and Program Manipulation - PEPM 2016  
the following command: opam switch 4.02.1+modular-implicits-ber The staged SYB library implementation may be installed by running the following command: opam pin add metaocaml-syb \ https://github.com/yallop  ... 
doi:10.1145/2847538.2847546 dblp:conf/pepm/Yallop16 fatcat:qzlpgfexyfduborunh7k3eg2ni

Lambda: the ultimate sublanguage (experience report)

Jeremy Yallop, Leo White
2019 Proceedings of the ACM on Programming Languages (PACMPL)  
Besides applications to GADTs, encodings of type equalities can also be used as a basis (or, at least, as an inspiration) for encodings of other relationships between types, such as subtyping [Yallop  ...  The so-called Leibniz encoding Eq (which is given in roughly this form by Church [1940] , and appears more recently in various functional programming papers [Baars and Swierstra 2002; Weirich 2004; Yallop  ... 
doi:10.1145/3342713 fatcat:6hv3lrjfwnh4vcitzsodczjrhy

Generating mutually recursive definitions

Jeremy Yallop, Oleg Kiselyov
2019 Proceedings of the 2019 ACM SIGPLAN Workshop on Partial Evaluation and Program Manipulation - PEPM 2019  
2016] or hard-coding templates for a few fixed numbers of binding-group sizes [Yallop 2017 ].  ...  back on a variety of workarounds, simulating mutual recursion using ordinary recursion [Kiselyov 2013] or nested recursion [Inoue 2014], encoding recursion using higher-order state ("Landin's knot") [Yallop  ... 
doi:10.1145/3294032.3294078 dblp:conf/pepm/YallopK19 fatcat:qxqbphfjtnccbf4za2mfdfxjea

From Theory to Practice of Algebraic Effects and Handlers (Dagstuhl Seminar 16112)

Andrej Bauer, Martin Hofmann, Matija Pretnar, Jeremy Yallop, Marc Herbstritt
2016 Dagstuhl Reports  
Dagstuhl Seminar 16112 was devoted to research in algebraic effects and handlers, a chapter in the principles of programming languages which addresses computational effects (such as I/O, state, exceptions, nondeterminism, and many others). The speakers and the working groups covered a range of topics, including comparisons between various control mechanisms (handlers vs. delimited control), implementation of an effect system for OCaml, compilation techniques for algebraic effects and handlers, and implementations of effects in Haskell.
doi:10.4230/dagrep.6.3.44 dblp:journals/dagstuhl-reports/Bauer0PY16 fatcat:5whd2flnxbg6lck2kx3qlkekaq

Automatic acquisition of adjectival subcategorization from corpora

Jeremy Yallop, Anna Korhonen, Ted Briscoe
2005 Proceedings of the 43rd Annual Meeting on Association for Computational Linguistics - ACL '05  
This paper describes a novel system for acquiring adjectival subcategorization frames (SCFs) and associated frequency information from English corpus data. The system incorporates a decision-tree classifier for 30 SCF types which tests for the presence of grammatical relations (GRs) in the output of a robust statistical parser. It uses a powerful patternmatching language to classify GRs into frames hierarchically in a way that mirrors inheritance-based lexica. The experiments show that the
more » ... m is able to detect SCF types with 70% precision and 66% recall rate. A new tool for linguistic annotation of SCFs in corpus data is also introduced which can considerably alleviate the process of obtaining training and test data for subcategorization acquisition.
doi:10.3115/1219840.1219916 dblp:conf/acl/YallopKB05 fatcat:75qypk47w5blxjfqs7cnsapwwq
« Previous Showing results 1 — 15 out of 82 results