notebooks/MutableAndImmutableObjects.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "dental-minority",
   "metadata": {},
   "source": [
    "# Mutable and Immutable Objects in Ruby\n",
    "\n",
    "Mutable objects are objects whose state can change. Immutable objects are objects whise state never changes after creation.\n",
    "\n",
    "Immutable objects have many desirable properties:\n",
    "\n",
    "* Immutable objects are thread-safe. Threads cannot corrupt what they cannot change.\n",
    "* Immutable objects make it easier to implement encapsulation. If part of an object's state is stored in an immutable object, then accessor methods can return that object to outside callers, without fear that those callers can change the object's state.\n",
    "* Immutable objects make good hash keys, since their hash codes cannot change.\n",
    "\n",
    "In Ruby, Mutability is a property of an instance, not of an entire class. Any instance can become immutable by calling `freeze`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "joint-season",
   "metadata": {},
   "source": [
    " ## Freezing Objects\n",
    " \n",
    " The `freeze` method in class `Object` prevents you from changing an object, effectively turning an object into a constant. After we freeze an object, an attempt to modify it results in `TypeError`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "portuguese-puppy",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FrozenError - can't modify frozen String: \"A simple string.\"\n"
     ]
    }
   ],
   "source": [
    "str = 'A simple string.'\n",
    "str.freeze\n",
    "begin\n",
    "  str << 'An attempt to modify.'\n",
    "rescue StandardError => e\n",
    "  puts \"#{e.class} - #{e}\"\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "exotic-amino",
   "metadata": {},
   "source": [
    "However, `freeze` operates on an object reference, not on a variable. This means that any operation resulting in a new object will work. This is illustrated by the following example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "modified-announcement",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original string - attachment\n"
     ]
    }
   ],
   "source": [
    "str = 'Original string - '\n",
    "str.freeze\n",
    "str += 'attachment'\n",
    "puts str"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "white-bikini",
   "metadata": {},
   "source": [
    "The expression `str + attachment` is evaluated to a new object, which is then assigned to `str`. The object is not changed, but the variable `str` now refers to a new object."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "diagnostic-hungary",
   "metadata": {},
   "source": [
    "## `frozen?`\n",
    "\n",
    "A method `frozen?` tells you whether an object is frozen or not. Let's take an example here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "partial-medicare",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true\n",
      "true\n",
      "New string\n",
      "Original string\n",
      "false\n",
      "true\n"
     ]
    }
   ],
   "source": [
    "a = b = 'Original string'\n",
    "b.freeze\n",
    "\n",
    "puts a.frozen?\n",
    "puts b.frozen?\n",
    "\n",
    "a = 'New string'\n",
    "puts a\n",
    "puts b\n",
    "\n",
    "puts a.frozen?\n",
    "puts b.frozen?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "hearing-illinois",
   "metadata": {},
   "source": [
    "Let us understand what we are doing here - `a` and `b` are two variables both of which are pointing to a string object - _Original string_. We then freeze the object _Original string_. Hence both `a` and `b` are now pointing to the frozen object _Original string_. This is verified by the statements `puts a.frozen?` and `puts b.frozen?`. Next, we create a new string object _New String_ and make variable `a` point to this new object _New String_. Variable `b` is still pointing to the frozen object while `a` is not. This verified by the last 2 statements to the program.\n",
    "\n",
    "**Usage**:\n",
    "\n",
    "Ruby sometimes copies objects and freezes the copies. When you use a string as a hash key, Ruby actually copies the string, freezes the copy, and uses the copy as the hash key: that way, if the original string changes later on, the hash key isn't affected.\n",
    "\n",
    "Ruby's internal file operations work from a frozen copy of a filename instead of using the filename directly. If another thread modifies the original filename in the middle of an operation that's suppose to be atomic, there's no problem: Ruby wasn't relying on the original filename anyway. You can adopt this copy-and-freeze pattern in multi-threaded code to prevent data structure you're working on from being changed by another thread.\n",
    "\n",
    "Another commom programmer-level use of this feature is to freeze a class in order to prevent future modifications to it.\n",
    "\n",
    "**Note**: Whenever an object in Ruby has no reference to it, then that object is marked for removal and the garbage collector will remove that object based on its algorithm. There is no way to access an un-referenced object."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Ruby 3.0.0",
   "language": "ruby",
   "name": "ruby"
  },
  "language_info": {
   "file_extension": ".rb",
   "mimetype": "application/x-ruby",
   "name": "ruby",
   "version": "3.0.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}