diff --git a/Rakefile b/Rakefile
index bee64e8..774a3e7 100644
--- a/Rakefile
+++ b/Rakefile
@@ -107,6 +107,7 @@ task :backport do
       .gsub(/\b(record|nil|or)\b/) { |match| match.upcase }
       .gsub(/proc\(/, 'PROCEDURE(')
       .gsub(/ & /, ' AND ')
+      .gsub(/ -> /, ': ')
       .gsub(/([[:space:]]*)end(;?)$/, '\1END\2')
       .gsub(/^([[:space:]]*)(while|return|if)\b/) { |match| match.upcase }
       .gsub(/^from ([[:alnum:]]+) import/, 'FROM \1 IMPORT')
diff --git a/source/Lexer.def b/source/Lexer.def
index 6557849..0df33cd 100644
--- a/source/Lexer.def
+++ b/source/Lexer.def
@@ -73,13 +73,13 @@ TYPE
     lexerKindFrom,
     lexerKindPointer,
     lexerKindArray,
-    lexerKindTrait,
+    lexerKindArrow,
     lexerKindProgram,
     lexerKindModule,
     lexerKindImport
   );
   LexerToken = RECORD
-    CASE Kind: LexerKind OF
+    CASE kind: LexerKind OF
       lexerKindBoolean: booleanKind: BOOLEAN |
       lexerKindIdentifier: identifierKind: ARRAY[1..256] OF CHAR
     END
diff --git a/source/Lexer.elna b/source/Lexer.elna
index 264f895..902e93a 100644
--- a/source/Lexer.elna
+++ b/source/Lexer.elna
@@ -72,6 +72,8 @@ var
   transitions: [16]TransitionClasses;
 
 proc initialize_classification();
+var
+  i: CARDINAL;
 begin
   classification[1] := transitionClassEof; (* NUL *)
   classification[2] := transitionClassInvalid; (* SOH *)
@@ -200,265 +202,274 @@ begin
   classification[125] := transitionClassSingle; (* | *)
   classification[126] := transitionClassOther; (* } *)
   classification[127] := transitionClassSingle; (* ~ *)
-  classification[128] := transitionClassInvalid (* DEL *)
+  classification[128] := transitionClassInvalid; (* DEL *)
+
+  i := 129;
+  while i <= 256 do
+    classification[i] := transitionClassOther;
+    i := i + 1
+  end
 end;
 
-proc compare_keyword(Keyword: ARRAY OF CHAR,  TokenStart: PLexerBuffer,  TokenEnd: PLexerBuffer): BOOLEAN;
+proc compare_keyword(Keyword: ARRAY OF CHAR,  TokenStart: PLexerBuffer,  TokenEnd: PLexerBuffer) -> BOOLEAN;
 var
-  Result: BOOLEAN;
-  Index: CARDINAL;
+  result: BOOLEAN;
+  index: CARDINAL;
 begin
-  Index := 0;
-  Result := TRUE;
+  index := 0;
+  result := TRUE;
 
-  while (Index < Length(Keyword)) & (TokenStart <> TokenEnd) & Result DO
-    Result := (Keyword[Index] = TokenStart^) or (Lower(Keyword[Index]) = TokenStart^);
+  while (index < Length(Keyword)) & (TokenStart <> TokenEnd) & result DO
+    result := (Keyword[index] = TokenStart^) or (Lower(Keyword[index]) = TokenStart^);
     INC(TokenStart);
-    INC(Index)
+    INC(index)
   end;
-  Result := (Index = Length(Keyword)) & (TokenStart = TokenEnd) & Result;
-  return Result
+  result := (index = Length(Keyword)) & (TokenStart = TokenEnd) & result;
+  return result
 end;
 
 (* Reached the end of file. *)
-proc transition_action_eof(lexer: PLexer,  AToken: PLexerToken);
+proc transition_action_eof(lexer: PLexer,  token: PLexerToken);
 begin
-  AToken^.Kind := lexerKindEof
+  token^.kind := lexerKindEof
 end;
 
 (* Add the character to the token currently read and advance to the next character. *)
