Organizing Code with Subprograms
Pascal distinguishes between two kinds of subprograms: procedures, which perform an action but return no value, and functions, which compute and return a single value that can be used inside an expression. Both let you factor repeated logic into a named, reusable block, but the choice between them signals intent — a function is called for its result, a procedure is called for its effect.
Cricket analogy: A twelfth man bringing out drinks performs an action with no return value — a procedure — while a third umpire reviewing a run-out returns a definite Out or Not-Out verdict, exactly like a function's return value.
Declaring and Calling Procedures
A procedure is declared as procedure Name(param1: Type1; param2: Type2); begin ... end; and invoked simply by writing its name and arguments as a statement, e.g. PrintReport(total, count);. Procedures are ideal for grouping a sequence of actions — input/output, updating variables via var parameters, or coordinating other calls — that don't need to hand back a single computed value.
Cricket analogy: A procedure SetField that repositions all eleven fielders performs a coordinated action affecting the state of the field but hands back no single number, just like a Pascal procedure.
procedure PrintInvoice(itemName: String; quantity: Integer; price: Real);
var
lineTotal: Real;
begin
lineTotal := quantity * price;
WriteLn(itemName, ' x', quantity, ' = $', lineTotal:0:2);
end;
begin
PrintInvoice('Widget', 3, 9.99);
end.Declaring and Calling Functions
A function is declared as function Name(param1: Type1): ReturnType; begin ... Name := someValue; end; — inside the body, assigning to the function's own name sets the value that will be returned, and that assignment can happen more than once, with the last one before the function exits taking effect. Because a function call produces a value, it can be used anywhere an expression of its return type is legal, such as total := ComputeArea(width, height) + margin;.
Cricket analogy: A function StrikeRate that computes and hands back a specific number is immediately plugged by a commentator directly into a broader stats sentence, exactly like using a function's return value inside an expression.
function CircleArea(radius: Real): Real;
const
Pi = 3.14159;
begin
CircleArea := Pi * radius * radius;
end;
var
total: Real;
begin
total := CircleArea(4.0) + CircleArea(2.5);
WriteLn('Combined area: ', total:0:2);
end.Inside a function body, the function's own name acts as a pseudo-variable that holds the eventual return value — you can assign to it multiple times, and the value present at the last assignment before the function exits is what gets returned to the caller.
Forward Declarations and Mutual Recursion
When two procedures or functions need to call each other — mutual recursion — Pascal's single-pass, top-to-bottom declaration order creates a problem: whichever one is written first would need to reference the other before it has been declared. The forward directive solves this by declaring a subprogram's header early with the body supplied later, letting the compiler know the signature exists before it is fully defined.
Cricket analogy: Two commentators who each reference the other's earlier remark mid-broadcast need a producer to pre-confirm both segments exist in the show's running order before either airs, just like a forward declaration confirming a subprogram's signature ahead of its full definition.
If you write two subprograms that call each other without using forward for the first one, the compiler will report an 'unknown identifier' error at the point where the first subprogram references the second, because standard Pascal does not allow forward references without an explicit forward declaration.
- Procedures perform actions and return no value; functions compute and return a single value
- A function's own name acts as a pseudo-variable that holds its return value
- The last assignment to a function's name before it exits determines the returned value
- Function calls can be used directly inside expressions; procedure calls cannot
- Mutually recursive subprograms require a forward declaration for the first one
- forward declares a subprogram's header now, with its full body supplied later
- Omitting forward for mutually calling subprograms causes an unknown-identifier compile error
Practice what you learned
1. What is the fundamental difference between a procedure and a function in Pascal?
2. How does a Pascal function specify its return value?
3. Why would two mutually recursive procedures require a forward declaration?
4. Where can a function call legally appear in Pascal, that a procedure call cannot?
5. What error occurs if you omit the forward directive for mutually recursive subprograms?
Was this page helpful?
You May Also Like
Parameters and Scope
Understand Pascal's value vs var parameters and how block-structured scoping controls variable visibility.
Recursion in Pascal
Learn how Pascal functions and procedures can call themselves, and how to design correct base cases and recursive cases.
Conditionals in Pascal
Learn how Pascal's if-then-else and case statements let programs branch based on boolean conditions.
Related Reading
Related Study Notes in Programming
Browse all study notesApache Spark Study Notes
Programming · 30 topics
ProgrammingApache Flink Study Notes
Programming · 30 topics
ProgrammingHadoop Study Notes
Programming · 30 topics
ProgrammingSnowflake Study Notes
Programming · 30 topics
ProgrammingApache Airflow Study Notes
Programming · 30 topics
Programmingdbt (Data Build Tool) Study Notes
Programming · 30 topics