book

F# in Action

Name: F# in Action
Author: Isaac Abraham
ISBN: 9781633439535

by Isaac Abraham

May 2024

Beginner to intermediate

336 pages

9h 45m

English

Manning Publications

Read now

Unlock full access

Praise for the previous edition
F# in Action
Copyright
contents
front matter
forewordprefaceacknowledgmentsabout this bookWho should read this bookHow this book is organized: A road mapAbout the codeliveBook discussion forumabout the authorabout the cover illustration
1 Introducing F#
1.1 What is F#?1.2 Why F#?1.3 When F#?1.4 How will this book teach me F#?1.5 How does F# work?1.5.1 Collaborative exploration1.5.2 Type-driven development1.5.3 Trusting the compiler1.5.4 An opinionated language1.5.5 Data and functions1.5.6 Separation of business logic and external systems1.5.7 Varied targetsSummary
2 Hands on with F#
2.1 Writing code the F# way2.1.1 What, not how2.1.2 Composability2.1.3 Data and behavior2.1.4 Working with a smarter compiler2.2 F# and .NET2.3 Creating your first F# program2.3.1 Installing F#2.3.2 The .NET CLI2.3.3 Hello World in F#2.4 Getting Started with Visual Studio Code2.4.1 The Ionide extension2.4.2 Exploring F# with VS Code2.4.3 Writing your first F#2.5 REPL and scripts2.5.1 The F# REPL2.5.2 Trying out FSI2.5.3 Moving to interactive scripts2.5.4 State in the REPL2.5.5 Creating your first function2.6 Development flows2.7 Where scripts and the REPL fit inSummary
3 F# Syntax Basics
3.1 F# syntax basics3.1.1 Characteristics of F# syntax3.1.2 The let keyword3.1.3 Scoping3.2 Type inference3.2.1 Benefits of type inference3.2.2 Type inference basics3.2.3 Inferring generics3.2.4 Diagnosing unexpected type inference behavior3.2.5 Limitations of type inference3.2.6 Criticisms of type inference3.3 Exercise answersSummary
4 F# Fundamentals
4.1 Expressions4.1.1 Purity and side effects4.1.2 Difficulties with statements4.1.3 Expressions to the rescue4.1.4 Expressions in F#4.1.5 Composability4.1.6 Unit4.1.7 Ignore4.2 Immutable data4.2.1 The problem with mutability4.2.2 Modeling with mutable and immutable data4.2.3 Optimizing and opinionated languages4.2.4 Other benefits of immutable data4.3 Exercise AnswersSummary
5 Shaping data
5.1 Composing types in F#5.1.1 Data and functions in F#5.2 Tuples5.2.1 Tuple basics5.2.2 More on tuples5.2.3 Costs and benefits of tuples5.3 Records5.3.1 Defining, creating, and consuming records5.3.2 More on records5.3.3 Records and .NET5.4 Anonymous records5.4.1 Anonymous record tricks5.5 Tuples or records5.6 Exercise answersSummary