-proc transition_action_accumulate(lexer: PLexer,  AToken: PLexerToken);
+proc transition_action_accumulate(lexer: PLexer,  token: PLexerToken);
 begin
   INC(lexer^.Current)
 end;
 
 (* The current character is not a part of the token. Finish the token already
  * read. Don't advance to the next character. *)
-proc transition_action_finalize(lexer: PLexer,  AToken: PLexerToken);
+proc transition_action_finalize(lexer: PLexer,  token: PLexerToken);
 begin
   if lexer^.Start^ = ':' then
-    AToken^.Kind := lexerKindColon
+    token^.kind := lexerKindColon
   end;
   if lexer^.Start^ = '>' then
-    AToken^.Kind := lexerKindGreaterThan
+    token^.kind := lexerKindGreaterThan
   end;
   if lexer^.Start^ = '<' then
-    AToken^.Kind := lexerKindLessThan
+    token^.kind := lexerKindLessThan
   end;
   if lexer^.Start^ = '(' then
-    AToken^.Kind := lexerKindLeftParen
+    token^.kind := lexerKindLeftParen
   end;
   if lexer^.Start^ = '-' then
-    AToken^.Kind := lexerKindLeftParen
+    token^.kind := lexerKindLeftParen
   end;
   if lexer^.Start^ = '.' then
-    AToken^.Kind := lexerKindDot
+    token^.kind := lexerKindDot
   end
 end;
 
 (* An action for tokens containing multiple characters. *)
-proc transition_action_composite(lexer: PLexer,  AToken: PLexerToken);
+proc transition_action_composite(lexer: PLexer,  token: PLexerToken);
 begin
   if lexer^.Start^ = '<' then
     if lexer^.Current^ = '>' then
-      AToken^.Kind := lexerKindNotEqual
+      token^.kind := lexerKindNotEqual
     end;
     if lexer^.Current^ = '=' then
-      AToken^.Kind := lexerKindLessEqual
+      token^.kind := lexerKindLessEqual
     end
   end;
   if (lexer^.Start^ = '>') & (lexer^.Current^ = '=') then
-    AToken^.Kind := lexerKindGreaterEqual
+    token^.kind := lexerKindGreaterEqual
   end;
   if (lexer^.Start^ = '.') & (lexer^.Current^ = '.') then
-    AToken^.Kind := lexerKindRange
+    token^.kind := lexerKindRange
   end;
   if (lexer^.Start^ = ':') & (lexer^.Current^ = '=') then
-    AToken^.Kind := lexerKindAssignment
+    token^.kind := lexerKindAssignment
+  end;
+  if (lexer^.Start^ = '-') & (lexer^.Current^ = '>') then
+    token^.kind := lexerKindArrow
   end;
   INC(lexer^.Current)
 end;
 
 (* Skip a space. *)
-proc transition_action_skip(lexer: PLexer,  AToken: PLexerToken);
+proc transition_action_skip(lexer: PLexer,  token: PLexerToken);
 begin
   INC(lexer^.Current);
   INC(lexer^.Start)
 end;
 
 (* Delimited string action. *)
-proc transition_action_delimited(lexer: PLexer,  AToken: PLexerToken);
+proc transition_action_delimited(lexer: PLexer,  token: PLexerToken);
 begin
   if lexer^.Start^ = '(' then
-    AToken^.Kind := lexerKindComment
+    token^.kind := lexerKindComment
   end;
   if lexer^.Start^ = '"' then
-    AToken^.Kind := lexerKindCharacter
+    token^.kind := lexerKindCharacter
   end;
   if lexer^.Start^ = "'" then
-    AToken^.Kind := lexerKindString
+    token^.kind := lexerKindString
   end;
   INC(lexer^.Current)
 end;
 
 (* Finalize keyword or identifier. *)
-proc transition_action_key_id(lexer: PLexer,  AToken: PLexerToken);
+proc transition_action_key_id(lexer: PLexer,  token: PLexerToken);
 begin
-  AToken^.Kind := lexerKindIdentifier;
+  token^.kind := lexerKindIdentifier;
 
-  AToken^.identifierKind[1] := lexer^.Current - lexer^.Start;
-  MemCopy(lexer^.Start, ORD(AToken^.identifierKind[1]), ADR(AToken^.identifierKind[2]));
+  token^.identifierKind[1] := lexer^.Current - lexer^.Start;
+  MemCopy(lexer^.Start, ORD(token^.identifierKind[1]), ADR(token^.identifierKind[2]));
 
   if compare_keyword('PROGRAM', lexer^.Start, lexer^.Current) then
-    AToken^.Kind := lexerKindProgram
+    token^.kind := lexerKindProgram
   end;
   if compare_keyword('IMPORT', lexer^.Start, lexer^.Current) then
-    AToken^.Kind := lexerKindImport
+    token^.kind := lexerKindImport
   end;
   if compare_keyword('CONST', lexer^.Start, lexer^.Current) then
-    AToken^.Kind := lexerKindConst
+    token^.kind := lexerKindConst
   end;
   if compare_keyword('VAR', lexer^.Start, lexer^.Current) then
-    AToken^.Kind := lexerKindVar
+    token^.kind := lexerKindVar
   end;
   if compare_keyword('IF', lexer^.Start, lexer^.Current) then
-    AToken^.Kind := lexerKindIf
+    token^.kind := lexerKindIf
   end;
   if compare_keyword('THEN', lexer^.Start, lexer^.Current) then
-    AToken^.Kind := lexerKindThen
+    token^.kind := lexerKindThen
   end;
   if compare_keyword('ELSIF', lexer^.Start, lexer^.Current) then
-    AToken^.Kind := lexerKindElsif
+    token^.kind := lexerKindElsif
   end;
   if compare_keyword('ELSE', lexer^.Start, lexer^.Current) then
-    AToken^.Kind := lexerKindElse
+    token^.kind := lexerKindElse
   end;
   if compare_keyword('WHILE', lexer^.Start, lexer^.Current) then
-    AToken^.Kind := lexerKindWhile
+    token^.kind := lexerKindWhile
   end;
   if compare_keyword('DO', lexer^.Start, lexer^.Current) then
-    AToken^.Kind := lexerKindDo
+    token^.kind := lexerKindDo
   end;
   if compare_keyword('proc', lexer^.Start, lexer^.Current) then
-    AToken^.Kind := lexerKindProc
+    token^.kind := lexerKindProc
   end;
   if compare_keyword('BEGIN', lexer^.Start, lexer^.Current) then
-    AToken^.Kind := lexerKindBegin
+    token^.kind := lexerKindBegin
   end;
   if compare_keyword('END', lexer^.Start, lexer^.Current) then
-    AToken^.Kind := lexerKindEnd
+    token^.kind := lexerKindEnd
   end;
   if compare_keyword('TYPE', lexer^.Start, lexer^.Current) then
-    AToken^.Kind := lexerKindType
+    token^.kind := lexerKindType
   end;
   if compare_keyword('RECORD', lexer^.Start, lexer^.Current) then
-    AToken^.Kind := lexerKindRecord
+    token^.kind := lexerKindRecord
   end;
   if compare_keyword('UNION', lexer^.Start, lexer^.Current) then
-    AToken^.Kind := lexerKindUnion
+    token^.kind := lexerKindUnion
   end;
   if compare_keyword('NIL', lexer^.Start, lexer^.Current) then
-    AToken^.Kind := lexerKindNull
+    token^.kind := lexerKindNull
   end;
   if compare_keyword('AND', lexer^.Start, lexer^.Current) then
-    AToken^.Kind := lexerKindAnd
+    token^.kind := lexerKindAnd
   end;
   if compare_keyword('OR', lexer^.Start, lexer^.Current) then
-    AToken^.Kind := lexerKindOr
+    token^.kind := lexerKindOr
   end;
   if compare_keyword('RETURN', lexer^.Start, lexer^.Current) then
-    AToken^.Kind := lexerKindReturn
+    token^.kind := lexerKindReturn
   end;
   if compare_keyword('DEFINITION', lexer^.Start, lexer^.Current) then
-    AToken^.Kind := lexerKindDefinition
+    token^.kind := lexerKindDefinition
   end;
   if compare_keyword('TO', lexer^.Start, lexer^.Current) then
-    AToken^.Kind := lexerKindTo
+    token^.kind := lexerKindTo
   end;
   if compare_keyword('CASE', lexer^.Start, lexer^.Current) then
-    AToken^.Kind := lexerKindCase
+    token^.kind := lexerKindCase
   end;
   if compare_keyword('OF', lexer^.Start, lexer^.Current) then
-    AToken^.Kind := lexerKindOf
+    token^.kind := lexerKindOf
   end;
   if compare_keyword('FROM', lexer^.Start, lexer^.Current) then
-    AToken^.Kind := lexerKindFrom
+    token^.kind := lexerKindFrom
   end;
   if compare_keyword('MODULE', lexer^.Start, lexer^.Current) then
-    AToken^.Kind := lexerKindModule
+    token^.kind := lexerKindModule
   end;
   if compare_keyword('IMPLEMENTATION', lexer^.Start, lexer^.Current) then
-    AToken^.Kind := lexerKindImplementation
+    token^.kind := lexerKindImplementation
   end;
   if compare_keyword('POINTER', lexer^.Start, lexer^.Current) then
-    AToken^.Kind := lexerKindPointer
+    token^.kind := lexerKindPointer
   end;
   if compare_keyword('ARRAY', lexer^.Start, lexer^.Current) then
-    AToken^.Kind := lexerKindArray
+    token^.kind := lexerKindArray
   end;
   if compare_keyword('TRUE', lexer^.Start, lexer^.Current) then
-    AToken^.Kind := lexerKindBoolean;
-    AToken^.booleanKind := TRUE
+    token^.kind := lexerKindBoolean;
+    token^.booleanKind := TRUE
   end;
   if compare_keyword('FALSE', lexer^.Start, lexer^.Current) then
-    AToken^.Kind := lexerKindBoolean;
-    AToken^.booleanKind := FALSE
+    token^.kind := lexerKindBoolean;
+    token^.booleanKind := FALSE
   end
 end;
 
 (* Action for tokens containing only one character. The character cannot be
  * followed by other characters forming a composite token. *)
-proc transition_action_single(lexer: PLexer,  AToken: PLexerToken);
+proc transition_action_single(lexer: PLexer,  token: PLexerToken);
 begin
   if lexer^.Current^ = '&' then
-    AToken^.Kind := lexerKindAnd
+    token^.kind := lexerKindAnd
   end;
   if lexer^.Current^ = ';' then
-    AToken^.Kind := lexerKindSemicolon
+    token^.kind := lexerKindSemicolon
   end;
   if lexer^.Current^ = ',' then
-    AToken^.Kind := lexerKindComma
+    token^.kind := lexerKindComma
   end;
   if lexer^.Current^ = ',' then
-    AToken^.Kind := lexerKindComma
+    token^.kind := lexerKindComma
   end;
   if lexer^.Current^ = ')' then
-    AToken^.Kind := lexerKindRightParen
+    token^.kind := lexerKindRightParen
   end;
   if lexer^.Current^ = '[' then
-    AToken^.Kind := lexerKindLeftSquare
+    token^.kind := lexerKindLeftSquare
   end;
   if lexer^.Current^ = ']' then
-    AToken^.Kind := lexerKindRightSquare
+    token^.kind := lexerKindRightSquare
   end;
   if lexer^.Current^ = '^' then
-    AToken^.Kind := lexerKindHat
+    token^.kind := lexerKindHat
   end;
   if lexer^.Current^ = '=' then
-    AToken^.Kind := lexerKindEqual
+    token^.kind := lexerKindEqual
   end;
   if lexer^.Current^ = '+' then
-    AToken^.Kind := lexerKindPlus
+    token^.kind := lexerKindPlus
   end;
   if lexer^.Current^ = '/' then
-    AToken^.Kind := lexerKindDivision
+    token^.kind := lexerKindDivision
   end;
   if lexer^.Current^ = '%' then
-    AToken^.Kind := lexerKindRemainder
+    token^.kind := lexerKindRemainder
   end;
   if lexer^.Current^ = '@' then
-    AToken^.Kind := lexerKindAt
+    token^.kind := lexerKindAt
   end;
   if lexer^.Current^ = '|' then
-    AToken^.Kind := lexerKindPipe
+    token^.kind := lexerKindPipe
   end;
   INC(lexer^.Current)
 end;
 
 (* Handle an integer literal. *)
-proc transition_action_integer(lexer: PLexer,  AToken: PLexerToken);
+proc transition_action_integer(lexer: PLexer,  token: PLexerToken);
 begin
-  AToken^.Kind := lexerKindInteger
+  token^.kind := lexerKindInteger
 end;
 
 proc set_default_transition(CurrentState: TransitionState,  DefaultAction: TransitionAction,  NextState: TransitionState);
@@ -756,12 +767,12 @@ begin
   lexer^.Size := CHUNK_SIZE
 end;
 
-proc lexer_current(lexer: PLexer): LexerToken;
+proc lexer_current(lexer: PLexer) -> LexerToken;
 var
   CurrentClass: TransitionClass;
   CurrentState: TransitionState;
   CurrentTransition: Transition;
-  Result: LexerToken;
+  result: LexerToken;
 begin
   lexer^.Current := lexer^.Start;
   CurrentState := transitionStateStart;
@@ -771,16 +782,16 @@ begin
 
     CurrentTransition := transitions[ORD(CurrentState) + 1][ORD(CurrentClass) + 1];
     if CurrentTransition.Action <> nil then
-      CurrentTransition.Action(lexer, ADR(Result))
+      CurrentTransition.Action(lexer, ADR(result))
     end;
     CurrentState := CurrentTransition.NextState
   end;
-  return Result
+  return result
 end;
 
-proc lexer_lex(lexer: PLexer): LexerToken;
+proc lexer_lex(lexer: PLexer) -> LexerToken;
 var
-  Result: LexerToken;
+  result: LexerToken;
 begin
   if lexer^.Length = 0 then
     lexer^.Length := ReadNBytes(lexer^.Input, CHUNK_SIZE, lexer^.Buffer);
@@ -788,8 +799,8 @@ begin
   end;
   lexer^.Start := lexer^.Current;
 
-  Result := lexer_current(lexer);
-  return Result
+  result := lexer_current(lexer);
+  return result
 end;
 
 proc lexer_destroy(lexer: PLexer);
diff --git a/source/Transpiler.elna b/source/Transpiler.elna
index bdb6c5a..9820193 100644
--- a/source/Transpiler.elna
+++ b/source/Transpiler.elna
@@ -13,13 +13,13 @@ type
   end;
 
 (* Calls lexer_lex() but skips the comments. *)
-proc transpiler_lex(lexer: PLexer): LexerToken;
+proc transpiler_lex(lexer: PLexer) -> LexerToken;
 var
   result: LexerToken;
 begin
   result := lexer_lex(lexer);
 
-  while result.Kind = lexerKindComment do
+  while result.kind = lexerKindComment do
     result := lexer_lex(lexer)
   end;
 
@@ -50,7 +50,7 @@ begin
   written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
 
   token := transpiler_lex(lexer);
-  while token.Kind <> lexerKindSemicolon do
+  while token.kind <> lexerKindSemicolon do
     WriteString(', ');
     token := transpiler_lex(lexer);
     written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
@@ -66,7 +66,7 @@ var
 begin
   token := lexer_current(lexer);
 
-  while token.Kind = lexerKindFrom do
+  while token.kind = lexerKindFrom do
     transpile_import(context, lexer);
     token := lexer_current(lexer)
   end;
@@ -75,39 +75,39 @@ end;
 
 proc transpile_constant(context: PTranspilerContext,  lexer: PLexer);
 var
-  Token: LexerToken;
+  token: LexerToken;
   written_bytes: CARDINAL;
 begin
   WriteString('  ');
-  Token := lexer_current(lexer);
+  token := lexer_current(lexer);
   written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
 
-  Token := transpiler_lex(lexer);
+  token := transpiler_lex(lexer);
   WriteString(' = ');
 
-  Token := transpiler_lex(lexer);
+  token := transpiler_lex(lexer);
   written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
 
-  Token := transpiler_lex(lexer);
+  token := transpiler_lex(lexer);
   write_semicolon()
 end;
 
-proc transpile_constant_part(context: PTranspilerContext,  lexer: PLexer): BOOLEAN;
+proc transpile_constant_part(context: PTranspilerContext,  lexer: PLexer) -> BOOLEAN;
 var
-  Token: LexerToken;
+  token: LexerToken;
   result: BOOLEAN;
 begin
-  Token := lexer_current(lexer);
-  result := Token.Kind = lexerKindConst;
+  token := lexer_current(lexer);
+  result := token.kind = lexerKindConst;
 
   if result then
     WriteString('CONST');
     WriteLn();
-    Token := transpiler_lex(lexer);
+    token := transpiler_lex(lexer);
 
-    while Token.Kind = lexerKindIdentifier do
+    while token.kind = lexerKindIdentifier do
       transpile_constant(context, lexer);
-      Token := transpiler_lex(lexer)
+      token := transpiler_lex(lexer)
     end
   end;
   return result
@@ -115,31 +115,31 @@ end;
 
 proc transpile_module(context: PTranspilerContext,  lexer: PLexer);
 var
-  Token: LexerToken;
+  token: LexerToken;
   written_bytes: CARDINAL;
 begin
-  Token := transpiler_lex(lexer);
+  token := transpiler_lex(lexer);
 
-  if Token.Kind = lexerKindDefinition then
+  if token.kind = lexerKindDefinition then
     WriteString('DEFINITION ');
-    Token := transpiler_lex(lexer)
+    token := transpiler_lex(lexer)
   end;
-  if Token.Kind = lexerKindImplementation then
+  if token.kind = lexerKindImplementation then
     WriteString('IMPLEMENTATION ');
-    Token := transpiler_lex(lexer)
+    token := transpiler_lex(lexer)
   end;
   WriteString('MODULE ');
 
   (* Write the module name and end the line with a semicolon and newline. *)
-  Token := transpiler_lex(lexer);
+  token := transpiler_lex(lexer);
   written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
 
-  Token := transpiler_lex(lexer);
+  token := transpiler_lex(lexer);
   write_semicolon();
   WriteLn();
 
   (* Write the module body. *)
-  Token := transpiler_lex(lexer);
+  token := transpiler_lex(lexer);
   transpile_import_part(context, lexer);
   if transpile_constant_part(context, lexer) then
     WriteLn()
@@ -153,33 +153,33 @@ begin
 
   WriteString('END ');
 
-  Token := transpiler_lex(lexer);
+  token := transpiler_lex(lexer);
   written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
 
-  Token := transpiler_lex(lexer);
+  token := transpiler_lex(lexer);
   Write('.');
 
-  Token := transpiler_lex(lexer);
+  token := transpiler_lex(lexer);
   WriteLn()
 end;
 
 proc transpile_type_fields(context: PTranspilerContext,  lexer: PLexer);
 var
-  Token: LexerToken;
+  token: LexerToken;
   written_bytes: CARDINAL;
 begin
-  Token := transpiler_lex(lexer);
+  token := transpiler_lex(lexer);
 
-  while Token.Kind <> lexerKindEnd do
+  while token.kind <> lexerKindEnd do
     WriteString('    ');
     written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
-    Token := transpiler_lex(lexer);
+    token := transpiler_lex(lexer);
     WriteString(': ');
     transpile_type_expression(context, lexer);
-    Token := transpiler_lex(lexer);
+    token := transpiler_lex(lexer);
 
-    if Token.Kind = lexerKindSemicolon then
-      Token := transpiler_lex(lexer);
+    if token.kind = lexerKindSemicolon then
+      token := transpiler_lex(lexer);
       Write(';')
     end;
     WriteLn()
@@ -188,7 +188,7 @@ end;
 
 proc transpile_record_type(context: PTranspilerContext,  lexer: PLexer);
 var
-  Token: LexerToken;
+  token: LexerToken;
 begin
   WriteString('RECORD');
   WriteLn();
@@ -198,33 +198,33 @@ end;
 
 proc transpile_pointer_type(context: PTranspilerContext,  lexer: PLexer);
 var
-  Token: LexerToken;
+  token: LexerToken;
   written_bytes: CARDINAL;
 begin
-  Token := lexer_current(lexer);
+  token := lexer_current(lexer);
   WriteString('POINTER TO ');
-  if Token.Kind = lexerKindPointer then
-    Token := transpiler_lex(lexer)
+  if token.kind = lexerKindPointer then
+    token := transpiler_lex(lexer)
   end;
   transpile_type_expression(context, lexer)
 end;
 
 proc transpile_array_type(context: PTranspilerContext,  lexer: PLexer);
 var
-  Token: LexerToken;
+  token: LexerToken;
   written_bytes: CARDINAL;
 begin
   WriteString('ARRAY');
-  Token := lexer_current(lexer);
+  token := lexer_current(lexer);
 
-  if Token.Kind = lexerKindArray then
-    Token := transpiler_lex(lexer)
+  if token.kind = lexerKindArray then
+    token := transpiler_lex(lexer)
   end;
-  if Token.Kind <> lexerKindOf then
+  if token.kind <> lexerKindOf then
     WriteString('[1..');
-    Token := transpiler_lex(lexer);
+    token := transpiler_lex(lexer);
     written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
-    Token := transpiler_lex(lexer);
+    token := transpiler_lex(lexer);
     Write(']')
   end;
   WriteString(' OF ');
@@ -233,26 +233,26 @@ end;
 
 proc transpile_enumeration_type(context: PTranspilerContext,  lexer: PLexer);
 var
-  Token: LexerToken;
+  token: LexerToken;
   written_bytes: CARDINAL;
 begin
   WriteString('(');
   WriteLn();
   WriteString('    ');
 
-  Token := transpiler_lex(lexer);
+  token := transpiler_lex(lexer);
   written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
 
-  Token := transpiler_lex(lexer);
+  token := transpiler_lex(lexer);
 
-  while Token.Kind = lexerKindComma do
+  while token.kind = lexerKindComma do
     Write(',');
     WriteLn();
     WriteString('    ');
-    Token := transpiler_lex(lexer);
+    token := transpiler_lex(lexer);
     written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
 
-    Token := transpiler_lex(lexer)
+    token := transpiler_lex(lexer)
   end;
   WriteLn();
   WriteString('  )')
@@ -260,25 +260,25 @@ end;
 
 proc transpile_union_type(context: PTranspilerContext,  lexer: PLexer);
 var
-  Token: LexerToken;
+  token: LexerToken;
 end;
 
 proc transpile_procedure_type(context: PTranspilerContext,  lexer: PLexer);
 var
-  Token: LexerToken;
+  token: LexerToken;
   written_bytes: CARDINAL;
 begin
-  Token := transpiler_lex(lexer);
+  token := transpiler_lex(lexer);
   WriteString('PROCEDURE(');
 
-  Token := transpiler_lex(lexer);
+  token := transpiler_lex(lexer);
 
-  while Token.Kind <> lexerKindRightParen do
+  while token.kind <> lexerKindRightParen do
     written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
 
-    Token := transpiler_lex(lexer);
-    if Token.Kind = lexerKindComma then
-      Token := transpiler_lex(lexer);
+    token := transpiler_lex(lexer);
+    if token.kind = lexerKindComma then
+      token := transpiler_lex(lexer);
       WriteString(', ')
     end
   end;
@@ -287,43 +287,43 @@ end;
 
 proc transpile_type_expression(context: PTranspilerContext,  lexer: PLexer);
 var
-  Token: LexerToken;
+  token: LexerToken;
   written_bytes: CARDINAL;
 begin
-  Token := transpiler_lex(lexer);
-  if Token.Kind = lexerKindRecord then
+  token := transpiler_lex(lexer);
+  if token.kind = lexerKindRecord then
     transpile_record_type(context, lexer)
   end;
-  if Token.Kind = lexerKindLeftParen then
+  if token.kind = lexerKindLeftParen then
     transpile_enumeration_type(context, lexer)
   end;
-  if (Token.Kind = lexerKindArray) or (Token.Kind = lexerKindLeftSquare) then
+  if (token.kind = lexerKindArray) or (token.kind = lexerKindLeftSquare) then
     transpile_array_type(context, lexer)
   end;
-  if Token.Kind = lexerKindHat then
+  if token.kind = lexerKindHat then
     transpile_pointer_type(context, lexer)
   end;
-  if Token.Kind = lexerKindProc then
+  if token.kind = lexerKindProc then
     transpile_procedure_type(context, lexer)
   end;
-  if Token.Kind = lexerKindIdentifier then
+  if token.kind = lexerKindIdentifier then
     written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start)
   end
 end;
 
 proc transpile_type_declaration(context: PTranspilerContext,  lexer: PLexer);
 var
