Kids Library Home

Welcome to the Kids' Library!

Search for books, movies, music, magazines, and more.

     
Available items only
E-Books/E-Docs
Author Syme, Don, author.

Title Expert F# 4.0 / Don Syme, Adam Granicz, Antonio Cisternino.

Publication Info. [Berkeley, California] : Apress, 2015.
New York, NY : Distributed to the Book trade worldwide by Springer
2015

Copies

Location Call No. OPAC Message Status
 Axe Books 24x7 IT E-Book  Electronic Book    ---  Available
Edition Fourth edition.
Description 1 online resource (xxvii, 582 pages) : illustrations
text txt rdacontent
computer c rdamedia
online resource cr rdacarrier
text file PDF rda
Note Online resource; title from PDF title page (SpringerLink, viewed January 4, 2016).
Includes index.
Summary Learn from F#'s inventor to become an expert in the latest version of this powerful programming language so you can seamlessly integrate functional, imperative, object-oriented, and query programming style flexibly and elegantly to solve any programming problem. Expert F# 4.0 will help you achieve unrivaled levels of programmer productivity and program clarity across multiple platforms including Windows, Linux, Android, OSX, and iOS as well as HTML5 and GPUs. F# 4.0 is a mature, open source, cross-platform, functional-first programming language which empowers users and organizations to tackle complex computing problems with simple, maintainable, and robust code. Expert F# 4.0 is: A comprehensive guide to the latest version of F# by the inventor of the language A treasury of F# techniques for practical problem-solving An in-depth case book of F# applications and F# 4.0 concepts, syntax, and features Written by F#'s inventor and two major F# community members, Expert F# 4.0 is a comprehensive and in-depth guide to the language and its use. Designed to help others become experts, the book quickly yet carefully describes the paradigms supported by F# language, and then shows how to use F# elegantly for a practical web, data, parallel and analytical programming tasks. The world's experts in F# show you how to program in F# the way they do!
Bibliography Includes bibliographical references.
Contents Machine generated contents note: ch. 1 Introduction -- Genesis of F# -- About This Book -- Who This Book Is For -- ch. 2 Your First F# Program: Getting Started with F# -- Creating Your First F# Program -- Documenting Code -- Using let -- Understanding Types -- Calling Functions -- Lightweight Syntax -- Understanding Scope -- Using Data Structures -- Using Properties and the Dot-Notation -- Using Tuples -- Using Imperative Code -- Using Object-Oriented Libraries from F# -- Using open to Access Namespaces and Modules -- Fetching a Web Page -- Getting and Using Packages -- Accessing External Data Using F# Packages -- Starting a Web Server and Serving Data using F# Packages -- Summary -- ch. 3 Introducing Functional Programming -- Starting with Numbers and Strings -- Some Simple Types and Literals -- Arithmetic Conversions -- Arithmetic Comparisons -- Simple Strings -- Working with Conditionals: && and II -- Defining Recursive Functions -- Lists -- Options -- Getting Started with Pattern Matching -- Matching on Structured Values -- Guarding Rules and Combining Patterns -- Further Ways of Forming Patterns -- Introducing Function Values -- Using Function Values -- Computing with Collection Functions -- Using Fluent Notation on Collections -- Composing Functions with >> -- Building Functions with Partial Application -- Using Local Functions -- Iterating with Functions -- Abstracting Control with Functions -- Using Object Methods as First-Class Functions -- Some Common Uses of Function Values -- Summary -- ch. 4 Introducing Imperative Programming -- About Functional and Imperative Programming -- Imperative Looping and Iterating -- Simple for Loops -- Simple While Loops -- More Iteration Loops over Sequences -- Using Mutable Records -- Avoiding Aliasing -- Using Mutable let Bindings -- Hiding Mutable Data -- Working with Arrays -- Generating and Slicing Arrays -- Two-Dimensional Arrays -- Introducing the Imperative .NET Collections -- Using Resizable Arrays -- Using Dictionaries -- Using Dictionary's TryGetValue -- Using Dictionaries with Compound Keys -- Some Other Mutable Data Structures -- Exceptions and Controlling Them -- Catching Exceptions -- Using try . . . finally -- Defining New Exception Types -- Having an Effect: Basic I/O -- .NET I/O via Streams -- Some Other I/O-Related Types -- Using System.Console -- Combining Functional and Imperative Efficient Precomputation and Caching -- Precomputation and Partial Application -- Precomputation and Objects -- Memoizing Computations -- Lazy Values -- Other Variations on Caching and Memoization -- Mutable Reference Cells -- Combining Functional and Imperative: Functional Programming with Side Effects -- Consider Replacing Mutable Locals and Loops with Recursion -- Separating Pure Computation from Side-Effecting Computations -- Separating Mutable Data Structures -- Not All Side Effects Are Equal -- Avoid Combining Imperative Programming and Laziness -- Summary -- ch. 5 Understanding Types in Functional Programming -- Exploring Some Simple Type Definitions -- Defining Type Abbreviations -- Defining Record Types -- Handling Non-Unique Record Field Names -- Cloning Records -- Defining Discriminated Unions -- Using Discriminated Unions as Records -- Defining Multiple Types Simultaneously -- Understanding Generics -- Writing Generic Functions -- Some Important Generic Functions -- Making Things Generic -- Generic Algorithms through Explicit Arguments -- Generic Algorithms through Function Parameters -- Generic Algorithms through Inlining -- More on Different Kinds of Types -- Reference Types and Value Types -- Other Flavors of .NET Types -- Understanding Subtyping -- Casting Up Statically -- Casting Down Dynamically -- Performing Type Tests via Pattern Matching -- Knowing When Upcasts Are Applied Automatically -- Flexible Types -- Troubleshooting Type-Inference Problems -- Using a Visual Editing Environment -- Using Type Annotations -- Understanding the Value Restriction -- Working Around the Value Restriction -- Understanding Generic Overloaded Operators -- Summary -- ch. 6 Programming with Objects -- Getting Started with Objects and Members -- Using Classes -- Adding Further Object Notation to Your Types -- Working with Indexer Properties -- Adding Overloaded Operators -- Using Named and Optional Arguments -- Adding Method Overloading -- Defining Object Types with Mutable State -- Using Optional Property Settings -- Declaring Auto-Properties -- Getting Started with Object Interface Types -- Defining New Object Interface Types -- Implementing Object Interface Types Using Object Expressions -- Implementing Object Interface Types Using Concrete Types -- Using Common Object Interface Types from the .NET Libraries -- Understanding Hierarchies of Object Interface Types -- More Techniques for Implementing Objects -- Combining Object Expressions and Function Parameters -- Defining Partially Implemented Class Types -- Using Partially Implemented Types via Delegation -- Using Partially Implemented Types via Implementation Inheritance -- Combining Functional and Objects: Cleaning Up Resources -- Resources and IDisposable -- Managing Resources with More-Complex Lifetimes -- Cleaning Up Internal Objects -- Cleaning Up Unmanaged Objects -- Extending Existing Types and Modules -- Working with F# Objects and .NET Types -- Structs -- Delegates -- Enums -- Working with null Values -- Summary -- ch. 7 Encapsulating and Organizing Your Code -- Hiding Things -- Hiding Things with Local Definitions -- Hiding Things with Accessibility Annotations -- Organizing Code with Namespaces and Modules -- Putting Your Code in a Module -- Putting Your Modules and Types in Namespaces -- Defining a Module with the Same Name as a Type -- Preventing Client Code from Opening a Module -- Using Files as Modules -- Automatically Opening Modules -- Projects, Assemblies, and Compilation Order -- Creating Assemblies, DLLs, and EXEs -- Project Files and Compilation Order -- Using Signature Files -- Designing with Signatures -- When Are Signature Types Checked? -- Reusing Your Code -- Using Files as Small Reusable Components -- Creating and Sharing Packages -- Summary -- ch. 8 Working with Textual Data -- Building Strings and Formatting Data -- Building Strings -- More about String Literals -- Using printf and Friends -- Generic Structural Formatting -- Formatting Strings Using .NET Formatting -- Parsing Strings and Textual Data -- Parsing Basic Values -- Processing Line-Based Input -- Using Regular Expressions -- More on Matching with System.Text.RegularExpressions -- More Robust Code with the Regular Expression Type Provider -- Using XML as a Concrete Language Format -- Using the System.Xml Namespace -- From Concrete XML to Abstract Syntax -- Using the FSharp.Data XmlTypeProvider -- Using JSON as a Concrete Language Format -- Parsing JSON Data -- Using the FSharp.Data JsonProvider -- Some Recursive Descent Parsing -- Simple Tokenizer -- Recursive-Descent Parsing -- Binary Parsing and Formatting -- Encoding and Decoding Unicode Strings -- Encoding and Decoding Binary Data -- Summary -- ch.
9 Working with Sequences and Tree-Structured Data -- Getting Started with Sequences -- Using Range Expressions -- Iterating a Sequence -- Transforming Sequences with Functions -- Which Types Can Be Used as Sequences? -- Using Lazy Sequences from External Sources -- Using Sequence Expressions -- Enriching Sequence Expressions with Additional Logic -- Generating Lists and Arrays Using Sequence Expressions -- More on Working with Sequences -- Using Other Sequence Operators: Truncate and Sort -- Selecting Multiple Elements from Sequences -- Finding Elements and Indexes in Sequences -- Grouping and Indexing Sequences -- Folding Sequences -- Cleaning Up in Sequence Expressions -- Expressing Operations Using Sequence Expressions -- Structure beyond Sequences: Domain Modeling -- Transforming Domain Models -- Using On-Demand Computation with Domain Models -- Caching Properties in Domain Models -- Memoizing Construction of Domain Model Nodes -- Active Patterns: Views for Structured Data -- Converting the Same Data to Many Views -- Matching on .NET Object Types -- Defining Partial and Parameterized Active Patterns -- Hiding Representations with Active Patterns -- Equality, Hashing, and Comparison -- Asserting Equality, Hashing, and Comparison Using Attributes -- Fully Customizing Equality, Hashing, and Comparison on a Type -- Suppressing Equality, Hashing, and Comparison on a Type -- Customizing Generic Collection Types -- Tail Calls and Recursive Programming -- Tail Recursion and List Processing -- Tail Recursion and Object-Oriented Programming -- Tail Recursion and Processing Unbalanced Trees -- Using Continuations to Avoid Stack Overflows -- Another Example: Processing Syntax Trees -- Summary -- ch. 10 Numeric Programming and Charting -- Getting Started with FsLab -- Basic Charting with FSharp.Charting -- Basic Numeric Types and Literals -- Arithmetic Operators -- Checked Arithmetic -- Arithmetic Conversions -- Arithmetic Comparisons -- Overloaded Math Functions -- Bitwise Operations -- Sequences, Statistics, and Numeric Code -- Summing, Averaging, Maximizing, and Minimizing Sequences -- Counting and Categorizing -- Writing Fresh Numeric Code -- Making Numeric Code Generic -- Example: KMeans -- Statistics, Linear Algebra, and Distributions with Math.NET
Note continued: Basic Statistical Functions in Math.NET Numerics -- Using Histograms and Distributions from Math.NET Numerics -- Using Matrices and Vectors from Math.NET -- Matrix Inverses, Decomposition, and Eigenvalues -- Time Series and Data Frames with Deedle -- Units of Measure -- Adding Units to a Numeric Algorithms -- Adding Units to a Type Definition -- Applying and Removing Units -- Some Limitations of Units of Measure -- Summary -- ch. 11 Reactive, Asynchronous, and Parallel Programming -- Introducing Terminology -- Events -- Creating and Publishing Events -- Events as First-Class Values -- From Events to Observables -- Asynchronous Computations -- Fetching Multiple Web Pages in Parallel, Asynchronously -- Understanding Asynchronous Computations -- Example: Parallel File Processing Using Async Computations -- Running Async Computations -- Common I/O Operations in Asynchronous Computations -- Understanding Exceptions and Cancellations -- Interoperating with .NET Tasks -- Agents -- Introducing Agents -- Creating Objects That React to Messages -- Scanning Mailboxes for Relevant Messages -- Example: An Asynchronous Agent for Web Crawling -- Example: Using async for CPU Parallelism -- Under the Hood: Implementing Async.Parallel -- Using Shared-Memory Concurrency -- Creating Threads Explicitly -- Creating Tasks Explicitly -- Shared Memory, Race Conditions, and the .NET Memory Model -- Using Locks to Avoid Race Conditions -- Using ReaderWriterLock -- Some Other Concurrency Primitives -- Summary -- ch. 12 Symbolic Programming with Structured Data -- Verifying Circuits with Propositional Logic -- Representing Propositional Logic -- Evaluating Propositional Logic Naively -- From Circuits to Propositional Logic -- Checking Simple Properties of Circuits -- Representing Propositional Formulae Efficiently Using BDDs -- Circuit Verification with BDDs -- Expression Simplification and Differentiation -- Implementing Local Simplifications -- Richer Language of Algebraic Expressions -- Parsing Algebraic Expressions -- Simplifying Algebraic Expressions -- Symbolic Differentiation of Algebraic Expressions -- Driver -- Web API -- Summary -- ch. 13 Integrating External Data and Services -- Some Basic REST Requests -- Getting Data in JSON Format -- Parsing and Handling Multiple Pages -- Getting Started with Queries -- Example: Language-Integrated SQL -- Sorting -- Aggregation -- Nullables -- Inner Queries -- Grouping -- Joins -- More Choices for SQL -- Directly Embedding T-SQL Using SqICommandProvider -- Raw Access to Databases Using ADO.NET -- Establishing Connections Using ADO.NET -- Creating a Database Using ADO.NET -- Creating Tables Using ADO.NET -- Using Stored Procedures via ADO.NET -- Summary -- ch. 14 Building Smart Web Applications -- Serving Web Content Directly -- Rich Client Web Applications with WebSharper -- Getting Started with WebSharper -- Pagelets -- Working with Reactive HTML and Client-Side Code -- HTML Templates -- Sitelets -- Developing REST Applications -- Formlets and Piglets: Building Functional Web Forms -- Automated Resource Tracking and Handling -- Using Third-Party JavaScript Libraries -- Working with .NET Proxies -- Summary -- ch. 15 Visualization and Graphical User Interfaces -- Getting Started with Eto -- Writing "Hello, World!" in a Click -- Understanding the Anatomy of a Graphical Application -- Composing Controls and Menus -- Composing User Interfaces -- Drawing Applications -- Creating a Mandelbrot Viewer -- Computing Mandelbrot -- Setting Colors -- Creating the Visualization Application -- Creating the Application Plumbing -- Writing Your Own Controls -- Developing a Custom Control -- Anatomy of a Control -- World, the View, and Coordinate Systems -- Drawing an Analog Clock -- World and View Coordinates -- Lightweight Controls -- Summary -- ch. 16 Language-Oriented Programming -- Computation Expressions -- Example: Success/Failure Computation Expressions -- Defining a Computation-Expression Builder -- Computation Expressions and Untamed Side Effects -- Computation Expressions with Custom Query Operators -- Example: Probabilistic Computations -- Combining Computation Expressions and Resources -- Recursive Workflow Expressions -- Using F# Reflection -- Reflecting on Types -- Schema Compilation by Reflecting on Types -- Using the F# Dynamic Reflection Operators -- Using F# Quotations -- Example: Using F# Quotations for Error Estimation -- Resolving Reflected Definitions -- Writing an F# Type Provider -- Summary -- ch. 17 Libraries and Interoperability -- Types, Memory, and Interoperability -- Libraries: A High-Level Overview -- Namespaces from the .NET Framework -- Namespaces from FSharp.Core and FSharp.Data Libraries -- Some F# Community Libraries -- Using the System Types -- Using Further F# and .NET Data Structures -- System.Collections.Generic and Other .NET Collections -- Supervising and Isolating Execution -- Further Libraries for Reflective Techniques -- Using General Types -- Using FSharp.Reflection -- Some Other .NET Types You May Encounter -- Some F# Community Type Providers -- Under the Hood: Interoperating with C# and Other .NET Languages -- Memory Management at Runtime -- Interoperating with C and C++ with Plnvoke -- Getting Started with Plnvoke -- Mapping C Data Structures to F# Code -- Marshalling Parameters to and from C -- Marshalling Strings to and from C -- Passing Function Pointers to C -- Wrapper Generation and the Limits of Plnvoke -- Summary -- ch. 18 Developing and Testing F# Code -- Developing Your Code -- Editing Your Code -- Mixing Scripting and Compiled Code -- Choosing Optimization Settings -- Generating Documentation -- Building Libraries -- Using Static Linking -- Packaging Different Kinds of Code -- Managing Dependencies -- Using Data and Configuration Settings -- Using F# Interactive Effectively -- Controlling F# Interactive -- Some Common F# Interactive Directives -- Understanding How F# Interactive Compiles Code -- Using Tracing Diagnostics -- Debugging Your Code with an IDE -- Debugging Across Multiple Languages -- Debugging Concurrent Applications -- Testing Your Code -- Using Test Fixtures in NUnit/XUnit -- Combining NUnit/XUnit and F# Interactive Debugging -- Property-based Testing Using FsCheck -- Summary -- ch.
19 Designing F# Libraries -- Designing Vanilla .NET Libraries -- Understanding Functional-Design Methodology -- Understanding Where Functional Programming Comes From -- Understanding Functional-Design Methodology -- Applying the Good Library Design to F# -- Recommendation: Use Correct Naming and Capitalization Conventions Where Possible -- Recommendation: Avoid Using Underscores in Names -- Recommendation: Follow the Recommended Guidelines for Exceptions -- Recommendation: Consider Using Option Values for Return Types Instead of Raising Exceptions -- Recommendation: Follow the Recommended Guidelines for Value Types -- Recommendation: Consider Using Explicit Signature Files for Your Framework -- Recommendation: Consider Avoiding the Use of Implementation Inheritance for Extensibility -- Recommendation: Use Properties and Methods for Attributes and Operations Essential to a Type -- Recommendation: Avoid Revealing Concrete Data Representations Such as Records -- Recommendation: Use Active Patterns to Hide the Implementations of Discriminated Unions -- Recommendation: Use Object-Interface Types Instead of Tuples or Records of Functions -- Recommendation: Understand When Currying Is Useful in Functional Programming APIs -- Recommendation: Use Tuples for Return Values, Arguments, and Intermediate Values -- Recommendation: Use Async for Asynchronous Computations -- Recommendation: Use Choice or a Named Type for Alternative Results -- Some Recommended Coding Idioms -- Recommendation: Use the Standard Operators -- Recommendation: Place the Pipeline Operator Recommendation: Format Object Expressions Using the member Syntax -- Summary -- Appendix F# Brief Language Guide -- Comments and Attributes -- Basic Types and Literals -- Types -- Patterns and Matching -- Functions, Composition, and Pipelining -- Binding and Control Flow -- Exceptions -- Tuples, Arrays, Lists, and Collections -- Operators -- Type Definitions and Objects -- Namespaces and Modules -- Sequence Expressions and Workflows -- Queries and Quotations.
Subject Microsoft .NET Framework.
Microsoft .NET Framework. (OCoLC)fst01020083
F# (Computer program language)
Functional programming languages.
COMPUTERS -- Software Development & Engineering -- General.
F# (Computer program language) (OCoLC)fst01745123
Functional programming languages. (OCoLC)fst00936087
Computer Science.
Engineering & Applied Sciences.
Computer Science.
Programming Languages, Compilers, Interpreters.
Programming & scripting languages: general.
Genre/Form Electronic books.
Electronic books.
Added Author Granicz, Adam, author.
Cisternino, Antonio, author.
Other Form: Printed edition: 9781484207413
ISBN 9781484207406 (electronic bk.)
1484207408 (electronic bk.)
1484207416 (print)
9781484207413 (print)
Standard No. 10.1007/978-1-4842-0740-6 doi
CHNEW 000894185
CHVBK 374533415
DEBBG BV043627986
DEBSZ 454931794
NZ1 16308277
AU@ 000061156022
UKMGB 019177042

 
    
Available items only