6 Functions and modules
6.1 Functions6.1.1 The truth behind F# functions6.1.2 Partially applying functions6.1.3 Pipelines6.1.4 Using records and tuples with functions6.1.5 Tupled functions6.1.6 Comparing functions and methods6.2 Organizing code6.2.1 Namespaces6.2.2 Modules6.2.3 Moving from script to application: A step-by-step exercise6.2.4 Referencing programs from scripts6.2.5 Best practices for modules and namespaces6.2.6 Tips and tricks6.3 Answers to exercisesSummary
7 Working with collections
7.1 Higher-order functions7.2 Functional collection pipelines7.2.1 Imperative and declarative pipelines7.2.2 Debugging pipelines7.2.3 Understanding the List module7.2.4 Common List functions7.2.5 Ranges, slices, and indexing7.3 Other collection types7.3.1 Arrays7.3.2 Sequences7.3.3 ResizeArray7.3.4 Dictionary7.3.5 Map7.3.6 Set7.3.7 More on Sequences7.3.8 Comprehensions7.3.9 Comparing the different collection types7.4 Aggregations7.4.1 Imperative loops7.4.2 Functional folds7.4.3 Simulating Sequences7.5 Answers to exercisesSummary
8 Patterns and unions
8.1 Introducing pattern matching8.1.1 Exhaustive matching8.1.2 Tuple matching8.1.3 Simplifying pattern matches: A worked example8.1.4 Record matching8.1.5 Type inference8.1.6 When guards8.2 More advanced pattern matching8.2.1 Recursive matching8.2.2 Nested or conditions8.2.3 Binding symbols8.2.4 Collection matching8.2.5 Match vs. if/then8.3 Discriminated unions8.3.1 Basics of discriminated unions8.3.2 Pattern matching8.3.3 Exhaustive matching with discriminated unions8.3.4 Nested types with discriminated unions8.3.5 Single-case discriminated unions8.4 The F# type system8.4.1 ANDing types8.4.2 ORing types8.4.3 ANDing valuesSummary
9 Building rich domains
9.1 Working with missing values9.1.1 The billion-dollar mistake: Working with nulls9.1.2 Options are the answer9.1.3 Option.map9.1.4 Option.bind9.1.5 Interop with .NET9.1.6 Options and collections9.2 Handling errors9.2.1 Results9.2.2 Handling multiple errors9.2.3 Strongly typed errors9.2.4 Exceptions9.2.5 When to safely leave options and results9.2.6 When to use options, results, and exceptions9.3 Computation expressions9.4 Domain modeling: A worked exampleSummary
10 Working effectively with data
10.1 Best practices10.1.1 Data is data10.1.2 Separation of data and functionality10.1.3 Don’t treat scripts as programs10.1.4 Working with lists of results10.2 Serialization of data10.2.1 Deserializing JSON to F#10.2.2 Acceptable alternatives to DTOs10.2.3 Serializing F# into JSON10.3 Type providers10.3.1 Working with the JSON type provider10.3.2 Working with external data sources10.3.3 More data types from FSharp.Data10.3.4 Best practices for type providers10.4 Data visualization10.5 Working with other data sources10.5.1 The CLIMutable attribute10.5.2 Working with SQL10.6 Tooling optionsSummary
11 F# Interop
11.1 Working with other .NET code11.1.1 Consuming C# classes11.1.2 Interfaces11.1.3 Fluent APIs11.1.4 Tuples11.1.5 Out parameters11.1.6 Object-based programming11.1.7 F# wrappers11.2 Exposing F# to C#11.2.1 Core F# concepts11.2.2 Tips and tricks11.2.3 Introducing F# into existing codebases11.3 Consuming NuGet packages11.3.1 Working with NuGet package dependencies11.3.2 Working with NuGet tools11.4 The Fable project: F# and JavaScript11.4.1 JavaScript to F#: A brief history11.4.2 Introducing FableSummary
12 Asynchronous programming
12.1 What is asynchronous programming?12.1.1 Async and sync programming12.1.2 A brief history of async on .NET12.2 Asynchronous support in F#12.2.1 Tasks in .NET12.2.2 Consuming Tasks12.2.3 The task { } block: F#’s async/await12.2.4 Executing multiple Tasks in parallel12.2.5 Benefits of Tasks’ computation expressions12.2.6 The async block12.3 Final thoughts on asynchronous workloads12.3.1 The importance of immutable data12.3.2 The viral nature of asynchronous workloadsSummary
13 Web programming
13.1 The web and functional programming13.1.1 Web programming on .NET and F#13.1.2 The HTTP Context13.2 Server-side web development in F#13.2.1 Creating our first ASP.NET application13.2.2 The HTTP Handler13.2.3 Composing HTTP Handlers together13.2.4 Composing multiple routes13.2.5 Writing our own HTTP Handlers13.2.6 Reading inputs13.2.7 Validation13.3 Functional patterns in a web application13.4 Creating HTML views13.4.1 Creating views through code13.4.2 The ViewEngine DSL13.4.3 Benefits of an F# DSL for HTML13.5 Full-stack F# apps with SAFE Stack13.5.1 Overview of SAFE Stack13.5.2 Installing the SAFE Stack template13.5.3 The MVU pattern13.5.4 Removing all ToDo items: A worked exerciseSummary
14 Testing F# code
14.1 Automated tests: The value proposition14.1.1 F#: Types over tests14.2 Basic unit testing in F#14.2.1 Tests as functions14.2.2 Expecto14.2.3 Plugging Expecto into our code14.2.4 Advantages of Expecto14.3 Making testable code14.3.1 Preferring pure functions where possible14.3.2 Preferring smaller functions14.3.3 Unit testing small function hierarchies14.3.4 Integration testing higher-level composed functions14.3.5 Pushing side effects to the boundaries of your code14.3.6 Using higher-order functions to replace side effects14.3.7 Don’t worry about encapsulation14.4 Working with NUnit-style test frameworks14.5 Other forms of testing14.5.1 Performance testing14.5.2 Property-based testingSummary
15 Pure functional programming
15.1 A functional architecture pattern15.1.1 External and internal boundaries15.1.2 Structuring larger functional codebases15.2 Composing functions15.2.1 The object-oriented approach to composition15.2.2 Higher-order functions15.2.3 Dependency rejection15.2.4 Procedural composition15.2.5 What should you use and when?15.3 Working with low-level dependencies15.3.1 A worked example: Working with a logging function15.3.2 Flipping dependencies with a bootstrapper15.3.3 Pros and cons of the wireup pattern15.3.4 Applying the dependency rejection pattern15.4 Working with effects15.4.1 What are effects in F# and .NET?15.4.2 Common effects in F#15.4.3 Map and Bind15.4.4 Using Computation Expressions to hide bind pipelinesSummary
16 Where next?
16.1 How do I start using F# in practice?16.1.1 Data analysis16.1.2 Hobby projects16.1.3 Coding challenges16.1.4 Before-and-after proof of concept16.1.5 Operational scripts16.2 How do I introduce F# to my team?16.3 The F# community16.3.1 Social media16.3.2 Conferences and user groups16.3.3 Open source16.4 Advanced F# language features16.4.1 Units of Measure16.4.2 Active Patterns16.4.3 Type Extensions16.4.4 Implicit Conversions16.4.5 Statically Resolved Type Parameters16.4.6 MetaprogrammingSummary
index

Content preview from F# in Action

15 Pure functional programming

This chapter covers

Functional architecture patterns
Composing functions
Bootstrappers and inverting dependencies
Working with effects

So far, we’ve looked at specific language features and integration, but aside from the web application portion, much of the book so far has looked at each area in isolation. That’s been intentional so that we can focus on one thing at a time and not lose context. However, it’s also important to have an awareness of how things plug together effectively. That’s what this chapter is about: we’re going to look at different challenges you might face when writing applications that adhere to a functional programming (FP) architecture and different strategies for composing code together ...

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: 9781633439535Publisher Support Publisher Website

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

F# in Action

by Isaac Abraham

15 Pure functional programming

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.