Implementation and Application of Functional Languages

Name: Implementation and Application of Functional Languages | 20th International Symposium, IFL 2008, Hatfield, UK, September 10-12, 2008. Revised Selected Papers
Brand: Springer
Price: 53.49 EUR
Availability: OnlineOnly

20th International Symposium, IFL 2008, Hatfield, UK, September 10-12, 2008. Revised Selected Papers

Sven-Bodo Scholz Olaf Chitil(Herausgeber*in)

Springer (Verlag)

Erschienen am 28. September 2011

X, 291 Seiten

E-Book

PDF mit Wasserzeichen-DRM

Systemvoraussetzungen

978-3-642-24452-0 (ISBN)

53,49 €inkl. 7% MwSt.

Systemvoraussetzungen

für PDF mit Wasserzeichen-DRM

E-Book Einzellizenz

Als Download verfügbar

Beschreibung

Weitere Details

Weitere Ausgaben

Inhalt

Title
Preface
Organization
Table of Contents
Scans and Convolutions- A Calculational Proof of Moessner's Theorem
Introduction
Streams
Operations
Definitions
Proofs
Scans
Convolutions
Moessner's Process Formalised
Moessner's Process Verified
Moessner's Original Theorem
Paasche's Generalisation of Moessner's Theorem
Related Work
Conclusion
References
From Functional Logic Programs to Purely Functional Programs Preserving Laziness
Introduction
Informal Presentation of the Transformation
Non-determinism and Laziness
Naive Functional Encoding of Non-determinism
Combining Laziness and Call-Time Choice
Failing Computations
Formal Definition of Transformation
Preliminaries
Programs and Operations
The Transformation of Programs
Evaluation to Head Normal Form and Transformation of Goals
Related Work
Experimental Comparison
Conclusions and Future Work
References
An Interaction Net Implementation of Closed Reduction
Introduction
Interaction Nets
?-calculus: Closed Reduction Strategy
Interaction Net Encoding
Reduction
Testing
Conclusions
References
Implementation Architecture and Multithreaded Runtime System of S-Net
Introduction
S-Net in a Nutshell
Implementation Architecture
Network Deployment
Operational Behaviour of Components
Guaranteeing Causal Record Order
Performance Evaluation
Related Work
Conclusion and Future Work
References
Parsing Mixfix Operators
Introduction
Precedence and Associativity
A Grammar Scheme for Mixfix Operators
Unambiguity
Formalisation
Operators
Precedence Graphs
Expressions
Parser Combinators
The Grammar Scheme
Correctness
Implementation
Related Work
Conclusions
References
Descriptor-Free Representation of Arrays with Dependent Types
Introduction
Array Programming Basics
Types
Array Properties on Demand
Evaluation of Annotated Array Programs
Experimental Evaluation
Implementation
A Custom Benchmark
Related Work
Conclusion and Future Work
References
Collected Size Semantics for Functional Programs over Lists
Introduction
Language
Type System
Semantics of Zero-order Types
Operational Semantics of Program Expressions
Typing Rules
Semantics of Typing Judgements (soundness)
Approximation of Multivalued Size Functions
Inferring a Candidate Approximating Family of Polynomials
Checking If a Family Approximates a Size Function
Feasibility of Analysing of a Typical List Library
Related Work
Conclusions and Future Work
References
Embedding a Functional Hybrid Modelling Language in Haskell
Introduction
Fundamental Concepts of FHM and Hydra
Signals and Signal Functions
Signal Relations
The Hydra Syntax
Embedding Hydra
Why Quasiquoting?
The Haskell Embedding
Non-causal Connections
Model Flattening
Simulating Hydra Models
Related Work
Flask
Modelling Kernel Language
FHM at Yale
Non-causal Modelling and Simulation of Hybrid Systems
Future Work
Conclusions
References
Obsidian: A Domain Specific Embedded Language for Parallel Programming of Graphics Processors
Introduction
Connection Patterns for Hardware Design and Parallel Programming
Graphics Processing Units, Accessible High Performance Parallel Computing
Obsidian: A Domain Specific Embedded Language for GPU Programming
Implementation
Results
Discussion
Our Influences
Related Work on GPU and GPGPU Programming Languages
Lessons Learned so Far in the Project
Future Work
Conclusion
References
A Library for Processing Ad hoc Data in Haskell
Introduction
The Data Description Calculus
A Haskell Embedding
An Introductory Example
Primitive Parsers
Parser Combinators
Implementation
Adding Tools
Pretty Printing
Practical Considerations
Performance
Lines of Code
Error Detection
Related Work
Conclusions and Further Work
References
iEditors: Extending iTask with Interactive Plug-ins
Introduction
The iTask Toolkit
The Architecture of iTask Applications
The SAPL Interpreter and Clean-SAPL Dynamics
Examples of iTask Applications
iEditor: Plug-ins in iTask
The iTask Architecture Including iEditors
The PlugIn Wrapper Type
Interface Functions for a Plug-in
A Graphical Editor Plug-in for iTask
Implementation of iEditors
Fitting a Plug-in into the iTask Architecture
Data Exchange between Client, Plug-in and Server
Handling Call-Backs
Evaluation of Efficiency of Handling Call-Backs
Implementation for Java Applets
Mapping Clean and Java Data Types onto Each other
Java Applet Plug-in Interface
Discussion
Related Work
Conclusions
References
An Executable and Testable Semantics for iTasks
Introduction
A Semantics for iTasks
Task Identification
Events
Rewriting Tasks Given an Event
Equivalence of Tasks
Determining the Equivalence of Task Trees
Determining Equivalence by Applying Events
Determining Equivalence of Tasks by Comparing Task Trees
Testing Properties of iTasks
Discussion
References
Monatron: An Extensible Monad Transformer Library
Introduction
Combining Monads
Some Problems with the Traditional Design
Non-uniform Liftings
Quadratic Number of Instances
Shadowing of Operations
Portability
A New Approach
Overloading of Operations
Implementation of Monatron
Types for Operation Implementation
Implementing Transformers and Operations
Conclusion
Related Work
References
Catch Me If You Can
Introduction
The Error Monad
Representing Errors
Errors as Heavy-weight Sums
Errors as Lightweight Composition of Sums
Errors as Extensible Types
Errors as Polymorphic Variant
From Polymorphic Variants to Exception Hierarchies
Bottom Line
Measuring Performance
Conclusion
References
Between Types and Tables
Introduction
Motivating Example
ORM Formalization
Types and Tables
Object Role Models
Representation Types
From ORM To Representation Types
From Representation Types to Tables
Reverse Engineering: From Tables to Representation Types
Generic CRUD Operations
Reading Objects
Local Changes with Global Meaning
Updating Objects
Shared Consequences
Implementation in Clean
Jack of All Trades
Convenient Wrappers
Project Management Example System
Performance
Related Work
Conclusions and Future Work
References
Author Index

Inhalt (PDF)

Systemvoraussetzungen

Als PDF speichern Als Link merken