Getting Started with F# Basics

Introduction

Welcome to the wonderful world of F#! If you’re here, you’ve either decided to give functional programming a try, are intrigued by F#'s reputation for clean and elegant code, or accidentally clicked on this article while looking for “how to fix F Sharp on my piano.” Whatever the case, buckle up, because we’re diving into a language where whitespace is king, semicolons are banished, and code flows like poetry.

In this article, you’ll:

1. Set up your F# environment, including Polyglot Notebooks.
2. Learn the F# basics of values, functions, and expressions.
3. Experiment interactively with F# code in a notebook.
4. Write, compile, and run a simple F# application.
5. Save your work as a .ipynb notebook for further exploration.

By the end, you’ll feel ready to impress your friends and coworkers with phrases like, “F# doesn’t need semicolons, and neither do I.” Let’s jump in!

1. Setting Up Your Environment

Before writing any F# code, let’s make sure your environment is ready for some functional programming fun.

Install the .NET SDK

F# runs on the .NET platform, so the first thing you need is the .NET SDK.

1. Download it from dotnet.microsoft.com.
2. Follow the installation instructions for your operating system.
3. Verify your installation with:

   dotnet --version
   

   If you see a version number, you’re good to go! If not, take a moment to blame the computer before double-checking the installation steps.

Install Visual Studio Code

1. Grab Visual Studio Code.
2. Install these extensions from the Extensions Marketplace:
   • Ionide-fsharp: Enables F# support, including IntelliSense and debugging.
   • Polyglot Notebooks: For interactive F# coding in .ipynb files.

Experimenting with Polyglot Notebooks

Polyglot Notebooks let you test F# code interactively. Let’s explore this feature:

Step 1: Create a Notebook

1. Open Visual Studio Code.
2. Create a new .ipynb file: File > New File, then save it as Experiments.ipynb.

Step 2: Write Some F# Code

Add this to your first cell:

let language = "F#"
let excitement = "is awesome!"
language + " " + excitement

Run the cell by pressing Shift + Enter. Congratulations—you’ve just written and executed your first F# code in a notebook!

F# Basics: Values, Functions, and Expressions

In F#, you don’t need to wrestle with the syntax quirks of other languages. Forget about curly brackets ({}) and semicolons (;). Here, indentation and whitespace handle the job, and your code feels refreshingly clean.

Defining Values

In F#, you use the let keyword to declare values. These values are immutable by default (once set, they can’t be changed).

let greeting = "Hello, F#!"
let answer = 42

Writing Functions

Functions are the bread and butter of F#, and defining one is as straightforward as declaring a value.

let add x y = x + y
let result = add 5 10
printfn "The sum is %d" result

Conditional Expressions

Even conditional logic in F# is elegant:

let isEven x =
    if x % 2 = 0 then "Even" else "Odd"

printfn "%s" (isEven 7)

No Curly Brackets or Semicolons

Unlike C-inspired languages, F# doesn't use punctuation gymnastics to mark the end of a statement. For example, instead of:

System.out.println("Hello, Java!");

In F#, you'd simply write:

printfn "Hello, F#"

It’s cleaner, less error-prone, and easier on the eyes.

Compiling and Running Your First F# Application

Now it’s time to step out of the notebook and write a standalone F# application.

Create Your First F# Project:

• Open a terminal in VS Code and create a new console app:

  dotnet new console -lang "F#" -o HelloWorld
  

• Navigate to the project folder:

  cd HelloWorld
  

• Open the folder in Visual Studio Code:

  code .
  

Modify the Program.fs file in your HelloWorld project:

open System

[<EntryPoint>]
let main argv =
    printfn "Hello, F#!"
    0

Explanation

1. open System: Similar to using System in C#, this imports the System namespace.
2. [<EntryPoint>]: This attribute designates the main function as the entry point of the program.
3. argv: An array of command-line arguments (optional, but included here).
4. 0: The exit code. A return value of 0 usually indicates success.

Run the program:

dotnet run

You should see:

Hello, F#!

Wrapping Up and Next Steps

Congratulations! You’ve mastered the F# basics, from declaring values and writing functions to experimenting interactively with Polyglot Notebooks and compiling standalone applications.

In the next article, we’ll explore intermediate concepts like collections, pattern matching, and modules. But for now, take a moment to bask in the glory of your newfound F# skills—and perhaps impress your friends by casually mentioning how “whitespace-driven syntax promotes clarity and elegance.”

Until next time: keep coding, keep learning, and remember—F# isn’t just a language. It’s an experience.