Inheritance and polymorphism - Revision history

JAL at 16:33, 23 October 2013

2013-10-23T16:33:05Z

← Older revision		Revision as of 16:33, 23 October 2013
Line 193:		Line 193:
	because the member name did not exist in the base class.		because the member name did not exist in the base class.
	</ul>		</ul>

	==Multiple inheritance==		==Multiple inheritance==
	<var class="product">SOUL</var> allows a class to extend more than a single class.		<var class="product">SOUL</var> allows a class to extend more than a single class.
Line 524:		Line 525:
	inheritance.		inheritance.
	</p>		</p>

	<li>The absence of instance-specific variable support for interfaces can		<li>The absence of instance-specific variable support for interfaces can
	also be a problem.		also be a problem.
Line 641:		Line 643:
	end constructor		end constructor
	</p>		</p>
	===Rules for ~~Constructors~~ and ~~inheritance~~===		===Rules for constructors and Inheritance===
	A perhaps somewhat arbitrary rule for ~~a <var>Constructor</var>~~ that is enforced at compile time is that a <var>Construct</var> statement must be placed inside a constructor for an extension class of the base class being constructed.		A perhaps somewhat arbitrary rule for constructors that is enforced at compile time is that a <var>Construct</var> statement must be physically placed inside a constructor for an extension class of the base class being constructed.

	In addition to that rule are four major inheritance-specific rules for constructors.		In addition to that rule are four major inheritance-specific rules for constructors:
	<ul>		<ul>
	<li>It is invalid to refer to a base class member until the ~~<var>Constructor</var>~~		<li>It is invalid to refer to a base class member until the constructor
	for that base class has been entered, that is, until a <var>Construct</var>		for that base class has been entered, that is, until a <var>Construct</var>
	statement has been issued for that base class.		statement has been issued for that base class.
Line 663:		Line 665:
	<var>Discard</var> of the object being constructed. </p>		<var>Discard</var> of the object being constructed. </p>
	</ul>		</ul>

	All violations of these rules are caught at run-time.		All violations of these rules are caught at run-time.
	This allows more flexibility in writing constructors at the cost of the compile-time checks for rules conformance.		This allows more flexibility in writing constructors at the cost of the compile-time checks for rules conformance.
Line 749:		Line 752:
	class to a more general class, hence a widening assignment.		class to a more general class, hence a widening assignment.

	~~SOUL like~~ many other object-oriented languages also allows what are called '''narrowing assignments'''		Like many other object-oriented languages, <var class="product">SOUL</var> also allows what are called '''narrowing assignments'''
	— assignments from a base class variable to an extension class variable.		— assignments from a base class variable to an extension class variable.
	Because narrowing assignments are usually not recommended, special syntax is required in SOUL to perform them.		Because narrowing assignments are usually not recommended, special syntax is required in SOUL to perform them.
Line 836:		Line 839:
	This is why it is recommended that SOUL programmers not use the Instance Of clause to determine an object's "true" class: this would almost certainly be used to defeat the encapsulation of an object's behavior in the class definition.		This is why it is recommended that SOUL programmers not use the Instance Of clause to determine an object's "true" class: this would almost certainly be used to defeat the encapsulation of an object's behavior in the class definition.

	If a class, such as the Mammal class, requires extension-class specific		If a class, such as the <code>Mammal</code> class, requires extension-class specific
	processing, a far superior approach to If tests based on the object's		processing, a far superior approach to If tests based on the object's
	class is to use an approach called '''dynamic dispatch'''.		class is to use an approach called '''dynamic dispatch'''.

JAL: /* Rules for Constructors and Inheritance */

2013-10-23T16:15:47Z

Rules for Constructors and Inheritance

Alex: /* Polymorphism */

2013-10-23T03:34:50Z

Polymorphism