-  Token: LexerToken;
+  token: LexerToken;
   written_bytes: CARDINAL;
 begin
   WriteString('  ');
-  Token := lexer_current(lexer);
+  token := lexer_current(lexer);
   written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
 
-  Token := transpiler_lex(lexer);
+  token := transpiler_lex(lexer);
   WriteString(' = ');
   transpile_type_expression(context, lexer);
-  Token := transpiler_lex(lexer);
+  token := transpiler_lex(lexer);
   write_semicolon();
 end;
 
@@ -333,12 +333,12 @@ var
 begin
   token := lexer_current(lexer);
 
-  if token.Kind = lexerKindType then
+  if token.kind = lexerKindType then
     WriteString('TYPE');
     WriteLn();
     token := transpiler_lex(lexer);
 
-    while token.Kind = lexerKindIdentifier do
+    while token.kind = lexerKindIdentifier do
       transpile_type_declaration(context, lexer);
       token := transpiler_lex(lexer)
     end;
@@ -348,42 +348,42 @@ end;
 
 proc transpile_variable_declaration(context: PTranspilerContext,  lexer: PLexer);
 var
-  Token: LexerToken;
+  token: LexerToken;
   written_bytes: CARDINAL;
 begin
   WriteString('  ');
-  Token := lexer_current(lexer);
+  token := lexer_current(lexer);
   written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
 
