PascalABC.NET

PascalABC.NET

Paradigm	Multi-paradigm:procedural,functional,object-oriented,generic
Designed by	PascalABC.NET Compiler Team
First appeared	2007(2007)
Stable release	3.8.3.3255 / 4 April 2023(2023-04-04)
Typing discipline	Static,partially inferred
Implementation language	PascalABC.NET
OS	Cross-platform
License	LGPLv3
Filename extensions	.pas
Website	pascalabc.net/en
Influenced by
Delphi,Pascal,Oxygene,C#,Python,Kotlin,Haskell

PascalABC.NETis ahigh-levelgeneral-purposeprogramming languagesupporting multiple paradigms. PascalABC.NET is based onDelphi'sObject Pascal,but also has influences fromC#,Python,Kotlin,andHaskell.It is distributed both as a command-line tool for Windows (.NETframework), Linux and MacOS (Mono), and with anintegrated development environmentfor Windows and Linux, including interactive debugger,IntelliSensesystem,form designer,code templates and code auto-formatting.

PascalABC.NET is implemented for the.NETframework platform, so that it is compatible with all.NET libraries and utilizes all the features ofCommon Language Runtime,such asgarbage collection,exception handling,andgenerics.Some language constructions, e.g. tuples, sequences, and lambdas, are based on regular.NET types. PascalABC.NET is ideologically close toOxygene,but unlike it, provides high compatibility withDelphi.

History of PascalABC.NET

PascalABC.NET was developed by a group of enthusiasts at the Institute of Mathematics, Mechanics, and Computer Science in Rostov-on-Don, Russia.In 2003, a predecessor of the modern PascalABC.NET, called Pascal ABC, was implemented by associate professor Stanislav Mikhalkovich to be used for teaching schoolchildren instead ofTurbo Pascal,which became outdated and incompatible with modern operating systems but was still used for educational purposes. Pascal ABC was implemented as aninterpreted programming language,that led to a significant lack of performance. Four years after that it was completely rewritten by students Ivan Bondarev, Alexander Tkachuk, and Sergey Ivanov as acompiled programming languagefor the.NET platform. In 2009, PascalABC.NET started to be actively used for teaching high school students. By 2015, the number of users of the language had increased significantly. It began to be actively used throughout Russia in schools and at programming contests, surpassingFree Pascal.Since then, the PascalABC.NET developers have set themselves the goal of actively incorporating modern features into the language. In the same year, PascalABC.NET became an open source project distributed under theGNU Lesser General Public License(LGPLv3).

In 2017and 2022,independent audit ofPascalABC.NET public repositorywas conducted. Based on the results of the static check, potentially dangerous code fragments were listed that require additional analysis by developers. It was also noted that the overall quality of the code could be improved. To do this, code duplication and redundant checks should be eliminated, and refactoring should be performed more carefully.

Use in school and higher education

Designed for education, PascalABC.NET remains the most common programming language in Russian schools and one of the recommended languages for passing theUnified State Examon informatics.In the Southern Federal University, it is used as the first language for teaching students majoring in computer science, and for teaching children in one of the largest computer schools in Russia.PascalABC.NET is widely used as a basic programming language in pedagogical universities for the training of computer science teachers.It also serves as a tool for scientific computing.PascalABC.NET is also built into a number of validation systems used for programming competitions.

In 2020, during anti-COVID lockdowns and home schooling period, PascalABC.NET website was ranked 3^rdin Yandex traffic rating in the "Programming" category, and the number of downloads of the installation kit exceeded 10000 a day.

Though the core of the PascalABC.NET community is located in Russia, the language is also known in other countries such as Belarus,Romania,Indonesia,Algeria.

Language syntax

Differences between Delphi and PascalABC.NET

New features

•loopstatement

loop10do
Write('*');

•forloop with a step

forvari:=1to20step2do
Print(i);

•foreachloop with an index

foreachvarcinArr('a'..'z')indexido
ifimod2=0then
Print(c);

•a..branges

(1..10).Printlines

•short function definition syntax

functionSum(a,b:real):=a+b;

•method implementation can be placed inside a class definition

typePoint=class
x,y:real;
procedureOutput;
begin
Print(x,y);
end;
end;

•sequence of Ttype as an abstraction of arrays, lists and sets

varseq:sequenceofinteger:=Arr(1..10);
seq.Println;
seq:=Lst(11..100);seq.Println;
seq:=HSet(1..20);seq.Println;

•lambda functions

vara:=ArrGen(10,i->i*i);

•auto classes - classes with an automatically generated constructor

typePoint=autoclass
x,y:real;
end;
varp:=newPoint(2,5);

•one-dimensional and multi-dimensional array slices

