Working with Records in FSharp

Introduction: Record is used to group different types of data into a single unit in structural format. Records are immutable by default. It is similar to structure in C language. Its values are separated by semicolons. A record definition starts with the type keyword then we simply define a series of data in the format of Label : Type in curly braces. The syntax for Record definition is given below.

Defining a Record

type record_type_name={
Label1 : type1;
Label2 : type2;
--------------;
--------------;
}

Like,

type Rectyp = { First : string; Last : string; City: string; Age : int}

or,

type Rectyp = {
First : string;
Last : string;
City: string;
Age : int
}

Here RecTyp is the Record name and First, Last, City and Age are Lalels and string and int are their Datatypes.

Creating an Instance:  Now we create a record with named student and fill values First_Name, Last_Name, City and Age. We write the following code.

// Creating Record

type student = { First_Name : string; Last_Name : string; City: string; Age : int}
 
let ob = {
  First_Name = "Satish";
  Last_Name = "Kumar";
  City= "Delhi";
  Age = 14
   } 

printfn " First Name %s" ob.First_Name
printfn " Last Name %s" ob.Last_Name
printfn " City %s" ob.City
printfn " Age %d" ob.Age 

Now we run this application by pressing Crtl+F5 key. The output will look like the below figure



It may be that the field name of two or more records is the same. In that case, the compiler requires information about the types of records to be operated. For that, we need to create an instance of record. We create an instances with a Colon (:), like the below example.

// Creating Record's instance

type student = { Name : string; City: string;}
type employee={ Name : string; Department: string;}
 
let (std : student) = {
  Name = "Satish";
  City= "Delhi"
    }
let (emp : employee) = {Name = "Alok"; Department = "IT"}

Copy of a Record: Records can be easily copied into another record with updated value. To copy a record, we use the with keyword between the old record name and a list of updated fields in curly braces. To understand it, we write the following code

// Copy and updating Record

type record1 = { x : int; y : int; z : int;}
let ref = { x=1; y=2;z=3}
let cpy={ ref with z=4}

printfn "%A" ref
printfn "%A" cpy

Now we run this code. The output will look like the below figure

Accessing Value: The field values are accessed by the dot (.) operator. We use the  dot (.) operator with record_name or instance name of a record, like the following example,

//simple record
type student = { Name : string; City: string;}
let student = {Name = "Satish";City= "Delhi" }

//accessing with record name
printfn "Name :%s" student.Name
printfn "City :%s" student.City

//instance
type employee = {Name : string; City: string;}
let (emp : employee) = {Name = "Satish";City= "Delhi" }

//accessing with instance name
printfn "\nName :%s" emp.Name
printfn "City :%s" emp.City 

//specifying the type
type teacher = {Name : string; City: string;}
let teacher = {teacher.Name = "Satish";City= "Delhi" }
printfn "\nName :%s" teacher.Name 
printfn "City :%s" teacher.City  

//All field value
printfn "\nAll field values of teacher record \n %A " teacher
printfn ""

Output: