F# Modules

F# modules provide a way to organize and reuse code in a flexible and efficient manner.

In this article, we will explore the world of F# modules, understanding what they are, how they work, and how you can leverage them to write modular and maintainable code.

As per the MSDN library, an F# module is a logical grouping of F# code constructs. These constructs include types, values, function values, and code in the bindings that hold these code constructs.

It is implemented in the CLR as a static class which only has static members and is called from within the CLR.

What are F# Modules?

F# modules are units of code that group related functions, types, and values together. They provide a way to organize and encapsulate code in a cohesive and logical manner.

Modules in F# can be used to define namespaces, create reusable libraries, and organize code within a single file or across multiple files. Modules can be used for functional programming, object-oriented programming, and other paradigms, making them a versatile tool for structuring F# code.

Creating and Using F# Modules

In F#, modules can be created using the module keyword, followed by the module name.

A module can contain various elements such as functions, types, and values, which are defined using the familiar syntax of F#.

There are two types of module declarations based on the situation whether the whole file or only portions of it is included in the module:

  • Top-level module declaration
  • Local module declaration

Top-level module declarations include all the files within the module as part of the package. The module declaration is the first declaration in this file. A top-level module does not require indentation.

As far as the local module declaration is concerned, only those declarations which are indented under the local module declaration are deemed to be part of this module declaration.


The syntax for declaring a module is as follows:

// Top-level module declaration.
module [accessibility-modifier] [qualified-namespace.]module-name

// Local module declaration.
module [accessibility-modifier] module-name =

There are three types of accessibility modifiers you can use: public, private, and internal.

As a default, the accessibility modifiers are set to public.

F# Module Arithmetic

One common use of F# modules is to define arithmetic operations, such as addition, subtraction, multiplication, and division, as reusable functions.

By encapsulating arithmetic operations in modules, you can create reusable components that can be easily used in different parts of your application.

Let’s take a look at an example of how you can define a module for arithmetic operations in F#:


module Arithmetic let add x y = x + y let subtract x y = x – y let multiply x y = x * y let divide x y = x / y let sum = add 10 2 printfn "The sum is: %d" sum let difference = subtract 10 2 printfn "The difference is: %d" difference let multiple = multiply 10 2 printfn "The multiply is: %d" multiple let division = divide 10 2 printfn "The division is: %d" division

And the output will be as follows:

The sum is: 12
The difference is: 8
The multiply is: 20
The division is: 5

Custom Module

Creating a custom module in F# is straightforward.

You can define a module using the module keyword followed by the name of the module.

Here’s an example of how you can create a custom module:


// Module1 module module1 = let value1 = 50 let module1Function x = x + value1 // Module2 module module2 = let value2 = 100 let module2Function x = x + (module1.module1Function value2) let result = module1.module1Function 50 printfn "Sum from Module1: %d" result let result2 = module2.module2Function 50 printfn "Sum from Module2 after adding from Module1: %d" result2

The output of both module in above example are:

Sum from Module1: 100
Sum from Module2 after adding from Module1: 200

Example Explanation

In this example, we have two modules: module1 and module2. I’ll explain how they work together to produce output.

In module1, we define a value called value1 with a value of 50, and a function called module1Function that takes an argument x and returns the sum of x and value1.

In module2, we define a value called value2 with a value of 100, and a function called module2Function that takes an argument x. This function calls module1.module1Function value2, which means it calls the module1Function from module1 with an argument of value2. The result of this call is then added to the argument x and returned.

We then call module1.module1Function with an argument of 50 and print the result, which is 100. This is because module1Function adds 50 to value1, which is 50, resulting in 100.

Next, we call module2.module2Function with an argument of 50 and print the result, which is 200. This is because module2Function adds 50 to the result of module1.module1Function value2, which is 150. The module1Function call returns 150 because it adds value2 to value1, resulting in 150. module2Function then adds 50 to this, resulting in 200.

So, in summary, module2 depends on module1 because it calls module1Function from module1. By using modules in this way, we can break up our code into smaller, more manageable pieces and build on top of each other’s work.


F# modules are a powerful feature that allows you to organize and reuse code in a modular and efficient manner. They provide a way to encapsulate code, create reusable libraries, and organize code in a hierarchical manner. With advanced features such as private and internal members, type abbreviations, and extension members, F# modules offer a flexible and powerful way to structure your code and write maintainable, reusable, and expressive F# applications.

Whether you are building functional applications, object-oriented applications, or a combination of both, F# modules can greatly enhance your development process and help you write more organized and maintainable code. So, dive into the world of F# modules and leverage their power to write efficient and modular F# applications!

If you liked this article and found it informative, you can subscribe to our newsletter 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 *