User-defined data types

The built-in data types (INTEGER, REAL, CHAR, STRING, BOOLEAN, DATE) can each hold only one kind of value, but real problems are about things: students, seasons, flights, sets of options. A user-defined data type lets the programmer describe those things directly. In Paper 3 you are asked to explain why such types are needed, to classify them as composite or non-composite, and to write TYPE declarations in Cambridge pseudocode; in Paper 4 you implement the same ideas (records especially) in Python, Java or Visual Basic.

Why user-defined types are needed

A program that stores a student as five separate arrays (LastName[], FirstName[], DateOfBirth[], YearGroup[], FormGroup[]) works, but every array has to be kept in step by hand. Sort one array and forget another, and the data is silently corrupted. If instead there is one type, StudentRecord, that holds all five fields, the program can store one array of StudentRecord, and a student's data can never be split apart.

That is the general reason: the built-in types describe how data is stored, not what it means. A user-defined type is built from the built-in types (or from other user-defined types) so that the program's data matches the problem.

The benefits that earn marks are:

• It models the problem. Data that belongs together is stored together and referred to by one identifier.
• It restricts values. An enumerated type Season can only hold the four seasons, so an invalid value such as "Smmer" cannot be stored.
• It makes code readable and maintainable. ThisSeason ← Winter explains itself; ThisSeason ← 3 does not.
• It can be reused. Once StudentRecord is defined, any number of variables, arrays and files can use it, and a change to the definition is made in one place.
• It provides types the language lacks. Data structures that are not built into a language (records in Python, sets in some languages, linked lists everywhere) have to be constructed from what the language does provide.

Composite and non-composite types

Cambridge classifies every user-defined type in one of two ways.

Enumerated types

An enumerated data type is a non-composite type defined by listing every value it may take. The values are identifiers, not strings, so they are written without quotation marks.

TYPE Season = (Spring, Summer, Autumn, Winter)

DECLARE ThisSeason : Season
DECLARE NextSeason : Season

ThisSeason ← Autumn
NextSeason ← ThisSeason + 1     // NextSeason is now Winter
IF ThisSeason > Summer THEN
   OUTPUT "Second half of the year"
ENDIF

The values are ordered in the order they are listed. That is why ThisSeason + 1 and ThisSeason > Summer make sense: Spring < Summer < Autumn < Winter. Adding 1 to the last value (Winter + 1) is not defined, so a careful program checks for it.

In Python, the enum module provides enumerations. IntEnum keeps the ordering and arithmetic of the pseudocode version.

from enum import IntEnum

class Season(IntEnum):
    SPRING = 1
    SUMMER = 2
    AUTUMN = 3
    WINTER = 4

this_season = Season.AUTUMN
next_season = Season(this_season + 1)   # Season.WINTER
print(next_season.name)                 # WINTER
print(this_season > Season.SUMMER)      # True

for s in Season:                        # iterate in order
    print(s.value, s.name)

Pointer types

A pointer is a non-composite type whose value is the memory address of another data item. The declaration states what type of data lives at that address.

TYPE TIntPointer = ^INTEGER      // a pointer to an integer
DECLARE Number : INTEGER
DECLARE MyPointer : TIntPointer  // no caret when declaring the variable

Number ← 5
MyPointer ← ^Number              // ^Number is the ADDRESS of Number
MyPointer^ ← MyPointer^ + 3      // MyPointer^ is the VALUE at that address
OUTPUT Number                    // 8

The caret does two different jobs depending on where it stands:

Pointers matter because they let a program build dynamic structures. A linked list node holds data and a pointer to the next node; a binary tree node holds two pointers. When you implement those structures in an array (as Cambridge questions usually do), the "pointer" becomes an integer array index, which is exactly the same idea: a value that tells you where to find the next item.

Python has no pointer type. Every Python variable already holds a reference to an object, so an object can be shared, but you cannot take or print an address. In Paper 4, pointers are almost always simulated with integer indices into a list.

Records

A record is a composite type made of a fixed number of named fields, which may be of different types.

TYPE StudentRecord
   DECLARE LastName : STRING
   DECLARE FirstName : STRING
   DECLARE DateOfBirth : DATE
   DECLARE YearGroup : INTEGER
   DECLARE FormGroup : CHAR
ENDTYPE

DECLARE Pupil1 : StudentRecord
DECLARE Form : ARRAY[1:30] OF StudentRecord

Pupil1.LastName ← "Johnson"
Pupil1.YearGroup ← 6
Form[1] ← Pupil1                 // whole records can be assigned
FOR Index ← 1 TO 30
   Form[Index].YearGroup ← Form[Index].YearGroup + 1
NEXT Index

Fields are reached with dot notation: Pupil1.LastName, Form[Index].YearGroup. Records are the foundation of file processing: a random-access file is usually a file of records of one type.

Python has no record keyword. The usual Paper 4 approach is a class with only a constructor; a dataclass is a tidy alternative.

class StudentRecord:
    def __init__(self, last_name="", first_name="", date_of_birth=None,
                 year_group=0, form_group=""):
        self.last_name = last_name
        self.first_name = first_name
        self.date_of_birth = date_of_birth
        self.year_group = year_group
        self.form_group = form_group

# an "array" of 30 empty records
form = [StudentRecord() for _ in range(30)]
form[0] = StudentRecord("Johnson", "Leroy", "02/01/2005", 6, "A")

for pupil in form:
    pupil.year_group += 1

print(form[0].last_name, form[0].year_group)   # Johnson 7
print(form[1].year_group)                      # 1

In Java a record is a class with fields; in Visual Basic it is a Structure:

Structure StudentRecord
    Dim LastName As String
    Dim FirstName As String
    Dim DateOfBirth As Date
    Dim YearGroup As Integer
    Dim FormGroup As Char
End Structure

Sets

A set is a composite type holding an unordered collection of values of one type, with no duplicates. Cambridge pseudocode declares a set type and then defines a set of that type:

TYPE LetterSet = SET OF CHAR
DEFINE Vowels ('A', 'E', 'I', 'O', 'U') : LetterSet

The operations you should be able to describe are the mathematical ones:

Sets suit problems where you only ask "is it in or not?": which pizza toppings were chosen, which seats are booked, which letters have been guessed in a word game. Python's built-in set supports all of these.

vowels = {'A', 'E', 'I', 'O', 'U'}
word = "EXAMINATION"
letters = set(word)                 # duplicates removed automatically

print(sorted(letters & vowels))     # intersection: ['A', 'E', 'I', 'O']
print(sorted(letters - vowels))     # difference:   ['M', 'N', 'T', 'X']
print('U' in letters)               # membership:   False
print(len(letters | vowels))        # union size:   9

Classes and objects

A class is a composite type that bundles data (attributes) with the methods that operate on it; an object is an instance of a class. It goes beyond a record because the data can be made private and changed only through the class's own methods (encapsulation). Classes are covered fully in object-oriented programming; for this topic, know that a class is a composite user-defined type.

CLASS Pet
   PRIVATE Name : STRING
   PUBLIC PROCEDURE NEW(GivenName : STRING)
      Name ← GivenName
   ENDPROCEDURE
   PUBLIC FUNCTION GetName() RETURNS STRING
      RETURN Name
   ENDFUNCTION
ENDCLASS

Choosing a user-defined type

TYPE LightState = (Red, RedAmber, Green, Amber)

DECLARE Current : LightState
Current ← Red
...
IF Current = Amber THEN
   Current ← Red
ELSE
   Current ← Current + 1
ENDIF

TYPE Book
   DECLARE ISBN : STRING
   DECLARE Title : STRING
   DECLARE Copies : INTEGER
   DECLARE LastBorrowed : DATE
   DECLARE ReferenceOnly : BOOLEAN
ENDTYPE

DECLARE Library : ARRAY[1:500] OF Book
DECLARE Index : INTEGER

FOR Index ← 1 TO 500
   IF Library[Index].ReferenceOnly = TRUE AND Library[Index].Copies > 2 THEN
      OUTPUT Library[Index].Title
   ENDIF
NEXT Index

class Book:
    def __init__(self, isbn, title, copies, last_borrowed, reference_only):
        self.isbn = isbn
        self.title = title
        self.copies = copies
        self.last_borrowed = last_borrowed
        self.reference_only = reference_only

library = [
    Book("9780000000011", "Atlas of the World", 3, "01/09/2026", True),
    Book("9780000000028", "Learning Python", 5, "14/09/2026", False),
    Book("9780000000035", "Oxford Dictionary", 4, "20/08/2026", True),
    Book("9780000000042", "Tide Tables", 1, "02/02/2026", True),
]

for book in library:
    if book.reference_only and book.copies > 2:
        print(book.title)
# Atlas of the World
# Oxford Dictionary

TYPE TIntPointer = ^INTEGER
DECLARE A, B : INTEGER
DECLARE P, Q : TIntPointer

A ← 10
B ← 20
P ← ^A
Q ← ^B
P^ ← P^ + Q^
Q ← P
Q^ ← Q^ * 2
OUTPUT A, " ", B

TYPE TrainStatus = (OnTime, Delayed, Cancelled)

TYPE Train
   DECLARE Code : STRING
   DECLARE Status : TrainStatus
   DECLARE NextTrain : INTEGER     // index acting as a pointer; 0 = none
ENDTYPE

DECLARE Trains : ARRAY[1:100] OF Train

PROCEDURE ShowRoute(Start : INTEGER)
   DECLARE Current : INTEGER
   Current ← Start
   WHILE Current <> 0
      OUTPUT Trains[Current].Code
      Current ← Trains[Current].NextTrain
   ENDWHILE
ENDPROCEDURE

from enum import Enum

class TrainStatus(Enum):
    ON_TIME = 1
    DELAYED = 2
    CANCELLED = 3

class Train:
    def __init__(self, code="", status=TrainStatus.ON_TIME, next_train=0):
        self.code = code
        self.status = status
        self.next_train = next_train

trains = [Train() for _ in range(101)]          # index 0 unused, as in [1:100]
trains[4] = Train("IC205", TrainStatus.ON_TIME, 9)
trains[9] = Train("IC211", TrainStatus.DELAYED, 2)
trains[2] = Train("IC230", TrainStatus.CANCELLED, 0)

def show_route(start):
    current = start
    while current != 0:
        print(trains[current].code, trains[current].status.name)
        current = trains[current].next_train

show_route(4)
# IC205 ON_TIME
# IC211 DELAYED
# IC230 CANCELLED

Practice questions

```pseudocode

TYPE Direction = (North, East, South, West)
DECLARE Facing : Direction
Facing ← Facing + 1
```

`Facing + 1` works because enumerated values are ordered as listed; a full solution would set `Facing ← North` when `Facing = West`.

```pseudocode

TYPE Patient
   DECLARE PatientID : STRING
   DECLARE Name : STRING
   DECLARE AdmissionDate : DATE
   DECLARE WardNumber : INTEGER
   DECLARE IntensiveCare : BOOLEAN
ENDTYPE

DECLARE Ward : ARRAY[1:25] OF Patient
```

The ID is a `STRING` because it contains a letter and leading zeros.

```pseudocode
DECLARE Count, Index : INTEGER
Count ← 0
FOR Index ← 1 TO 25
   IF Ward[Index].IntensiveCare = TRUE THEN
      Count ← Count + 1
   ENDIF
NEXT Index
OUTPUT Count
```

```python

class Car:
    def __init__(self, registration, make, year, electric):
        self.registration = registration
        self.make = make
        self.year = year
        self.electric = electric

cars = [Car("AB21 XYZ", "Nissan", 2021, True),
        Car("CD19 PQR", "Ford", 2019, False),
        Car("EF18 LMN", "Tesla", 2018, True)]

for car in cars:
    if car.electric and car.year > 2020:
        print(car.registration)      # AB21 XYZ
```

```pseudocode
TYPE WeekDay = (Monday, Tuesday, Wednesday, Thursday, Friday)
TYPE GroupSet = SET OF STRING

TYPE Lesson
   DECLARE Day : WeekDay
   DECLARE Period : INTEGER
   DECLARE Subject : STRING
   DECLARE Room : STRING
   DECLARE Groups : GroupSet
ENDTYPE

DECLARE Timetable : ARRAY[1:200] OF Lesson
```

`WeekDay` is enumerated: five fixed, ordered values, and no invalid day can be stored. `Period` is an `INTEGER` (1 to 6, can be range-checked and compared). `Room` is a `STRING` because rooms such as `"S12"` contain letters. The groups form a set because a group either attends or does not, with no order or repetition, and membership ("does 12B attend?") is the question asked. `Lesson` is a record because the five items describe one lesson and must be kept together; an array of `Lesson` holds the timetable.