Don Syme

• Microsoft

Most modern applications interact with external services and access data in structured formats such as XML, JSON and CSV. Static type systems do not understand such formats, often making data access more cumbersome. Should we give up and leave the messy world of external data to dynamic typing and runtime checks? Of course, not! We present F# Data,...

Most modern applications interact with external services and access data in structured formats such as XML, JSON and CSV. Static type systems do not understand such formats, often making data access more cumbersome. Should we give up and leave the messy world of external data to dynamic typing and runtime checks? Of course, not! We present F# Data,...

Most modern applications interact with external services and access data in structured formats such as XML, JSON and CSV. Static type systems do not understand such formats, often making data access more cumbersome. Should we give up and leave the messy world of external data to dynamic typing and runtime checks? Of course, not! We present F# Data,...

Most programming languages were designed before the age of web. This matters because the web changes many assumptions that typed functional language designers take for granted. For example, programs do not run in a closed world, but must instead interact with (changing and likely unreliable) services and data sources, communication is often asynchr...

One of the major trends in modern computing is the “data deluge,” meaning the rapid rise in digital information available for analysis, especially through reliable networked services and large-scale data-storage systems. Some of this data may be collected by an individual or an organization, some may be acquired from data providers, and some may be...

So far in this book, you’ve seen functions and objects that process their inputs immediately using a single thread of execution in which the code runs to completion and produces useful results or state changes. In this chapter, you will turn your attention to concurrent, parallel, asynchronous, and programs. These represent substantially different...

Chapters 2 through 5 dealt with the basic constructs of F# functional and imperative programming, and by now we trust you’re familiar with the foundational concepts and techniques of practical, small-scale F# programming. This chapter covers language constructs related to object programming.

Delivering content and applications via web browsers is one of the most important aspects of modern software development. This chapter will examine how you can build web applications using F#. Some of the topics covered are the following:

In Chapters 8 and 9, you learned constructs and techniques for programming with three important kinds of data in F#: textual data, sequences of data, and structured data. In this chapter, we will return to constructs and techniques for one of the most important kinds of data in programming systems: numeric data.

This appendix will describe the essential constructs of the F# language in a compact form. You can find a full guide to the F# language in the F# Language Specification on the F# website ( http://fsharp.org/specs/ ).

Chapters 2 and 3 introduced the F# type for strings. While F#’s specialty is in programming with structured data, unstructured textual data is exceptionally common in programming, both as a data format and as an internal representation in algorithms that work over documents and text. In this chapter, you will learn some of the techniques available...

Organizing code and making it available for people and programs to use is a key part of best using F#. In this book, you’ve already seen many of the constructs to help you do this: functions, objects, type definitions, modules, namespaces, and assemblies. In some cases, however, you’ve encountered these only peripherally when using the libraries th...

F# is a typed language, and F# programmers often use types in sophisticated ways. In this chapter, you will learn about the foundations of types, focusing on how they are defined and used in F# functional programming. You also will look closely at generics, and closely related to generics is the notion of subtyping. Generics and subtyping combine t...

Software integration and reuse is becoming one of the most relevant activities in software development. This chapter will discuss how F# programs can interoperate with the outside world by accessing code available from both .NET and other languages.

GUI applications revolve around events, and F# provides a natural way to process events with functions. Graphical interfaces are often developed using visual editors, in particular to build GUIs by assembling controls. Applications, however, often need drawing capabilities for displaying and manipulating data, which requires custom programming to a...

Symbols are everywhere. Numbers are symbols that stand for quantities, and you can add, multiply, or take square roots of numbers that are so small or large that it’s hard to imagine the quantity they represent. You can solve equations, multiply polynomials, approximate functions using series, and differentiate or integrate numerically or symbolica...

In the previous chapter, you learned to manipulate textual data, including how to convert text to structured data through parsing and back again through formatting. In this chapter, you will focus on F# programming techniques related to structured data.