← Older revision		Revision as of 03:34, 23 October 2013
Line 747:		Line 747:
	class to a more general class, hence a widening assignment.		class to a more general class, hence a widening assignment.

	~~Some~~ object-oriented languages also ~~allow~~ what are called '''narrowing assignments'''		SOUL like many other object-oriented languages also allows what are called '''narrowing assignments'''
	— assignments from a base class variable to an extension class		— assignments from a base class variable to an extension class variable.
	variable.		Because narrowing assignments are usually not recommended, special syntax is required in SOUL to perform them.
	~~Before &sirmods. version 6.9~~,
	~~<var class="product">~~SOUL~~</var> did ''not'' allow such assignments.~~
	~~(For more information about the support that was added for such assignments in <var class="product">Sirius Mods</var>~~
	~~Version 6.9, see [[#Narrowing assignments and class tests\|"Narrowing assignments and class tests"]]~~.
	That is, the following assignment from <code>%fuzzy</code> to <code>%tarka</code> is <i><b>not allowed</b></i> and		That is, the following assignment from <code>%fuzzy</code> to <code>%tarka</code> is <i><b>not allowed</b></i> and
	results in a compilation error:		results in a compilation error:
Line 781:		Line 777:
	determined at run-time.		determined at run-time.

	~~Languages~~ that allow narrowing assignments simply compile the		Many languages that allow narrowing assignments simply compile the assignments, and if the assignment fails, produce a run-time
	assignments, and if the assignment fails, produce a run-time		error. Such languages make it the programmer's job to write code in such a way as to avoid such errors. Other languages that allow narrowing assignments, require the assignments to use a special syntax for the narrowing assignments to make it clear that the programmer meant to do what is being done, and to make it clear to anyone reading the code that something "funny" is going on.
	error.
	Such languages make it
	the programmer's job to write code in such a way as to
	avoid such errors.
	~~Many~~ languages that allow narrowing assignments, require the assignments
	to use a special syntax for the narrowing assignments to make it clear
	that the programmer meant to do what is being done, and to make it clear
	to anyone reading the code that something "funny" is going on.

	Unfortunately, in the case of narrowing assignments, almost anything		Unfortunately, in the case of narrowing assignments, almost anything a programmer is likely to do to prevent narrowing assignment errors is likely to have bad code maintainability implications. To understand why, it is worth continuing the Otter and Mammal
	a programmer is likely to do to prevent narrowing assignment errors
	is likely to have bad code maintainability implications.
	To understand why, it is worth continuing the Otter and Mammal
	example.		example.

Line 810:		Line 795:
	end if		end if
	</p>		</p>
	~~<p class="note">'''Note:'''~~		While the above code looks inncent enough, it can ultimately be quite troublesome. To understand why, consider the following scenario:
	~~<!-- Before <var class="product">Sirius Mods</var> Version 6.9 -->~~
	~~Formerly,~~ the ~~"is instance of" test,~~ above, ~~was ''not'' provided by <var class="product">SOUL</var>, nor was any~~
	~~other method that allowed one to determine programmatically the "true"~~
	~~class of an object.~~
	~~This ''intentional'' omission was to prevent just the sort of~~
	~~innocent looking, but~~ ultimately~~, very~~ troublesome ~~code illustrated~~
	~~in the example~~. ~~</p>~~

	To understand why ~~the above example code is troublesome~~,
	consider the following scenario:
	<ol>		<ol>
	<li>The code works as needed and some special processing is		<li>The code works as needed and some special processing is
	done for <code>Otter</code> objects.		done for <code>Otter</code> objects.
			<li>There is other <code>Otter</code>-specific processing. That processing could be handled by <var>If</var> statements placed wherever needed.
	<li>There is other <code>Otter</code>-specific processing.		<li>Someone wants to extend the <code>Mammal</code> class with, say, a Ferret class.

	That processing could be handled by <var>If</var> statements placed wherever needed.
	<li>Someone wants to extend the <code>Mammal</code> class with, say, a
	Ferret class.

	The theory of object-oriented programming is that the <code>Ferret</code> class implementer		The theory of object-oriented programming is that the <code>Ferret</code> class implementer
Line 837:		Line 808:
	Which, if any, of the <var>If</var> clauses that are executed for <code>Otters</code> should be executed		Which, if any, of the <var>If</var> clauses that are executed for <code>Otters</code> should be executed
	for <code>Ferrets</code>?		for <code>Ferrets</code>?
	Probably, some of them should be (after all, ferrets are very similar		Probably, some of them should be (after all, ferrets are very similar to otters; both are mustelids, that is, members of the weasel family).
	to otters; both		And probably some of them should not be executed (most otters are aquatic, ferrets are not).
	are mustelids, that is, members of the weasel family).
	And probably some of them should not be executed (most
	otters are aquatic, ferrets are not).
	</ol>		</ol>

Line 855:		Line 823:
	If it seems like it would end up defeating many of the benefits		If it seems like it would end up defeating many of the benefits
	of object-oriented programming, it would.		of object-oriented programming, it would.
	This is why <var class="product">SOUL</var> ~~initially did not support~~ narrowing assignments —		This is why <var class="product">SOUL</var> requires special syntax to pewrform narrowing assignments —
	they are a formula for defeating many of the benefits of object-oriented programming.		they are a formula for defeating many of the benefits of object-oriented programming.

Line 864:		Line 832:
	based on an object's "true" class can cause maintainability problems		based on an object's "true" class can cause maintainability problems
	whether or not there are narrowing assignments inside the <var>If</var> clauses.		whether or not there are narrowing assignments inside the <var>If</var> clauses.
	This is why ~~<var class="product">~~SOUL~~</var> initially did~~ not ~~provide any methods for determining~~ an		This is why it is recommended that SOUL programmers not use the Instance Of clause to determine an object's "true" class: this would almost certainly be used to defeat the encapsulation of an object's behavior in the class definition.
	object's "true" class: ~~they~~ would almost certainly be used to defeat
	the encapsulation of an object's behavior in the class definition.

	If a class, such as the Mammal class, requires extension-class specific		If a class, such as the Mammal class, requires extension-class specific

Alex: /* Inheritance and constructors */

2013-10-23T03:24:15Z

Inheritance and constructors

← Older revision		Revision as of 03:24, 23 October 2013
Line 641:		Line 641:
	end constructor		end constructor
	</p>		</p>
			===Rules for Constructors and Inheritance===
	~~There~~ are ~~three basic~~ inheritance-specific rules for constructors:		Ones perhaps somewhat arbitrary rule for constructors that is enforced at compile time is that a <var>Construct</var> statement must be physically placed inside a constructor for an extension class of the base class being constructed.

			Beyond that there are four major inheritance-specific rules for constructors.
	<ul>		<ul>
	<li>It is invalid to refer to a base class member until the constructor		<li>It is invalid to refer to a base class member until the constructor
Line 651:		Line 653:
	<li>When exiting from an extension class constructor, <var>Construct</var>		<li>When exiting from an extension class constructor, <var>Construct</var>
	statements must have been issued for all base classes for the object.		statements must have been issued for all base classes for the object.
	<~~/ul~~>		<li>
	~~All violations of these rules are caught at run-time.~~		The <code>%this</code> variable cannot be changed by assignment ''within a base class constructor''.
	~~This allows more flexibility in writing constructors at the cost of the compile-time checks for rules conformance.~~

	The ~~one perhaps somewhat arbitrary rule that is enforced at compile time is that a <var>Construct</var> statement must be physically placed inside a constructor.~~

	~~One other inheritance related constructor restriction concerns~~ <code>%this</code> ~~assignments in base class constructors called by <var>Construct</var> statements.~~
	~~In such a case, the request is canceled if <code>%this</code> is~~ changed by assignment ''within a base class constructor''.
	Because an extension class constructor that does a <var>Construct</var> has its own implicit or explicit <code>%this</code> to reference the extension object being constructed, assigning to <code>%this</code> in the base class constructor cannot be allowed		Because an extension class constructor that does a <var>Construct</var> has its own implicit or explicit <code>%this</code> to reference the extension object being constructed, assigning to <code>%this</code> in the base class constructor cannot be allowed
	to have an effect on the extension class.		to have an effect on the extension class.
Line 664:		Line 660:
	For example, a base class constructor might use <code>%this = null</code> to signal a problem in the base object construction. An alternative to using <code>%this=null</code> in this case is to use <code>%this:discard</code>. Another alternative is to [[#Throwing exceptions\|throw an exception]]. A <var>Throw</var> statement that executes within a constructor causes an automatic		For example, a base class constructor might use <code>%this = null</code> to signal a problem in the base object construction. An alternative to using <code>%this=null</code> in this case is to use <code>%this:discard</code>. Another alternative is to [[#Throwing exceptions\|throw an exception]]. A <var>Throw</var> statement that executes within a constructor causes an automatic
	<var>Discard</var> of the object being constructed. </p>		<var>Discard</var> of the object being constructed. </p>
			</ul>
			All violations of these rules are caught at run-time.
			This allows more flexibility in writing constructors at the cost of the compile-time checks for rules conformance.

	==Polymorphism==		==Polymorphism==

Alex: /* Inheritance and constructors */

2013-10-23T03:15:26Z

Inheritance and constructors

Show changes

JAL at 22:02, 22 October 2013

2013-10-22T22:02:49Z

← Older revision		Revision as of 22:02, 22 October 2013
Line 575:		Line 575:

	==Inheritance and constructors==		==Inheritance and constructors==
	An extension class might or might not have any <var>[[~~Janus SOAP User Language Interface~~#constructor\|constructors]]</var>.		An extension class might or might not have any <var>[[Object oriented programming in SOUL#constructor\|constructors]]</var>.
	If an extension class has no constructors, the default (<var>[[Object variables#Using New or other Constructors\|New]]</var>) constructors for the base classes are called in sequence with no parameters.		If an extension class has no constructors, the default (<var>[[Object variables#Using New or other Constructors\|New]]</var>) constructors for the base classes are called in sequence with no parameters.
	However, if any of the base class constructors require parameters or		However, if any of the base class constructors require parameters or

JAL: /* Polymorphism */

2013-10-22T21:58:49Z

Polymorphism

← Older revision		Revision as of 21:58, 22 October 2013
Line 1,086:		Line 1,086:
	In fact, a successful implementation of the <code>Ferret</code> class might require		In fact, a successful implementation of the <code>Ferret</code> class might require
	modifying the code that has the narrowing assignments, adding extra <var>ElseIf</var>		modifying the code that has the narrowing assignments, adding extra <var>ElseIf</var>
	clauses with Ferret-specific processing.		clauses with <code>Ferret</code>-specific processing.

	If the approach in this scenario seems antithetical to the idea of		If the approach in this scenario seems antithetical to the idea of
Line 1,124:		Line 1,124:
	present themselves in an application, <var class="product">SOUL</var> provides support for such assignments.		present themselves in an application, <var class="product">SOUL</var> provides support for such assignments.
	For more information, see [[Narrowing assignments and class tests]].		For more information, see [[Narrowing assignments and class tests]].

	==See also==		==See also==
	<ul>		<ul>

JAL at 21:52, 22 October 2013

2013-10-22T21:52:58Z

Show changes

JAL at 20:41, 22 October 2013

2013-10-22T20:41:51Z

← Older revision		Revision as of 20:41, 22 October 2013
Line 1:		Line 1:

	~~Support for inheritance and polymorphism was added to <var class="product">SOUL</var> in~~
	~~<var class="product">Sirius Mods</var> version 6.7.~~

	==Background==		==Background==
	Inheritance and polymorphism are two closely related but subtly different		Inheritance and polymorphism are two closely related but subtly different
Line 29:		Line 25:

	As this example illustrates, it is possible to extend many system classes		As this example illustrates, it is possible to extend many system classes
	as well as ~~<var class="product">User Language</var>~~ classes.		as well as user-defined classes.
	There are exceptions, however.		There are exceptions, however:
	It is not possible to extend the following types of system classes:		<ul>
			<li>It is not possible to extend the following types of system classes:
	<ul>		<ul>
	<li>[[Collections]]		<li>[[Collections]]
Line 38:		Line 35:
	</ul>		</ul>

	~~Before~~ <~~var class="product">Sirius Mods</var> 7.0, it was also not possible to extend~~		<li>It is possible to extend a file class in a specific context.
	~~file classes, such as the <var>Recordset</var> class, the <var>Record</var> class, and the~~
	~~<var>RecordsetCursor</var> class.~~
	~~Under <var class="product">Sirius Mods</var~~> ~~7.0 and later, it~~ is possible to extend a file class
	in a specific context.
	For example, the following <code>Class</code> statement extends the <var>Recordset</var> class		For example, the following <code>Class</code> statement extends the <var>Recordset</var> class
	for file <code>FOOBAR</code>:		for file <code>FOOBAR</code>:
Line 48:		Line 41:
	</p>		</p>

	It is not possible to generically extend any file classes.		<li>It is not possible to generically extend any file classes.
	For example, the following is '''not''' allowed:		For example, the following is '''not''' allowed:
	<p class="code">class myRecordset extends recordset		<p class="code">class myRecordset extends recordset
	</p>		</p>
			</ul>

	When one class extends another class, members of the base class can		When one class extends another class, members of the base class can

JAL: /* Repeat inheritance */

2013-10-22T17:55:54Z

Repeat inheritance

← Older revision		Revision as of 17:55, 22 October 2013
Line 307:		Line 307:
	class, and once via the AmericanDriver class.		class, and once via the AmericanDriver class.
	This is an example of '''repeat inheritance''' and was <i><b>not</b></i>		This is an example of '''repeat inheritance''' and was <i><b>not</b></i>
	allowed by ~~the~~ <var class="product">SOUL</var> before <var class="product">Sirius Mods</var> version 7.8.		allowed by <var class="product">SOUL</var> before <var class="product">Sirius Mods</var> version 7.8.
	<var class="product">Sirius Mods</var> version 7.8, however, <i><b>does</b></i> support repeat inheritance.		<var class="product">Sirius Mods</var> version 7.8, however, <i><b>does</b></i> support repeat inheritance.

Line 482:		Line 482:
	%americanMale:birthYear = 1992		%americanMale:birthYear = 1992
	</p>		</p>

	==Interfaces==		==Interfaces==
	Multiple inheritance provides all the capabilities that interfaces		Multiple inheritance provides all the capabilities that interfaces

← Older revision		Revision as of 16:15, 23 October 2013
Line 641:		Line 641:
	end constructor		end constructor
	</p>		</p>
	===Rules for Constructors and ~~Inheritance~~===		===Rules for Constructors and inheritance===
	~~Ones~~ perhaps somewhat arbitrary rule for ~~constructors~~ that is enforced at compile time is that a <var>Construct</var> statement must be ~~physically~~ placed inside a constructor for an extension class of the base class being constructed.		A perhaps somewhat arbitrary rule for a <var>Constructor</var> that is enforced at compile time is that a <var>Construct</var> statement must be placed inside a constructor for an extension class of the base class being constructed.

	~~Beyond~~ that ~~there~~ are four major inheritance-specific rules for constructors.		In addition to that rule are four major inheritance-specific rules for constructors.
	<ul>		<ul>
	<li>It is invalid to refer to a base class member until the ~~constructor~~		<li>It is invalid to refer to a base class member until the <var>Constructor</var>
	for that base class has been entered, that is, until a <var>Construct</var>		for that base class has been entered, that is, until a <var>Construct</var>
	statement has been issued for that base class.		statement has been issued for that base class.

	<li>It is invalid to invoke multiple <var>Construct</var> statements against the		<li>It is invalid to invoke multiple <var>Construct</var> statements against the
	same base class for the same object instance.		same base class for the same object instance.

	<li>When exiting from an extension class constructor, <var>Construct</var>		<li>When exiting from an extension class constructor, <var>Construct</var>
	statements must have been issued for all base classes for the object.		statements must have been issued for all base classes for the object.
	<li>
	The <code>%this</code> variable cannot be changed by assignment ''within a base class constructor''.		<li>The <code>%this</code> variable cannot be changed by assignment ''within a base class constructor''.
	Because an extension class constructor that does a <var>Construct</var> has its own implicit or explicit <code>%this</code> to reference the extension object being constructed, assigning to <code>%this</code> in the base class constructor cannot be allowed		Because an extension class constructor that does a <var>Construct</var> has its own implicit or explicit <code>%this</code> to reference the extension object being constructed, assigning to <code>%this</code> in the base class constructor cannot be allowed
	to have an effect on the extension class.		to have an effect on the extension class.