specification

Great, thanks! There are books online for free, e.g. https://people.inf.ethz.ch/wirth/ProgInOberonWR.pdf and https://ssw.jku.at/Research/Books/Oberon2.pdf Oberon+ is a superset of Oberon 90 and Oberon-2. Here is more information: https://oberon-lang.github.io/, and here is the current language specification: https://github.com/oberon-lang/specification/blob/master/The.... I already had valuable feedback here on HN concerning the channel extensions. Further research brought me to the conclusion, that Oberon+ should support both, channels and also monitors, because even in Go, the sync package primitives are used twice as much as channels. Mutexes and condition variables can be emulated with channels (I tried my luck here: https://www.quora.com/How-can-we-emulate-mutexes-and-conditi...), but for efficiency reasons I think monitors should be

> Presumably one could have multiple SEND and/or RECEIVE function clauses in the WITH statement, so acting as an equivalent to the Go Select? Correct. Here is the specification: https://github.com/oberon-lang/specification/blob/master/The.... You can have an unlimited number of guards. > What would ELSE do? It it acting the same as the default clause in a Go select, i.e. allowing for a non-blocking call? Correct, that's the idea. > how would one detect a closed channel when the RECEIVE clause hits? EDIT: I added yet another build-in procedure which returns the closed state of a channel. A blocking WITH would continue if no channel was ready to communicate, but at least one was closed.

Oberon+ already has generics and they should play well with my present proposal: https://github.com/oberon-lang/specification/blob/master/The... > Most of the time people don't want unbounded and unknown lifetimes on the executors, but instead want to be able to see that directly in the code. You mean something like join? This can easily be done by adding a channel on which each thread of the interesting group sends when finished. Thanks for the link, I will have a look at it. EDIT: Ok, after looking through the referenced article I can confirm that it is about join and that there is a solution with channels as described. Unfortunately I don't have an example in Oberon yet, but here is one from my C library: https://github.com/rochus-keller/CspChan/blob/6867c1a28e1443.... What is called a "Nursery" in the article is just a procedure here

A proc is a function with no return. A function is a function that returns something. Oberon+ keeps it's predecessors' idiotic distinction, but takes it one step further: both functions and procedures are decalred with `proc` or `procedure`, functions are `proc`s that have a return type. And yet: - procedure calls don't have to specify parameters apparently, but function calls must specify all parameters - functions cannot be used in Oberon+'s weird exception handling. [1] You do a call with `PCALL(res, P, args)` where res is a variable that will hold the result of the exception if it happened, and P is the procedure. You cannot pass functions (aka procedures which have a return type) As the spec so wonderfully says [2], --- start quote --- There are two kinds of procedures: proper procedures and function procedures. The latter are activa

Oberon and Oberon+ are very interesting and are certainly a step forward from Pascal. Wish Oberon+ had moved forward a few more steps, like making everything an expression, for example, or more lax variable declaration rules (which probably require scoping rules changes). If only the FPC compiler supported it and allowed combining units in Oberon with Pascal ones in one project! The language specs: https://github.com/oberon-lang/specification/blob/master/The...

> Although the relative plethora of Oberon variants [..] suggests that maybe it was still not quite fully evolved. That's a reasonable conclusion, but one has to consider that most variants came from academia and focused on specific scientific questions, not on the adaptation to practical needs of the industry. > it would be possible to re-unify them under one standard, in the way that Common Lisp managed to do I did that with Oberon+ which unifies Oberon, Oberon-07 and Oberon-2. It also includes what I consider the best ideas of Component Pascal and Active Oberon (though I don't like the syntax of these two languages very much). See https://oberon-lang.github.io/2021/07/15/motivation-for-a-ne..., https://oberon-lang.github.io/2021/07/16/comparing-oberon+-w... and https://github.com/oberon-lang/specification/blob/master/The....

> ...from the point of definition to the end of the scope.. Not sure what you mean. Is it about the fact that all variables are declared in the header of the procedure, i.e. not somewhere in the body as e.g. in C# or Java? This is actually the same with Active Oberon and Modula-3. In case you mean that the order of declarations is relevant, Oberon+ assumes at least a two pass parser by design; a declaration sequence can contain more than one CONST, TYPE and VAR section in arbitrary order, interleaved with procedures, and the order of declaration is not relevant; see e.g. https://github.com/oberon-lang/specification/blob/master/The... and https://oberon-lang.github.io/2021/07/16/comparing-oberon+-w...

Here is an example: https://oberon-lang.github.io/, see section Generic Programming; note how the modules have type parameters and how generic module is instantiated by the import declaration in the example of section Object Oriented Programming. Here is the specification: https://github.com/oberon-lang/specification/blob/master/The... Here is a discussion why it is designed like this: https://oberon-lang.github.io/2021/07/17/considering-generic...