Successful programming must involve a healthy marriage of good code and good software engineering. Sometimes these overlap: functional programming is a good software-engineering technique. Among other benefits, anecdotal evidence indicates that functional programming frequently leads to a substantially reduced bug rate for good programmers. Program...

This chapter will cover simple interactive programming with F#. To begin, download and install F# from fsharp.org, if you don’t have it installed already. The sections that follow use F# Interactive (fsi.exe or fsharpi), a tool you can use to execute fragments of F# code interactively, and that is convenient for exploring the language. Along the wa...

Chapters 3 to 6 covered three well-known programming paradigms in F#: functional, imperative, and object programming. Throughout this book, however, you have in many ways been exploring what is essentially a fourth programming paradigm: language-oriented programming. In this chapter, you will focus on advanced aspects of language-oriented programmi...

Program logic can often be structured using abstract computation types such as monoids, monad transformers or applicative functors. Functional programmers use those abstractions directly while main-stream languages often integrate concrete instances as language features – e.g. generators in Python or asynchronous computations in C# 5.0. The questio...

Mobile applications are changing the way people interact with software. With the abundance of mobile devices such as smart phones and tablets, developing mobile applications and delivering content to mobile devices requires learning new skills and technologies. This chapter examines how you can build mobile web and native applications in F# using W...

So far in this book, you’ve seen functions and objects that process their inputs immediately using a single thread of execution in which the code runs to completion and produces useful results or state changes. In this chapter, you turn your attention to concurrent, parallel, asynchronous, and reactive programs. These represent substantially differ...

Chapters 2 through 5 dealt with the basic constructs of F# functional and imperative programming, and by now we trust you’re familiar with the foundational concepts and techniques of practical, small-scale F# programming. This chapter covers language constructs related to object programming.

Chapters 2 and 3 introduced the F# type for strings. While F#’s specialty is in programming with structured data, unstructured or semi-structured textual data are exceptionally common in programming, both as a data format and as working representation internally in algorithms that work over documents and text. In this section, you will learn some o...

This chapter covers simple interactive programming with F# and .NET. To begin, download and install a version of the F# distribution from www.fsharp.net. (You may have a version on your machine already—for instance, if you have installed Visual Studio.) The sections that follow use F# Interactive, a tool you can use to execute fragments of F# code...

GUI applications revolve around events, and F# provides a natural way to process events with functions. Graphical interfaces are often developed using visual editors, in particular to build GUIs by assembling controls. Applications, however, often need drawing capabilities for displaying and manipulating data, which requires custom programming to a...

In the previous chapter, you learned about some techniques used to manipulate unstructured data, including how to parse and format structured data as unstructured text. In this chapter, you focus on F# programming techniques related to structured data.

In Chapters 8 and 9, you learned constructs and techniques for programming with three important kinds of data in F#: textual data, sequences of data, and structured data. In this chapter, we return to constructs and techniques for one of the most important kinds of data in all programming systems: numeric data.

Software integration and reuse is becoming one of the most relevant activities in software development. This chapter discusses how F# programs can interoperate with the outside world, accessing code available from both .NET and other languages.

Organizing code and making it available for people and programs to use is a key part of making the best use of F#. In this book, you’ve already seen many of the constructs to help do this: functions, objects, type definitions, modules, namespaces, and assemblies. In some cases, however, you’ve encountered these only peripherally when using the libr...

Symbols are everywhere. Numbers are symbols that stand for quantities, and you can add, multiply, or take square roots of numbers that are so small or large that it’s hard to imagine the quantity they represent. You can solve equations, multiply polynomials, approximate functions using series, and differentiate or integrate numerically or symbolica...

F# is a typed language, and F# programmers often use types in sophisticated ways. In this chapter, you learn about the foundations of types, focusing on how types are defined and used in F# functional programming. You also look closely at generics, and closely related to generics is the notion of subtyping. Generics and subtyping combine to allow y...