-  Token := transpiler_lex(lexer);
+  token := transpiler_lex(lexer);
   WriteString(': ');
   transpile_type_expression(context, lexer);
-  Token := transpiler_lex(lexer);
+  token := transpiler_lex(lexer);
   write_semicolon()
 end;
 
-proc transpile_variable_part(context: PTranspilerContext,  lexer: PLexer): BOOLEAN;
+proc transpile_variable_part(context: PTranspilerContext,  lexer: PLexer) -> BOOLEAN;
 var
-  Token: LexerToken;
+  token: LexerToken;
   result: BOOLEAN;
 begin
-  Token := lexer_current(lexer);
-  result := Token.Kind = lexerKindVar;
+  token := lexer_current(lexer);
+  result := token.kind = lexerKindVar;
 
   if result then
     WriteString('VAR');
     WriteLn();
-    Token := transpiler_lex(lexer);
+    token := transpiler_lex(lexer);
 
-    while Token.Kind = lexerKindIdentifier do
+    while token.kind = lexerKindIdentifier do
       transpile_variable_declaration(context, lexer);
-      Token := transpiler_lex(lexer)
+      token := transpiler_lex(lexer)
     end
   end;
   return result
 end;
 
-proc transpile_procedure_heading(context: PTranspilerContext, lexer: PLexer): LexerToken;
+proc transpile_procedure_heading(context: PTranspilerContext, lexer: PLexer) -> LexerToken;
 var
   token: LexerToken;
   result: LexerToken;
