book

Expert F# 4.0, Fourth Edition

Name: Expert F# 4.0, Fourth Edition
ISBN: 9781484207406

by Don Syme, Adam Granicz, Antonio Cisternino

December 2015

Intermediate to advanced

612 pages

15h 47m

English

Apress

Read now

Unlock full access

Cover
Title
Copyright
Contents at a Glance
Contents
About the Authors
About the Technical Reviewers
Acknowledgments
Chapter 1: Introduction
The Genesis of F#About This BookWho This Book Is For
Chapter 2: Your First F# Program: Getting Started with F#
Creating Your First F# ProgramDocumenting CodeUsing letUnderstanding TypesCalling FunctionsLightweight SyntaxUnderstanding ScopeUsing Data StructuresUsing Properties and the Dot-NotationUsing TuplesUsing Imperative CodeUsing Object-Oriented Libraries from F#Using open to Access Namespaces and ModulesFetching a Web PageGetting and Using PackagesAccessing External Data Using F# PackagesStarting a Web Server and Serving Data using F# PackagesSummary

Chapter 3: Introducing Functional Programming
Starting with Numbers and StringsSome Simple Types and LiteralsArithmetic ConversionsArithmetic ComparisonsSimple StringsWorking with Conditionals: & and ||Defining Recursive FunctionsListsOptionsGetting Started with Pattern MatchingMatching on Structured ValuesGuarding Rules and Combining PatternsFurther Ways of Forming PatternsIntroducing Function ValuesUsing Function ValuesComputing with Collection FunctionsUsing Fluent Notation on CollectionsComposing Functions with >>Building Functions with Partial ApplicationUsing Local FunctionsIterating with FunctionsAbstracting Control with FunctionsUsing Object Methods as First-Class FunctionsSome Common Uses of Function ValuesSummary
Chapter 4: Introducing Imperative Programming
About Functional and Imperative ProgrammingImperative Looping and IteratingSimple for LoopsSimple While LoopsMore Iteration Loops over SequencesUsing Mutable RecordsAvoiding AliasingUsing Mutable let BindingsHiding Mutable DataWorking with ArraysGenerating and Slicing ArraysTwo-Dimensional ArraysIntroducing the Imperative .NET CollectionsUsing Resizable ArraysUsing DictionariesUsing Dictionary’s TryGetValueUsing Dictionaries with Compound KeysSome Other Mutable Data StructuresExceptions and Controlling ThemCatching ExceptionsUsing try . . . finallyDefining New Exception TypesHaving an Effect: Basic I/O.NET I/O via StreamsSome Other I/O-Related TypesUsing System.ConsoleCombining Functional and Imperative Efficient Precomputation and CachingPrecomputation and Partial ApplicationPrecomputation and ObjectsMemoizing ComputationsLazy ValuesOther Variations on Caching and MemoizationMutable Reference CellsCombining Functional and Imperative: Functional Programming with Side EffectsConsider Replacing Mutable Locals and Loops with RecursionSeparating Pure Computation from Side-Effecting ComputationsSeparating Mutable Data StructuresNot All Side Effects Are EqualAvoid Combining Imperative Programming and LazinessSummary
Chapter 5: Understanding Types in Functional Programming
Exploring Some Simple Type DefinitionsDefining Type AbbreviationsDefining Record TypesHandling Non-Unique Record Field NamesCloning RecordsDefining Discriminated UnionsUsing Discriminated Unions as RecordsDefining Multiple Types SimultaneouslyUnderstanding GenericsWriting Generic FunctionsSome Important Generic FunctionsMaking Things GenericGeneric Algorithms through Explicit ArgumentsGeneric Algorithms through Function ParametersGeneric Algorithms through InliningMore on Different Kinds of TypesReference Types and Value TypesOther Flavors of .NET TypesUnderstanding SubtypingCasting Up StaticallyCasting Down DynamicallyPerforming Type Tests via Pattern MatchingKnowing When Upcasts Are Applied AutomaticallyFlexible TypesTroubleshooting Type-Inference ProblemsUsing a Visual Editing EnvironmentUsing Type AnnotationsUnderstanding the Value RestrictionWorking Around the Value RestrictionUnderstanding Generic Overloaded OperatorsSummary
Chapter 6: Programming with Objects
Getting Started with Objects and MembersUsing ClassesAdding Further Object Notation to Your TypesWorking with Indexer PropertiesAdding Overloaded OperatorsUsing Named and Optional ArgumentsAdding Method OverloadingDefining Object Types with Mutable StateUsing Optional Property SettingsDeclaring Auto-PropertiesGetting Started with Object Interface TypesDefining New Object Interface TypesImplementing Object Interface Types Using Object ExpressionsImplementing Object Interface Types Using Concrete TypesUsing Common Object Interface Types from the .NET LibrariesUnderstanding Hierarchies of Object Interface TypesMore Techniques for Implementing ObjectsCombining Object Expressions and Function ParametersDefining Partially Implemented Class TypesUsing Partially Implemented Types via DelegationUsing Partially Implemented Types via Implementation InheritanceCombining Functional and Objects: Cleaning Up ResourcesResources and IDisposableManaging Resources with More-Complex LifetimesCleaning Up Internal ObjectsCleaning Up Unmanaged ObjectsExtending Existing Types and ModulesWorking with F# Objects and .NET TypesStructsDelegatesEnumsWorking with null ValuesSummary
Chapter 7: Encapsulating and Organizing Your Code
Hiding ThingsHiding Things with Local DefinitionsHiding Things with Accessibility AnnotationsOrganizing Code with Namespaces and ModulesPutting Your Code in a ModulePutting Your Modules and Types in NamespacesDefining a Module with the Same Name as a TypePreventing Client Code from Opening a ModuleUsing Files as ModulesAutomatically Opening ModulesProjects, Assemblies, and Compilation OrderCreating Assemblies, DLLs, and EXEsProject Files and Compilation OrderUsing Signature FilesDesigning with SignaturesWhen Are Signature Types Checked?Reusing Your CodeUsing Files as Small Reusable ComponentsCreating and Sharing PackagesSummary
Chapter 8: Working with Textual Data
Building Strings and Formatting DataBuilding StringsMore about String LiteralsUsing printf and FriendsGeneric Structural FormattingFormatting Strings Using .NET FormattingParsing Strings and Textual DataParsing Basic ValuesProcessing Line-Based InputUsing Regular ExpressionsMore on Matching with System.Text.RegularExpressionsMore Robust Code with the Regular Expression Type ProviderUsing XML as a Concrete Language FormatUsing the System.Xml NamespaceFrom Concrete XML to Abstract SyntaxUsing the FSharp.Data XmlTypeProviderUsing JSON as a Concrete Language FormatParsing JSON DataUsing the FSharp.Data JsonProviderSome Recursive Descent ParsingA Simple TokenizerRecursive-Descent ParsingBinary Parsing and FormattingEncoding and Decoding Unicode StringsEncoding and Decoding Binary DataSummary
Chapter 9: Working with Sequences and Tree-Structured Data
Getting Started with SequencesUsing Range ExpressionsIterating a SequenceTransforming Sequences with FunctionsWhich Types Can Be Used as Sequences?Using Lazy Sequences from External SourcesUsing Sequence ExpressionsEnriching Sequence Expressions with Additional LogicGenerating Lists and Arrays Using Sequence ExpressionsMore on Working with SequencesUsing Other Sequence Operators: Truncate and SortSelecting Multiple Elements from SequencesFinding Elements and Indexes in SequencesGrouping and Indexing SequencesFolding SequencesCleaning Up in Sequence ExpressionsExpressing Operations Using Sequence ExpressionsStructure beyond Sequences: Domain ModelingTransforming Domain ModelsUsing On-Demand Computation with Domain ModelsCaching Properties in Domain ModelsMemoizing Construction of Domain Model NodesActive Patterns: Views for Structured DataConverting the Same Data to Many ViewsMatching on .NET Object TypesDefining Partial and Parameterized Active PatternsHiding Representations with Active PatternsEquality, Hashing, and ComparisonAsserting Equality, Hashing, and Comparison Using AttributesFully Customizing Equality, Hashing, and Comparison on a TypeSuppressing Equality, Hashing, and Comparison on a TypeCustomizing Generic Collection TypesTail Calls and Recursive ProgrammingTail Recursion and List ProcessingTail Recursion and Object-Oriented ProgrammingTail Recursion and Processing Unbalanced TreesUsing Continuations to Avoid Stack OverflowsAnother Example: Processing Syntax TreesSummary
Chapter 10: Numeric Programming and Char?ting
Getting Started with FsLabBasic Charting with FSharp.ChartingBasic Numeric Types and LiteralsArithmetic OperatorsChecked ArithmeticArithmetic ConversionsArithmetic ComparisonsOverloaded Math FunctionsBitwise OperationsSequences, Statistics, and Numeric CodeSumming, Averaging, Maximizing, and Minimizing SequencesCounting and CategorizingWriting Fresh Numeric CodeMaking Numeric Code GenericExample: KMeansStatistics, Linear Algebra, and Distributions with Math.NETBasic Statistical Functions in Math.NET NumericsUsing Histograms and Distributions from Math.NET NumericsUsing Matrices and Vectors from Math.NETMatrix Inverses, Decomposition, and EigenvaluesTime Series and Data Frames with DeedleUnits of MeasureAdding Units to a Numeric AlgorithmsAdding Units to a Type DefinitionApplying and Removing UnitsSome Limitations of Units of MeasureSummary
Chapter 11: Reactive, Asynchronous, and Parallel Programming
Introducing TerminologyEventsCreating and Publishing EventsEvents as First-Class ValuesFrom Events to ObservablesAsynchronous ComputationsFetching Multiple Web Pages in Parallel, AsynchronouslyUnderstanding Asynchronous ComputationsExample: Parallel File Processing Using Async ComputationsRunning Async ComputationsCommon I/O Operations in Asynchronous ComputationsUnderstanding Exceptions and CancellationsInteroperating with .NET TasksAgentsIntroducing AgentsCreating Objects That React to MessagesScanningMailboxes for Relevant MessagesExample: An Asynchronous Agent for Web CrawlingExample: Using async for CPU ParallelismUnder the Hood: Implementing Async.ParallelUsing Shared-Memory ConcurrencyCreating Threads ExplicitlyCreating Tasks ExplicitlyShared Memory, Race Conditions, and the .NET Memory ModelUsing Locks to Avoid Race ConditionsUsing ReaderWriterLockSome Other Concurrency PrimitivesSummary
Chapter 12: Symbolic Programming with Structured Data
Verifying Circuits with Propositional LogicRepresenting Propositional LogicEvaluating Propositional Logic NaivelyFrom Circuits to Propositional LogicChecking Simple Properties of CircuitsRepresenting Propositional Formulae Efficiently Using BDDsCircuit Verification with BDDsExpression Simplification and DifferentiationImplementing Local SimplificationsA Richer Language of Algebraic ExpressionsParsing Algebraic ExpressionsSimplifying Algebraic ExpressionsSymbolic Differentiation of Algebraic ExpressionsThe DriverThe Web APISummary
Chapter 13: Integrating External Data and Services
Some Basic REST RequestsGetting Data in JSON FormatParsing and Handling Multiple PagesGetting Started with QueriesExample: Language-Integrated SQLSortingAggregationNullablesInner QueriesGroupingJoinsMore Choices for SQLDirectly Embedding T-SQL Using SqlCommandProviderRaw Access to Databases Using ADO.NETEstablishing Connections Using ADO.NETCreating a Database Using ADO.NETCreating Tables Using ADO.NETUsing Stored Procedures via ADO.NETSummary
Chapter 14: Building Smart Web Applications
Serving Web Content DirectlyRich Client Web Applications with WebSharperGetting Started with WebSharperPagelets - Working with Reactive HTML and Client-Side CodeHTML TemplatesSiteletsDeveloping REST ApplicationsFormlets and Piglets: Building Functional Web FormsAutomated Resource Tracking and HandlingUsing Third-Party JavaScript LibrariesWorking with .NET ProxiesSummary
Chapter 15: Visualization and Graphical User Interfaces
Getting Started with EtoWriting “Hello, World!” in a ClickUnderstanding the Anatomy of a Graphical ApplicationComposing Controls and MenusComposing User InterfacesDrawing ApplicationsCreating a Mandelbrot ViewerComputing MandelbrotSetting ColorsCreating the Visualization ApplicationCreating the Application PlumbingWriting Your Own ControlsDeveloping a Custom ControlAnatomy of a ControlThe World, the View, and Coordinate SystemsDrawing an Analog ClockWorld and View CoordinatesLightweight ControlsSummary
Chapter 16: Language-Oriented Programming
Computation ExpressionsAn Example: Success/Failure Computation ExpressionsDefining a Computation-Expression BuilderComputation Expressions and Untamed Side EffectsComputation Expressions with Custom Query OperatorsExample: Probabilistic ComputationsCombining Computation Expressions and ResourcesRecursive Workflow ExpressionsUsing F# ReflectionReflecting on TypesSchema Compilation by Reflecting on TypesUsing the F# Dynamic Reflection OperatorsUsing F# QuotationsExample: Using F# Quotations for Error EstimationResolving Reflected DefinitionsWriting an F# Type ProviderSummary
Chapter 17: Libraries and Interoperability
Types, Memory, and InteroperabilityLibraries: A High-Level OverviewNamespaces from the .NET FrameworkNamespaces from FSharp.Core and FSharp.Data LibrariesSome F# Community LibrariesUsing the System TypesUsing Further F# and .NET Data StructuresSystem.Collections.Generic and Other .NET CollectionsSupervising and Isolating ExecutionFurther Libraries for Reflective TechniquesUsing General TypesUsing FSharp.ReflectionSome Other .NET Types You May EncounterSome F# Community Type ProvidersUnder the Hood: Interoperating with C# and Other .NET LanguagesMemory Management at RuntimeInteroperating with C and C++ with PInvokeGetting Started with PInvokeMapping C Data Structures to F# CodeMarshalling Parameters to and from CMarshalling Strings to and from CPassing Function Pointers to CWrapper Generation and the Limits of PInvokeSummary
Chapter 18: Developing and Testing F# Code
Developing Your CodeEditing Your CodeMixing Scripting and Compiled CodeChoosing Optimization SettingsGenerating DocumentationBuilding LibrariesUsing Static LinkingPackaging Different Kinds of CodeManaging DependenciesUsing Data and Configuration SettingsUsing F# Interactive EffectivelyControlling F# InteractiveSome Common F# Interactive DirectivesUnderstanding How F# Interactive Compiles CodeUsing Tracing DiagnosticsDebugging Your Code with an IDEDebugging Across Multiple LanguagesDebugging Concurrent ApplicationsTesting Your CodeUsing Test Fixtures in NUnit/XUnitCombining NUnit/XUnit and F# Interactive DebuggingProperty-based Testing Using FsCheckSummary
Chapter 19: Designing F# Libraries
Designing Vanilla .NET LibrariesUnderstanding Functional-Design MethodologyUnderstanding Where Functional Programming Comes FromUnderstanding Functional-Design MethodologyApplying the Good Library Design to F#Recommendation: Use Correct Naming and Capitalization Conventions Where PossibleRecommendation: Avoid Using Underscores in NamesRecommendation: Follow the Recommended Guidelines for ExceptionsRecommendation: Consider Using Option Values for Return Types Instead of Raising ExceptionsRecommendation: Follow the Recommended Guidelines for Value TypesRecommendation: Consider Using Explicit Signature Files for Your FrameworkRecommendation: Consider Avoiding the Use of Implementation Inheritance for ExtensibilityRecommendation: Use Properties and Methods for Attributes and Operations Essential to a TypeRecommendation: Avoid Revealing Concrete Data Representations Such as RecordsRecommendation: Use Active Patterns to Hide the Implementations of Discriminated UnionsRecommendation: Use Object-Interface Types Instead of Tuples or Records of FunctionsRecommendation: Understand When Currying Is Useful in Functional Programming APIsRecommendation: Use Tuples for Return Values, Arguments, and Intermediate ValuesRecommendation: Use Async for Asynchronous ComputationsRecommendation: Use Choice or a Named Type for Alternative ResultsSome Recommended Coding IdiomsRecommendation: Use the Standard OperatorsRecommendation: Place the Pipeline Operator |> at the Start of a LineRecommendation: Format Object Expressions Using the member SyntaxSummary
Appendix: F# Brief Language Guide
Comments and AttributesBasic Types and LiteralsTypesPatterns and MatchingFunctions, Composition, and PipeliningBinding and Control FlowExceptionsTuples, Arrays, Lists, and CollectionsOperatorsType Definitions and ObjectsNamespaces and ModulesSequence Expressions and WorkflowsQueries and Quotations
Index

Content preview from Expert F# 4.0, Fourth Edition

CHAPTER 18

Developing and Testing F# Code

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. Programs built using functional techniques tend to be highly compositional, building correct programs out of correct building blocks. The functional programming style avoids or substantially reduces the use of side effects in the program, one property that makes programs ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781484207406Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Expert F# 4.0, Fourth Edition

by Don Syme, Adam Granicz, Antonio Cisternino

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.