One of the major trends in modern computing is “the data deluge,” meaning the rapid rise in availability of massive quantities of digital information available for analysis, especially through reliable networked services and large-scale data storage systems. Some of this data may be collected by an individual or an organization, some may be acquire...

Delivering content and aplications via web browsers is one of the most important aspects of modern software development. This chapter examines how you can build web applications using F#. The topics covered are: Serving static files and dynamic content by directly responding to HTTP requests Techniques to build client-based web applications with We...

Chapters 3 to 6 covered three well-known programming paradigms in F#: functional, imperative, and object programming. Throughout this book, however, you have in many ways been exploring what is essentially a fourth programming paradigm: language-oriented programming. In this chapter, you will focus on advanced aspects of language-oriented programmi...

Successful programming must involve a healthy marriage of good code with good software engineering techniques and practice. Sometimes these overlap: functional programming is a good software-engineering technique: among other benefits, anecdotal evidence indicates that functional programming frequently leads to a substantially reduced bug rate for...

Sequencing of effectful computations can be neatly captured using monads and elegantly written using do notation. In practice such monads often allow additional ways of composing computations, which have to be written explicitly using combinators. We identify joinads, an abstract notion of computation that is stronger than monads and captures many...

Technology transfer is typically viewed as being from academia to industry but it can indeed go in either direction. Many of the same challenges then apply -- platform suitability, timeliness, support, and community building. In this paper, we describe recent efforts to transfer technology for research and teaching from an industrial research labor...

We describe the asynchronous programming model in F#, and its applications to reactive, parallel and concurrent programming. The key feature combines a core language with a non-blocking modality to author lightweight asynchronous tasks, where the modality has control flow constructs that are syntactically a superset of the core language and are giv...

Modern challenges led to a design of a wide range of programming models for reactive, parallel and concurrent programming, but these are often difficult to encode in general purpose languages. We present an abstract type of computations called joinads together with a syntactic language extension that aims to make it easier to use joinads in modern...

Current compilers are still largely ignorant of the scheduling of parallel tasks at runtime. Without this information, however, they have difficulties optimizing and verifying concurrent programs. In this paper, we present a programming model where the ...

The reactive programming model is largely different to what we're used to as we don't have full control over the application's control flow. If we mix the declarative and imperative programming style, which is usual in the ML family of languages, the situation is even more complex. It becomes easy to introduce patterns where the usual garbage colle...

The reactive programming model is largely different to what we're used to as we don't have full control over the application's control flow. If we mix the declarative and imperative programming style, which is usual in the ML family of languages, the situation is even more complex. It becomes easy to introduce patterns where the usual garbage colle...

The reactive programming model is largely different to what we're used to as we don't have full control over the application's control flow. If we mix the declarative and imperative programming style, which is usual in the ML family of languages, the situation is even more complex. It becomes easy to introduce patterns where the usual garbage colle...

F# is effective and productive primarily because it’s built on the tried and tested constructs of functional programming. This chapter covers the core building blocks of functional programming with F#, including simple types and function values, pattern matching, lists, options, and sequences; as well as how to declare some of your own simple types...

GUI applications revolve around events, and F# provides a natural way to process events with functions. Graphical interfaces are often developed using visual editors, in particular to build GUIs by assembling controls. Applications, however, often need drawing capabilities for displaying and manipulating data, which requires custom programming to a...

Chapters 2 through 5 dealt with the basic constructs of F# functional and imperative programming, and by now we trust you’re familiar with the foundational concepts and techniques of practical, small-scale F# programming. This chapter covers language constructs related to object-oriented (OO) programming. We assume some familiarity with the basic c...

So far in this book, you’ve seen functions and objects that process their inputs immediately using a single thread of execution where the code runs to completion and produces useful results or state changes. In this chapter, you turn your attention to concurrent, parallel, asynchronous, and reactive programs. These represent substantially different...

Symbols are everywhere. Numbers are symbols that stand for quantities, and you can add, multiply, or take square roots of numbers that are so small or large that it’s hard to imagine the quantity they represent. You can solve equations, multiply polynomials, approximate functions using series, and differentiate or integrate numerically or symbolica...