varm:array[,]ofinteger:=MatrGen(3,4,(i,j)->i+j+1);
Println(m);// [[1,2,3,4],[2,3,4,5],[3,4,5,6]]
Println(m[:2,1:3]);// [[2,3],[3,4]]

Some other features such as inline variable declarations, type inference, andforstatement with a variable declaration are standard in the current version of Delphi. However, PascalABC.NET pioneered these features in 2007,while in Delphi they were implemented in 2018.

Changed features

• strings incasestatements
• sets based on arbitrary type:set of string
• constructors can be invoked withnew T(...)syntax
• type extension methods instead of class helpers
• modules can be defined in a simplified form (withoutinterfaceandimplementationsections)

Not implemented features

• records with variant parts
• open arrays
• nested class definitions
• inline assembly code

Functional style features

In PascalABC.NET, functions arefirst-class objects.They can be assigned to variables, passed as parameters, and returned from other functions. Functional type is set in the formT -> Res.Ananonymous functioncan be assigned to the variable of this type:

##// denotes that the main program will be written without enclosing begin-end
varf:real->real:=x->x*x;

Here is an example ofsuperpositionof two functions:

##
functionSuper<T,T1,T2>(f:T1->T2;g:T->T1):T->T2:=x->f(g(x));

varf:real->real:=x->x*x;
varfg:=Super(f,Sin);
vargf:=Super(Sin,f);

Print(fg(2));
Print(gf(2));

Superposition operation is defined in the standard library:

##
varf:real->real:=x->x*x;

Print((f*Cos)(2));
Print((Cos*f)(2));

In the book "How To Program Effectively In Delphi"and in the corresponding video tutorials,Dr. Kevin Bond, a programmer and a Computer Science teaching specialist,notes that PascalABC.NET has powerful functional programming capabilities which are missing in Delphi. As an example,partial function applicationis demonstrated:

begin
varf:integer->integer->integer:=x->y->x+y;
Writeln(f(2)(6));
end.

Code examples

PascalABC.NET is a multi-paradigm programming language. It allows one to use different coding styles from oldschool Pascal to functional and object-oriented programming. The same task can be solved in different styles as follows:

Usual PascalABC.NET style

begin
var(a,b):=ReadInteger2;// read input into tuple of two variables
varsum:=0;// type auto-inference
forvari:=atobdo
sum+=i*i;
Print($'Sum = {sum}')// string interpolation
end.

Procedural style

functionSumSquares(a,b:integer):integer;
begin
Result:=0;
forvari:=atobdo
Result+=i*i
end;

begin
var(a,b):=ReadInteger2;
Print($'Sum = {SumSquares(a,b)}')
end.

Functional style

This solution uses.NET extension methods for sequences and PascalABC.NET-specific range(a..b).

begin
var(a,b):=ReadInteger2;
(a..b).Sum(x->x*x).Print// method chaining with lambda expressions
end.

Object-oriented style

This solution demonstrates PascalABC.NET-specific short function definition style.

typeAlgorithms=class
staticfunctionSumSquares(a,b:integer):=(a..b).Sum(x->x*x);
staticfunctionSumCubes(a,b:integer):=(a..b).Sum(x->x*x*x);
end;

begin
var(a,b):=ReadInteger2;
Println($'Squares sum = {Algorithms.SumSquares(a,b)}');
Println($'Cubes sum = {Algorithms.SumCubes(a,b)}')
end.

Close to regular C# style

It is possible to write programs without usage of PascalABC.NET standard library. All standard.NET Framework classes and methods can be used directly.

usesSystem;// using.NET System namespace
begin
vararr:=Console.ReadLine.Split(
newchar[](' '),
StringSplitOptions.RemoveEmptyEntries
);
var(a,b):=(integer.Parse(arr[0]),integer.Parse(arr[1]));
varsum:=0;
forvari:=atobdo
sum+=i*i;
Console.WriteLine($'Sum = {sum}')
end.

Criticism

Though PascalABC.NET is actively used for teacher training,some members of the teaching community ignore difference between historically used Turbo Pascal and PascalABC.NET, criticizing some unspecified "Pascal" language for being far from modern programming, too wordy and not simple enough to be used as the first programming language.They consider Python to be the best starting point, as it is more concise and practically applicable. Their opponents, including PascalABC.NET developers themselves, argue that it is incorrect to put an equal sign between the classic Pascal and PascalABC.NET, as the latter contains lots of modern multi-paradigm features, including the ones from Python.PascalABC.NET allows students to write as concise and expressive programs as Python,and acts as a "bridge to production programming" by applying a static typing concept.PascalABC.NET is also a compilable language, which makes it easier to learn programming, because all semantic errors are caught at compile time rather than occur unpredictably at runtime.

External links

• Official website
• PascalABC.NETonGitHub
• Official Telegram ChannelPascalABC.NET