This is how M2 people thinking about M3

[ghost]

https://lists.gnu.org/archive/html/gm2/2025-10/msg00005.html

I heard about M2 before M3. I watch the gm2 mailing list but have never tried M2. This thread is what making me want to try M3, as M3 seems to be more interesting than M2.

[VictorMiasnikov]

} M3 seems to be more interesting than M2.

It's possible . . . But let's go to practice:

Do you have a Modula-2 to Modula-3 converter, m2tom3?

(
URL (as usual on "my branch"):

https://github.com/VictorMiasnikov/cm3/releases/tag/d5.11.9-ZZYYXX-20251001_00-00
in sub-folder:
m3-tools\m2tom3

)

P.S.

} https://lists.gnu.org/archive/html/gm2/2025-10/msg00005.html

Benjamin Kowarsch . . . Future Modula-2 R10 . . .

[VictorMiasnikov]

Are You seeing Issue #1198 about the Modula-3 IDEA IntelliJ plugin?

P.S. I have seen (and read) h-t--t-ps://gi-t-hub.com/SpartanJ/ecode/issues/693

(

on Apr 15, 2024 

(
h-t-tps://gi-t-hub.com/SpartanJ/ecode/issues/251#issue-2243207721
)

List of text editors support Modula-3:

https://github.com/modula3/cm3/discussions/1130

Scintillua lexers for Modula-2 and Modula-3:

https://github.com/paaguti/textadept-modula-lexers

It's not the normal Makefile, as it's written in a completely different scripting language.

I know nothing about the language. I can't find any documentation.

( . . .)

I don't know the full list of keywords on this language, but it seems to be a simple language.

Making everything of the form something( and something ( as functions is a good starting point IMO.

The fact is you can't write Modula 3 without m3makefile based on my research. Like ELENA (with the .prj and .cfg files), Modula 3 does all of the preprocessing via m3makefile. This is very different from C/C++ that all of the preprocessing is done on source files.

I think this is a good addition to https://github.com/SpartanJ/ecode/issues/251.

)

[OrlandoDiLasso]

Unless you do maintenance or development work on the Modula3 compiler, there
is no need to understand but a very small subset of quake. But just in
case, I found www.modula3.com/cm3/doc/help/cm3/quake.html. This is a long-
unmaintained site, but I believe the contents have not changed in even longer.
I guess we need to get all these onto github. I have local copies, if needed.

For straightforward cases, there is no necessity to write an m3makefile
at all. The CM3 compiler will, if it does not find a file named "m3makefile"
in the same "src" directory that the compiler is run in, will attempt to
infer what to do from the presence of Modula3 source files named "*.[im][g3]"
in the "src" directory. I don't know of any documentation of just what it
will and won't handle. Probably not an interface exported by >1 module
or a module exporting >1 interface. Also not use of previously compiled
libraries.

Otherwise, an m3makefile needs to be present. Its contents are Quake code,
but only Quake calls on a compiler-provided library of Quake functions.
Strictly, Quake is an imperative language, but these functions are coded
to behave decoratively. You can find their documentation in
www.modula3.com/cm3/doc/help/cm3/m3build/m3build.html and others it links
t

[VictorMiasnikov]

https://lists.gnu.org/archive/html/gm2/2025-10/msg00005.html

I heard about M2 before M3. I watch the gm2 mailing list but have never tried M2. This thread is what making me want to try M3, as M3 seems to be more interesting than M2.

https://freepages.modula2.org/forml.html
= =
Other groups
There is a Telegram Modula-2 group. The implementation of Modula-2 R10 is for example discussed there as well as general topics related to Modula-2.
= =

Benjamin Kowarsch say:
https://t.me/c/2345663232/3926
= =
I am not sure if it is correct to say (in the title) that this is how Modula-2 people think of Modula-3.
It is my personal opinion and there are no other responses on the GM2 mailing list.
We don’t know what the other people think.
= =

[OrlandoDiLasso]

I have used the m2tom2 source code converter several times. It only does syntactic-level translation, but that saves
a lot of tedious editing. The only thing I would call bordering on semantic is it swaps the parameters to VAL. Some
amount of subsequent changing will be needed. The way a function returns its result is an example. Another lies ijn
the way M3 handles the controlled variable of FOR. The translation might work, but not if the M2 code uses it after the
loop has completed. In any case, you will want to delete the separate declaration of it to avoid setting a subtle
mine-trap for maintainers.

The most difficult conversion I have done was with portions of the Cocktail toolbox, because the M2 code did a lot of unsafe stuff. Just getting it to work is only part of the job. It really ought to be recoded to take advantage of M3's
heap allocation, garbage collection, open arrays, etc.

[VictorMiasnikov]

I have used the m2tom3 source code converter several times. It only does syntactic-level translation, but that saves a lot of tedious editing. The only thing I would call bordering on semantic is it swaps the parameters to VAL. Some amount of subsequent changing will be needed. The way a function returns its result is an example. Another lies ijn the way M3 handles the controlled variable of FOR. The translation might work, but not if the M2 code uses it after the loop has completed. In any case, you will want to delete the separate declaration of it to avoid setting a subtle mine-trap for maintainers.

The most difficult conversion I have done was with portions of the Cocktail toolbox, because the M2 code did a lot of unsafe stuff. Just getting it to work is only part of the job. It really ought to be recoded to take advantage of M3's heap allocation, garbage collection, open arrays, etc.

1)

m2tom3 use WHILE instead of FOR by default

( TODO: add details)

2)

