F# Program Structure

The purpose of this article is to show you F# program structure, how to define variables, functions, and modules in an F# application with examples.

The F# programming language uses Functional Programming.

The concept of functions in F# is very similar to the concept of data types. Similarly to variables, functions are also able to be declared and used in the same way.

There is typically no specific entry point in an F# application since F# applications are designed to be modular. A top-level statement in the file is then executed from the top to the bottom by the compiler.

A procedural program typically consists of a single top-level statement called the main loop, which is used in many programs.

An example of a simple F# program is shown below.


open System (* This is a multi-line comment *) // This is a single-line commentlet Number num = if num > 0 then "positive number" elif num < 0 then "negative number" else "zero"let main() = Console.WriteLine("Number 5: {0}", (Number 5))main()

Once the program is compiled and executed, we are able to get the following output:

F# Program example

The following information needs to be noted:

In many F# code files, the first statement usually begins with an open statement that is used to import namespaces from other code files.

Other functions in the body of the file are responsible for implementing the necessary logic of the application that can be found in the document.

This main loop is responsible for executing the statements at the top of the loop.

F# has a unique program structure that is designed to promote modularity, reusability, and maintainability.


Modules are the building blocks of an F# program. They are used to organize code into logical units, making it easier to manage and maintain.

Modules can contain functions, types, and other modules.

They are defined using the module keyword, followed by the module name, and then the code block enclosed in braces.

Below module contains a single function named add that takes two parameters and returns their sum.

Here is an example of a simple module:

module MyModule =
   let add a b = a + b


Functions are the core components of F# programs. They are used to perform operations and calculations on data.

Functions can be defined inside modules or as standalone entities.

Functions are defined using the let keyword followed by the function name, the parameters enclosed in parentheses, and the code block enclosed in braces.

Here is an example of a simple function:

let square x = x * x


Types are used to define data structures in F# programs. They are used to specify the shape and behavior of data.

Types can be defined inside modules or as standalone entities.

Types are defined using the type keyword followed by the type name, the data structure enclosed in braces, and any behavior or functions associated with the type.

Here is an example of a simple type:


type Person = {
Name : string
Age : int

Top Level Entry Point

Many applications follow a procedural programming style in that they contain only a single top-level statement which calls the main loop according to the following example.


open Systemlet message = "Welcome to F# Tutorial on mrexamples.com"let main () = Console.WriteLine(message) main()
If you liked this article and found it informative regarding F# program structure, you can leave your feedback by reacting below.
We value your feedback.

Subscribe To Our Newsletter
Enter your email to receive a weekly round-up of our best posts. Learn more!

Leave a Reply

Your email address will not be published. Required fields are marked *