Software applications deal with data in a wide array of forms: single values such as integers or strings; composite values paired together as tuples, records, or objects; collections of smaller pieces of data represented as lists, sets, arrays, or sequences; XML strings with tags describing the shape and kind of data; and data coming from relationa...

Delivering content and applications via web browsers is one of the most important aspects of modern software development. This chapter examines how you can build web applications using F#. The topics covered are as follows: Serving static files and dynamic content by directly responding to HTTP requests Using the ASP.NET framework to develop page-b...

Expert F# 2.0 is about practical programming in a beautiful language that puts the power and elegance of functional programming into the hands of professional developers. In combination with .NET, F# achieves unrivaled levels of programmer productivity and program clarity. Expert F# 2.0 is • The authoritative guide to F# by the inventor of F# • A...

Pattern matching of algebraic data types (ADTs) is a standard feature in typed functional programming languages, but it is well known that it interacts poorly with abstraction. While several partial solutions to this problem have been proposed, few have been implemented or used. This paper describes an extension to the .NET language F# called activ...

So far in this book you’ve seen functions and objects that process their inputs immediately using a single “thread” of execution where the code runs to completion and produces useful results or state changes. In this chapter, you’ll turn your attention to concurrent, parallel, asynchronous, and reactive programs. These each represent substantially...

F# is effective and productive primarily because it is built on the tried and tested constructs of functional programming. In this chapter, we cover the core building blocks of functional programming with F#, including simple types and function values, pattern matching, lists, options, and sequences, as well as how to declare some of your own simpl...

This book deals with F#, a language situated in the context of .NET-based software construction and engineering. As an expert F# programmer, you will need more than a knowledge of the F# language; you will also need to use a range of software engineering tools and methodologies wisely to let you build software that is truly valuable for the situati...

In Chapter 3 you saw some of the simple but powerful data types and language constructs that make up F# functional programming. The functional programming paradigm is strongly associated with “programming without side effects,” called pure functional programming. In this paradigm, programs compute the result of a mathematical expression and do not...

Software integration and reuse is becoming one of the most relevant activities of software development nowadays. In this chapter, we discuss how F# programs can interoperate with the outside world, accessing code available in the form of DLLs and COM components.

In Chapters 3,4, and 6 we covered three well-known programming paradigms in F#: functional, imperative, and objectoriented programming. In this chapter, we cover techniques and constructs related to what is essentially a fourth programming paradigm, which we call languageoriented programming. The word language can have a number of meanings in this...

F# and the .NET Framework offer a rich set of libraries for functional and imperative programming. In this chapter, we step back and give a broader overview of the .NET and F# libraries.

F# is a powerful language with relatively simple constructs. Learning the constructs of the language is easy, but learning how to use the constructs well takes a little more time. In this chapter, we present some of the common F# coding techniques you will need as you work across multiple programming domains. These techniques are either application...

In this chapter, you take a closer look at lexing and parsing, topics introduced briefly in Chapters 9 and 11. In particular, the chapter introduces the lexer and parser generators, fslex and fsyacc, that come with the F# distribution. A typical scenario when these techniques and tools can come in handy is the following: You want to read user-reada...

Software applications deal with data in a wide array of forms: single values such as integers or strings; composite values paired together as tuples, records, or objects; collections of smaller pieces of data represented as lists, sets, arrays, or sequences; XML strings with tags describing the shape and kind of data; or data coming from relational...

Delivering content and applications via web browsers is one of the most important aspects of modern software development. In this chapter, we examine how you can build web applications using F#. The topics we cover are as follows: Serving static files and dynamic content by directly responding to HTTP requests Using the ASP.NET framework to develop...

Packaging code and making it available for people and programs to use is a key part of making the best use of F#. In this book, you have already seen many of the constructs to help do this: functions, objects, type definitions, modules, namespaces, and assemblies. However, in some cases you have encountered these only peripherally when using the .N...

