View source for Pascal Programming/Enumerations

One powerful notational as well as syntactical tool of Pascal is the declaration of custom enumeration data types.

== Handling ==
=== Notion ===
An enumeration data type is a finite list of named discrete values.
Enumerations virtually give names to individual integer values, however, you cannot (directly) do arithmetic operations on it.

=== Declaration ===
An enumeration data type is declared by following the data type identifier with a non-empty comma-separated list of (new, not previously used) [[../Variables and Constants#Identifiers|identifiers]].
<syntaxhighlight lang="pascal" line start="2" style="page-break-inside: avoid;">
type
	weekday = (Monday, Tuesday, Wednesday, Thursday, Friday,
		Saturday, Sunday);
</syntaxhighlight>
The individual list items refer to specific values the data type may assume.
The data type identifier identifies the data type as a whole.

=== Operations ===
Once an enumeration data type has been declared, you can use it like any other data type:
<syntaxhighlight lang="pascal" line start="5" highlight="2,4" style="page-break-inside: avoid">
var
	startOfWeek: weekday;
begin
	startOfWeek := Sunday;
end.
</syntaxhighlight>
The variable <syntaxhighlight lang="pascal" inline>startOfWeek</syntaxhighlight> is restricted to assume only legal values of the data type <syntaxhighlight lang="pascal" inline>weekday</syntaxhighlight>.
Note that <syntaxhighlight lang="pascal" inline>Sunday</syntaxhighlight> is not enclosed by typewriter quotation marks&nbsp;(<syntaxhighlight lang="pascal" inline>'</syntaxhighlight>) which usually indicate a string literal.
The identifier <syntaxhighlight lang="pascal" inline>Sunday</syntaxhighlight> indicates a value in its own right.

=== Ordinal values ===
==== Automatism ====
Every enumeration data type declaration implicitly defines an order.
The comma-separated list is per definition a ''sorted'' list.
The built‑in function <syntaxhighlight lang="pascal" inline>ord</syntaxhighlight>, short for ''ordinal value'', gives you the opportunity to obtain the ordinal value of an enumeration element, that is an <syntaxhighlight lang="pascal" inline>integer</syntaxhighlight>-value unique/specific to that enumeration member.

The first element of an enumeration is numbered as&nbsp;<syntaxhighlight lang="pascal" inline>0</syntaxhighlight>.
The second, if applicable, has the number&nbsp;<syntaxhighlight lang="pascal" inline>1</syntaxhighlight>, and so forth.

==== Override ====
Some compilers, such as the {{abbr|FPC|FreePascal Compiler}}, allow you to specify explicit indexes for some, or even all elements of an enumeration:
<syntaxhighlight lang="pascal" highlight="2" style="page-break-inside: avoid;">
type
	month = (January := 1, February, March, April, May, June,
		July, August, September, October, November, December);
</syntaxhighlight>
Here, <syntaxhighlight lang="pascal" inline>January</syntaxhighlight> will have the ordinal value <syntaxhighlight lang="pascal" inline>1</syntaxhighlight>.
And all ''following'' items have an ordinal value greater than <syntaxhighlight lang="pascal" inline>1</syntaxhighlight>.
The automatic assignment of numbers still ensures every enumeration member has a unique number among the entire enumeration data type.
<syntaxhighlight lang="pascal" inline>February</syntaxhighlight> will have the ordinal value&nbsp;<syntaxhighlight lang="pascal" inline>2</syntaxhighlight>, <syntaxhighlight lang="pascal" inline>March</syntaxhighlight> the value&nbsp;<syntaxhighlight lang="pascal" inline>3</syntaxhighlight>, and so on.
The value&nbsp;<syntaxhighlight lang="pascal" inline>0</syntaxhighlight>, however, is not assigned to any element of that enumeration.

{{XNote|If you specify explicit indices for particular elements, you need to ensure all numbers are ''ascending'' order. You cannot assign the same number twice. If you skip giving numbers, the automatic numbering system will assign and “reserve” numbers. You cannot use numbers the automatism uses.}}

Specifying explicit indices is a non-standard extension.
In {{abbr|FPC|FreePascal Compiler}}’s {{nowrap|<syntaxhighlight lang="pascal" inline>{$mode Delphi}</syntaxhighlight>}} you need to use a plain equal sign&nbsp;(<syntaxhighlight lang="delphi" inline>=</syntaxhighlight>) instead of&nbsp;<syntaxhighlight lang="pascal" inline>:=</syntaxhighlight>.
This is also referred to as “C‑style enumeration declaration”, since the programming language C uses that syntax.

==== Inverse ====
Pascal does not provide a generic function that lets you determine the enumeration element based on a number.
There is no function returning <syntaxhighlight lang="pascal" inline>January</syntaxhighlight>, for instance, if it is supplied with the <syntaxhighlight lang="pascal" inline>integer</syntaxhighlight>-value&nbsp;<syntaxhighlight lang="pascal" inline>1</syntaxhighlight>.<ref group="fn">Some compilers, such as the {{abbr|FPC|FreePascal compiler}}, allow “typecasting” effectively transforming&nbsp;<syntaxhighlight lang="pascal" inline>1</syntaxhighlight> into <syntaxhighlight lang="pascal" inline>January</syntaxhighlight>. However, this&nbsp;– typecasting&nbsp;– is not a function, especially typecasting does not work properly if the values are out of range (no {{abbr|RTE|run-time error}}-generation, nor whatsoever).</ref>

=== Neighbors ===
The standard functions <syntaxhighlight lang="pascal" inline>pred</syntaxhighlight> and <syntaxhighlight lang="pascal" inline>succ</syntaxhighlight>, short for ''predecessor'' and ''successor'' respectively, are ''automatically'' defined for ''every'' enumeration data type.
These functions return the previous or next value of an enumeration value.
For example <syntaxhighlight lang="pascal" inline>succ(January)</syntaxhighlight> will return <syntaxhighlight lang="pascal" inline>February</syntaxhighlight>, as it is the successor of the value <syntaxhighlight lang="pascal" inline>January</syntaxhighlight>.

However, <syntaxhighlight lang="pascal" inline>pred(January)</syntaxhighlight> will fail as there is technically no member prior <syntaxhighlight lang="pascal" inline>January</syntaxhighlight>.
An enumeration list is ''not'' cyclical.
Although in real life January follows December, the enumeration data type <syntaxhighlight lang="pascal" inline>month</syntaxhighlight> does not “know” that.

The {{abbr|EP|extended Pascal}} standard allows a second optional <syntaxhighlight lang="pascal" inline>integer</syntaxhighlight> parameter to be supplied to either <syntaxhighlight lang="pascal" inline>pred</syntaxhighlight> or <syntaxhighlight lang="pascal" inline>succ</syntaxhighlight>.
{{nowrap|<syntaxhighlight lang="pascal" inline>succ(January, 2)</syntaxhighlight>}} is identical to <syntaxhighlight lang="pascal" inline>succ(succ(January))</syntaxhighlight>, yet more convenient and shorter, but also {{nowrap|<syntaxhighlight lang="pascal" inline>pred(January, -2)</syntaxhighlight>}} returns the same value.

Utilizing this functionality you can obtain an enumeration value given its index.
{{nowrap|<syntaxhighlight lang="pascal" inline>succ(Monday, 3)</syntaxhighlight>}} evaluates to the <syntaxhighlight lang="pascal" inline>weekday</syntaxhighlight> value that has the ordinal value&nbsp;<syntaxhighlight lang="pascal" inline>3</syntaxhighlight>, thus virtually providing a means for an [[#Inverse|inverse]] <syntaxhighlight lang="pascal" inline>ord</syntaxhighlight> function.
However, it is necessary to know the ''first'' element of the enumeration though, and the enumeration may not use any [[#Override|explicit indices]] in its declaration (unless ''all'' indices coincide with the automatic numbering pattern).

=== Operators ===
Enumeration data type values are automatically eligible to be used with several operators.
Since every enumeration value has an ordinal value, they can be ordered and you can test for that.
The relational operators
{{columns-list|3|
* <syntaxhighlight lang="pascal" inline><</syntaxhighlight>
* <syntaxhighlight lang="pascal" inline>></syntaxhighlight>
* <syntaxhighlight lang="pascal" inline><=</syntaxhighlight>
* <syntaxhighlight lang="pascal" inline>>=</syntaxhighlight>
* <syntaxhighlight lang="pascal" inline>=</syntaxhighlight>
* <syntaxhighlight lang="pascal" inline><></syntaxhighlight>
}}
work in conjunction with enumeration values.
For example, {{nowrap|<syntaxhighlight lang="pascal" inline>January < February</syntaxhighlight>}} will evaluate to <syntaxhighlight lang="pascal" inline>true</syntaxhighlight>, because <syntaxhighlight lang="pascal" inline>January</syntaxhighlight> has a smaller ordinal value than <syntaxhighlight lang="pascal" inline>February</syntaxhighlight>.

Although, ''technically'' you ''can'' compare apples and oranges (spoiler alert: they are unequal), all relational operators only work in conjunction with two values of the ''same'' kind.
In Pascal, you cannot compare a <syntaxhighlight lang="pascal" inline>weekday</syntaxhighlight> value with a <syntaxhighlight lang="pascal" inline>month</syntaxhighlight> value.
Nonetheless, something like {{nowrap|<syntaxhighlight lang="pascal" inline>ord(August) > ord(Monday)</syntaxhighlight>}} ''is'' legal, since you are then in fact comparing <syntaxhighlight lang="pascal" inline>integer</syntaxhighlight> values.

Note, arithmetic operators {{nowrap|(<syntaxhighlight lang="pascal" inline>+</syntaxhighlight>, <syntaxhighlight lang="pascal" inline>-</syntaxhighlight>, and}} so on) do not work with enumeration data types, despite their ordinal values.

== <syntaxhighlight lang="pascal" inline>Boolean</syntaxhighlight> as an enumeration data type ==
=== Definition ===
The data type <syntaxhighlight lang="pascal" inline>Boolean</syntaxhighlight> is a built‑in special enumeration data type.
It is guaranteed that
* <syntaxhighlight lang="pascal" inline>ord(false)</syntaxhighlight> = 0,
* <syntaxhighlight lang="pascal" inline>ord(true)</syntaxhighlight> = 1, and, in consequence,
* <syntaxhighlight lang="pascal" inline>pred(true)</syntaxhighlight> = <syntaxhighlight lang="pascal" inline>false</syntaxhighlight>.

=== Logical operators ===
<syntaxhighlight lang="pascal" inline>Boolean</syntaxhighlight> is only enumeration data type operations can be ''directly'' performed on using ''logical operators''.

==== Negation ====
The most basic operator is the negation.
It is a unary operator, that means it expects only one operand.
In Pascal it uses the keyword <syntaxhighlight lang="pascal" inline>not</syntaxhighlight>.
By preceding a <syntaxhighlight lang="pascal" inline>Boolean</syntaxhighlight> expression with <syntaxhighlight lang="pascal" inline>not</syntaxhighlight> (and some separator such as a space character), the expression is negated.
{| class="wikitable" style="margin: auto;"
! expression                                                        !! result
|-
| <syntaxhighlight lang="pascal" inline>not true</syntaxhighlight>  || <syntaxhighlight lang="pascal" inline>false</syntaxhighlight>
|-
| <syntaxhighlight lang="pascal" inline>not false</syntaxhighlight> || <syntaxhighlight lang="pascal" inline>true</syntaxhighlight>
|-
|+ <syntaxhighlight lang="pascal" inline>not</syntaxhighlight>
|}

==== Conjunction ====
While this may be pretty straightforward, the so-called logical conjunction, indicated by <syntaxhighlight lang="pascal" inline>and</syntaxhighlight>, might not be.
The ''truth table'' for it looks like this:
{| class="wikitable" style="text-align: center; margin: auto;"
! value of <syntaxhighlight lang="pascal" inline>tired</syntaxhighlight>
! value of <syntaxhighlight lang="pascal" inline>intoxicated</syntaxhighlight>
! result of <syntaxhighlight lang="pascal" inline>tired and intoxicated</syntaxhighlight>
|-
| <syntaxhighlight lang="pascal" inline>false</syntaxhighlight> || <syntaxhighlight lang="pascal" inline>false</syntaxhighlight> || <syntaxhighlight lang="pascal" inline>false</syntaxhighlight>
|-
| <syntaxhighlight lang="pascal" inline>false</syntaxhighlight> || <syntaxhighlight lang="pascal" inline>true</syntaxhighlight>  || <syntaxhighlight lang="pascal" inline>false</syntaxhighlight>
|-
| <syntaxhighlight lang="pascal" inline>true</syntaxhighlight>  || <syntaxhighlight lang="pascal" inline>false</syntaxhighlight> || <syntaxhighlight lang="pascal" inline>false</syntaxhighlight>
|-
| <syntaxhighlight lang="pascal" inline>true</syntaxhighlight>  || <syntaxhighlight lang="pascal" inline>true</syntaxhighlight>  || <syntaxhighlight lang="pascal" inline>true</syntaxhighlight>
|-
|+ conjunction truth table
|}
In {{abbr|EE|electrical engineering}} this is frequently written as <math>\cdot</math> (“times”) or even omitted, because (like an mathematics) an invisible “times” is assumed.
Given that the ordinal values of <syntaxhighlight lang="pascal" inline>false</syntaxhighlight> and <syntaxhighlight lang="pascal" inline>true</syntaxhighlight> are as defined above, you could calculate the <syntaxhighlight lang="pascal" inline>and</syntaxhighlight> result by multiplying them.

==== Disjunction ====
A little more confusing, because it may be contradictory to someone’s ''natural'' language, is the word <syntaxhighlight lang="pascal" inline>or</syntaxhighlight>.
If either operand is <syntaxhighlight lang="pascal" inline>true</syntaxhighlight>, the overall expression’s result becomes <syntaxhighlight lang="pascal" inline>true</syntaxhighlight>.
{| class="wikitable" style="text-align: center; margin: auto;"
! value of <syntaxhighlight lang="pascal" inline>raining</syntaxhighlight>
! value of <syntaxhighlight lang="pascal" inline>snowing</syntaxhighlight>
! result of <syntaxhighlight lang="pascal" inline>raining or snowing</syntaxhighlight>
|-
| <syntaxhighlight lang="pascal" inline>false</syntaxhighlight> || <syntaxhighlight lang="pascal" inline>false</syntaxhighlight> || <syntaxhighlight lang="pascal" inline>false</syntaxhighlight>
|-
| <syntaxhighlight lang="pascal" inline>false</syntaxhighlight> || <syntaxhighlight lang="pascal" inline>true</syntaxhighlight>  || <syntaxhighlight lang="pascal" inline>true</syntaxhighlight>
|-
| <syntaxhighlight lang="pascal" inline>true</syntaxhighlight>  || <syntaxhighlight lang="pascal" inline>false</syntaxhighlight> || <syntaxhighlight lang="pascal" inline>true</syntaxhighlight>
|-
| <syntaxhighlight lang="pascal" inline>true</syntaxhighlight>  || <syntaxhighlight lang="pascal" inline>true</syntaxhighlight>  || <syntaxhighlight lang="pascal" inline>true</syntaxhighlight>
|-
|+ disjunction truth table
|}
Electrical engineers frequently use the <math>+</math> symbol to denote this operation.
With respect to <syntaxhighlight lang="pascal" inline>Boolean</syntaxhighlight>’s ordinal value, though, you must “define” that <math>1 + 1</math> was still <math>1</math>.

==== Precedence ====
Like the usual rule in mathematics “multiplication and division first, then addition and subtraction”, a conjunction is evaluated first before a disjunction is.
However, since the negation is a unary operator, it is evaluated first in any case.
That means you must be really careful not to forget placing parenthesis.
The expression
<syntaxhighlight lang="pascal">not hungry or thirsty</syntaxhighlight>
is fundamentally different to
<syntaxhighlight lang="pascal">not (hungry or thirsty)</syntaxhighlight>

== Ranges ==
=== Ordinal types ===
Enumeration data types belong to the category of ''ordinal data types''.
Other ordinal data types are:
* <syntaxhighlight lang="pascal" inline>integer</syntaxhighlight>,
* <syntaxhighlight lang="pascal" inline>char</syntaxhighlight>,
* and all enumeration data types, including <syntaxhighlight lang="pascal" inline>Boolean</syntaxhighlight>.
They all have in common, that a value of them can be mapped to a distinct <syntaxhighlight lang="pascal" inline>integer</syntaxhighlight>-value.
The <syntaxhighlight lang="pascal" inline>ord</syntaxhighlight> function lets you retrieve that value.

=== Intervals ===
Sometimes, it makes sense to restrict a set of values to a certain range.
For instance, the hours on a military time clock may show values from&nbsp;<syntaxhighlight lang="pascal" inline>0</syntaxhighlight> up to and including&nbsp;<syntaxhighlight lang="pascal" inline>23</syntaxhighlight>.
Yet the data type  <syntaxhighlight lang="pascal" inline>integer</syntaxhighlight> will permit other values too.

Pascal allows you to declare (sub‑)range data types.
A&nbsp;(sub‑)range data type has a host data type, e.&#8239;g. <syntaxhighlight lang="pascal" inline>integer</syntaxhighlight>, and two limits.
One lower and one upper limit.
A range is specified by giving the limits in ascending order, separated through two periods back-to-back (<syntaxhighlight lang="pascal" inline>..</syntaxhighlight>):
<syntaxhighlight lang="pascal" highlight="2" style="page-break-inside: avoid;">
type
	majuscule = 'A'..'Z';
</syntaxhighlight>
The limits may be given as any computable expression, as long as it does not depend on run-time data.<ref group="fn">This is an “Extended Pascal” (ISO 10206) extension. In Standard “unextended” Pascal (ISO 7185) only constants are allowed.</ref>
For example constants (that have already been defined) may be used:
<syntaxhighlight lang="pascal" highlight="2" style="page-break-inside: avoid;">
type
	integerNonNegative = 0..maxInt;
</syntaxhighlight>
<small>
Note, we named this range <syntaxhighlight lang="pascal" inline>integerNonNegative</syntaxhighlight> and not <syntaxhighlight lang="pascal" inline>nonNegativeInteger</syntaxhighlight>, because this will facilitate alphabetical sorting of some documentation tools or in {{abbr|IDEs|integrated development environments}}.
</small>

=== Restriction ===
A variable possessing one (sub‑)range data type may only assume values ''within'' the range.
If the variable exceeds its legal range, the program aborts.
The following error message may appear (memory address at the end can vary):
<syntaxhighlight lang="text">./a.out: value out of range (error #300 at 402a54)</syntaxhighlight>
The corresponding test program has been compiled with {{abbr|GPC|GNU Pascal compiler}}.
Other compilers may emit different messages.

The default configuration of the {{abbr|FPC|FreePascal compiler}}, however, ignores this.
Assigning out-of-range values to variables will not yield an error (if it depends on run-time data).
The developers of the {{abbr|FPC|FreePascal compiler}} cite compatibility reasons to other compilers, which decided to ignore out-of-range values for speed reasons.<ref group="fn">The Pascal ISO standards ''do'' allow this. It is at the compiler programmer’s discretion to ignore such errors. Nonetheless, accompanying documents (manuals, etc.) are meant to point that out.</ref>
You need to specifically request that illegal values cannot be assigned to ordinal type variables.
This can be done by placing a specially crafted comment prior any (crucial) assignments:
{{nowrap|<syntaxhighlight lang="pascal" inline>{$rangeChecks on}</syntaxhighlight>}} (case-insensitive) or <syntaxhighlight lang="pascal" inline>{$R+}</syntaxhighlight> for short (case-sensitive) will ensure illegal values are not assigned and the program aborts if any attempts are made anyway.
Specifying this compiler switch ''once'' in your source code file is sufficient.
{{abbr|FPC|FreePascal compiler}}’s <syntaxhighlight lang="bash" inline>‑Cr</syntaxhighlight> command-line switch has the same effect.

{{XNote|The range restriction has to be met when ''storing'' the value, when saving the value to a variable for instance. ''Intermediate'' calculations, such as when evaluating an expression, may fall out of range though.}}

== Selections ==
{{Wikibook|Programming Fundamentals/Case Control Structure}}
With the advent of enumeration data types, it may become cumbersome and tedious to check for values just using <syntaxhighlight lang="pascal" inline>if</syntaxhighlight>‑branches.

=== Explanation ===
The <syntaxhighlight lang="pascal" inline>case</syntaxhighlight> selection statement unites multiple ''exclusive'' <syntaxhighlight lang="pascal" inline>if</syntaxhighlight>‑branches in one language construct.<ref group="fn">This is an analogy. <syntaxhighlight lang="pascal" inline>case</syntaxhighlight>-statements are usually ''not'' translated into a series of <syntaxhighlight lang="pascal" inline>if</syntaxhighlight>‑branches.</ref>
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;">
case sign(x) of
	-1:
	begin
		writeLn('You have entered a negative number.');
	end;
	0:
	begin
		writeLn('The numbered you have entered is sign-less.');
	end;
	1:
	begin
		writeLn('That is a positive number.');
	end;
end;
</syntaxhighlight>
Between <syntaxhighlight lang="pascal" inline>case</syntaxhighlight> and <syntaxhighlight lang="pascal" inline>of</syntaxhighlight> any expression that evaluates to an ordinal value may appear.
After that, <syntaxhighlight lang="pascal" inline>-1:</syntaxhighlight>, <syntaxhighlight lang="pascal" inline>0:</syntaxhighlight> and <syntaxhighlight lang="pascal" inline>1:</syntaxhighlight> are ''case labels''.
These case labels mark the start of alternatives.
After a case label follows a statement.

<syntaxhighlight lang="pascal" inline>-1</syntaxhighlight>, <syntaxhighlight lang="pascal" inline>0</syntaxhighlight> and <syntaxhighlight lang="pascal" inline>1</syntaxhighlight> denote case values.
Every case label consists of a non-empty comma-separated list of case values, followed by a colon&nbsp;(<syntaxhighlight lang="pascal" inline>:</syntaxhighlight>).
All case values have to be legal constant values, ''constant'' expressions, that are compatible to the comparison expression above, what is written between <syntaxhighlight lang="pascal" inline>case</syntaxhighlight> and <syntaxhighlight lang="pascal" inline>of</syntaxhighlight>.
Every specified case value needs to appear exclusively in ''one'' case label.
No case label value can appear twice.
It is not necessary to put them in order, according their ordinal value, although it can make your source code more readable.

=== Shorthand for many cases ===
In {{abbr|EP|extended Pascal}} case labels may contain ranges.
<syntaxhighlight lang="pascal" highlight="9,13" style="page-break-inside: avoid;">
program letterReport(input, output);
var
	c: char;
begin
	write('Give me a letter: ');
	readLn(c);
	
	case c of
		'A'..'Z':
		begin
			writeLn('Wow! That’s a big letter!');
		end;
		'a'..'z':
		begin
			writeLn('What a nice small letter.');
		end;
	end;
end.
</syntaxhighlight>
This shorthand notation allows you to catch many cases.
The case label <syntaxhighlight lang="pascal" inline>'A'..'Z':</syntaxhighlight> includes all upper-case letters, without requiring you to list them all individually.

Take care that no range ''overlaps'' with other case label values.
This is forbidden.
Good processors will complain about such a mistake though.
The {{abbr|GPC|GNU Pascal compiler}} yields the error message <syntaxhighlight lang="text" inline>duplicate case-constant in `case' statement</syntaxhighlight>, the {{abbr|FPC|Free Pascal compiler}} reports just <syntaxhighlight lang="text" inline>duplicate case label</syntaxhighlight><ref group="fn">This error message is imprecise. The error message of {{abbr|GPC|GNU Pascal compiler}} is more correct. The problem is that a certain value, “case-constant”, appears multiple times.</ref>, both telling you some information about the location in your source code.

=== Fall-back ===
It is important that any (expected) value of the comparison expression matches one case label.
If the comparison expression evaluates to a value no case label contains the corresponding value, the program aborts.<ref group="fn">Many compilers do not respect this requirement in their default configuration. The {{abbr|GPC|GNU Pascal compiler}} needs to be instructed to be “completely” ISO-compliant (<syntaxhighlight lang="bash" inline>‑‑classic‑pascal</syntaxhighlight>, <syntaxhighlight lang="bash" inline>‑‑extended‑pascal</syntaxhighlight>, or just <syntaxhighlight lang="bash" inline>‑‑case‑value‑checking</syntaxhighlight>). In {{abbr|BP}}, Delphi will just continue, leaving a missing case unnoticed. As of version 3.2.0 the {{abbr|FPC|FreePascal compiler}} does not regard this requirement at all.</ref>
If this is not desired the “Extended Pascal” standard allows a special case label called <syntaxhighlight lang="pascal" inline>otherwise</syntaxhighlight> (note, without a colon).
This case treats all values that have no explicit case label associated with them.
<syntaxhighlight lang="pascal" highlight="15" style="page-break-inside: avoid;">
program asciiTest(input, output);
var
	c: char;
begin
	write('Supply any character: ');
	readLn(c);
	case c of
		// empty statement, so the control characters are not
		// considered by the otherwise-branch as non-ASCII characters
		#0..#31, #127: ;
		#32..#126:
		begin
			writeLn('You entered an ASCII printable character.');
		end;
		otherwise
		begin
			writeLn('You entered a non-ASCII character.');
		end;
	end;
end.
</syntaxhighlight>
<syntaxhighlight lang="pascal" inline>otherwise</syntaxhighlight> may only appear ''at the end''.
There must be at least one case label beforehand, otherwise (no pun intended) the <syntaxhighlight lang="pascal" inline>otherwise</syntaxhighlight> case is always taken, rendering the entire <syntaxhighlight lang="pascal" inline>case</syntaxhighlight>-statement useless.

{{abbr|BP|Borland Pascal}}, that is Delphi, re-uses the word [[../Expressions and Branches#Alternative statement|<syntaxhighlight lang="delphi" inline>else</syntaxhighlight>]] having the same semantics, the same meaning as <syntaxhighlight lang="pascal" inline>otherwise</syntaxhighlight>.
The {{abbr|FPC|FreePascal Compiler}} and {{abbr|GPC|GNU Pascal compiler}} support both, although GPC can be instructed to ''only'' accept <syntaxhighlight lang="pascal" inline>otherwise</syntaxhighlight>.

== Tasks ==
{{question-answer
| question = Write a concise <syntaxhighlight lang="pascal" inline>function</syntaxhighlight> that returns the successor of <syntaxhighlight lang="pascal" inline>month</syntaxhighlight>, but for <syntaxhighlight lang="pascal" inline>December</syntaxhighlight> the value <syntaxhighlight lang="pascal" inline>January</syntaxhighlight> is returned.
| answer = Using knowledge you have learned in this unit, a <syntaxhighlight lang="pascal" inline>case</syntaxhighlight> statement is just perfect:
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;">
function successor(start: month): month;
begin
	case start of
		January..November:
		begin
			successor := succ(start);
		end;
		December:
		begin
			successor := January;
		end;
	end;
end;
</syntaxhighlight>
For the purposes of this exercise (demonstrating that relational operators such as <syntaxhighlight lang="pascal" inline><</syntaxhighlight> are automatically defined for enumeration data types) the following is acceptable too:
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;">
function successor(start: month): month;
begin
	if start < December then
	begin
		successor := succ(start);
	end
	else
	begin
		successor := January;
	end;
end;
</syntaxhighlight>
Yet the <syntaxhighlight lang="pascal" inline>case</syntaxhighlight>-implementation is, mathematically speaking, more precise.
In the first implementation, if the parameter is wrong, out of range, the program aborts.
The latter implementation with {{nowrap|<syntaxhighlight lang="pascal" inline>if … then … else</syntaxhighlight>}} will be “wrongly” defined for illegal values too.
}}
{{-}}
{{question-answer
| question = The [[w:Material conditional|implication]] is a logical operator. In mathematics it is written as <math>\implies</math> or <math>\to</math> (different authors prefer different arrows). Implication shows the following behavior:
{{{!}} class="wikitable" style="text-align: center; margin: auto;"
! value of <syntaxhighlight lang="pascal" inline>hasRained</syntaxhighlight>
! value of <syntaxhighlight lang="pascal" inline>streetWet</syntaxhighlight>
! result of <math>\texttt{hasRained } \implies \texttt{ streetWet}</math>
{{!}}-
{{!}} <syntaxhighlight lang="pascal" inline>false</syntaxhighlight> {{!!}} <syntaxhighlight lang="pascal" inline>false</syntaxhighlight> {{!!}} <syntaxhighlight lang="pascal" inline>true</syntaxhighlight>
{{!}}-
{{!}} <syntaxhighlight lang="pascal" inline>false</syntaxhighlight> {{!!}} <syntaxhighlight lang="pascal" inline>true</syntaxhighlight>  {{!!}} <syntaxhighlight lang="pascal" inline>true</syntaxhighlight>
{{!}}-
{{!}} <syntaxhighlight lang="pascal" inline>true</syntaxhighlight>  {{!!}} <syntaxhighlight lang="pascal" inline>false</syntaxhighlight> {{!!}} <syntaxhighlight lang="pascal" inline>false</syntaxhighlight>
{{!}}-
{{!}} <syntaxhighlight lang="pascal" inline>true</syntaxhighlight>  {{!!}} <syntaxhighlight lang="pascal" inline>true</syntaxhighlight>  {{!!}} <syntaxhighlight lang="pascal" inline>true</syntaxhighlight>
{{!}}-
{{!}}+ implication truth table
{{!}}} 
Write a <syntaxhighlight lang="pascal" inline>Boolean</syntaxhighlight> expression in Pascal resulting in the same truth values. Say <syntaxhighlight lang="pascal" inline>hasRained</syntaxhighlight> and <syntaxhighlight lang="pascal" inline>streetWet</syntaxhighlight> are <syntaxhighlight lang="pascal" inline>Boolean</syntaxhighlight> variables; how would you link them so the entire <syntaxhighlight lang="pascal" inline>Boolean</syntaxhighlight> expression is the same as the mathematical expression <math>\texttt{hasRained } \implies \texttt{ streetWet}</math>?
| answer = Remember that <syntaxhighlight lang="pascal" inline>Boolean</syntaxhighlight> is a built-in enumeration data type. This means it is ordered and thus members of this data type can be put in relational ordering. In programing the most frequent translation of <math>\implies</math>you will encounter is<syntaxhighlight lang="pascal">not hasRained or streetWet</syntaxhighlight>but in Pascal you can write<syntaxhighlight lang="pascal">hasRained <= streetWet</syntaxhighlight>because of <syntaxhighlight lang="pascal" inline>Boolean</syntaxhighlight> being an enumeration data type. Some people, however, who are ''not programming'' in Pascal (e.&#x202F;g. writing ''personal text'' messages) may use <syntaxhighlight lang="pascal" inline><=</syntaxhighlight> as a way of writing <math>\Leftarrow</math> which is just the opposite of <math>\Rightarrow</math> (that means in mathematics <math>B \Leftarrow A</math>, i.&#8239;e. with swapped <math>A</math> and <math>B</math>, is another ''equally valid'' way of writing <math>A \Rightarrow B</math>). If you are one of those people you may find the shorter expression counterintuitive, because in Pascal <syntaxhighlight lang="pascal" inline><=</syntaxhighlight> is in fact&nbsp;≤ (less than or equal to) and not a&nbsp;⇐.
}}
{{newpage}}
<hr class="noprint"/>
<small>Notes:</small>
{{Smallrefs|group="fn"}}


{{auto navigation|Sets|Routines}}