Segui questo link per vedere altri tipi di pubblicazioni sul tema: Functional programming.
Tesi sul tema "Functional programming"
Cita una fonte nei formati APA, MLA, Chicago, Harvard e in molti altri stili
Vedi i top-50 saggi (tesi di laurea o di dottorato) per l'attività di ricerca sul tema "Functional programming".
Accanto a ogni fonte nell'elenco di riferimenti c'è un pulsante "Aggiungi alla bibliografia". Premilo e genereremo automaticamente la citazione bibliografica dell'opera scelta nello stile citazionale di cui hai bisogno: APA, MLA, Harvard, Chicago, Vancouver ecc.
Puoi anche scaricare il testo completo della pubblicazione scientifica nel formato .pdf e leggere online l'abstract (il sommario) dell'opera se è presente nei metadati.
Vedi le tesi di molte aree scientifiche e compila una bibliografia corretta.
1
Hill, Stephen A. "Functional programming techniques." Thesis, University of Kent, 1989. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.236147.
Testo completo
2
Longley, Mark. "Functional programming applications." Thesis, University of Kent, 1991. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.303191.
Testo completo
3
Perera, Roland. "Interactive functional programming." Thesis, University of Birmingham, 2013. http://etheses.bham.ac.uk//id/eprint/4209/.
Testo completoAbstract (sommario):
We propose a new kind of execution environment where applications can be debugged and re-programmed while they are being used. We call our overall concept interactive programming. We develop some of the key components of interactive programming in the setting of a pure, call-by-value functional language. We illustrate our ideas via a proof-of-concept implementation called lambdaCalc, but leave several important components of the overall vision, including efficient incremental update and scaling to large programs, for future work. Our specific achievements are as follows. First, we show how to reify the execution of a program into a live document which can be interactively decomposed into both sequential steps and parallel slices. We give a novel characterisation of forward and backward dynamic slicing and show that for a fixed computation the two problems describe a Galois connection. Second, we introduce a novel execution indexing scheme which derives execution differences from program differences. Our scheme supports the wholesale reorganisation of a computation via operations such as moves and splices. The programmer is able to see the consequences of edits on the intensional structure of the execution. Where possible, node identity is preserved, allowing an edit to be made whilst an execution is being explored and the changes to be reflected in the user's current view of the execution.
4
Clark, Allan. "Abstraction-level functional programming." Thesis, University of Edinburgh, 2008. http://hdl.handle.net/1842/24458.
Testo completoAbstract (sommario):
This thesis is concerned with the abstraction-level programming, where abstraction-level is the level of programming tasks which extend the abstraction of the machine. Extending the abstraction of the machine is generally done by compiler writers for high-level programming languages or those implementing an interface to lower-level or legacy libraries. The abstractions which are implemented are then used, either explicitly or implicitly, by the high-level language programmer. The main aim of the abstraction is often to increase programmer productivity but can also be for efficiency or security reasons. Implementing an automatic runtime garbage collector is a common example of an abstraction-level programming task. To date most abstraction-level programming has been done in low-level programming languages such as C. The contents of this thesis describes an investigation into the design of a functional language Nitro, for use in abstraction-level programming. The main goal is to provide the abstraction-level programmer with some of the benefits enjoyed by high-level functional language programmers.
5
Widera, Manfred. "Testing in functional programming." Aachen Shaker, 2006. http://d-nb.info/988123983/04.
Testo completo
6
Widera, Manfred. "Testing in functional programming /." Aachen : Shaker, 2008. http://d-nb.info/988123983/04.
Testo completo
7
Meehan, Gary. "Aspects of functional programming." Thesis, University of Warwick, 1999. http://wrap.warwick.ac.uk/58566/.
Testo completoAbstract (sommario):
This thesis explores the application of functional programming in new areas and its implementation using new technologies. We show how functional languages can be used to implement solutions to problems in fuzzy logic using a number of languages: Haskell, Ginger and Aladin. A compiler for the weakly-typed, lazy language Ginger is developed using Java byte-code as its target code. This is used as the inspiration for an implementation of Aladin, a simple functional language which has two novel features: its primitives are designed to be written in any language, and evaluation is controlled by declaring the strictness of all functions. Efficient denotational and operational semantics are given for this machine and an implementation is devel- oped using these semantics. We then show that by using the advantages of Aladin (simplicity and strictness control) we can employ partial evaluation to achieve con- siderable speed-ups in the running times of Aladin programs.
8
Martins, Pedro M. "Context-oriented functional programming." Thesis, Imperial College London, 2013. http://hdl.handle.net/10044/1/24669.
Testo completoAbstract (sommario):
The modern computing landscape, featuring heterogeneous interconnected mobile devices, poses new challenges and opportunities for application development. Mobility and heterogeneity of devices imply that applications need to adapt depending on their execution context. Contexts such as the device that an application is running on, or the power profile, may require widespread program-wide adaptation. Dealing with this adaptation can lead to the introduction of subtle bugs, and subsequent runtime errors, such as null pointer exceptions when context has not been initialized. Current approaches to encoding context-aware behaviour are either very flexible but unsafe, or safe but too restrictive. In this thesis we present a new approach to context-aware application development based on functional programming, which attempts to be both flexible and safe. In order to do so, we present an embedded domain specific language in Haskell, where we explore the design space of context-dependent values within a functional programming language. In particular, we explore how to use Haskell's type system to automatically derive the context dependencies needed by a computation at the type level, and use this to ensure that required context is always available. We then develop context-dependent types to ensure safety in the presence of program-wide variation. By using different return types for different modes of operation of the program when appropriate, we can ensure isolation between them through type checking. We extend our domain specific language to support context-dependent types, whilst retaining type soundness, as well as sound and (we conjecture) complete type inference. We present a core calculus for these features and a high-level language that extends the calculus with practical programming features. Evaluation is performed by examining a context-aware application requiring exactly the kind of adaptation that is unsafe to implement in current approaches. We show that our language compares favourably to the state of the art in terms of both safety and code clarity.
9
Yoo, Daniel. "Building Web Based Programming Environments for Functional Programming." Digital WPI, 2012. https://digitalcommons.wpi.edu/etd-dissertations/181.
Testo completoAbstract (sommario):
Functional programming offers an accessible and powerful algebraic model for computing. JavaScript is the language of the ubiquitous Web, but it does not support functional programs well due to its single-threaded, asynchronous nature and lack of rich control flow operators. The purpose of this work is to extend JavaScript to a language environment that satisfies the needs of functional programs on the Web. This extended language environment uses sophisticated control operators to provide an event-driven functional programming model that cooperates with the browser's DOM, along with synchronous access to JavaScript's asynchronous APIs. The results of this work are used toward two projects: (1) a programming environment called WeScheme that runs in the web browser and supports a functional programming curriculum, and (2) a tool-chain called Moby that compiles event-driven functional programs to smartphones, with access to phone-specific features.
10
Alam, Abu S. "A programming system for end-user functional programming." Thesis, University of Gloucestershire, 2015. http://eprints.glos.ac.uk/2738/.
Testo completoAbstract (sommario):
This research involves the construction of a programming system, HASKEU, to support end-user programming in a purely functional programming language. An end-user programmer is someone who may program a computer to get their job done, but has no interest in becoming a computer programmer. A purely functional programming language is one that does not require the expression of statement sequencing or variable updating. The end-user is offered two views of their functional program. The primary view is a visual one, in which the program is presented as a collection of boxes (representing processes) and lines (representing data flow). The secondary view is a textual one, in which the program is presented as a collection of written function definitions. It is expected that the end-user programmer will begin with the visual view, perhaps later moving on to the textual view. The task of the programming system is to ensure that the visual and textual views are kept consistent as the program is constructed. The foundation of the programming system is a implementation of the Model-View-Controller (MVC) design pattern as a reactive program using the elegant Functional Reactive Programming (FRP) framework. Human-Computer Interaction (HCI) principles and methods are considered in all design decisions. A usabilty study was made to �find out the effectiveness of the new system.
11
Christiansen, Jan [Verfasser]. "Investigating Minimally Strict Functions in Functional Programming / Jan Christiansen." Kiel : Universitätsbibliothek Kiel, 2012. http://d-nb.info/1024079805/34.
Testo completo
12
Berg, Klaas Gerrit van den. "Software measurement and functional programming." Enschede : University of Twente [Host], 1995. http://doc.utwente.nl/57883.
Testo completo
13
Gordon, Andrew Donald. "Functional programming and input/output." Thesis, University of Cambridge, 1992. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.259479.
Testo completo
14
Josephs, M. B. "Functional programming with side-effects." Thesis, University of Oxford, 1986. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.375263.
Testo completo
15
Grattage, Jonathan James. "A functional quantum programming language." Thesis, University of Nottingham, 2006. http://eprints.nottingham.ac.uk/10250/.
Testo completoAbstract (sommario):
This thesis introduces the language QML, a functional language for quantum computations on finite types. QML exhibits quantum data and control structures, and integrates reversible and irreversible quantum computations. The design of QML is guided by the categorical semantics: QML programs are interpreted by morphisms in the category FQC of finite quantum computations, which provides a constructive operational semantics of irreversible quantum computations, realisable as quantum circuits. The quantum circuit model is also given a formal categorical definition via the category FQC. QML integrates reversible and irreversible quantum computations in one language, using first order strict linear logic to make weakenings, which may lead to the collapse of the quantum wavefunction, explicit. Strict programs are free from measurement, and hence preserve superpositions and entanglement. A denotational semantics of QML programs is presented, which maps QML terms into superoperators, via the operational semantics, made precise by the category Q. Extensional equality for QML programs is also presented, via a mapping from FQC morphisms into the category Q.
16
King, David Jonathan. "Functional programming and graph algorithms." Thesis, University of Glasgow, 1996. http://theses.gla.ac.uk/1629/.
Testo completoAbstract (sommario):
This thesis is an investigation of graph algorithms in the non-strict purely functional language Haskell. Emphasis is placed on the importance of achieving an asymptotic complexity as good as with conventional languages. This is achieved by using the monadic model for including actions on the state. Work on the monadic model was carried out at Glasgow University by Wadler, Peyton Jones, and Launchbury in the early nineties and has opened up many diverse application areas. One area is the ability to express data structures that require sharing. Although graphs are not presented in this style, data structures that graph algorithms use are expressed in this style. Several examples of stateful algorithms are given including union/find for disjoint sets, and the linear time sort binsort. The graph algorithms presented are not new, but are traditional algorithms recast in a functional setting. Examples include strongly connected components, biconnected components, Kruskal's minimum cost spanning tree, and Dijkstra's shortest paths. The presentation is lucid giving more insight than usual. The functional setting allows for complete calculational style correctness proofs - which is demonstrated with many examples. The benefits of using a functional language for expressing graph algorithms are quantified by looking at the issues of execution times, asymptotic complexity, correctness, and clarity, in comparison with traditional approaches. The intention is to be as objective as possible, pointing out both the weaknesses and the strengths of using a functional language.
17
Grimley, Allan. "Inductive types in functional programming." Thesis, University of Kent, 1990. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.253737.
Testo completo
18
Toyn, I. "Exploratory environments for functional programming." Thesis, University of York, 1987. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.377289.
Testo completo
19
Schwendner, Alex (Alex R. ). "Distributed functional programming in Scheme." Thesis, Massachusetts Institute of Technology, 2010. http://hdl.handle.net/1721.1/61515.
Testo completoAbstract (sommario):
Thesis (M. Eng.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 2010.<br>This electronic version was submitted by the student author. The certified thesis is available in the Institute Archives and Special Collections.<br>Cataloged from student-submitted PDF version of thesis.<br>Includes bibliographical references (p. 61-62).<br>In this thesis, we present a framework for writing distributed computer programs in Scheme using simple "future" semantics. This allows a Scheme program originally written for execution on a single computer to be run in a distributed manner on a cluster of computers with very little modification to the program. The structure of the computation can be extremely general and need not be specified in advance. In order to provide this programming environment, we implemented a system of job execution servers which transparently execute arbitrary Scheme code written in a functional or mostly functional style. The use of a functional, side effect free style of programming simplifies the challenges of data consistency. A number of demonstrations of the system are presented, including a distributed SAT solver. The performance of the system is shown to increase roughly linearly with the number of servers employed.<br>by Alex Schwendner.<br>M.Eng.
20
Wallace, Malcolm. "Functional programming and embedded systems." Thesis, University of York, 1995. http://etheses.whiterose.ac.uk/10807/.
Testo completo
21
Roe, Paul. "Parallel programming using functional languages." Thesis, Connect to e-thesis, 1991. http://theses.gla.ac.uk/1052.
Testo completo
22
Abdul, Rauf Rose Hafsah Binti. "Integrating functional programming into C++." Thesis, Swansea University, 2008. https://cronfa.swan.ac.uk/Record/cronfa43069.
Testo completo
23
Ryder, Chris. "Software measurement for functional programming." Thesis, University of Kent, 2004. https://kar.kent.ac.uk/14117/.
Testo completoAbstract (sommario):
This thesis presents an investigation into the usefulness of software measurement techniques, also known as software metrics, for software written in functional programming languages such as Haskell. Statistical analysis is performed on a selection of metrics for Haskell programs, some taken from the world of imperative languages. An attempt is made to assess the utility of various metrics in predicting likely places that bugs may occur in practice by correlating bug fixes with metric values within the change histories of a number of case study programs. This work also examines mechanisms for visualising the results of the metrics and shows some proof of concept implementations for Haskell programs, and notes the usefulness of such tools in other software engineering processes such as refactoring.
24
Toczé, Klervie. "Functional Reactive Programming as programming model for telecom server software." Thesis, Linköpings universitet, Programvara och system, 2014. http://urn.kb.se/resolve?urn=urn:nbn:se:liu:diva-113142.
Testo completoAbstract (sommario):
This thesis studies the use of the functional reactive programming (FRP) framework reactive-banana in a prototype which simulates a part of a Long-Term Evolution (LTE) base station: the Radio Resource Control connection setup procedure. The investigated problem is to determine whether using this FRP framework leads to an implementation with suitable performance and improved maintainability compared to the current implementation. Enhancing the maintainability of the base station software enables quicker and more efficient maintenance activities, which lead to an improved customer satisfaction. Moreover, it means that less programmers need to work on maintenance, so they can work on developing new products instead. In order to compare the use of the FRP paradigm to the one currently used in the base station implementation, the object-oriented programming (OOP) paradigm, a second prototype using this paradigm was also implemented. Having two prototypes implementing the same designed reference model (which is a simplified version of the Radio Resource Control connection setup procedure) enables a relevant comparison of the two paradigms. The two prototypes were then compared in terms of performance and maintainability. The maintainability evaluation consisted in using both software metrics and experts’ assessment, as this has been proven to be the most efficient way to evaluate software maintainability. Four experts were asked to fill in a questionnaire after reviewing the code of the two implementations. The comparison of the two prototypes indicates that the FRP prototype is more maintainable than the OOP one, but the OOP prototype has better performances than the FRP one. Moreover, the performance of the FRP prototype during the conducted tests indicates that such an implementation of the FRP paradigm is not suitable for a real base station.
25
King, Christopher T. "An axiomatic semantics for functional reactive programming." Worcester, Mass. : Worcester Polytechnic Institute, 2008. http://www.wpi.edu/Pubs/ETD/Available/etd-042908-133033/.
Testo completo
26
Benini, Enrico. "Functional Programming In Modern Software Systems." Master's thesis, Alma Mater Studiorum - Università di Bologna, 2017. http://amslaurea.unibo.it/13264/.
Testo completoAbstract (sommario):
Con questa tesi si vuole studiare come il paradigma funzionale, sebbene sia meno utilizzato rispetto alle controparti imperative ed object oriented, stia influenzando l'industria del software. Durante la trattazione verranno analizzate le motivazioni alla base di questa tendenza e illustrate, attraverso semplici esempi, le principali astrazioni fondanti lo stile funzionale.
I risultati delle analisi svolte mostrano come lo stile funzionale sia oramai una conoscenza essenziale e un'alternativa matura e concreta per la produzione del software. Inoltre, questo argomento viene avvalorato dalla crescente importanza che stanno assumendo proprietà software come: concorrenza, scalabilità, correttezza e manutenibilità.
Infine, alla luce di queste considerazioni, si presenta un semplice domain-specific language estensibile e integrabile con applicazioni già esistenti. Questo incorpora un sottoinsieme dei concetti trattati e una precisa architettura con lo scopo di astrarre dalle esistenti tecnologie e rendere queste tematiche accessibili.
27
Svallfors, Hugo. "Sard: An Object-Functional Programming Language." Thesis, Umeå universitet, Institutionen för datavetenskap, 2011. http://urn.kb.se/resolve?urn=urn:nbn:se:umu:diva-51276.
Testo completoAbstract (sommario):
This bachelor's degree concerns the specification of a new programming language. This language, called Sard, is a backwards-incompatible new version of the existing language Scala. Sard, like Scala, is a high-level object-functional language. Unlike Scala, it is not very closely tied to the JVM or Java, eliminating some constraints on the language's design. Since this necessitates breaking backwards compatibility with Scala, the opportunity to disregard it is used to x some of the author's irritations with the language. This degree mostly focuses on deciding on the exact changes to Scala, and on the overall design, rather than on implementing a compiler for the language. A reason for this is that the bachelor's degree provides insuficient time to properly implement´and debug a compiler. Another is the desirability of pushing changes to the language as early into the design process as possible. Preferably, almost all changes to the language should occur before any compiler code has been written. The design eventually produced gets rid of some known issues stemming from the JVM, like null pointers, non-reified generics and single inheritance. Several features of Scala, like self-type annotations and in x syntax for methods are scrapped. Others, like pattern matching, are generalized. Some changes to the syntax are also made, particularly in the areas of closures, pattern matching and object construction. As of yet, this language has no implementation, and in future work, this must be rectified. Sard also requires calling compatibility with another programming language, but this remains to be specified. Nevertheless, Sard constitutes a promising refinement of an already great programming language, and it is hoped that Sard will x the few remaining issues with Scala's design.
28
Bergstrom, Lars. "Parallel functional programming with mutable state." Thesis, The University of Chicago, 2013. http://pqdtopen.proquest.com/#viewpdf?dispub=3568360.
Testo completoAbstract (sommario):
<p> Immutability greatly simplifies the implementation of parallel languages. In the absence of mutable state the language implementation is free to perform parallel operations with fewer locks and fewer restrictions on scheduling and data replication. In the Manticore project, we have achieved nearly perfect speedups across both Intel and AMD manycore machines on a variety of benchmarks using this approach. </p><p> There are parallel stateful algorithms, however, that exhibit significantly better performance than the corresponding parallel algorithm without mutable state. For example, in many search problems, the same problem configuration can be reached through multiple execution paths. Parallel stateful algorithms share the results of evaluating the same configuration across threads, but parallel mutation-free algorithms are required to either duplicate work or thread their state through a sequential store. Additionally, in algorithms where each parallel task mutates an independent portion of the data, non-conflicting mutations can be performed in parallel. The parallel state-free algorithm will have to merge each of those changes individually, which is a sequential operation at each step. </p><p> In this dissertation, we extend Manticore with two techniques that address these problems while preserving its current scalability. <i>Memoization </i>, also known as function caching, is a technique that stores previously returned values from functions, making them available to parallel threads of executions that call that same function with those same values. We have taken this deterministic technique and combined it with a high-performance implementation of a dynamically sized, parallel hash table to provide scalable performance. We have also added <i>mutable state</i> along with two execution models — one of which is deterministic — that allow the user to share arbitrary results across parallel threads under several execution models, all of which preserve the ability to reason locally about the behavior of code. </p><p> For both of these techniques, we present a detailed description of their implementations, examine a set of relevant benchmarks, and specify their semantics. </p>
29
Taylor, Frank Stephen. "Parallel functional programming by declarative partitioning." Thesis, Imperial College London, 1997. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.264268.
Testo completo
30
Iglesias, Pablo Nogueira. "Polytypic functional programming and data abstraction." Thesis, University of Nottingham, 2005. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.430769.
Testo completo
31
Howells, William Gareth James. "Data modelling, subtyping and functional programming." Thesis, University of Kent, 1991. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.279165.
Testo completo
32
Widera, Manfred [Verfasser]. "Testing in Functional Programming / Manfred Widera." Aachen : Shaker, 2008. http://d-nb.info/1162790296/34.
Testo completo
33
Al-Khanji, L. (Louai). "Expressing functional reactive programming in C++." Master's thesis, University of Oulu, 2015. http://jultika.oulu.fi/Record/nbnfioulu-201511212160.
Testo completoAbstract (sommario):
Abstract. Most C++ programs are written in a straight-forward imperative style. While e.g. callbacks are employed either directly or through the observer pattern, the mental overhead of keeping program state congruent is high and increases with program size.
This paper presents a translation of functional reactive programming into C++ terms. This paradigm originates from the Haskell language community and seeks to express easily how programs should react to new input.
Concretely, an implementation of a reactive property class is presented, where property in this context is a class holding a value of a user-specified type. The property class provides a mechanism to bind to it an expression that takes an arbitrary number of inputs, some of which can be other instances of property classes. When any of these dependent properties is updated the expression is re-evaluated, so that a dataflow graph may be built using this type. The automatic re-evaluation reduces the boilerplate code necessary to update variables, which can lead to fewer programming errors and more concise programs.
The implementation demonstrates that the core principles of functional reactive programming can be expressed in modern C++. Further, the implementation can be done in an idiomatic manner which appears familiar to C++ developers.
At the same time, the implementation’s complexity highlights how much further the C++ meta-programming facilities must be developed to properly support facilities such as a functional reactive programming library implementation.
A number of compile-time template metaprogramming utilities used in the implementation are also introduced.
34
Pitcher, C. S. "Functional programming and erratic non-determinism." Thesis, University of Oxford, 2001. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.393759.
Testo completo
35
Perez, Dominguez Ivan. "Extensible and robust functional reactive programming." Thesis, University of Nottingham, 2018. http://eprints.nottingham.ac.uk/50348/.
Testo completoAbstract (sommario):
Programming GUI and multimedia in functional languages has been a long-term challenge, and no solution convinces the community at large. Purely functional GUI and multimedia toolkits enable abstract thinking, but have enormous maintenance costs. General solutions like Functional Reactive Programming present a number of limitations. FRP has traditionally resisted efficient implementation, and existing libraries sacrifice determinism and abstraction in the name of performance. FRP also enforces structural constraints that facilitate reasoning, but at the cost of modularity and separation of concerns. This work addresses those limitations with the introduction of Monadic Stream Functions, an extension to FRP parameterised over a monad. I demonstrate that, in spite of being simpler than other FRP proposals, Monadic Stream Functions subsume and exceed other FRP implementations. Unlike other proposals, Monadic Stream Functions maintain purity at the type level, which is crucial for testing and debugging. I demonstrate this advantage by introducing FRP testing facilities based on temporal logics, together with debugging tools specific for FRP. I present two uses cases for Monadic Stream Functions: First, I show how the new constructs improved the design of game features and non-trivial games. Second, I present Reactive Values and Relations, an abstraction for model-view coordination in GUI programs based on a relational language, built on top of Monadic Stream Functions. Comprehensive examples are used to illustrate the benefits of this proposal in terms of clarity, modularity, feature coverage, and its low maintenance costs. The testing facilities mentioned before are used to encode and statically check desired interaction properties.
36
Seres, Silvija. "The algebra of logic programming." Thesis, University of Oxford, 2001. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.365466.
Testo completo
37
Yu, Gwoing Tina. "An analysis of the impact of functional programming techniques on genetic programming." Thesis, University College London (University of London), 2000. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.313519.
Testo completo
38
Gammon, Shauna C. A. "Notions of category theory in functional programming." Thesis, University of British Columbia, 2007. http://hdl.handle.net/2429/31756.
Testo completoAbstract (sommario):
We present a detailed examination of applications of category theory to functional
programming languages, with a primary focus on monads in Haskell.
First, we explore E. Moggi's work in categorical semantics, which provides
the theoretical foundation for employing monads in functional languages.
In particular, we examine his use of Kleisli triples to model notions of computation.
We then study P. Wadler's implementation of Moggi's ideas as
a means to mimic side-effects in the purely functional language Haskell.
We explicitly demonstrate the connections between Kleisli triples, categorytheoretic
monads, and Haskell monads. It is our principal aim to provide a
coherent translation between the abstracted concept of monads that exists
in category theory, and the formulation of monads as type-constructors that
is implemented in Haskell.<br>Science, Faculty of<br>Mathematics, Department of<br>Graduate
39
Wray, S. C. "Implementation and programming techniques for functional languages." Thesis, University of Cambridge, 1986. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.373719.
Testo completo
40
Sculthorpe, Neil. "Towards safe and efficient functional reactive programming." Thesis, University of Nottingham, 2011. http://eprints.nottingham.ac.uk/11981/.
Testo completoAbstract (sommario):
Functional Reactive Programming (FRP) is an approach to reactive programming where systems are structured as networks of functions operating on time-varying values (signals). FRP is based on the synchronous data-flow paradigm and supports both continuous-time and discrete-time signals (hybrid systems). What sets FRP apart from most other reactive languages is its support for systems with highly dynamic structure (dynamism) and higher-order reactive constructs (higher-order data-flow). However, the price paid for these features has been the loss of the safety and performance guarantees provided by other, less expressive, reactive languages. Statically guaranteeing safety properties of programs is an attractive proposition. This is true in particular for typical application domains for reactive programming such as embedded systems. To that end, many existing reactive languages have type systems or other static checks that guarantee domain-specific constraints, such as feedback being well-formed (causality analysis). However, compared with FRP, they are limited in their capacity to support dynamism and higher-order data-flow. On the other hand, as established static techniques do not suffice for highly structurally dynamic systems, FRP generally enforces few domain-specific constraints, leaving the FRP programmer to manually check that the constraints are respected. Thus, there is currently a trade-off between static guarantees and dynamism among reactive languages. This thesis contributes towards advancing the safety and efficiency of FRP by studying highly structurally dynamic networks of functions operating on mixed (yet distinct) continuous-time and discrete-time signals. First, an ideal denotational semantics is defined for this kind of FRP, along with a type system that captures domain-specific constraints. The correctness and practicality of the language and type system are then demonstrated by proof-of-concept implementations in Agda and Haskell. Finally, temporal properties of signals and of functions on signals are expressed using techniques from temporal logic, as motivation and justification for a range of optimisations.
41
Loidl, Hans Wolfgang. "Granularity in large-scale parallel functional programming." Thesis, University of Glasgow, 1998. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.241782.
Testo completo
42
Wall, Karl. "G#, a graphical approach to functional programming." Thesis, Tekniska Högskolan, Högskolan i Jönköping, JTH, Datateknik och informatik, 2019. http://urn.kb.se/resolve?urn=urn:nbn:se:hj:diva-43359.
Testo completoAbstract (sommario):
The purpose of this bachelor thesis was to present a solution for how a graphical programming language with a functional mindset can be constructed with the help of inspiration from functional programming. An artefact was created by using design science as a research methodology and has in several iterations gone through development and testing to reassure the outcome works as intended. The graphical programming language which has been developed is a language that allows the programmer to code in depth, functions are written as blocks inside blocks and the language is made compact. A code structure in a JSON-format was developed at the same time as G#, allowing it to be presented in a texted data format. The purpose of the JSON-format was to enable execution of G# and the transformation to a text-based programming language. Implications can be made from this study by learning about how a graphical programming language can be built from scratch and what difficulties needs to be tackled to get a result that works as intended. G# was developed to only support a few selected and commonly used functions in programming due to time limitations. The final version of G# in this study can do calculations, handle lists and perform less complex algorithms. Under the development of G#’s graphical functions, the free tool Draw.io was used. Unknowingly from the start, Draw’s limitations made it not perform as expected. Therefore, it is recommended to investigate which available tools are most suited for the construction of the graphical functions before development begins.<br>Syftet med examensarbetet var att med hjälp av inspiration från funktionell programmering, presentera en lösning på hur ett nytt grafiskt programmeringsspråk med ett funktionellt djup och tänk kan konstrueras. Med hjälp av designbaserad forskning har en artefakt tagits fram som genomgått iterationer av utveckling och testning för att uppnå ett resultat som fungerar som tänkt. Det grafiska språket som tagits fram kallas för G# och är ett språk som tillåter programmeraren att programmera på djupet, funktioner skrivs som block inuti block och språket blir kompakt. Tillhörande G# så konstruerades en struktur i ett JSON-format för hur funktioner i G# kan representeras i ett textat dataformat. Syftet med JSON-formatet var att möjliggöra exekvering av G# och transformering till ett textbaserat programmeringsspråk. Av denna studie kan det dras lärdomar kring hur ett programmeringsspråk kan byggas upp från grunden och vilka svårigheter som måste tacklas för att få ett resultat som fungerar. På grund av begränsning av tid så utvecklades endast vanligt förekommande funktioner inom programmering till G#, språkets slutversion kan göra beräkningar, sköta hantering av listor och utföra enklare algoritmer. Vid utvecklingen av G# användes verktyget Draw.io för att konstruera funktioner. Verktyget var begränsat i funktionalitet och presterade inte enligt förväntan. Därför borde en undersökning som svarar på vilket typ av verktyg som är mest lämpligt för utvecklingen av de grafiska funktionerna göras innan utvecklingen börjar.
43
Ostheimer, Gerald. "Parallel functional programming for message-passing multiprocessors." Thesis, University of St Andrews, 1993. http://hdl.handle.net/10023/13426.
Testo completoAbstract (sommario):
We propose a framework for the evaluation of implicitly parallel functional programs on message passing multiprocessors with special emphasis on the issue of load bounding. The model is based on a new encoding of the lambda-calculus in Milner's pi-calculus and combines lazy evaluation and eager (parallel) evaluation in the same framework. The pi-calculus encoding serves as the specification of a more concrete compilation scheme mapping a simple functional language into a message passing, parallel program. We show how and under which conditions we can guarantee successful load bounding based on this compilation scheme. Finally we discuss the architectural requirements for a machine to support our model efficiently and we present a simple RISC-style processor architecture which meets those criteria.
44
Kelso, Joel. "A visual programming environment for functional languages." Thesis, Kelso, Joel (2002) A visual programming environment for functional languages. PhD thesis, Murdoch University, 2002. https://researchrepository.murdoch.edu.au/id/eprint/50254/.
Testo completoAbstract (sommario):
The purported advantages of Visual Programming, as applied to general purpose programmjng languages, have remained largely unfulfilled. The essence of this thesis is that functional programming languages have at least one natural visual representation, and that a useful programming environment can be based upon this representation.
This thesis describes the implementation of a Visual Functional Programming Environment (VFPE). The programming environment has several significant features.
•The environment includes a program editor that is inherently visual and interactive: syntactic program components have a visual representation and are assembled via a graphical interface.
•The program editor incorporates a static analysis system that tracks types for the whole program, making it impossible to construct syntactically incorrect or type-incorrect programs. Type information is continually and explicitly available to the programmer.
•The environment implements an implicitly typed higher-order purely functional language without conforming exactly to any particular language with respect to syntactic structures or reduction semantics.
•Programs can be output as source code for an existing functional language.
•The visual representation allows for continued experimentation with new syntactic features. Some currently included features are algebraic data types, pattern matching, and guarded expressions.
•The environment includes a visual interpreter which allows any expression to be reduced in source form, with a choice of reduction behaviors.
Please note that this thesis was written to be read in conjunction with a set of animated examples. The examples should be present on some form of digital media accompanying this thesis: at the points indicated in the thesis text, the reader should view the associated example.
45
Graham, Gwyneth Clare. "An investigation of nondeterminism in functional programming languages." Thesis, Rhodes University, 1997. http://hdl.handle.net/10962/d1006658.
Testo completoAbstract (sommario):
This thesis investigates nondeterminism in functional programming languages. To establish a precise understanding of nondeterministic language properties, Sondergaard and Sestoft's analysis and definitions of functional language properties are adopted as are the characterizations of weak and strong nondeterminism. This groundwork is followed by a denotational semantic description of a nondeterministic language (suggested by Sondergaard and Sestoft). In this manner, a precise characterization of the effects of strong nondeterminism is developed. Methods used to hide nondeterminism to in order to overcome or sidestep the problem of strong nondeterminism in pure functional languages are defined. These different techniques ensure that functional languages remain pure but also include some of the advantages of nondeterminism. Lastly, this discussion of nondeterminism is applied to the area of functional parallel language implementation to indicate that the related problem and the possible solutions are not purely academic. This application gives rise to an interesting discussion on optimization of list parallelism. This technique relies on the ability to decide when a bag may be used instead of a list.
46
McNamara, Brian. "Multiparadigm programming novel devices for implementing functional and logic programming constructs in C++ /." Diss., Available online, Georgia Institute of Technology, 2004:, 2004. http://etd.gatech.edu/theses/available/etd-07122004-121450/unrestricted/mcnamara%5Fbrian%5Fm%5F200407%5Fphd.pdf.
Testo completoAbstract (sommario):
Thesis (Ph. D.)--College of Computing, Georgia Institute of Technology, 2005. Directed by Yannis Smaragdakis.<br>Spencer Rugaber, Committee Member ; Olin Shivers, Committee Member ; Mary Jean Harrold, Committee Member ; Yannis Smaragdakis, Committee Chair ; Philip Wadler, Committee Member. Includes bibliographical references.
47
Mathaikutty, Deepak Abraham. "Functional Programming and Metamodeling frameworks for System Design." Thesis, Virginia Tech, 2005. http://hdl.handle.net/10919/32639.
Testo completoAbstract (sommario):
System-on-Chip (SoC) and other complex distributed hardware/software systems contain heterogeneous components whose behavior are best captured by different models of computations (MoCs). As a result, any system design framework for such systems requires the capability to express heterogeneous MoCs. Although a number of system level design languages (SLDL)s and frameworks have proliferated over the last few years, most of them are lacking in multiple ways. Some of the SLDLs and system design frameworks we have worked with are SpecC, Ptolemy II, SystemC-H, etc. From our analysis of these, we identify their following shortcomings: First, their dependence on specific programming language artifacts (Java or C/C++) make them less amenable to formal analysis. Second, the refinement strategies proposed in the design flows based on these languages lack formal semantics underpinnings making it difficult to prove that refinements preserve correctness, and third, none of the available SLDLs are easily customizable by users. In our work, we address these problems as follows: To alleviate the first problem, we follow Axel Jantschâ s paradigm of function-based semantic definitions of MoCs and formulate a functional programming framework called SML-Sys. We illustrate through a number of examples how to model heterogenous computing systems using SML-Sys. Our framework provides for formal reasoning due to its formal semantic underpinning inherited from SMLâ s precise denotational semantics. To handle the second problem and apply refinement strategies at a higher-level, we propose a refinement methodology and provide a semantics preserving transformation library within our framework. To address the third shortcoming, we have developed EWD, which allows users to customize MoC-specific visual modeling syntax defined as a metamodel. EWD is developed using a metamodeling framework GME (Generic Modeling Environment). It allows for automatic design-time syntactic and semantic checks on the models for conformance to their metamodel. Modeling in EWD facilitates saving the model in an XML-based interoperability language (IML) we defined for this purpose. The IML format is in turn automatically translated into Standard ML, or Haskell models. These may then be executed and analyzed either by our existing model analysis tools SMLSys, or the ForSyDe environment. We also generate SMV-based template from the XML representation to obtain verification models.<br>Master of Science
48
Penney, Alastair William. "Augmenting trace-based functional debugging." Thesis, University of Bristol, 2000. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.310594.
Testo completo
49
Mountjoy, Jon-Dean. "Static analysis of functional languages." Thesis, Rhodes University, 1994. http://hdl.handle.net/10962/d1006690.
Testo completoAbstract (sommario):
Static analysis is the name given to a number of compile time analysis techniques used to automatically generate information which can lead to improvements in the execution performance of function languages. This thesis provides an introduction to these techniques and their implementation. The abstract interpretation framework is an example of a technique used to extract information from a program by providing the program with an alternate semantics and evaluating this program over a non-standard domain. The elements of this domain represent certain properties of interest. This framework is examined in detail, as well as various extensions and variants of it. The use of binary logical relations and program logics as alternative formulations of the framework , and partial equivalence relations as an extension to it, are also looked at. The projection analysis framework determines how much of a sub-expression can be evaluated by examining the context in which the expression is to be evaluated, and provides an elegant method for finding particular types of information from data structures. This is also examined. The most costly operation in implementing an analysis is the computation of fixed points. Methods developed to make this process more efficient are looked at. This leads to the final chapter which highlights the dependencies and relationships between the different frameworks and their mathematical disciplines.<br>KMBT_223
50
Schütz, Marko. "Analyzing demand in non-strict functional programming languages /." Frankfurt a. M, 2000. http://deposit.ddb.de/cgi-bin/dokserv?idn=979469546.
Testo completo