ch05-self.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Default object (self), scope & visibility (Chap 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Self (5.1.1)\n",
    "- the default or current object. at every point in a program's execution, there is only one copy of self.\n",
    "![pic](px/Selection_150.png)\n",
    "![pic](px/Selection_151.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "main"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# top-level self (5.1.2)\n",
    "# - refers to code outside any class or module def.\n",
    "# - \"main\" = special term; self refers to itself.\n",
    "m = self"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "just started C.\n",
      "C\n",
      "nested module C::M\n",
      "C::M\n",
      "back to C outer level\n",
      "C\n"
     ]
    }
   ],
   "source": [
    "# self inside class, module, method defs (5.1.3)\n",
    "class C\n",
    "    puts \"just started C.\"\n",
    "    puts self\n",
    "    module M\n",
    "        puts \"nested module C::M\"\n",
    "        puts self\n",
    "    end\n",
    "    puts \"back to C outer level\"\n",
    "    puts self\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "class C, method x.\n",
      "#<C:0x000055e69388b830>\n",
      "#<C:0x000055e69388b830>\n"
     ]
    }
   ],
   "source": [
    "class C\n",
    "    def x\n",
    "        puts \"class C, method x.\"\n",
    "        puts self\n",
    "    end\n",
    "end\n",
    "c = C.new; c.x; puts \"#{c}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inside singleton method of #<Object:0x000055e693877010>\n"
     ]
    }
   ],
   "source": [
    "# self in singleton & class method defs\n",
    "obj = Object.new\n",
    "def obj.showme\n",
    "    puts \"inside singleton method of #{self}\"\n",
    "end\n",
    "obj.showme"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "class method of C.self: C\n"
     ]
    }
   ],
   "source": [
    "class C\n",
    "    def C.x\n",
    "        puts \"class method of C.self: #{self}\"\n",
    "    end\n",
    "end\n",
    "C.x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":y"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# using self instead of hard-coded class names\n",
    "class C\n",
    "    def self.x\n",
    "        puts \"class method of C.self: #{self}\"\n",
    "    end\n",
    "end\n",
    "\n",
    "# for multiple class methods:\n",
    "# class << self tells class that following methods\n",
    "#   will be class methods.\n",
    "# if you decide to rename the class, self.x auto-\n",
    "#   adjusts to the new name. \n",
    "class C\n",
    "    class << self\n",
    "        def x\n",
    "            # \n",
    "        end\n",
    "        def y\n",
    "            #\n",
    "        end\n",
    "    end\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dot not needed.\n",
      "dot not needed.\n"
     ]
    }
   ],
   "source": [
    "# self as default message receiver (5.1.4)\n",
    "# method calls, usual notation: object.method\n",
    "# can omit objec & dot, if receiver is \"self\".\n",
    "class C\n",
    "    def C.nodot\n",
    "        puts \"dot not needed.\"\n",
    "    end\n",
    "    nodot\n",
    "end\n",
    "C.nodot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y calls x without a dot\n",
      "this is 'x'\n"
     ]
    }
   ],
   "source": [
    "class C\n",
    "    def x\n",
    "        puts \"this is 'x'\"\n",
    "    end\n",
    "    def y\n",
    "        puts \"y calls x without a dot\"\n",
    "        x\n",
    "    end\n",
    "end\n",
    "c = C.new; c.y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"problems...\""
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Person\n",
    "    attr_accessor :first, :middle, :last \n",
    "    def whole\n",
    "        n = first+\" \"\n",
    "        n << \"#{middle}\" if middle\n",
    "        n << last\n",
    "    end\n",
    "end\n",
    "begin\n",
    "    d = Person.new\n",
    "    d.first=\"david\"; d.last=\"black\"\n",
    "    puts \"#{d.whole}\"\n",
    "    d.middle=\"alan\"\n",
    "    puts \"#{d.whole}\"\n",
    "rescue\n",
    "    \"problems...\"\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "instance var; belongs to any C.\n"
     ]
    }
   ],
   "source": [
    "# resolving instance variables through self (5.1.5)\n",
    "class C\n",
    "    def setv\n",
    "        @v = \"instance var; belongs to any C.\"\n",
    "    end\n",
    "    def showv\n",
    "        puts @v\n",
    "    end\n",
    "    def self.setv\n",
    "        @v = \"instance var; belongs to C.\"\n",
    "    end\n",
    "end\n",
    "\n",
    "# every instance variable belongs to the object that\n",
    "# is playing the role of \"self\" at that moment.\n",
    "\n",
    "C.setv\n",
    "c = C.new; c.setv\n",
    "c.showv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "just inside class def. here's self.\n",
      "C\n",
      "instance var, top level of class body. belongs to C\n",
      "#<C:0x000055e693b52258>\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# demo'ing relation between instance vars & self (listing 5.3)\n",
    "class C\n",
    "    puts \"just inside class def. here's self.\"\n",
    "    p self\n",
    "    @v = \"instance var, top level of class body.\"\n",
    "    puts \"#{@v} belongs to #{self}\"\n",
    "    \n",
    "    def showv\n",
    "        puts self; puts @v\n",
    "    end\n",
    "end\n",
    "c = C.new; c.showv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Scope"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i'm a global.\n"
     ]
    }
   ],
   "source": [
    "# global variables\n",
    "# - denoted by leading \"$\"\n",
    "$gvar = \"i'm a global.\"\n",
    "class C\n",
    "    def seeglobal\n",
    "        puts $gvar\n",
    "    end\n",
    "end\n",
    "c = C.new; c.seeglobal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/usr/local/bin/iruby\n",
      "[\"/home/bjpcjp/.gem/ruby/2.7.0/gems/iruby-0.4.0/lib\", \"/home/bjpcjp/.gem/ruby/2.7.0/gems/bond-0.5.1/lib\", \"/home/bjpcjp/.gem/ruby/2.7.0/extensions/x86_64-linux/2.7.0-static/bond-0.5.1\", \"/home/bjpcjp/.gem/ruby/2.7.0/gems/multi_json-1.14.1/lib\", \"/usr/local/lib/ruby/gems/2.7.0/gems/mimemagic-0.3.5/lib\", \"/home/bjpcjp/.gem/ruby/2.7.0/gems/data_uri-0.1.0/lib\", \"/home/bjpcjp/.gem/ruby/2.7.0/gems/iruby-0.4.0/lib\", \"/home/bjpcjp/.gem/ruby/2.7.0/gems/czmq-ffi-gen-0.16.1/lib\", \"/home/bjpcjp/.gem/ruby/2.7.0/gems/cztop-0.14.1/lib\", \"/usr/local/lib/ruby/gems/2.7.0/gems/ffi-1.13.1/lib\", \"/usr/local/lib/ruby/gems/2.7.0/extensions/x86_64-linux/2.7.0-static/ffi-1.13.1\", \"/usr/local/lib/ruby/gems/2.7.0/gems/coderay-1.1.2/lib\", \"/usr/local/lib/ruby/gems/2.7.0/gems/method_source-1.0.0/lib\", \"/usr/local/lib/ruby/gems/2.7.0/gems/pry-0.13.1/lib\", \"/usr/local/lib/ruby/site_ruby/2.7.0\", \"/usr/local/lib/ruby/site_ruby/2.7.0/x86_64-linux\", \"/usr/local/lib/ruby/site_ruby\", \"/usr/local/lib/ruby/vendor_ruby/2.7.0\", \"/usr/local/lib/ruby/vendor_ruby/2.7.0/x86_64-linux\", \"/usr/local/lib/ruby/vendor_ruby\", \"/usr/local/lib/ruby/2.7.0\", \"/usr/local/lib/ruby/2.7.0/x86_64-linux\"]\n",
      "5999\n"
     ]
    }
   ],
   "source": [
    "# example built-in Ruby globals\n",
    "puts $0 # startup file\n",
    "puts $: # search paths\n",
    "puts $$ # processs ID\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "# local scope (5.2.2)\n",
    "class C\n",
    "    a=1\n",
    "    def local_a\n",
    "        a=2; puts a\n",
    "    end\n",
    "    puts a\n",
    "end\n",
    "c = C.new; c.local_a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "# var name reuse - nested local scopes (listing 5.4)\n",
    "class C\n",
    "    a=5\n",
    "    module M\n",
    "        a=4\n",
    "        module N\n",
    "            a=3\n",
    "            class D\n",
    "                a=2\n",
    "                def show_a\n",
    "                    a=1; puts a\n",
    "                end\n",
    "                puts a\n",
    "            end\n",
    "            puts a\n",
    "        end\n",
    "        puts a\n",
    "    end\n",
    "    puts a\n",
    "end\n",
    "d = C::M::N::D.new; d.show_a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#<C:0x000055e6939ff5e0>\n",
      "1st val for a\n",
      "recursion\n",
      "#<C:0x000055e6939ff5e0>\n",
      "2nd val for a\n",
      "1st val for a\n"
     ]
    }
   ],
   "source": [
    "# local scope and self (5.2.3)\n",
    "class C\n",
    "    def x(value_for_a, recurse=false)\n",
    "        a=value_for_a\n",
    "        puts self; puts a\n",
    "        if recurse\n",
    "            puts \"recursion\";\n",
    "            x(\"2nd val for a\"); puts a\n",
    "        end\n",
    "    end\n",
    "end\n",
    "c = C.new; c.x(\"1st val for a\",true)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "# scope & constant resolution (5.2.4)\n",
    "# stripped of nesting, constants... aren't.\n",
    "module M\n",
    "    class C\n",
    "        X=2\n",
    "        class D\n",
    "            module N\n",
    "                X=1\n",
    "            end\n",
    "        end\n",
    "    end\n",
    "end\n",
    "puts M::C::D::N::X\n",
    "puts M::C::X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":make_mates"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# class variable syntax, scope, visibility (5.2.5)\n",
    "class Car\n",
    "    @@makes = [] # array; \"@@\" = class variable\n",
    "    @@cars = {} # hash\n",
    "    @@total_count = 0\n",
    "    attr_reader :make\n",
    "    \n",
    "    def self.total_count\n",
    "        @@total_count\n",
    "    end\n",
    "    def self.add_make(make)\n",
    "        unless @@makes.include?(make)\n",
    "            @@makes<<make\n",
    "            @@cars[make]=0\n",
    "        end\n",
    "    end\n",
    "    def initialize(make)\n",
    "        if @@makes.include?(make)\n",
    "            puts \"new #{make}\"\n",
    "            @make=make\n",
    "            @@cars[make]+=1\n",
    "            @@total_count+=1\n",
    "        else\n",
    "            raise \"no such make: #{make}\"\n",
    "        end\n",
    "    end\n",
    "    def make_mates\n",
    "        @@cars[self.make]\n",
    "    end\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "new honda\n",
      "new ford\n",
      "new honda\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "#<Car:0x000055e6938c2998 @make=\"honda\">"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Car.add_make(\"honda\"); Car.add_make(\"ford\")\n",
    "h = Car.new(\"honda\"); f = Car.new(\"ford\")\n",
    "h2 = Car.new(\"honda\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "no such beast.\n"
     ]
    }
   ],
   "source": [
    "begin\n",
    "    x = Car.new(\"bogus\")\n",
    "rescue\n",
    "    puts \"no such beast.\"\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200\n"
     ]
    }
   ],
   "source": [
    "# class variables & class hierarchies\n",
    "class Parent\n",
    "    @@value = 100\n",
    "end\n",
    "class Child<Parent\n",
    "    @@value = 200\n",
    "end\n",
    "class Parent\n",
    "    puts @@value\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Method access rules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":stir_batter"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# private methods (5.3.1)\n",
    "# - private methods can't be called with an explicit receiver:\n",
    "# b=Baker.new; b.add_egg <== will fail.\n",
    "\n",
    "class Cake\n",
    "    def initialize(batter)\n",
    "        @batter=batter\n",
    "        @baked=true\n",
    "    end\n",
    "end\n",
    "class Egg\n",
    "end\n",
    "class Flour\n",
    "end\n",
    "class Baker\n",
    "    def bakeit\n",
    "        @batter=[]\n",
    "        # if you don't use an explicit receiver, Ruby assumes you want to\n",
    "        # send the message to self. (Nobody can send this msg to a Baker.)\n",
    "        pour_flour\n",
    "        add_egg\n",
    "        stir_batter\n",
    "        return Cake.new(@batter)\n",
    "    end\n",
    "    private # also valid: private :pour_flour, :add_egg, :stir_batter\n",
    "    def pour_flour\n",
    "        @batter.push(Flour.new)\n",
    "    end\n",
    "    def add_egg\n",
    "        @batter.push(Egg.new)\n",
    "    end\n",
    "    def stir_batter\n",
    "    end\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dog"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# private setter methods\n",
    "# -- Ruby doesn't apply \"no explicit receiver\" rule to setters.\n",
    "#\n",
    "#      dog_years = age*7 <== Ruby thinks dog_years is a local variable.\n",
    "# self.dog_years = age*7 <== legit.\n",
    "\n",
    "class Dog\n",
    "    attr_reader :age, :dog_years\n",
    "    def dog_years=(years)\n",
    "        @dog_years=years\n",
    "    end\n",
    "    def age=(years)\n",
    "        @age=years\n",
    "        self.dog_years=years*7\n",
    "    end\n",
    "    private :dog_years=\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "other object's n is bigger.\n"
     ]
    }
   ],
   "source": [
    "# protected methods (5.3.2)\n",
    "# you can call protected methods on an object, as long as the default\n",
    "# object (self) is an instance of the same class.\n",
    "# use case: when you want an instance of a class to do something with\n",
    "# another instance of the same class.\n",
    "class C\n",
    "    def initialize(n)\n",
    "        @n=n\n",
    "    end\n",
    "    def n\n",
    "        @n\n",
    "    end\n",
    "    def compare(c)\n",
    "        if c.n>n\n",
    "            puts \"other object's n is bigger.\"\n",
    "        else\n",
    "            puts \"other object's n is same or smaller.\"\n",
    "        end\n",
    "    end\n",
    "    protected :n\n",
    "end\n",
    "c1=C.new(100); c2=C.new(200); c1.compare(c2) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Top-level methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "howdy\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\"nope. can't do that.\""
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# definitions (5.4.1)\n",
    "# methods defined at the top level are stored as private instance methods\n",
    "# of Object. equivalent to:\n",
    "class Object\n",
    "    private\n",
    "    def talk\n",
    "        puts 'howdy'\n",
    "    end\n",
    "end\n",
    "# must be called in \"bareword\" style, 'cause they are private.\n",
    "# can be called anywhere (Object is in lookup path of every class)\n",
    "\n",
    "def talk\n",
    "    puts 'howdy'\n",
    "end\n",
    "talk\n",
    "begin\n",
    "    obj=Object.new\n",
    "    obj.talk\n",
    "rescue\n",
    "    \"nope. can't do that.\"\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[:Array, :Complex, :Float, :Hash, :Integer, :JSON, :Pathname, :Rational, :String, :URI, :__callee__, :__dir__, :__method__, :`, :abort, :at_exit, :autoload, :autoload?, :binding, :block_given?, :caller, :caller_locations, :catch, :eval, :exec, :exit, :exit!, :fail, :fork, :format, :gem, :gem_original_require, :gets, :global_variables, :initialize_clone, :initialize_copy, :initialize_dup, :iterator?, :j, :jj, :lambda, :load, :local_variables, :loop, :open, :p, :pp, :print, :printf, :proc, :putc, :puts, :raise, :rand, :readline, :readlines, :require, :require_relative, :respond_to_missing?, :select, :set_trace_func, :sleep, :spawn, :sprintf, :srand, :syscall, :system, :test, :throw, :trace_var, :trap, :untrace_var, :warn]"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# predefined top-level methds (5.4.2)\n",
    "# examples: puts, print (private methods of Kernel.)\n",
    "Kernel.private_instance_methods.sort"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Ruby 2.7.0",
   "language": "ruby",
   "name": "ruby"
  },
  "language_info": {
   "file_extension": ".rb",
   "mimetype": "application/x-ruby",
   "name": "ruby",
   "version": "2.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}