Programming F#

  • ポイントキャンペーン

Programming F#

  • ただいまウェブストアではご注文を受け付けておりません。 ⇒古書を探す
  • 製本 Paperback:紙装版/ペーパーバック版/ページ数 383 p.
  • 言語 ENG
  • 商品コード 9780596153649
  • DDC分類 005

Table of Contents

Foreword                                           xiii
Preface xv
Part I. Multiparadigm Programming
Introduction to F# 3 (10)
Getting to Know F# 3 (1)
Visual Studio 2010 4 (4)
Your Second F# Program 5 (1)
Values 6 (1)
Whitespace Matters 6 (2)
.Net Interop 8 (1)
Comments 8 (1)
F# Interactive 8 (3)
Managing F# Source Files 11 (2)
Fundamentals 13 (34)
Primitive Types 13 (8)
Numeric Primitives 14 (1)
Arithmetic 15 (2)
Conversion Routines 17 (1)
Biglnt 17 (1)
Bitwise Operations 18 (1)
Characters 18 (1)
Strings 19 (1)
Boolean Values 20 (1)
Comparison and Equality 21 (1)
Functions 22 (7)
Type Inference 23 (1)
Generic Functions 24 (1)
Scope 25 (2)
Control Flow 27 (2)
Core Types 29 (13)
Unit 29 (1)
Tuple 30 (2)
Lists 32 (4)
Aggregate Operators 36 (3)
Option 39 (2)
Printfn 41 (1)
Anatomy of an F# Program 42 (5)
Modules 43 (1)
Namespaces 43 (1)
Program Startup 44 (3)
Functional Programming 47 (38)
Programming with Functions 48 (14)
Immutability 49 (1)
Function Values 50 (3)
Recursive Functions 53 (2)
Symbolic Operators 55 (2)
Function Composition 57 (5)
Pattern Matching 62 (8)
Match Failure 64 (1)
Named Patterns 64 (1)
Matching Literals 65 (1)
When Guards 66 (1)
Grouping Patterns 67 (1)
Matching the Structure of Data 68 (1)
Outside of Match Expressions 69 (1)
Alternate Lambda Syntax 70 (1)
Discriminated Unions 70 (5)
Using Discriminated Unions for Tree 72 (1)
Structures
Pattern Matching 73 (2)
Methods and Properties 75 (1)
Records 75 (4)
Cloning Records 76 (1)
Pattern Matching 77 (1)
Type Inference 77 (1)
Methods and Properties 78 (1)
Lazy Evaluation 79 (1)
Lazy Types 79 (1)
Sequences 80 (1)
Sequence Expressions 81 (1)
Seq Module Functions 82 (1)
Aggregate Operators 83 (2)
Imperative Programming 85 (30)
Understanding Memory in .NET 86 (3)
Value Types Versus Reference Types 87 (1)
Default Values 87 (2)
Reference Type Aliasing 89 (1)
Changing Values 89 (3)
Reference Cells 91 (1)
Mutable Records 92 (1)
Arrays 92 (9)
Indexing an Array 93 (2)
Array Slices 95 (1)
Creating Arrays 96 (1)
Pattern Matching 97 (1)
Array Equality 97 (1)
Array Module Functions 98 (1)
Multidimensional Arrays 99 (2)
Mutable Collection Types 101 (4)
List<`T> 101 (1)
Dictionary<`K,`V> 102 (2)
HashSet<`T> 104 (1)
Looping Constructs 105 (3)
While Loops 105 (1)
For Loops 106 (2)
Exceptions 108 (7)
Handling Exceptions 109 (2)
Reraising Exceptions 111 (1)
Defining Exceptions 111 (4)
Object-Oriented Programming 115 (30)
Programming with Objects 115 (1)
The Benefits of OOP 115 (1)
When OOP Breaks Down 116 (1)
Understanding System.Object 116 (6)
Common Methods 117 (2)
Object Equality 119 (1)
Generated Equality 120 (2)
Understanding Classes 122 (5)
Explicit Construction 123 (1)
Implicit Class Construction 124 (1)
Generic Classes 125 (2)
The Self-Identifier 127 (1)
Methods and Properties 127 (9)
Properties 128 (1)
Setting Properties in the Constructor 129 (1)
Methods 129 (2)
Static Methods, Properties, and Fields 131 (2)
Method Overloading 133 (1)
Accessibility Modifiers 134 (2)
Inheritance 136 (9)
Method Overriding 138 (1)
Categories of Classes 139 (2)
Casting 141 (4)
.NET Programming 145 (18)
The .NET Platform 145 (3)
The CLI 145 (1)
Garbage Collection 146 (2)
Interfaces 148 (3)
Using Interfaces 149 (1)
Defining Interfaces 150 (1)
Object Expressions 151 (3)
Object Expressions for Interfaces 152 (1)
Object Expressions for Derived Classes 153 (1)
Extension Methods 154 (1)
Extending Modules 155 (1)
Enumerations 156 (3)
Creating Enumerations 156 (1)
Conversion 157 (1)
When to Use an Enum Versus a 158 (1)
Discriminated Union
Structs 159 (4)
Creating Structs 159 (2)
Restrictions 161 (1)
When to Use a Struct Versus a Record 161 (2)
Applied Functional Programming 163 (42)
Units of Measure 163 (5)
Defining Units of Measure 165 (1)
Converting Between Units of Measure 166 (1)
Generic Units of Measure 167 (1)
Active Patterns 168 (10)
Single-Case Active Patterns 169 (1)
Partial-Case Active Patterns 170 (2)
Parameterized Active Patterns 172 (1)
Multi-Case Active Patterns 173 (1)
Using Active Patterns 174 (4)
Using Modules 178 (5)
Converting Modules to Classes 178 (3)
Intentional Shadowing 181 (1)
Controlling Module Usage 182 (1)
Mastering Lists 183 (3)
List Operations 184 (1)
Using Lists 185 (1)
Tail Recursion 186 (9)
Understanding the Stack 187 (3)
Introducing Tail Recursion 190 (2)
Tail-Recursive Patterns 192 (3)
Programming with Functions 195 (4)
Currying 195 (1)
Eliminating Redundant Code 196 (1)
Closures 197 (2)
Functional Patterns 199 (6)
Memoization 199 (2)
Mutable Function Values 201 (1)
Lazy Programming 202 (3)
Applied Object-Oriented Programming 205 (24)
Operators 205 (6)
Operator Overloading 205 (2)
Indexers 207 (2)
Adding Slices 209 (2)
Generic Type Constraints 211 (3)
Delegates and Events 214 (4)
Defining Delegates 215 (2)
Combining Delegates 217 (1)
Events 218 (11)
Creating Events 218 (2)
The Event<_,_> Class 220 (1)
The Observable Module 221 (4)
Creating .NET Events 225 (4)
Part II. Programming F#
Scripting 229 (12)
F# Script Files 230 (1)
Directives 230 (4)
General Directives 231 (1)
F# Script-Specific Directives 231 (3)
F# Script Recipes 234 (7)
Colorful Output 234 (1)
Producing Sound 235 (1)
Walking a Directory Structure 235 (1)
Starting Processes Easily 236 (1)
Automating Microsoft Office 237 (4)
Computation Expressions 241 (16)
Toward Computation Expressions 241 (3)
Computation Expression Builders 244 (3)
Custom Computation Expression Builders 247 (10)
Asynchronous Workflows 248 (1)
The Rounding Workflow 249 (1)
The State Workflow 250 (7)
Asynchronous and Parallel Programming 257 (30)
Working with Threads 258 (7)
Spawning Threads 259 (1)
The .NET Thread Pool 260 (1)
Sharing Data 261 (4)
Asynchronous Programming 265 (3)
Asynchronous Workflows 268 (8)
The Async Library 269 (4)
Async Operations 273 (1)
Custom Async Primitives 274 (1)
Limitations 275 (1)
Parallel Programming 276 (2)
Parallel.For 276 (1)
The Array.Parallel Module 277 (1)
Parallel Extensions for .NET 278 (9)
Primitives 279 (4)
Concurrent Data Structures 283 (4)
Reflection 287 (24)
Attributes 287 (4)
Applying Attributes 289 (1)
Defining New Attributes 290 (1)
Type Reflection 291 (7)
Accessing Types 291 (5)
Reflecting on F# Types 296 (2)
Dynamic Instantiation 298 (3)
Instantiating Types 298 (1)
Instantiating F# Types 299 (1)
Dynamic Invocation 299 (1)
The Question Mark Operators 300 (1)
Using Reflection 301 (10)
Declarative Programming 302 (3)
Plug-in Architecture 305 (6)
Quotations 311 (18)
Quotation Basics 312 (9)
Decomposing Quotations 312 (4)
Quoting Method Bodies 316 (2)
Decomposing Arbitrary Code 318 (1)
Application: Deferring Computation to 319 (2)
Other Platforms
Generating Quotation Expressions 321 (8)
Expression Holes 322 (1)
Evaluating Quotations 322 (2)
Application: Generating Derivatives 324 (5)
A. Overview of .NET Libraries 329 (28)
B. F# Interop 357 (14)
Index 371