x++;
Useless!!!
You cant do
But you could do it C-style
while x++ < 10 do ...
while ++x < 10 do ...
while x-- > 0 do ...
while --x > 0 do ...
Maybe Inc() should return the incremented value? In C, x++ returns the value of x and then increments it, while ++x first increments the value and then returns the incremented value. What variant should Inc() follow? I know: none! 
That works in C or C++, because there
statements also return a value. In Pascal they do not. So if C/C++ would not provide that, then those examples of yours would not work either.
One think that Pascal are less user 'cause missing some C / C++ features and the other think that Pascal should compile and support C++ syntax and operators 'cause it will works better ?
Programming languages are living languages, they develop new features incorporate features from other languages. This is how languages work and how they have always worked.
But that does not mean that a programming language needs to have
every feature under the sun or - even more importantly - implemented as a direct copy-paste of some other language. Like attributes which Delphi simply copied from C#... 🙄 If it can't be implemented in a way that corresponds with how Pascal is designed (namely with readability and clarity being important) then it's better not implemented at all.
Take any feature from Pascal you like and most likely it was taken from another language.
I haven't seen that many (old) languages that have an integrated set type.
- In haskell I can write pass operators the same way as functions:
sort (<) myList # call sort to use the < operator for the sorting
Operators are simply not first class functions in Pascal, thus something like this will simply not be done.
- In java if I have a datatype and just want a basic constructor that initializes all of the values I can write:
@AllArgsConstructor
class MyClass {
public int i;
public string s;
// Automatically generates a constructor that takes an integer to set i and a string to set s
}
Something like this is mainly useful for records and there it would be better to implement Extended Pascal's support for true record constants (and thus the ability to use them inline).
- In Go or Haskell I have compiletime interfaces for generic types, which enforce a generic type to have certain methods:
myFunc :: Ord a => a -> a# the generic type a needs to be an ordinal
I indeed have plans for improving generic constraints.
- Languages like Go and Erlang have language level concurrency:
func foo() { msg <- "result" }
...
go foo(); // Run foo asynchronously
fmt.Println(<- msg); // Receive message from foo
The question is whether language level concurrency is
really important to have. But in this case one
could take inspiration from
Concurrent Pascal though I personally would simply prefer to port the
OmniThreadLibrary.
- LUA allows functions to return multiple values as tuples and to easily unpack what you need:
first, _, third, remainder = myFunc();
// first and third are elements from the tuple, second element is ignored and remainder is a tuple of all the rest
Implementing a tuple type including constructors and destructors is something I have somewhere on my ToDo list.
- Python allows a while ... else statement:
while x>0:
// Loop
else:
// x<=0 from the beginning
In Python this wouldn't be a problem, but in Pascal you would get into problems with existing code that combines
if … then … else … together with a
while … do inside the
then-branch.
- Javascript or python allow to write enumerators using a generator syntax:
function *fibbonacci() {
let p1 = 0;
let p2 = 1;
while (true) {
let result = p1 + p2;
p1 = p2;
p2 = result;
yield result;
}
}
for (let i of fibbonacci()) console.log(i); // 1, 2, 3, 5, 8, etc
While conceptually I find the concept of generators intriguing I also find them rather confusing considering
how they work.
- C#, Javascript or Python have language level co-routines
async void myFunc() {
var result = await otherFunc();
}
That would be something one
could think about as well. But on the other hand this can also be simply done by a library... Again, not everything that
can be done as part of the
language needs to be done as part of the language. It can just as well be done as part of some code.
That's one of the major design decisions of C++, to give the user as much control for optimizing their code as possible. C++ is inherently designed to give the programmer the ability to write code that allows the generation of the most efficient assembly and all features in the language are designed around performance.
And that is simply
not a major design decision of Pascal. Simplicity, Readability, Maintainability are more important. If you can simply look at the code and understand what it's doing then that is more important than squeezing every last bit of performance out of it. And already some features like operator overloading are counter intuitive to that (or at least they can be if they're abused by the users).
Poll
WIKI Timeout issues