@@ -398,7 +398,7 @@ begin
   Write('(');
 
   token := transpiler_lex(lexer);
-  while token.Kind <> lexerKindRightParen do
+  while token.kind <> lexerKindRightParen do
     written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
 
     token := transpiler_lex(lexer);
@@ -407,7 +407,7 @@ begin
     transpile_type_expression(context, lexer);
 
     token := transpiler_lex(lexer);
-    if (token.Kind = lexerKindSemicolon) or (token.Kind = lexerKindComma) then
+    if (token.kind = lexerKindSemicolon) or (token.kind = lexerKindComma) then
       WriteString('; ');
       token := transpiler_lex(lexer)
     end
@@ -416,7 +416,7 @@ begin
   token := transpiler_lex(lexer);
 
   (* Check for the return type and write it. *)
-  if token.Kind = lexerKindColon then
+  if token.kind = lexerKindArrow then
     WriteString(': ');
     token := transpiler_lex(lexer);
     written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
@@ -428,28 +428,28 @@ begin
   return result
 end;
 
-proc transpile_expression(context: PTranspilerContext,  lexer: PLexer,  TrailingToken: LexerKind);
+proc transpile_expression(context: PTranspilerContext,  lexer: PLexer, trailing_token: LexerKind);
 var
   token: LexerToken;
   written_bytes: CARDINAL;
 begin
   token := transpiler_lex(lexer);
 
