#### 3.9` `What are Reach’s limitations and its future roadmap

Today, Reach is a powerful language for build decentralized applications, as demonstrated in the overview, the tutorial, and the workshop series. However, it has a lot of potential for growth. This section describes a few of these areas and gives brief sketches of our roadmap for directing this growth. We welcome your contributions on GitHub and on the Discord community to helping make these improvement plans come to fruition.

`import`

and `export`

specifiers, syntactic sugar for `while`

patterns, like `for`

in JavaScript, and recursive functions (when they are in a tail-recursive set.)
We also plan to add features from typed languages, like abstract data types and pattern matching.
Similarly, we have plans to extend Reach’s type system to be able to track more specific features of values, such as refinement types, substructural types to allow mutation, and arbitrary range integer types.
Finally, we have plans to allow more exotic features, like non-communicating loops with guaranteed termination, statically computable exceptions, and pay-as-you-go closures, including non-tail-recursion through closure conversion of non-contifiable continuations.The introduction of inductive state through bounded induction, to ensure that arbitrary data is not communicated or stored in consensus state. Bounded inductive state can be represented via Merkle trees to ensure that consensus state remains finite.

The introduction of "participant classes", which are categories of participants that act identically. After which, Reach will be limited to finite sets of a predetermined number of participant classes.

The introduction of safe non-determinism through commutative monoid reduction, wherein a set of participants, P, may all contribute a value, v(P), from a monoid M. Since S is a commutative monoid, it has a combining operation + : S x S -> S such that (a + b) + c = a + (b + c) and a + b = b + a, so it is possible to combine the values in any order (i.e. non-deterministically) and arrive at the same value. In practice, each participant will actually contribute a value, u(P) from an arbitrary set U(P) such that an operation m(P) : U(P) -> M exists, so that the value computed will be 𝛴 { m(P)(u(P)) | P ∈ participants }.

This is analogous to using the so-called MapReduce programming model, with the additional constraint of commutativity on the reduce method.

This solution indicates why non-determinism is difficult: participants must be able to submit their values without knowing the other values in flight, yet must also still reach consensus on the outcome of the computation. Non-commutativity would be acceptable, but would be lower-performance as participants that "missed" and were not the first sender would be required to review the first value to ensure that they compute the same answer as the consensus state. This "reviewing" would be observable by frontends if they were involved in computing the initial value.

Reach’s communication language has other limitations for which we do not have short-term plans for removing. For example, we do not intend to support co-inductive or cyclic state, nor expose an arbitrary consensus heap to programmers.