F# and Data Science

Analogy categoryAnalogies

F# Interactive and Notebook-Based Data Exploration

F# supports an interactive, exploratory workflow well suited to data science through F# Interactive (dotnet fsi), a REPL that evaluates code incrementally, and through the .NET Interactive kernel, which brings the same F# language — plus C# and PowerShell — into Jupyter notebooks and VS Code's interactive Polyglot Notebooks with rich, inline visual output for charts and tables. Unlike a typical Python data-science workflow, F#'s static type system checks exploratory code as it's written, catching column-name typos or type mismatches immediately in the notebook cell rather than only surfacing them when a downstream computation fails.

🏏

Cricket analogy: A batter shadow-practicing shots in front of a mirror gets instant feedback on bad technique before ever facing a real bowler, just as F# Interactive's static type checking flags a typo'd column name the instant you write the line in a notebook cell, rather than after a full match-day production failure.

Type Providers: Typed Data Access Without Code Generation

FSharp.Data's type providers, such as CsvProvider and JsonProvider, read a sample file or URL at compile time and generate a fully typed API for that exact schema on the fly — type Stocks = CsvProvider<"stocks.csv"> then lets you write Stocks.Load("stocks.csv").Rows |> Seq.map (fun row -> row.Close) with row.Close statically typed as a decimal and checked by the compiler, all without running a separate code-generation step or hand-writing a matching record type. This eliminates an entire category of data-science bugs where a column gets renamed upstream and downstream code silently reads the wrong field or crashes at runtime instead of failing to compile.

🏏

Cricket analogy: A scorer who builds the day's scoresheet template directly from the actual team sheet handed in before the toss — with exactly the right number of batter and bowler rows — never has a mismatched row for a player who isn't actually playing, just as CsvProvider generates its typed API directly from the real file's actual columns.

Numerical and Data-Frame Libraries

Math.NET Numerics provides F#-friendly linear algebra, statistics, and numerical methods — matrix operations, probability distributions, curve fitting — while Deedle provides an R- or pandas-like Frame and Series type for tabular data with row/column alignment, missing-value handling, and group-by/aggregate operations idiomatic to F#. For visualization, Plotly.NET (and the older XPlot.Plotly) produce interactive charts directly from F# data structures, renderable both in scripts and inline inside .NET Interactive notebook cells, closing the loop from typed data loading through analysis to visual output without leaving the F# ecosystem.

🏏

Cricket analogy: A statistician computing a bowler's economy rate across a full tournament uses a purpose-built cricket-analytics spreadsheet with rows aligned by match and columns for overs, runs, and wickets, mirroring how Deedle's Frame aligns rows and columns of tabular data with built-in handling for a rained-off match's missing figures.

Machine Learning and Cross-Language Integration

ML.NET brings a full machine-learning pipeline — data loading, transforms, trainers for classification, regression, and clustering, and model evaluation — to F#, using a fluent pipeline API that composes naturally with F#'s pipe operator; for workloads that need Python-specific libraries like scikit-learn or PyTorch, F# projects can call into Python via Pythonnet-based interop packages or a subprocess-based bridge, letting a team keep type-safe F# orchestration around a Python model when a direct .NET equivalent isn't available. F#'s units of measure system also has a niche but valuable data-science use: attaching a unit like meter or second to numeric types at compile time so scientific computations can't accidentally mix incompatible units, catching an entire class of error that plain float code cannot.

🏏

Cricket analogy: A franchise's data team builds a player-auction valuation pipeline that loads historical stats, transforms them into normalized features, and trains a regression model to predict auction price, step by step in a clear sequence, mirroring ML.NET's fluent pipeline of Transforms and trainers composed with F#'s pipe operator.

fsharp

#r "nuget: FSharp.Data"
open FSharp.Data

type Stocks = CsvProvider<"stocks.csv", HasHeaders=true>

let stocks = Stocks.Load("stocks.csv")

let averageClose =
    stocks.Rows
    |> Seq.map (fun row -> row.Close)
    |> Seq.average

printfn "Average close: %.2f" averageClose

Because CsvProvider<"stocks.csv"> infers types from the sample file at compile time, renaming a column in the CSV — say Close to ClosePrice — makes row.Close a compile error everywhere it's used, turning what would be a silent runtime bug in many dynamically-typed data workflows into an immediate, precise compiler error.

Type providers infer column types from the sample data they're pointed at, so a CSV where the first thousand rows are all integers but a later row contains a decimal or blank value can cause the inferred type to mismatch real-world data. Widen the sample file or pass explicit schema hints when the full dataset's value ranges aren't represented in the sample used at compile time.

F# Interactive (dotnet fsi) and .NET Interactive Jupyter/Polyglot Notebooks support exploratory, incremental F# data analysis with inline visual output.
F#'s static typing catches column-name typos and type mismatches in exploratory notebook code immediately, unlike untyped workflows.
FSharp.Data's type providers (CsvProvider, JsonProvider) generate a typed API from a sample file at compile time, with no separate code-generation step.
Renaming a source column becomes a compile error via a type provider, instead of a silent runtime bug.
Math.NET Numerics covers linear algebra, statistics, and numerical methods; Deedle provides pandas/R-like Frame and Series types.
Plotly.NET (and XPlot.Plotly) render interactive charts directly from F# data structures, including inline in notebooks.
ML.NET provides a full, pipe-friendly ML pipeline in F#, and units of measure can catch unit-mismatch errors at compile time in scientific code.