-  while (token.Kind <> TrailingToken) & (token.Kind <> lexerKindEnd) do
+  while (token.kind <> trailing_token) & (token.kind <> lexerKindEnd) do
     written_bytes := 0;
-    if token.Kind = lexerKindNull then
+    if token.kind = lexerKindNull then
       WriteString('NIL ');
       written_bytes := 1
     end;
-    if token.Kind = lexerKindOr then
+    if token.kind = lexerKindOr then
       WriteString('OR ');
       written_bytes := 1
     end;
-    if token.Kind = lexerKindAnd then
+    if token.kind = lexerKindAnd then
       WriteString('AND ');
       written_bytes := 1
     end;
-    if token.Kind = lexerKindNot then
+    if token.kind = lexerKindNot then
       WriteString('NOT ');
       written_bytes := 1
     end;
@@ -478,7 +478,7 @@ end;
 
 proc transpile_while_statement(context: PTranspilerContext,  lexer: PLexer);
 var
-  Token: LexerToken;
+  token: LexerToken;
   written_bytes: CARDINAL;
 begin
   WriteString('  WHILE ');
@@ -488,7 +488,7 @@ begin
   WriteLn();
   transpile_statements(context, lexer);
   WriteString('  END');
-  Token := transpiler_lex(lexer)
+  token := transpiler_lex(lexer)
 end;
 
 proc transpile_assignment_statement(context: PTranspilerContext,  lexer: PLexer);
