Data Types In F#
Data types provide a way to handle Data Elements. When you relate an element with a Data type you are giving a specific range of values to that particular Element. F# programming uses an Immutable Data Type. If you know the difference between String and StringBuilder in .Net than you can easily understood that a String is an immutable data type and StringBuilder is a mutable type. When you make changes in a string, each change causes a new Object. F# contains two types of Data Types as mutable and immutable types. Mutable data types (Fundamental Data Types) are the same as what .Net contains. The new data types that F# has are Immutable Types. F# is a strongly typed Language. Every expression, value and data element contains a well defined and valid type which is fixed at the time of source code compilation.
Fundamental Data Types
![table1.gif]()
![table2.gif]()
Immutable Data Types- F# includes Functional Programming component supporting eager evaluation and for functional programming it supports a set of immutable data types such as Tuples, Discriminated union, Records and Lists .
Immutability
Immutability means that the memory associated with an identifier, once assigned is fixed and can not be changed. F# is not a pure functional programming language and it enables value mutability by the mutable keyword.
If you want to define a type that is modifiable you can give the name of the identifier with mutable keyword.
let mutable a=5
You can change the mutable value by (<-) destructive assignment operator:
a <- 6
When you print the value of "a" it will print the changed value.
![data1.gif]()
let mutable a=5
a <- 6
printfn "%d"a
![data2.gif]()
Immutable Data Types are
Tuples
Tuples are ad hoc data types that can be used to group two or more related values into a single Object. These are written as comma separated entities in F#. A Tuple is a simple type that groups multiple types of values. The length of the Tuple can be identified at the time of Compilation. Creating a Tuple value is very easy. You write a comma separated list of values enclosed in parentheses. On the first line we create a Tuple and assign it a tup value. Here we used the Type Inference mechanism of F#.
Example-
> let tup = ("Tuple Data Type!", 06)
val tp : string * int
Example-
> let tuple = (06, "Tuple Data Type");;
val tuple : int * string
> let (num, str) = tuple;;
val num : int
val str : string
Discriminated union
Discriminated unions are used to create well defined type hierarchies and hierarchal data types. This data type is used for showing a data type that can store one of several options. The example of a discriminated union is Abstract Syntax Tree. This data type is useful for heterogeneous data. This data type have a finite number of distinct alternative representations. F# discriminated unions are type safe and work with Pattern matching.
Example-
type area =
| Right
| Left
| Top
| Bottom
member this.ToLatin() =
match this with
| Right -> "Wand"
| Left -> "Coin"
| Top -> "Cup"
| Bottom -> "Sword"
> let card = Right;;
val card : Suit = Right
> card.ToLatin()
val it : string = "Wand"
> let card2 =Top
val card2 : Suit = Top
> card2.ToLatin()
val it : string = "Cup"
Records
F# record types are a simple named type. A Record is a group of variable that are considered as one entity. You can create one or more variables in a record. When you need to access the record you can access the complete record or its member individually. The syntax to create a record is:
type RecordName= { Members }
To declare members you will use the following syntax:
MemberName: DataType
Example-
type Student = { Rno : int; FName : string; LName : string; Gender : char }
Lists
Lists data types are used for storing a collection of values. A F# list is a typical linked list type. It can be either a empty list or a cell containing a value or a reference to the tail, which is itself a list. Lists in F# is an immutable and ordered series of elements.
Example:
let list456 = [ 4; 5; 6 ]
We can also define a list by putting Link Breaks between elements, in which a semicolon will be optional.
let list456 = [
4
5
6 ]
Now we are discussing example of some data types.
Byte-
![data3.gif]()
let age:byte = 21uy;
printf "Person Age: ";
printfn "%d" age;
![data4.gif]()
Number-
![data5.gif]()
let number = 0xFE;
printfn "Number: %d" number;
![data6.gif]()
Signed Byte-
![data7.gif]()
let roomTemperature = -82y;
printfn "When anyone will enter, the room temperature will %d" roomTemperature;
![data8.gif]()
Summary
In this article I covered all mutable and immutable data types.