HelpSource/Guides/Polymorphism.schelp

   1 title:: Polymorphism
   2 summary:: the ability of different classes to respond to a message in different ways
   3 categories:: Language>OOP
   4 related:: Reference/Messages, Reference/Classes, Guides/Intro-to-Objects
   5
   6 section:: Introduction
   7
   8 Polymorphism is the ability of different classes to respond to a message in different ways. A message generally has some underlying meaning and it is the responsibility of each class to respond in a way appropriate to that meaning.
   9
  10 For example, the code::value:: message means "give me the effective value of this object".
  11
  12 The value method is implemented by these classes (among others):
  13 definitionlist::
  14 ## Function : || this.value(args)
  15 ## Object : || this.value()
  16 ## Ref : || this.value
  17 ::
  18
  19 Let's look at how these classes implement the value message.
  20
  21 subsection:: Object
  22
  23 Here's the value method in class link::Classes/Object:: :
  24 code::
  25 value { ^this }
  26 ::
  27 It simply returns itself. Since all classes inherit from class Object this means that unless a class overrides code::value::, the object will respond to code::value:: by returning itself.
  28 code::
  29 5.postln;                       // posts itself
  30 5.value.postln;         // value returns itself
  31 'a symbol'.postln;
  32 'a symbol'.value.postln;
  33 [1,2,3].value.postln;
  34 //etc...
  35 ::
  36
  37 subsection:: Function
  38 In class link::Classes/Function:: the value method is a primitive:
  39 code::
  40 value { arg ... args;
  41     _FunctionValue
  42     // evaluate a function with args
  43     ^this.primitiveFailed
  44 }
  45 ::
  46
  47 code::_FunctionValue:: is a C code primitive, so it is not possible to know just by looking at it what it does. However what it does is to evaluate the function and return the result.
  48 code::
  49 { 5.squared }.postln;                   // posts Instance of Function
  50 { 5.squared }.value.postln;             // posts 25
  51 ::
  52
  53 subsection:: Ref
  54 The link::Classes/Ref:: class provides a way to create an indirect reference to an object. It can be used to pass a value by reference. Ref objects have a single instance variable called code::value::.
  55 The code::value:: method returns the value of the instance variable code::value::. Here is the class definition for Ref:
  56 code::
  57 Ref : AbstractFunction
  58 {
  59     var <>value;
  60     *new { arg thing; ^super.new.value_(thing) }
  61     set { arg thing; value = thing }
  62     get { ^value }
  63     dereference { ^value }
  64     asRef { ^this }
  65
  66     //behave like a stream
  67     next { ^value }
  68     embedInStream { arg inval;
  69         ^this.value.embedInStream(inval)
  70     }
  71
  72     printOn { arg stream;
  73         stream << "`(" << value << ")";
  74     }
  75     storeOn { arg stream;
  76         stream << "`(" <<< value << ")";
  77     }
  78 }
  79 ::
  80 Here is how it responds :
  81 code::
  82 Ref.new(123).postln;
  83 Ref.new(123).value.postln;
  84 ::
  85
  86 Ref also implements a message called code::dereference:: which is another good example of polymorphism. As implemented in Ref, dereference just returns the value instance variable which is no different than what the value method does.
  87 So what is the need for it? That is explained by how other classes respond to dereference. The dereference message means "remove any Ref that contains you".
  88 In class Object dereference returns the object itself, again just like the value message. The difference is that no other classes override this method. So that dereference of a Function is still the Function.
  89 definitionlist::
  90 ## Object : || this.dereference()
  91 ## Ref : || this.dereference()
  92 ::
  93 code::
  94 5.value.postln;
  95 { 5.squared }.value.postln;
  96 Ref.new(123).value.postln;
  97
  98 5.dereference.postln;
  99 { 5.squared }.dereference.postln;
 100 Ref.new(123).dereference.postln;
 101 ::
 102
 103 section:: Play
 104 Yet another example of polymorphism is play. Many different kinds of objects know how to play themselves.
 105
 106 subsection:: Function
 107 code::
 108 { PinkNoise.ar(0.1) }.play;
 109 ::
 110
 111 subsection:: AppClock
 112 code::
 113 (
 114 var w, r;
 115 w = Window.new("trem", Rect(512, 256, 360, 130));
 116 w.front;
 117 r = Routine({ arg appClockTime;
 118     ["AppClock has been playing for secs:",appClockTime].postln;
 119     60.do({ arg i;
 120         0.05.yield;
 121         w.bounds = w.bounds.moveBy(10.rand2, 10.rand2);
 122         w.alpha = cos(i*0.1pi)*0.5+0.5;
 123     });
 124     1.yield;
 125     w.close;
 126 });
 127 AppClock.play(r);
 128 )
 129 ::
 130
 131 subsection:: SynthDef
 132 code::
 133 (
 134 x = SynthDef("Help-SynthDef", { arg out=0;
 135     Out.ar(out, PinkNoise.ar(0.1))
 136 }).play;
 137 )
 138 ::
 139
 140 subsection:: Pattern
 141 code::
 142 Pbind(\degree, Pseq([0, 1, 2, 3],inf)).play;
 143 ::
 144
 145 section:: Conclusion
 146 Polymorphism allows you to write code that does not assume anything about the implementation of an object, but rather asks the object to "do what I mean" and have the object respond appropriately.
 147