@@ -499,27 +499,72 @@ end;
 
 proc transpile_call_statement(context: PTranspilerContext,  lexer: PLexer);
 var
-  Token: LexerToken;
+  token: LexerToken;
   written_bytes: CARDINAL;
 begin
   WriteString('(');
-  Token := transpiler_lex(lexer);
+  token := transpiler_lex(lexer);
 
-  while (Token.Kind <> lexerKindSemicolon) & (Token.Kind <> lexerKindEnd) do
+  while (token.kind <> lexerKindSemicolon) & (token.kind <> lexerKindEnd) do
     written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
-    Token := transpiler_lex(lexer)
+    token := transpiler_lex(lexer)
   end
 end;
 
-proc transpile_return_statement(context: PTranspilerContext,  lexer: PLexer);
+proc transpile_designator_expression(context: PTranspilerContext, lexer: PLexer);
 var
-  Token: LexerToken;
+  token: LexerToken;
+  written_bytes: CARDINAL;
+begin
+  WriteString('  ');
+  written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
+  token := transpiler_lex(lexer);
+
+  while token.kind = lexerKindLeftSquare do
+    Write('[');
+    token := transpiler_lex(lexer);
+    while token.kind <> lexerKindRightSquare do
+      written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
+      token := transpiler_lex(lexer)
+    end;
+    Write(']');
+    token := transpiler_lex(lexer)
+  end;
+  if token.kind = lexerKindHat then
+    Write('^');
+    token := transpiler_lex(lexer)
+  end;
+  if token.kind = lexerKindDot then
+    Write('.');
+    token := transpiler_lex(lexer);
+    written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
+    token := transpiler_lex(lexer)
+  end;
+  if token.kind = lexerKindHat then
+    Write('^');
+    token := transpiler_lex(lexer)
+  end;
+  while token.kind = lexerKindLeftSquare do
+    Write('[');
+    token := transpiler_lex(lexer);
+    while token.kind <> lexerKindRightSquare do
+      written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
+      token := transpiler_lex(lexer)
+    end;
+    Write(']');
+    token := transpiler_lex(lexer)
+  end
+end;
+
+proc transpile_return_statement(context: PTranspilerContext, lexer: PLexer);
+var
+  token: LexerToken;
   written_bytes: CARDINAL;
 begin
   WriteString('  RETURN ');
-  Token := transpiler_lex(lexer);
+  token := transpiler_lex(lexer);
   written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