There is translated to English
https://habr.com/ru/posts/910126/

Advantages of implementing the FOR loop in Modula-3

The FOR loop in Modula-3 has been significantly improved compared to its counterparts in Pascal and Modula-2. These changes made it safer, more flexible, and easier to develop with. Here are the key advantages:

1. Flexibility of range and step
   In Modula-3, the FOR loop allows arbitrary start, end values, and step, not only ±1 as in Pascal.
   Example:

text
FOR i := 10 TO 1 BY -2 DO
  ...  // countdown with step -2
END;

This simplifies iterations with non-standard steps, which is especially useful in scientific computing or data processing.

2. Local scope of the loop variable
   The loop variable is declared directly in the FOR construct, limiting its scope to the loop body. This prevents accidental name conflicts and reduces the risk of errors.
   Example:

text
FOR i := 1 TO 10 DO
  ...  // variable i exists only here
END;

3. Protection from modifying the loop variable
   The loop variable inside the body is read-only. It cannot be changed, eliminating common errors found in Pascal and Modula-2.

text
FOR i := 1 TO 5 DO
  i := 10;  // Compilation error: assignment not allowed
END;

4. Support for various data types
   The FOR loop in Modula-3 works not only with integers but also with other types such as:

• Enumerated types (ENUM).

• Subrange types (e.g., subranges [1..10]).

• Even characters (CHAR), if meaningful.
  Example with enumeration:

text
TYPE Color = {Red, Green, Blue};
FOR c := FIRST(Color) TO LAST(Color) DO
  ...  // iterating over all elements of the enumeration
END;

5. Safety and type checking
   Modula-3 strictly checks loop bounds at compile time. If the start value exceeds the end value with a positive step (or vice versa), the loop does not run, preventing infinite loops or runtime errors.

6. Improved readability
   The FOR syntax in Modula-3 is more expressive, especially working with arrays or lists. For example:

text
FOR i := 0 TO LAST(a) DO
  a[i] := ...  // explicit array traversal
END;

This makes code clearer than using WHILE loops.

Comparison with other languages

Feature | Pascal/Modula-2 | Ada | Modula-3 -- | -- | -- | -- Step size | Restricted to ±1 | Flexible | Flexible Loop variable modifiability | Can be modified inside loop body | Read-only | Read-only Behavior after loop | Undefined | Well-defined | Well-defined Safety features | Limited | Strong | Strong, inspired by Ada Syntax complexity | Simple but less safe | Complex | Simple yet safe

Summary
The FOR loop in Modula-3 combines flexibility, safety, and expressiveness. Its implementation reflects the language’s overall principles: strict type control, error minimization, and developer convenience. This makes Modula-3 an excellent choice for tasks where reliability and code readability are critical.

P.S, Known issue: table is broken

[VictorMiasnikov]

Comparison with other languages:

Pascal/Modula-2:

• Limited by a step of ±1.
• The loop variable can be modified inside the body.
• Undefined behavior after the loop ends.

Ada:

• Modula-3 borrowed many safety principles from Ada (for example, protection of the loop variable), but maintained simplicity in its syntax.