View source for Pascal Programming/Records

{{epigraph
| quote  = The key to successful programming is finding the "right" structure of data and program.
| cite   = Niklaus Wirth<ref name="module"/>
}}
After you have learned to use an [[../Array|<syntaxhighlight lang="pascal" inline>array</syntaxhighlight>]], this chapter introduces you to another data type ''structure concept'' called <syntaxhighlight lang="pascal" inline>record</syntaxhighlight>.
Like an <syntaxhighlight lang="pascal" inline>array</syntaxhighlight>, the use of <syntaxhighlight lang="pascal" inline>record</syntaxhighlight>s primarily serves the purposes of allowing you to write clean, ''structured'' programs.
It is otherwise optional.

== Concept ==
You briefly saw a <syntaxhighlight lang="pascal" inline>record</syntaxhighlight> in the [[../Beginning#Terminology|first chapter]].
While an <syntaxhighlight lang="pascal" inline>array</syntaxhighlight> is a ''homogenous'' aggregation of data, that means all members have to have the ''same'' base data type, a <syntaxhighlight lang="pascal" inline>record</syntaxhighlight> is potentially, but not necessarily an aggregation of data having various ''different'' data types.<ref name="ohpascal"/>

=== Declaration ===
A <syntaxhighlight lang="pascal" inline>record</syntaxhighlight> data type declaration looks pretty much like a ''collection'' of variable declarations:
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;" line highlight="9-13">
program recordDemo;
type
	(* a standard line on a text console *)
	line = string(80);
	(* 1st grade through 12th grade *)
	grade = 1..12;
	
	(* encapsulate all administrative data in one structure *)
	student = record
			firstname: line;
			lastname: line;
			level: grade;
		end;
</syntaxhighlight>
The declaration begins with the word <syntaxhighlight lang="pascal" inline>record</syntaxhighlight> and ends with <syntaxhighlight lang="pascal" inline>end</syntaxhighlight>.
Inbetween you declare fields, or ''members'', member elements of the entire <syntaxhighlight lang="pascal" inline>record</syntaxhighlight>.
{{technote
| heading =
| Here again the semicolon has the function of ''separating'' members. The keyword <syntaxhighlight lang="pascal" inline>end</syntaxhighlight> will actually ''terminate'' a <syntaxhighlight lang="pascal" inline>record</syntaxhighlight> declaration. Note, how in the following ''correct'' example there is no semicolon after the ''last'' member’s declaration:
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;" highlight="6">
program recordSemicolonDemo;
type
	sphere = record
			radius: real;
			volume: real;
			surface: real
		end;
</syntaxhighlight>Despite that, it is a frequent practice to put a semicolon there anyway, even though it is not necessary. You would otherwise too often simply ''add'' a new member below the last line, ''forgetting'' to add the semicolon in the preceding line and thus provoking a syntax error.}}
All <syntaxhighlight lang="pascal" inline>record</syntaxhighlight> members have to bear distinct names ''within'' the <syntaxhighlight lang="pascal" inline>record</syntaxhighlight> declaration itself.
For instance in the example above, declaring ''two'' “variables”, member elements of the name <syntaxhighlight lang="pascal" inline>level</syntaxhighlight> will be rejected.

There is no requirement on how many fields you have to declare.
An “empty” <syntaxhighlight lang="pascal" inline>record</syntaxhighlight> is also possible:<ref group="fn">This kind of <syntaxhighlight lang="pascal" inline>record</syntaxhighlight> will not be able to store anything. In the [[../Pointers|next chapter]] you will learn a (and the only) instance it could be useful.</ref>
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;">
type
	emptyRecord = record
		end;
</syntaxhighlight>

=== Many fields of the same data type ===
Similar to the [[../Variables and Constants#More variables|declaration of variables]] you can define multiple fields of the ''same'' data type at once by separating identifiers with a comma.
The previous declaration of <syntaxhighlight lang="pascal" inline>sphere</syntaxhighlight> could also be written as:
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;" start="2" highlight="3">
type
	sphere = record
			radius, volume, surface: real;
		end;
</syntaxhighlight>
Most Pascal veterans and style guides, however, ''discourage'' the use of this shorthand notation (both for variable as well as <syntaxhighlight lang="pascal" inline>record</syntaxhighlight> declarations, but also in formal parameter lists).
It ''is only reasonable if all'' declared identifiers ''absolutely always'' have same data type;
it is virtually guaranteed you will never want to change the data type of ''just one'' field in the comma-separated list.
If in doubt, use the longhand.
In programming, convenience plays a tangential role.

=== Use ===
By declaring a <syntaxhighlight lang="pascal" inline>record</syntaxhighlight> variable you immediately have the ''entire set'' of “sub”‑variables at your hand.
Accessing them is done by specifying the ''<syntaxhighlight lang="pascal" inline>record</syntaxhighlight> variable’s'' name, plus a dot (<syntaxhighlight lang="pascal" inline>.</syntaxhighlight>), followed by the <syntaxhighlight lang="pascal" inline>record</syntaxhighlight> ''field’s name'':
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;" line start="15" highlight="4-6">
var
	posterStudent: student;
begin
	posterStudent.firstname := 'Holden';
	posterStudent.lastname := 'Caulfield';
	posterStudent.level := 10;
end.
</syntaxhighlight>
You already saw the dot notation in the previous chapter on [[../Strings|strings]], where appending [[../Strings#Inquiry|<syntaxhighlight lang="pascal" inline>.capacity</syntaxhighlight>]] on a name of a <syntaxhighlight lang="pascal" inline>string(…)</syntaxhighlight> variable refers to the respective variable’s character capacity.
This is not a coincidence.
{{Code:Basic
|However, especially beginners occasionally confuse the ''data type'' name with the ''variable’s'' name. The following code highlights the difference. Remember that a ''data type [[../Routines#Declaration|declaration]]'' does not reserve any memory and is mainly informative for the compiler, whereas a ''variable'' declaration actually sets some chunk of memory aside.
|<syntaxhighlight lang="pascal" style="page-break-inside: avoid;">
program dotNoGo(output); { This program does not compile. }
type
	line = string(80);
	quizItem = record
			question: line;
			answer: line;
		end;
var
	response: line;
	challenge: quizItem;
begin
	writeLn(line.capacity); { ↯ `line` is not a variable }
	writeLn(response.capacity); { ✔ correct }
	
	writeLn(quizItem.question); { ↯ `quizItem` refers to a data type }
	{ Data type declarations (as per definition) do not reserve any memory }
	{ thus you cannot “read/write” from/to a data type. }
	writeLn(challenge.question); { ✔ correct }
end.
</syntaxhighlight>
|And, as it has always been, you first need to assign a value to a variable before you are allowed to read it. The source code above ignores that to focus on the main issue. The key point is, the dot&nbsp;(<syntaxhighlight lang="pascal" inline>.</syntaxhighlight>) notation is only valid ''if'' there is memory.<ref group="fn">Indeed most compilers consider the dot as a dereferencing indicator and the field name denotes a static offset from a base memory address.</ref>}}

=== Advantages ===
But why and when do we ''want'' to use a <syntaxhighlight lang="pascal" inline>record</syntaxhighlight>?
At first glance and in the given examples so far it may seem like a troublesome way to declare and use ''multiple'' variables.
Yet the fact that a <syntaxhighlight lang="pascal" inline>record</syntaxhighlight> is handled as ''one'' unit entails one big advantage:
* You can ''copy entire'' <syntaxhighlight lang="pascal" inline>record</syntaxhighlight> values via a simple assignment (<syntaxhighlight lang="pascal" inline>:=</syntaxhighlight>).
* This means you can pass much data at once: A&nbsp;<syntaxhighlight lang="pascal" inline>record</syntaxhighlight> can be a parameter of routines, and in {{abbr|EP|extended Pascal}} functions can return them as well.<ref group="fn">In Standard (“unextended”) Pascal, {{abbr|ISO|international organization for standardization}} standard 7185, a <syntaxhighlight lang="pascal" inline>function</syntaxhighlight> can only return “simple data type” and “[[../Pointers|pointer]] data type” values.</ref>
Evidently you want to ''group'' data together that always appear ''together''.
It does ''not'' make sense to group ''unrelated'' data, just because we can.
Another quite useful advantage is presented below in the section on [[#Variant records|variant records]].

== Routing override ==
As you saw earlier, referring to members of a <syntaxhighlight lang="pascal" inline>record</syntaxhighlight> can get a little tedious, because we are repeating the variable name over and over again.
Fortunately, Pascal allows us abbreviate things a bit.

=== <syntaxhighlight lang="pascal" inline>With</syntaxhighlight>-clause ===
The <syntaxhighlight lang="pascal" inline>with</syntaxhighlight>-clause allows us to eliminate repeating a common prefix, specifically the name of a <syntaxhighlight lang="pascal" inline>record</syntaxhighlight> variable.<ref name="revisedreport"/>
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;" line start="17" highlight="2-7">
begin
	with posterStudent do
	begin
		firstname := 'Holden';
		lastname := 'Caulfield';
		level := 10;
	end;
end.
</syntaxhighlight>
All identifiers that identify values are first looked for in the <syntaxhighlight lang="pascal" inline>record</syntaxhighlight> scope of <syntaxhighlight lang="pascal" inline>posterStudent</syntaxhighlight>.
If there is no match, all variable identifiers outside of the given <syntaxhighlight lang="pascal" inline>record</syntaxhighlight> are considered too.

Of course it is still possible to denote a <syntaxhighlight lang="pascal" inline>record</syntaxhighlight> member by its ''full'' name.
E.&#8239;g. in the source code above it would be perfectly legal to still write <syntaxhighlight lang="pascal" inline>posterStudent.level</syntaxhighlight> ''within'' the <syntaxhighlight lang="pascal" inline>with</syntaxhighlight>-clause.
Concededly, this would defeat the purpose of the <syntaxhighlight lang="pascal" inline>with</syntaxhighlight>-clause, but sometimes it may still be beneficial to emphasize the specific <syntaxhighlight lang="pascal" inline>record</syntaxhighlight> variable just for documentation.
It is nevertheless important to understand that the FQI, the fully-qualified identifier, the one with a dot in it, does ''not lose'' its “validity”.

In principle, all components of structured values “containing dots” can be abbreviated with <syntaxhighlight lang="pascal" inline>with</syntaxhighlight>.
This is also true for the [[../Strings|data type <syntaxhighlight lang="pascal" inline>string</syntaxhighlight>]] you have learned in the previous chapter.
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;" line highlight="12">
program withDemo(input, output);
type
	{ Deutsche Post „Maxi-Telegramm“ }
	telegram = string(480);
var
	post: telegram;
begin
	with post do
	begin
		writeLn('Enter your telegram. ',
			'Maximum length = ',
			capacity, ' characters.');
		readLn(post);
		{ … }
	end;
end.
</syntaxhighlight>
Here, within the <syntaxhighlight lang="pascal" inline>with</syntaxhighlight>-clause <syntaxhighlight lang="pascal" inline>capacity</syntaxhighlight>, and for that matter <syntaxhighlight lang="pascal" inline>post.capacity</syntaxhighlight>, refer to <syntaxhighlight lang="pascal" inline>post.capacity</syntaxhighlight>.

=== Multiple levels ===
If multiple <syntaxhighlight lang="pascal" inline>with</syntaxhighlight>-clauses ought to be nested, there is the short notation:
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;">
	with snakeOil, sharpTools do
	begin
		…
	end;
</syntaxhighlight>
which is equivalent to:
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;">
	with snakeOil do
	begin
		with sharpTools do
		begin
			…
		end;
	end;
</syntaxhighlight>
It is important to bear in mind, first identifiers in <syntaxhighlight lang="pascal" inline>sharpTools</syntaxhighlight> are searched, and if there is no match, ''secondly'', identifiers in <syntaxhighlight lang="pascal" inline>snakeOil</syntaxhighlight> are considered.

== Variant records ==
In Pascal a <syntaxhighlight lang="pascal" inline>record</syntaxhighlight> is the only data type structure concept that allows you to, so to speak, alter its structure during run-time, ''while'' a <syntaxhighlight lang="pascal" inline>program</syntaxhighlight> is running.
This super practical property of <syntaxhighlight lang="pascal" inline>record</syntaxhighlight> permits us to write versatile code covering many cases.

=== Declaration ===
Let’s take a look at an example:
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;" line start="2" highlight="15-20">
type
	centimeter = 10..199;
	
	// order of female, male has been chosen, so `ord(sex)`
	// returns the [minimum] number of non-defective Y chromosomes
	sex = (female, male)
	
	// measurements according EN 13402 size designation of clothes [incomplete]
	clothingSize = record
			shoulderWidth: centimeter;
			armLength: centimeter;
			bustGirth: centimeter;
			waistSize: centimeter;
			hipMeasurement: centimeter;
			case body: sex of
				female: (
					underbustMeasure: centimeter;
				);
				male: (
				);
		end;
</syntaxhighlight>
The ''variant part'' of a <syntaxhighlight lang="pascal" inline>record</syntaxhighlight> starts with the keyword <syntaxhighlight lang="pascal" inline>case</syntaxhighlight>, which you already know from [[../Enumerations#Selections|selections]].
After that follows a <syntaxhighlight lang="pascal" inline>record</syntaxhighlight> member declaration, the ''variant selector'', but instead of a semicolon you put the keyword <syntaxhighlight lang="pascal" inline>of</syntaxhighlight> thereafter.
Below that follow all possible variants.
Each variant is marked by a value out of the variant selector’s domain, here <syntaxhighlight lang="pascal" inline>female</syntaxhighlight> and <syntaxhighlight lang="pascal" inline>male</syntaxhighlight>.
Separated by a colon (<syntaxhighlight lang="pascal" inline>:</syntaxhighlight>) follows a ''variant denoter'' surrounded by parentheses.
Here you can list additional <syntaxhighlight lang="pascal" inline>record</syntaxhighlight> members that are only available if a certain variant is “active”.
Note that ''all'' identifiers across ''all'' alternatives must be unique.
The individual variants are separated by a semicolons, and there can be ''at most one variant part'' which has to appear ''at the end''.
Because you will need to be able to list all possible variants, the variant selector has to be an ordinal data type.

=== Use ===
Using variant records requires you to first ''select'' a variant.
Variants are “activated” by assigning a value to the variant selector.
Note, variants are not “created”; they all already exist at <syntaxhighlight lang="pascal" inline>program</syntaxhighlight> startup.
You merely need to make a choice.
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;" line start="26">
	boobarella.body := female;
	boobarella.underbustMeasure := 69;
</syntaxhighlight>
Only ''after'' assigning a value to the variant selector and ''as long as'' this value remains ''unchanged'', you are allowed to access any fields of the respective variant.
It is illegal to reverse the previous two lines of code and attempt accessing the <syntaxhighlight lang="pascal" inline>underbustMeasure</syntaxhighlight> field even though <syntaxhighlight lang="pascal" inline>body</syntaxhighlight> is not defined yet and, more importantly, does not bear the value <syntaxhighlight lang="pascal" inline>female</syntaxhighlight>.

It is certainly permissible to change the variant selector later in your <syntaxhighlight lang="pascal" inline>program</syntaxhighlight> and then use a different variant, but all previously stored values in the variant part ''relinquish'' their validity and you cannot restore them.
If you switch back the variant to a previous, original value, you will need to assign all values in that variant anew.

=== Application ===
This concept opens up new horizons:
You can design your programs more interactively in a neat fashion.
You can now choose a variant based on run-time data (data that is read ''while'' the <syntaxhighlight lang="pascal" inline>program</syntaxhighlight> is running).
Because at any time (after the first assignment of a value to the variant selector) only ''one'' variant is “active”, your <syntaxhighlight lang="pascal" inline>program</syntaxhighlight> will crash if it attempts reading/writing values of an “''in''active” variant.
This is a ''desirable'' behavior, because ''that'' is the whole idea of having distinct variants.
It guarantees your programs overall integrity.

=== Anonymous variants ===
Pascal also permits having anonymous variant selectors, that is selectors not bearing any name.
The implications are
* you cannot explicitly select (nor query) any variant, so
* in turn ''all'' variants are considered “active” at the same time.
“But wasn’t this the object of the exercise?” you might ask.
Yes, indeed, since there is no named selector your <syntaxhighlight lang="pascal" inline>program</syntaxhighlight> cannot keep track which variant is supposed to work and which one is “defective”.
''You'' are responsible to determine which variant you can sensibly read/write at present.

{{Code:Output
| {{Wikibook|Computer Programming/Type conversion}} Anonymous variants are/were frequently ''a''bused to implement “typecasts”. If you have an anonymous variant part, you can declare members bearing ''different'' data types which in turn determine the underlying data’s interpretation method. You can then exploit the fact that many (but not necessarily all) compilers put ''all'' variants in the ''same'' memory block.
| <syntaxhighlight lang="pascal" style="page-break-inside: avoid;">
program anonymousVariantsDemo(output);
type
	bitIndex = 0..(sizeOf(integer) * 8 - 1);
	
	exposedInteger = record
			case Boolean of
				false: (
						value: integer;
					);
				true: (
						bit: set of bitIndex;
					);
		end;

var
	i: exposedInteger;
begin
	i.bit := [4];
	writeLn(i.value);
end.
</syntaxhighlight>
| <syntaxhighlight lang="text">16</syntaxhighlight>
| The value <syntaxhighlight lang="pascal" inline>16</syntaxhighlight> is (and this should be considered “a coincidence”) <math>2^4</math>. We ''stress'' that all Pascal standards do not make any statement regarding internal memory structure. A high-level programming language is not concerned about how data is stored, it even does not know the notion of “bits”, “voltage high”/“voltage low”.
{{XWarning|Thus, ''if'' you are (intentionally) using any of this demonstrated behavior, you can ''not'' say “I am programming in Pascal” anymore, but you are programming ''specifically for'' the compiler so-and-so. The memory layout of data structures ''varies'' among Pascal implementations.}}
The example above, for example, was designed for and works with the {{abbr|GPC|GNU Pascal compiler}} and the {{abbr|FPC|FreePascal compiler}} in their default configurations. Do not deem it as “Pascal”, but a descendant of it. There is a good chance that using a different compiler will produce different results.
}}

This concept exists in many other programming languages too.
In the programming language&nbsp;C, for instance, it is called a [[C Programming/Advanced data types#Unions|union]].

== Conditional loops ==
So far we have been exclusively using counting [[../Sets#Loops|loops]].
This is great if you can predict in advance the number of iterations, how many times the loop’s body needs to be executed.
Yet every so often it is not possible to formulate a proper expression determining the number of iterations in advance.

''Conditional loops'' allow you to make the execution of the ''next iteration'' dependent on a ''<syntaxhighlight lang="pascal" inline>Boolean</syntaxhighlight> expression''.
They come in two flavors:
* Head-controlled loop, and
* tail-controlled loop.
The difference is, the loop’s body of a tail-controlled loop is executed ''at least once'' in any case, whereas a head-controlled loop might never execute the loop body at all.
In either case, a condition is evaluated over and over again and must ''uphold'' for the loop to continue.

=== Head-controlled loop ===
A head-controlled loop is frequently called <syntaxhighlight lang="pascal" inline>while</syntaxhighlight>-loop because of its syntax.
{{Code:Output
| The “control” condition appears ''above'' the loop body, i.&#8239;e. ''at the head''.
| <syntaxhighlight lang="pascal" style="page-break-inside: avoid;" highlight="10-14">
program characterCount(input, output);
type
	integerNonNegative = 0..maxInt;
var
	c: char;
	n: integerNonNegative;
begin
	n := 0;
	
	while not EOF do
	begin
		read(c);
		n := n + 1;
	end;
	
	writeLn('There are ', n:1, ' characters.');
end.
</syntaxhighlight>
| <syntaxhighlight lang="text">$ cat ./characterCount.pas | ./characterCount
There are 240 characters.
$ printf '' '' | ./characterCount
There are 0 characters.</syntaxhighlight>
| The loop’s condition is a <syntaxhighlight lang="pascal" inline>Boolean</syntaxhighlight> expression framed by the words <syntaxhighlight lang="pascal" inline>while</syntaxhighlight> and <syntaxhighlight lang="pascal" inline>do</syntaxhighlight>. The condition must evaluate to <syntaxhighlight lang="pascal" inline>true</syntaxhighlight> for any (subsequent) iteration to occur.
As you can see from the output, in the second case, it may even be ''zero'' times: Evidently for ''empty'' input {{nowrap|<syntaxhighlight lang="pascal" inline>n := n + 1</syntaxhighlight>}} was ''never'' executed.
}}
<syntaxhighlight lang="pascal" inline>EOF</syntaxhighlight> is shorthand for <syntaxhighlight lang="pascal" inline>EOF(input)</syntaxhighlight>.
This standard <syntaxhighlight lang="pascal" inline>function</syntaxhighlight> returns <syntaxhighlight lang="pascal" inline>true</syntaxhighlight> if there is no further data available to read, commonly called ''end of file''.
It is illegal, and will horribly fail, to <syntaxhighlight lang="pascal" inline>read</syntaxhighlight> from a file if the respective <syntaxhighlight lang="pascal" inline>EOF</syntaxhighlight> function call returns <syntaxhighlight lang="pascal" inline>true</syntaxhighlight>.

Unlike a counting loop, you ''are'' allowed to ''modify'' data the conditional loop’s condition depends on.
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;" highlight="24-30">
const
	(* instead of a hard-coded length `64` *)
	(* you can write `sizeOf(integer) * 8` in Delphi, FPC, GPC *)
	wordWidth = 64;
type
	integerNonNegative = 0..maxInt;
	wordStringIndex = 1..wordWidth;
	wordString = array[wordStringIndex] of char;

function binaryString(n: integerNonNegative): wordString;
var
	(* temporary result *)
	binary: wordString;
	i: wordStringIndex;
begin
	(* initialize `binary` with blanks *)
	for i := 1 to wordWidth do
	begin
		binary[i] := ' ';
	end;
	(* if n _is_ zero, the loop's body won't be executed *)
	binary[i] := '0';
	
	(* reverse Horner's scheme *)
	while n >= 1 do
	begin
		binary[i] := chr(ord('0') + n mod 2);
		n := n div 2;
		i := i - 1;
	end;
	
	binaryString := binary;
end;
</syntaxhighlight>
The <syntaxhighlight lang="pascal" inline>n</syntaxhighlight> the loop’s condition depends on will be repeatedly divided by two.
Because the division operator is an integer division (<syntaxhighlight lang="pascal" inline>div</syntaxhighlight>), at some point the value <syntaxhighlight lang="pascal" inline>1</syntaxhighlight> will be divided by two and the arithmetically correct result <syntaxhighlight lang="pascal" inline>0.5</syntaxhighlight> is truncated (<syntaxhighlight lang="pascal" inline>trunc</syntaxhighlight>) toward zero.
Yet the value <syntaxhighlight lang="pascal" inline>0</syntaxhighlight> does not satisfy the loop’s condition anymore, thus there will not be ''any'' subsequent iterations.

=== Tail-controlled loop ===
In a tail-controlled loop the condition appears ''below'' the loop’s body, at the foot.
The loop’s body is always run once before even the condition is evaluated at all.
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;" highlight="5-10">
program repeatDemo(input, output);
var
	i: integer;
begin
	repeat
	begin
		write('Enter a positive number: ');
		readLn(i);
	end
	until i > 0;
	
	writeLn('Wow! ', i:1, ' is a quite positive number.');
end.
</syntaxhighlight>
The loop’s body is encapsulated by the keywords <syntaxhighlight lang="pascal" inline>repeat</syntaxhighlight> and <syntaxhighlight lang="pascal" inline>until</syntaxhighlight>.<ref group="fn">Actually the shown {{nowrap|<syntaxhighlight lang="pascal" inline>begin … end</syntaxhighlight>}} is redundant since {{nowrap|<syntaxhighlight lang="pascal" inline>repeat … until</syntaxhighlight>}} constitute a frame in their own right. For pedagogical reasons we teach you to always use {{nowrap|<syntaxhighlight lang="pascal" inline>begin … end</syntaxhighlight>}} nevertheless wherever a ''sequence'' of statements usually appears. Otherwise you might change your {{nowrap|<syntaxhighlight lang="pascal" inline>repeat … until</syntaxhighlight> loop}} to a {{nowrap|<syntaxhighlight lang="pascal" inline>while … do</syntaxhighlight> loop}} ''forgetting'' to surround the loop’s body statements with a proper {{nowrap|<syntaxhighlight lang="pascal" inline>begin … end</syntaxhighlight>}} frame.</ref>
After <syntaxhighlight lang="pascal" inline>until</syntaxhighlight> follows a <syntaxhighlight lang="pascal" inline>Boolean</syntaxhighlight> expression.
In contrast to a <syntaxhighlight lang="pascal" inline>while</syntaxhighlight> loop, the tail-controlled loop always continues, always keeps going, ''<syntaxhighlight lang="pascal" inline>until</syntaxhighlight>'' the specified condition becomes <syntaxhighlight lang="pascal" inline>true</syntaxhighlight>.
A&nbsp;<syntaxhighlight lang="pascal" inline>true</syntaxhighlight> condition marks ''the end''.
In the above example the user will be prompted again and again until he eventually complies and enters a positive number.

== Date and time ==
This section introduces you to features of Extended Pascal as defined in the {{abbr|ISO|international organization for standardization}} standard 10206.
You will need an {{abbr|EP|Extended Pascal}}‑compliant compiler to use those features.

=== Time stamp ===
In {{abbr|EP|Extended Pascal}} there is a ''standard'' data type called <syntaxhighlight lang="pascal" inline>timeStamp</syntaxhighlight>.
It is declared as follows:<ref group="fn">The <syntaxhighlight lang="pascal" inline>packed</syntaxhighlight> designation has been omitted for simplicity.</ref>
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;">
type
	timeStamp = record
			dateValid: Boolean;
			timeValid: Boolean;
			year: integer;
			month: 1..12;
			day: 1..31;
			hour: 0..23;
			minute: 0..59;
			second: 0..59;
		end;
</syntaxhighlight>
As you can see from the declaration, <syntaxhighlight lang="pascal" inline>timeStamp</syntaxhighlight> also contains data fields for a calendar date, not just the time as indicated by a standard clock.
{{XNote|A processor (i.&#8239;e. usually a compiler) may provide ''additional'' (thus non-standard) fields. The {{abbr|GPC|GNU Pascal Compiler}} for instance supplies, among other fields, a field called <syntaxhighlight lang="pascal" inline>timeZone</syntaxhighlight> indicating the offset in seconds versus {{abbr|UTC|Coordinated Universal Time}} (“world time”).}}

=== Getting a time stamp ===
{{abbr|EP|Extended Pascal}} also defines a unary <syntaxhighlight lang="pascal" inline>procedure</syntaxhighlight> that populates a <syntaxhighlight lang="pascal" inline>timeStamp</syntaxhighlight> variable with values.
<syntaxhighlight lang="pascal" inline>GetTimeStamp</syntaxhighlight> assigns values to all members of a <syntaxhighlight lang="pascal" inline>timeStamp record</syntaxhighlight> passed in the first (and only) parameter.
These values represent the “current date” and “current time” as at the invocation of this procedure.
However, in the 1980’s not all (personal/home) computers did have a built-in “real time” clock.
Therefore, the {{abbr|ISO|international organization for standardization}} standard 10206 devised prior 21<sup>st</sup> century stated that the word “current” was “implementation-defined”.
The <syntaxhighlight lang="pascal" inline>dateValid</syntaxhighlight> and <syntaxhighlight lang="pascal" inline>timeValid</syntaxhighlight> fields were specifically inserted to address the issue that some computers simply do not know the current date and/or time.
When reading values from a <syntaxhighlight lang="pascal" inline>timeStamp</syntaxhighlight> variable, it is still advisable to check their validity first after having <syntaxhighlight lang="pascal" inline>getTimeStamp</syntaxhighlight> fill them out.

If <syntaxhighlight lang="pascal" inline>getTimeStamp</syntaxhighlight> was ''unable'' to obtain a “valid” value, it will set
* <syntaxhighlight lang="pascal" inline>day</syntaxhighlight>, <syntaxhighlight lang="pascal" inline>month</syntaxhighlight> and <syntaxhighlight lang="pascal" inline>year</syntaxhighlight> to a value representing {{nowrap|January 1, 1 {{abbr|CE|common era}}}}, but also <syntaxhighlight lang="pascal" inline>dateValid</syntaxhighlight> to <syntaxhighlight lang="pascal" inline>false</syntaxhighlight>.
* In the case of time, <syntaxhighlight lang="pascal" inline>hour</syntaxhighlight>, <syntaxhighlight lang="pascal" inline>minute</syntaxhighlight> and <syntaxhighlight lang="pascal" inline>second</syntaxhighlight> become all <syntaxhighlight lang="pascal" inline>0</syntaxhighlight>, a value representing ''midnight''. The <syntaxhighlight lang="pascal" inline>timeValid</syntaxhighlight> field becomes <syntaxhighlight lang="pascal" inline>false</syntaxhighlight>.
Both are independent from each other, so it may certainly be the case that just the time could be determined, but the date is invalid.

Note that the Gregorian calendar was introduced during the year 1582&nbsp;{{abbr|CE|common era}}, so the <syntaxhighlight lang="pascal" inline>timeStamp</syntaxhighlight> data type is generally useless for any dates before 1583&nbsp;{{abbr|CE|common era}}.

=== Printable dates and times ===
Having obtained a <syntaxhighlight lang="pascal" inline>timeStamp</syntaxhighlight>, {{abbr|EP|Extended Pascal}} furthermore supplies two unary functions:
* <syntaxhighlight lang="pascal" inline>date</syntaxhighlight> returns a human-readable <syntaxhighlight lang="pascal" inline>string</syntaxhighlight> representation of <syntaxhighlight lang="pascal" inline>day</syntaxhighlight>, <syntaxhighlight lang="pascal" inline>month</syntaxhighlight> and <syntaxhighlight lang="pascal" inline>year</syntaxhighlight>, and
* <syntaxhighlight lang="pascal" inline>time</syntaxhighlight> returns a human-readable <syntaxhighlight lang="pascal" inline>string</syntaxhighlight> representation of <syntaxhighlight lang="pascal" inline>hour</syntaxhighlight>, <syntaxhighlight lang="pascal" inline>minute</syntaxhighlight> and <syntaxhighlight lang="pascal" inline>second</syntaxhighlight>.
Both functions will fail and terminate the <syntaxhighlight lang="pascal" inline>program</syntaxhighlight> if <syntaxhighlight lang="pascal" inline>dateValid</syntaxhighlight> or <syntaxhighlight lang="pascal" inline>timeValid</syntaxhighlight> indicate an invalid datum respectively.
Note, the exact format of <syntaxhighlight lang="pascal" inline>string</syntaxhighlight> representation is not defined by the {{abbr|ISO|International Organization for Standardization}} standard 10206.
{{Code:Output
| Putting things together, consider the following <syntaxhighlight lang="pascal" inline>program</syntaxhighlight>:
| <syntaxhighlight lang="pascal" style="page-break-inside: avoid;">
program dateAndTimeFun(output);
var
	ts: timeStamp;
begin
	getTimeStamp(ts);
	
	if ts.dateValid then
	begin
		writeLn('Today is ', date(ts), '.');
	end;
	
	if ts.timeValid then
	begin
		writeLn('Now it is ', time(ts), '.');
	end;
end.</syntaxhighlight>
|
 Today is {{CURRENTMONTH1}} {{CURRENTMONTHABBREV}} {{CURRENTYEAR}}.
 Now it is {{CURRENTTIME}}:42.
| The output may differ. Here, the {{abbr|GPC|GNU Pascal compiler}} was used and the hardware had an {{abbr|RTC|real-time clock}}. It is needless to say, but also you might see ''nothing'' if both <syntaxhighlight lang="pascal" inline>dateValid</syntaxhighlight> and <syntaxhighlight lang="pascal" inline>timeValid</syntaxhighlight> are <syntaxhighlight lang="pascal" inline>false</syntaxhighlight>.
}}

== Summary on loops ==
This is a good time to take inventory and reiterate<!-- pun intended --> all kinds of loops.

=== Conditional loops ===
Conditional loops are the tools of choice if you cannot predict the total number of iterations.
{| class="wikitable" style="text-align: center; margin: auto;"
! head-controlled loop
! tail-controlled loop
|-
| <syntaxhighlight lang="pascal" style="text-align: left;" highlight="1">while condition do
begin
	…
end;
 </syntaxhighlight><!-- the last _empty_ line has been inserted deliberately -->
| <syntaxhighlight lang="pascal" style="text-align: left;" highlight="1,5">repeat
begin
	…
end
until condition;</syntaxhighlight>
|-
| <syntaxhighlight lang="pascal" inline>condition</syntaxhighlight> must evaluate to <syntaxhighlight lang="pascal" inline>true</syntaxhighlight> for any (including subsequent) iterations to occur.
| <syntaxhighlight lang="pascal" inline>condition</syntaxhighlight> must be <syntaxhighlight lang="pascal" inline>false</syntaxhighlight> for any ''subsequent'' iteration to occur.
|-
|+ comparison of conditional loops in Pascal
|}
It ''is'' possible to formulate either loop as the other one, but usually one of them is more suitable.
A tail-controlled loop is particularly suitable if you do not have any data yet to make a judgment, to evaluate a proper <syntaxhighlight lang="pascal" inline>condition</syntaxhighlight> prior the first iteration.

=== Counting loops ===
Counting loops are good if you ''can'' predict the total number of iterations before entering the loop.
{| class="wikitable" style="text-align: center; margin: auto;"
! counting up loop
! counting down loop
|-
| <syntaxhighlight lang="pascal" style="text-align: left;">for controlVariable := initialValue to finalValue do
begin
	…
end;
</syntaxhighlight>
| <syntaxhighlight lang="pascal" style="text-align: left;">for controlVariable := initialValue downto finalValue do
begin
	…
end;
</syntaxhighlight>
|-
| After each non-final iteration <syntaxhighlight lang="pascal" inline>controlVariable</syntaxhighlight> becomes <syntaxhighlight lang="pascal" inline>succ(controlVariable)</syntaxhighlight>. <syntaxhighlight lang="pascal" inline>controlVariable</syntaxhighlight> must be less than or equal to <syntaxhighlight lang="pascal" inline>finalValue</syntaxhighlight> for another iteration to occur.
| After each non-final iteration <syntaxhighlight lang="pascal" inline>controlVariable</syntaxhighlight> becomes <syntaxhighlight lang="pascal" inline>pred(controlVariable)</syntaxhighlight>. <syntaxhighlight lang="pascal" inline>controlVariable</syntaxhighlight> must be ''greater'' than or equal to <syntaxhighlight lang="pascal" inline>finalValue</syntaxhighlight> for another iteration to occur.
|-
|+ comparison of counting loop directions in Pascal
|}
{{XNote|Both, the <syntaxhighlight lang="pascal" inline>initialValue</syntaxhighlight> and <syntaxhighlight lang="pascal" inline>finalValue</syntaxhighlight> expressions, are evaluated exactly ''once''.<ref name="pumar"/> This is very different to conditional loops.}}

Inside counting loops’ bodies you cannot modify the counting variable, only read it.
This prevents you from any accidental manipulations and ensures the calculated predicted total number of iterations will indeed occur.

{{XNote|It is ''not'' guaranteed that <syntaxhighlight lang="pascal" inline>controlVariable</syntaxhighlight> is <syntaxhighlight lang="pascal" inline>finalValue</syntaxhighlight> “after” the loop. If there were exactly ''zero'' iterations, ''no'' assignments to <syntaxhighlight lang="pascal" inline>controlVariable</syntaxhighlight> were made. Thus ''generally presume'' <syntaxhighlight lang="pascal" inline>controlVariable</syntaxhighlight> is invalid/uninitialized after a <syntaxhighlight lang="pascal" inline>for</syntaxhighlight>-loop unless you are absolutely sure there was at least one iteration.}}

=== Loops on aggregations ===
If you are using an {{abbr|EP|Extended Pascal}}-compliant compiler, you furthermore have the option to use a {{nowrap|<syntaxhighlight lang="pascal" inline>for … in</syntaxhighlight> loop}} on [[../Sets|sets]].
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;" highlight="9-12">
program forInDemo(output);
type
	characters = set of char;
var
	c: char;
	parties: characters;
begin
	parties := ['R', 'D'];
	for c in parties do
	begin
		write(c:2);
	end;
	writeLn;
end.
</syntaxhighlight>

== Tasks ==
You have made it this far, and it is quite impressive how much you already know.
Since this chapter’s concept of a <syntaxhighlight lang="pascal" inline>record</syntaxhighlight> should not be too difficult to grasp, the following exercises mainly focus on training.
A&nbsp;''professional'' computer programmer spends most of his time on ''thinking'' what kind of implementation, using ''which'' tools (e.&#8239;g. <syntaxhighlight lang="pascal" inline>array</syntaxhighlight> “vs.” <syntaxhighlight lang="pascal" inline>set</syntaxhighlight>), is the most useful/reasonable.
You are encouraged to think first, before you even start typing anything.
Nonetheless, sometimes (esp. due to your lack of experience) you need to just try things out, which is fine if it is ''intentional''.
''Aimlessly'' finding a solution does not discern an actual programmer.

{{question-answer
| question = Can you have a <syntaxhighlight lang="pascal" inline>record</syntaxhighlight> contain another <syntaxhighlight lang="pascal" inline>record</syntaxhighlight>?
| answer   = Like it was possible for an <syntaxhighlight lang="pascal" inline>array</syntaxhighlight> to contain ''another'' <syntaxhighlight lang="pascal" inline>array</syntaxhighlight>, this is quite possible for a <syntaxhighlight lang="pascal" inline>record</syntaxhighlight> too. Write a test <syntaxhighlight lang="pascal" inline>program</syntaxhighlight> to see for yourself. The important thing is to note that the dot-notation can be expanded indefinitely (<syntaxhighlight lang="pascal" inline>myRecordVariable.topRecordFieldName.nestedRecordFieldName.doubleNestedRecordFieldName</syntaxhighlight>). Evidently at some point it becomes too difficult to read so use this wisely.
}}
{{-}}
{{question-answer
| question = Write a loop that ''never'' ends, that means it is ''impossible'' that the loop will ever terminate. If your test program does not terminate, you most likely have achieved this task. On a standard Linux terminal you can then press {{keypress|Ctrl|C}} to forcefully ''kill'' the program.
| answer   = There are two flavors of ''infinite loops'':
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;">
while true do
begin
	…
end;
</syntaxhighlight>
The condidition needs to be negated in a {{nowrap|<syntaxhighlight lang="pascal" inline>repeat … until</syntaxhighlight> loop}}:
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;">
repeat
begin
	…
end
until false;
</syntaxhighlight>
Infinite loops are very undesirable. While constant expressions like in these examples are easy to spot, [[Discrete Mathematics/Logic#Tautology|tautologies]], expressions that always evaluate to <syntaxhighlight lang="pascal" inline>true</syntaxhighlight>, or expressions that can never be fulfilled (in the case of a {{nowrap|<syntaxhighlight lang="pascal" inline>repeat … until</syntaxhighlight> loop}}), are not. For instance, given that <syntaxhighlight lang="pascal" inline>i</syntaxhighlight> was an <syntaxhighlight lang="pascal" inline>integer</syntaxhighlight> the loop {{nowrap|<syntaxhighlight lang="pascal" inline>while i <= maxInt do</syntaxhighlight>}} will run indefinitely, because <syntaxhighlight lang="pascal" inline>i</syntaxhighlight> can never exceed <syntaxhighlight lang="pascal" inline>maxInt</syntaxhighlight><ref group="fn">According to most compilers’ definition of <syntaxhighlight lang="pascal" inline>maxInt</syntaxhighlight>. The {{abbr|ISO|International Organization for Standardization}} standards merely require, that all arithmetic operations in the interval <syntaxhighlight lang="pascal" inline>-maxInt..maxInt</syntaxhighlight> work absolutely correct, but it is thinkable (although unlikely) that more values are supported.</ref> and thus break the loop’s condition. Therefore be reminded to carefully formulate expressions for conditional loops and ensure it will eventually reach a terminating state. Otherwise it can be frustrating for the user of your <syntaxhighlight lang="pascal" inline>program</syntaxhighlight>.
}}
{{-}}
{{question-answer
| question = Rewrite the following loop as a <syntaxhighlight lang="pascal" inline>while</syntaxhighlight>-loop:
<syntaxhighlight lang="pascal">repeat
begin
	imagineJumpingSheep;
	sheepCount := sheepCount + 1;
	waitTwoSeconds;
end
until asleep;</syntaxhighlight>
| answer   = The important thing is to realize is that the ''entire'' loop body is repeated above the <syntaxhighlight lang="pascal" inline>while</syntaxhighlight>-loop even begins:
<syntaxhighlight lang="pascal">
imagineJumpingSheep;
sheepCount := sheepCount + 1;
waitTwoSeconds;

while not asleep do
begin
	imagineJumpingSheep;
	sheepCount := sheepCount + 1;
	waitTwoSeconds;
end;</syntaxhighlight>
Do not forget to negate the condition when transforming a conditonal loop into the other kind. Obviously the {{nowrap|<syntaxhighlight lang="pascal" inline>repeat … until</syntaxhighlight>-loop}} is more suitable in this case.
}}
{{-}}
{{question-answer
| question = If you are using a Linux or FreeBSD {{abbr|OS|operating system}} and an {{abbr|EP|Extended Pascal}}‑compliant compiler: Write a <syntaxhighlight lang="pascal" inline>program</syntaxhighlight> that takes the output of the command {{nowrap|<syntaxhighlight lang="bash" inline>getent passwd</syntaxhighlight>}} as input and only prints the ''first'' field/column of every line. In a {{man|5|passwd|Linux||inline}} file, fields are separated by a colon (<syntaxhighlight lang="pascal" inline>:</syntaxhighlight>). Your <syntaxhighlight lang="pascal" inline>program</syntaxhighlight> will list all known user names.
| answer   = You can run the following program with the command {{nowrap|<syntaxhighlight lang="bash" inline>getent passwd | ./cut1</syntaxhighlight>}} (the file name of your executable program may differ).
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;">
program cut1(input, output);
const
	separator = ':';
var
	line: string(80);
begin
	while not EOF(input) do
	begin
		{ This reads the _complete_ line, but at most}
		{ line.capacity characters are actually saved. }
		readLn(line);
		writeLn(line[1..index(line, separator)-1]);
	end;
end.
</syntaxhighlight>
Remember that [[../Strings#First occurrence of substring|<syntaxhighlight lang="pascal" inline>index</syntaxhighlight>]] will return the index of the colon character which you do not want to print, thus you will need to subtract&nbsp;<syntaxhighlight lang="pascal" inline>1</syntaxhighlight> from its result. This <syntaxhighlight lang="pascal" inline>program</syntaxhighlight> will evidently fail if a line does not contain a colon.
}}
{{-}}
{{question-answer
| question = Based on your previous solution, extend your <syntaxhighlight lang="pascal" inline>program</syntaxhighlight> so only user names whose {{abbr|UID|user identification}} is greater than or equal to <syntaxhighlight lang="pascal" inline>1000</syntaxhighlight>. The {{abbr|UID|user identification}} is stored in the third field.
| answer   = The changed lines have been highlighted. A comment from the previous source code has been omitted.
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;" highlight="4,7,8,14-31,33">
program cut2(input, output);
const
	separator = ':';
	minimumID = 1000;
var
	line: string(80);
	nameFinalCharacter: integer;
	uid: integer;
begin
	while not EOF do
	begin
		readLn(line);
		
		nameFinalCharacter := index(line, separator) - 1;
		
		{ username:encryptedpassword:usernumber:… }
		{         ↑ `nameFinalCharacter + 1` }
		{          ↑ `… + 2` is the index of the 1st password character }
		uid := index(subStr(line, nameFinalCharacter + 2), separator);
		
		{ Note that the preceding `index` did not operate on `line` }
		{ but an altered/different/independent “copy” of it. }
		{ This means, we’ll need to offset the returned index once again. }
		readStr(subStr(line, nameFinalCharacter + 2 + uid), uid);
		{ Read/readLn/readStr automatically terminate reading an integer }
		{ number from the source if a non-digit character is encountered. }
		{ (Preceding blanks/space characters are ignored and }
		{ the _first_ character still may be a sign, that is `+` or `-`.)} 
		
		if uid >= minimumID then
		begin
			writeLn(line[1..nameFinalCharacter]);
		end;
	end;
end.
</syntaxhighlight>
Recall from the previous chapter that the [[../Strings#Substring|third parameter in <syntaxhighlight lang="pascal" inline>subStr</syntaxhighlight> can be omitted]] effectively meaning “give me ''the rest'' of a <syntaxhighlight lang="pascal" inline>string</syntaxhighlight>.” Note that this programming task mimics (some of) the behavior of {{man|1|cut|FreeBSD||inline}}. ''Use'' programs/source code that has already been programmed ''for you'' whenever possible. Reinventing the wheel is not necessary. Nonetheless, this basic task is a good exercise. On a {{abbr|RHEL|Red Hat Enterprise Linux}} system you may rather want to set <syntaxhighlight lang="pascal" inline>minimumID</syntaxhighlight> to <syntaxhighlight lang="pascal" inline>500</syntaxhighlight>.
}}
{{-}}
{{question-answer
| question = {{Wikibook|Discrete Mathematics/Sieve of Eratosthenes}} Write a prime sieve. One routine does the calculations, another routine prints them. This exercise’s goal is to give you an opportunity to type, to write an adequate program. If necessary, you can peek at existing [[Algorithm Implementation/Mathematics/Prime number generation|implementations]], but still ''write it on your own'', adding your ''own'' comments to the source code.
| answer   = The following <syntaxhighlight lang="pascal" inline>program</syntaxhighlight> meets all requirements. Note, an implementation using an {{nowrap|<syntaxhighlight lang="pascal" inline>array[1..limit] of Boolean</syntaxhighlight>}} would have been perfectly fine as well, although the shown {{nowrap|<syntaxhighlight lang="pascal" inline>set of natural</syntaxhighlight>}} implementation is ''in principle'' preferred.
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;">
program eratosthenes(output);

type
	{ in Delphi or FPC you will need to write 1..255 }
	natural = 1..4095;
	{$setLimit 4096}{ only in GPC }
	naturals = set of natural;

const
	{ `high` is a Borland Pascal (BP) extension. }
	{ It is available in Delphi, FPC and GPC. }
	limit = high(natural);

{ Note: It is important that `primes` is declared }
{ in front of `sieve` and `list`, so both of these }
{ routines can access the _same_ variable. }
var
	primes: naturals;

{ This procedure sieves the `primes` set. }
{ The `primes` set needs to be fully populated }
{ _before_ calling this routine. }
procedure sieve;
var
	n: natural;
	i: integer;
	multiples: naturals;
begin
	{ `1` is by definition not a prime number }
	primes := primes - [1];
	
	{ find the next non-crossed number }
	for n := 2 to limit do
	begin
		if n in primes then
		begin
			multiples := [];
			{ We do _not_ want to remove 1 * n. }
			i := 2 * n;
			while i in [n..limit] do
			begin
				multiples := multiples + [i];
				i := i + n;
			end;
			
			primes := primes - multiples;
		end;
	end;
end;

{ This procedures lists all numbers in `primes` }
{ and enumerates them. }
procedure list;
var
	count, n: natural;
begin
	count := 1;
	
	for n := 2 to limit do
	begin
		if n in primes then
		begin
			writeLn(count:8, '.:', n:22);
			count := count + 1;
		end;
	end;
end;

{ === MAIN program === }
begin
	primes := [1..limit];
	sieve;
	list;
end.
</syntaxhighlight>
Appreciate the fact that because you have separated the <syntaxhighlight lang="pascal" inline>sieve</syntaxhighlight> task from the <syntaxhighlight lang="pascal" inline>list</syntaxhighlight> task, both routine definitions and the main part of the <syntaxhighlight lang="pascal" inline>program</syntaxhighlight> at the bottom remain quite short and are thus easier to understand.
}}
{{-}}
{{question-answer
| question = Write a <syntaxhighlight lang="pascal" inline>program</syntaxhighlight> that reads an infinite number of numerical values from <syntaxhighlight lang="pascal" inline>input</syntaxhighlight> and at the end prints on <syntaxhighlight lang="pascal" inline>output</syntaxhighlight> the arithmetic mean.
| answer   = 
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;">
program arithmeticMean(input, output);
type
	integerNonNegative = 0..maxInt;
var
	i, sum: real;
	count: integerNonNegative;
begin
	sum := 0.0;
	count := 0;
	
	while not eof(input) do
	begin
		readLn(i);
		sum := sum + i;
		count := count + 1;
	end;
	
	{ count > 0: do not do division by zero. }
	if count > 0 then
	begin
		writeLn(sum / count);
	end;
end.
</syntaxhighlight>
Note that using a data <syntaxhighlight lang="pascal" inline>type</syntaxhighlight> excluding ''negative'' numbers (here we named it <syntaxhighlight lang="pascal" inline>integerNonNegative</syntaxhighlight>) mitigates the issue that <syntaxhighlight lang="pascal" inline>count</syntaxhighlight> may flip the sign, a condition known as [[Programming Fundamentals/Integer Overflow|overflow]]. This would cause the <syntaxhighlight lang="pascal" inline>program</syntaxhighlight> to fail if {{nowrap|<syntaxhighlight lang="pascal" inline>count := count + 1</syntaxhighlight>}} became too large, and effectively falls out of the range <syntaxhighlight lang="pascal" inline>0..maxInt</syntaxhighlight>.
There is, despite [[../Arrays#Limitations|<syntaxhighlight lang="pascal" inline>maxReal</syntaxhighlight>]], no programmatic way to tell that <syntaxhighlight lang="pascal" inline>sum</syntaxhighlight> became too large or too small rendering it severely inaccurate, because ''any'' value of <syntaxhighlight lang="pascal" inline>sum</syntaxhighlight> may be legit nevertheless.
}}
{{-}}
{{question-answer
| question = This task is a fine exercise for those using an {{abbr|EP|Extended Pascal}}-compliant compiler: Write a [[#Printable dates and times|<syntaxhighlight lang="pascal" inline>time function</syntaxhighlight>]] that returns a <syntaxhighlight lang="pascal" inline>string</syntaxhighlight> in the “American” time format {{nowrap|<syntaxhighlight lang="text" inline>9:04 PM</syntaxhighlight>}}. This may look easy at first, but it can become quite a challenge. Have fun!
| answer   = A smart person would try to ''reuse'' <syntaxhighlight lang="pascal" inline>time</syntaxhighlight> itself. However, the output of <syntaxhighlight lang="pascal" inline>time</syntaxhighlight> itself is ''not'' standardized, so we will need to define everything by ourselves:
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;" line start="3">
type
	timePrint = string(8);

function timeAmerican(ts: timeStamp): timePrint;
const
	hourMinuteSeparator = ':';
	anteMeridiemAbbreviation = 'AM';
	postMeridiemAbbreviation = 'PM';
type
	noonRelation = (beforeNoon, afterNoon);
	letterPair = string(2);
var
	{ contains 'AM' and 'PM' accessible via an index }
	m: array[noonRelation] of letterPair;
	{ contains a leading zero accessible via a Boolean expression }
	z: array[Boolean] of letterPair;
	{ holds temporary result }
	t: timePrint;
begin
	{ fill `t` with spaces }
	writeStr(t, '':t.capacity);
</syntaxhighlight>
This fallback value (in the case <syntaxhighlight lang="pascal" inline>ts.timeValid</syntaxhighlight> is <syntaxhighlight lang="pascal" inline>false</syntaxhighlight>) allows the programmer/“user” of this <syntaxhighlight lang="pascal" inline>function</syntaxhighlight> to “blindly” print its return value. There will be a ''noticeable'' gap in the output. Another sensible “fallback” value would be an empty <syntaxhighlight lang="pascal" inline>string</syntaxhighlight>.
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;" line start="25">
	with ts do
	begin
		if timeValid then
		begin
			m[beforeNoon] := anteMeridiemAbbreviation;
			m[afterNoon] := postMeridiemAbbreviation;
			z[false] := '';
			z[true] := '0';
			
			writeStr(t,
				((hour + 12 * ord(hour = 0) - 12 * ord(hour > 12)) mod 13):1,
				hourMinuteSeparator,
				z[minute < 10], minute:1, ' ',
				m[succ(beforeNoon, hour div 12)]);
</syntaxhighlight>
This is the most complicated part of this problem. First of all, all number parameters to <syntaxhighlight lang="pascal" inline>writeStr</syntaxhighlight> are ''explicitly'' suffixed with <syntaxhighlight lang="pascal" inline>:1</syntaxhighlight> as the minimum-width specification, because there are ''some'' compilers that would otherwise assume, for example, <syntaxhighlight lang="pascal" inline>:20</syntaxhighlight> as a default value. Since we know that <syntaxhighlight lang="pascal" inline>timeStamp.hour</syntaxhighlight> is in the range <syntaxhighlight lang="pascal" inline>0..23</syntaxhighlight> we can use the <syntaxhighlight lang="pascal" inline>div</syntaxhighlight> and <syntaxhighlight lang="pascal" inline>mod</syntaxhighlight> operations as demonstrated. However, we will need account of an <syntaxhighlight lang="pascal" inline>hour</syntaxhighlight> value of <syntaxhighlight lang="pascal" inline>0</syntaxhighlight>, which is usually denoted as 12:00&nbsp;{{abbr|AM|ante meridiem}} (and ''not'' zero). A conditional “shift” by 12 using the shown <syntaxhighlight lang="pascal" inline>Boolean</syntaxhighlight> expression and <syntaxhighlight lang="pascal" inline>ord</syntaxhighlight> “fixes” this. Furthermore, here is a brief reminder that in {{abbr|EP|Extended Pascal}} the [[../Enumerations#Neighbors|<syntaxhighlight lang="pascal" inline>succ</syntaxhighlight> function accepts a second parameter]].
<syntaxhighlight lang="pascal" style="page-break-inside: avoid;" line start="39">
		end;
	end;
	
	timeAmerican := t;
end;
</syntaxhighlight>
Finally we will need to copy our ''temporary'' result, to the ''function result'' variable. Remember [[../Routines#Function result|there must be exactly one assignment]], although not all compilers enforce this rule.
}}

{{newpage}}
<hr class="noprint"/>
<div style="font-size: smaller;">
Sources:
<references>
<ref name="module">{{cite conference
| title         = The Module: a system structuring facility in high-level programming languages
| last          = Wirth
| first         = Niklaus
| year          = 1979
| conference    = proceedings of the symposium on language design and programming methodology
| at            = Abstract
| doi           = 10.1007/3-540-09745-7_1
| isbn          = 978-3-540-09745-7 <!-- online version: 978-3-540-38579-0 -->
| publisher     = Springer
| location      = Berlin, Heidelberg
| url           = https://link.springer.com/content/pdf/10.1007%2F3-540-09745-7_1.pdf
| accessdate    = 2021-10-26
}}</ref>
<ref name="ohpascal">{{cite book
| title         = Oh! Pascal!
| edition       = third edition
| first1        = Doug
| last1         = Cooper
| isbn          = 0-393-96077-3 <!-- with 3.5" disk -->
| page          = 374
| chapter       = Chapter 11. The <syntaxhighlight lang="pascal" inline>record</syntaxhighlight> Type
| quote         = […] records have two unique aspects:<br>First, the stored values can have different types. This makes records potentially ''heterogeneous''—composed of values of different kinds. Arrays, in contrast, hold values of just one type, so they’re said to be ''homogeneous''.
<br>[…]
}}</ref>
<ref name="pumar">{{cite book
| title         = Pascal – user manual and report
| edition       = 4th revised
| first1        = Kathleen
| last1         = Jensen
| first2        = Niklaus
| last2         = Wirth
| doi           = 10.1007/978-1-4612-4450-9 <!-- digital version -->
| isbn          =         978-0-387-97649-5 <!-- printed copy -->
| page          = 39
| quote         = The initial and final values are evaluated only once.
}}</ref>
<ref name="revisedreport">{{cite book
| title         = The Programming Language Pascal
| edition       = Revised Report
| first1        = Niklaus
| last1         = Wirth
| date          = 1973-07-00
| page          = 30
| quote         = Within the component statement of the with statement, the components (fields) of the record variable specified by the with clause can be denoted by their field identifier only, i.e. without preceding them with the denotation of the entire record variable.
}}</ref>
</ref>
</references>
Notes:
<references group="fn"/>
</div>

{{auto navigation|Pointers|Strings}}