-  Token := transpiler_lex(lexer)
+  token := transpiler_lex(lexer)
 end;
 
 proc transpile_statement(context: PTranspilerContext,  lexer: PLexer);
@@ -529,59 +574,23 @@ var
 begin
   token := transpiler_lex(lexer);
 
-  if token.Kind = lexerKindIf then
+  if token.kind = lexerKindIf then
     transpile_if_statement(context, lexer)
   end;
-  if token.Kind = lexerKindWhile then
+  if token.kind = lexerKindWhile then
     transpile_while_statement(context, lexer)
   end;
-  if token.Kind = lexerKindReturn then
+  if token.kind = lexerKindReturn then
     transpile_return_statement(context, lexer)
   end;
-  if token.Kind = lexerKindIdentifier then
-    WriteString('  ');
-    written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
-    token := transpiler_lex(lexer);
+  if token.kind = lexerKindIdentifier then
+    transpile_designator_expression(context, lexer);
+    token := lexer_current(lexer);
 
-    while token.Kind = lexerKindLeftSquare do
-      Write('[');
-      token := transpiler_lex(lexer);
-      while token.Kind <> lexerKindRightSquare do
-        written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
-        token := transpiler_lex(lexer)
-      end;
-      Write(']');
-      token := transpiler_lex(lexer);
-    end;
-    if token.Kind = lexerKindHat then
-      Write('^');
-      token := transpiler_lex(lexer)
-    end;
-    if token.Kind = lexerKindDot then
-      Write('.');
-      token := transpiler_lex(lexer);
-      written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
-      token := transpiler_lex(lexer);
-    end;
-    if token.Kind = lexerKindHat then
-      Write('^');
-      token := transpiler_lex(lexer)
-    end;
-    while token.Kind = lexerKindLeftSquare do
-      Write('[');
-      token := transpiler_lex(lexer);
-      while token.Kind <> lexerKindRightSquare do
-        written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
-        token := transpiler_lex(lexer)
-      end;
-      Write(']');
-      token := transpiler_lex(lexer);
-    end;
-
-    if token.Kind = lexerKindAssignment then
+    if token.kind = lexerKindAssignment then
       transpile_assignment_statement(context, lexer)
     end;
-    if token.Kind = lexerKindLeftParen then
+    if token.kind = lexerKindLeftParen then
       transpile_call_statement(context, lexer)
     end
   end
@@ -589,15 +598,15 @@ end;
 
 proc transpile_statements(context: PTranspilerContext,  lexer: PLexer);
 var
-  Token: LexerToken;
+  token: LexerToken;
 begin
-  Token := lexer_current(lexer);
+  token := lexer_current(lexer);
 
-  while Token.Kind <> lexerKindEnd do
+  while token.kind <> lexerKindEnd do
     transpile_statement(context, lexer);
-    Token := lexer_current(lexer);
+    token := lexer_current(lexer);
 
-    if Token.Kind = lexerKindSemicolon then
+    if token.kind = lexerKindSemicolon then
       Write(';')
     end;
     WriteLn()
@@ -606,10 +615,10 @@ end;
 
 proc transpile_statement_part(context: PTranspilerContext,  lexer: PLexer);
 var
-  Token: LexerToken;
+  token: LexerToken;
 begin
-  Token := lexer_current(lexer);
-  if Token.Kind = lexerKindBegin then
+  token := lexer_current(lexer);
+  if token.kind = lexerKindBegin then
     WriteString('BEGIN');
     WriteLn();
     transpile_statements(context, lexer)
@@ -618,43 +627,43 @@ end;
 
 proc transpile_procedure_declaration(context: PTranspilerContext,  lexer: PLexer);
 var
-  Token: LexerToken;
+  token: LexerToken;
   seen_part: BOOLEAN;
   written_bytes: CARDINAL;
 begin
-  Token := transpile_procedure_heading(context, lexer);
+  token := transpile_procedure_heading(context, lexer);
   seen_part := transpile_constant_part(context, lexer);
   seen_part := transpile_variable_part(context, lexer);
   transpile_statement_part(context, lexer);
 
   WriteString('END ');
-  written_bytes := WriteNBytes(StdOut, ORD(Token.identifierKind[1]), ADR(Token.identifierKind[2]));
+  written_bytes := WriteNBytes(StdOut, ORD(token.identifierKind[1]), ADR(token.identifierKind[2]));
 
-  Token := transpiler_lex(lexer);
+  token := transpiler_lex(lexer);
   write_semicolon();
-  Token := transpiler_lex(lexer)
+  token := transpiler_lex(lexer)
 end;
 
 proc transpile_procedure_part(context: PTranspilerContext,  lexer: PLexer);
 var
-  Token: LexerToken;
+  token: LexerToken;
 begin
-  Token := lexer_current(lexer);
+  token := lexer_current(lexer);
 
-  while Token.Kind = lexerKindProc do
+  while token.kind = lexerKindProc do
     transpile_procedure_declaration(context, lexer);
-    Token := lexer_current(lexer);
+    token := lexer_current(lexer);
     WriteLn()
   end
 end;
 
 proc transpile(lexer: PLexer);
 var
-  Token: LexerToken;
+  token: LexerToken;
   written_bytes: CARDINAL;
-  Context: TranspilerContext;
+  context: TranspilerContext;
 begin
-  transpile_module(ADR(Context), lexer)
+  transpile_module(ADR(context), lexer)
 end;
 
 end Transpiler.