D Programming - Immutable

We often use variables that are mutable but there can be many occasions mutabipty is not required. Immutable variables can be used in such cases. A few examples are given below where immutable variable can be used.

In case of math constants such as pi that never change.

In case of arrays where we want to retain values and it is not requirements of mutation.

Immutabipty makes it possible to understand whether the variables are immutable or mutable guaranteeing that certain operations do not change certain variables. It also reduces the risk of certain types of program errors. The immutabipty concept of D is represented by the const and immutable keywords. Although the two words themselves are close in meaning, their responsibipties in programs are different and they are sometimes incompatible.

The immutabipty concept of D is represented by the const and immutable keywords. Although the two words themselves are close in meaning, their responsibipties in programs are different and they are sometimes incompatible.

Types of Immutable Variables in D

There are three types of defining variables that can never be mutated.

enum constants

immutable variables

const variables

enum Constants in D

The enum constants makes it possible to relate constant values to meaningful names. A simple example is shown below.

Example

import std.stdio;

enum Day{ 
   Sunday = 1, 
   Monday,
   Tuesday, 
   Wednesday, 
   Thursday, 
   Friday, 
   Saturday 
} 
 
void main() { 
   Day day; 
   day = Day.Sunday;
   
   if (day == Day.Sunday) { 
      writeln("The day is Sunday"); 
   } 
}

The day is Sunday

import std.stdio; 
import std.random; 
 
void main() { 
   int min = 1; 
   int max = 10; 
   
   immutable number = uniform(min, max + 1); 
   // cannot modify immutable expression number 
   // number = 34; 
   typeof(number) value = 100;  
   
   writeln(typeof(number).stringof, number); 
   writeln(typeof(value).stringof, value); 
}

immutable(int)4 
immutable(int)100

import std.stdio; 
import std.random; 
 
void main() { 
   int min = 1; 
   int max = 10; 
   
   const number = uniform(min, max + 1); 
   // cannot modify const expression number| 
   // number = 34; 
   typeof(number) value = 100; 
   
   writeln(typeof(number).stringof, number); 
   writeln(typeof(value).stringof, value); 
}

const(int)7 
const(int)100

import std.stdio; 
 
void print(immutable int[] array) { 
   foreach (i, element; array) { 
      writefln("%s: %s", i, element); 
   } 
}
  
void main() { 
   immutable int[] array = [ 1, 2 ]; 
   print(array); 
}

0: 1 
1: 2