F# constructs such as lists, tuples, and function values are all generic, which means they can be instantiated at multiple different types. For example, int list, string list, and (int * int) list are all instantiations of the generic family of F# list types. Likewise, int → int and string → int are both instantiations of the generic family of F# f...

In this chapter, we cover some simple interactive programming with F# and .NET. By now you should have downloaded and installed a version of the F# distribution as described in Chapter 1. In the sections that follow, we use F# Interactive, a tool you can use to execute fragments of F# code interactively and a convenient way to explore the language....

GUI applications revolve around events, and F# provides a natural way to process events with functions. Graphical interfaces are often developed using visual editors, in particular to build GUIs by assembling controls. Applications, however, often need drawing capabilities for displaying and manipulating data, which requires custom programming to a...

Anecdotal evidence indicates that functional programming frequently leads to a substantially reduced bug rate for good programmers. This is primarily because programs built using functional techniques tend to be highly compositional, building correct programs out of correct building blocks. Functional programming style, moreover, avoids or substant...

Chapters 2 through 5 dealt with the basic constructs of F# functional and imperative programming, and by now we trust you are familiar with the foundational concepts and techniques of practical, small-scale F# programming. In this chapter, we cover language constructs related to objectoriented (OO) programming. We assume some familiarity with the b...

Symbols are everywhere. Numbers are symbols that stand for quantities, and you can add, multiply, or take square roots of numbers that are so small or large that one has a hard time imagining the quantity they represent. You can solve equations, multiply polynomials, approximate functions using series, and differentiate or integrate numerically or...

F#is a typed functional programming language for the .NET Framework. It combines the succinctness, expressivity, and compositionality of typed functional programming with the runtime support, libraries, interoperability, tools, and object model of.NET. Our aim in this book is to help you become an expert in using F# and the .NET Framework.

Contenido: 1. Introducción; 2. Para comenzar con F# y .NET; 3. Introducción a la programación funcional; 4. Introducción a la programación imperativa; 5. Dominio de tipos y genéricos; 6. Trabajo con objetos y módulos; 7. Encapsular y empacar su código; 8. Dominio de F#: técnicas comunes; 9. Introducción a la programación orientada por el lenguaje;...

Language-integrated meta-programming and extensible compilation have been recurring themes of programming languages since the invention of LISP. A recent real-world application of these techniques is the use of small meta-programs to specify database queries, as used in the Microsoft LINQ extensions for .NET. It is important that .NET languages suc...

Mutual dependencies between objects arise frequently in programs, and programmers must typically solve this value recursion by manually filling “initialization holes” to help construct the corresponding object graphs, i.e. null values and/or explicitly mutable locations. This paper aims to augment ongoing theoretical work on value recursion with a...

The Forte formal verification environment for datapath-dominated hardware is described. Forte has proven to be effective in large-scale industrial trials and combines an efficient linear-time logic model-checking algorithm, namely the symbolic trajectory evaluation (STE), with lightweight theorem proving in higher-order logic. These are tightly int...

Mutual dependencies between objects arise frequently in programs, and pro-grammers must typically resort to manually filling "initialization holes" to help construct the corresponding object graphs, i.e. null values and/or explicitly mutable locations. This report describes a "base-line" proposal for a general-ized form of value recursion in an ML-...

The Forte formal verification environment for datapath-dominated hardware is described. Forte has proven to be effective in large-scale industrial trials and combines an efficient linear-time logic model-checking algorithm, namely the symbolic trajectory evaluation (STE), with lightweight theorem proving in higher-order logic. These are tightly int...

We present a type-preserving translation of System F (the polymorphic lambda calculus) into a forthcoming revision of the C♯ programming language supporting parameterized classes and polymorphic methods. The forthcoming revision of Java in JDK 1.5 also makes a suitable target. We formalize the translation using a subset of C♯ similar to Featherweig...

We describe problems that have arisen when combining the proposed design for generics for the Microsoft .NET Com-mon Language Runtime (CLR) with two resource-related features supported by the Microsoft CLR implementation: application domains and pre-compilation. Application do-mains are "software based processes" and the interaction between applica...

We present a formalization of the implementation of generics in the .NET Common Language Runtime (CLR), focusing on two novel aspectsof the implementation: mixed specialization and sharing, and efficient support for run-time types. Some crucial constructs used in the implementation are dictionaries and run-time type representations. We formalize th...

We present a type-preserving translation of the polymor- phic lambda calculus (System F) into an extension of the C) programming language supporting parameterized classes and polymorphic methods. We observe that whilst parameterized classes alone are sucient to encode the parameterized datatypes and let- polymorphism of languages such as ML and Has...

Operational models of fragments of the Java Virtual Machine and the .NET Common Language Runtime have been the focus of considerable study in recent years, and of particular interest have been speci cations and machine-checked proofs of type soundness. In this paper we aim to increase the level of automation used when checking type soundness for th...

This paper describes several extensions to the .NET Common Intermediary Language (CIL), each of which is designed to enable easier implementation of typed high-level programming languages on the .NET platform, and to promote closer integration and interoperability between these languages. In particular we aim for easier interoperability between com...

The Microsoft.NET Common Language Runtime provides a shared type system, intermediate language and dynamic execution environment for the implementation and inter-operation of multiple source languages. In this paper we extend it with direct support for parametric polymorphism (also known as generics), describing the design through examples written...

The Microsoft .NET Framework is a new computing architecture designed to support a variety of distributed applications and web-based services. .NET software components are typically distributed in an object-oriented intermediate language, Microsoft IL, executed by the Microsoft Common Language Runtime. To allow convenient multilanguage working, IL...

. We describe the key features of the proof description language of Declare, an experimental theorem prover for higher order logic. We take a somewhat radical approach to proof description: proofs are not described with tactics but by using just three expressive outlining constructs. The language is "declarative" because each step specifies its log...

Syntax of Java S and Java A . . . . . . . . . . . . . . . 103 6.3 von Oheimb's Extended Range of Types . . . . . . . . . . . . . . . . 103 6.4 Type checking environments . . . . . . . . . . . . . . . . . . . . . . . 105 6.5 Connections in the Subtype Graph . . . . . . . . . . . . . . . . . . . 107 6.6 The Runtime Machine: Configurations and State ....

This chapter describes a machine checked proof of the type soundness of a subset of Java (we call this subset JavaS). In Chapter 3, a formal semantics for approximately the same subset was presented by Drossopoulou and Eisenbach. The work presented here serves two roles: it complements the written semantics by correcting and clarifying some details...

. This article is concerned with interactive support for "declarative theorem proving ". After introducing declarative theorem proving, both in general and as implemented in the Declare system, we outline the requirements of an interactive system in this context. We describe Ideclare, the interactive environment for Declare, and in particular its s...

Syntax of Java S and Java A . . . . . . . . . . . . . . . 103 6.3 von Oheimb's Extended Range of Types . . . . . . . . . . . . . . . . 103 6.4 Type checking environments . . . . . . . . . . . . . . . . . . . . . . . 105 6.5 Connections in the Subtype Graph . . . . . . . . . . . . . . . . . . . 107 6.6 The Runtime Machine: Configurations and State ....

TkHolWorkbench is a new set of interface tools for HOL implemented using the Tk toolkit. It aims to be robust, extensible, lightweight and user-friendly. The tools are designed to augment the existing HOL interface. The project applies rapid prototyping and the use of an interpreted toolkit to the field of theorem proving interfaces. The topics con...

This paper describes the results of a project to embed the Formal Definition of the Standard ML Core language into the HOL mechanized reasoning system. HOL theories of the Core syntax and dynamic semantics are presented, including a purely definitional representation of the semantic inference rules. The correctness of the representation is demonstr...