UpdateFun | Android APP update library./android app自动检测更新库 | Android library

As mostly covered in @mb14's comments, the usual method involves doing two things:

• First, instead of returning either a type-checked tree or an error, be prepared to always return a type-checked tree together with a log of zero or more errors. This is easily accomplished with a Writer monad.
• Second, whenever an error is detected, log the error, try to recover by assuming some valid type for the node being type-checked, and continue the type check.

In this simple scheme, the type checking always returns a typed tree. If the log of error messages is empty, the type check has succeeded, and the typed tree is valid. Otherwise, the type check has failed with the given set of errors, and the typed tree can be discarded. In a more complex scheme, you could differentiate between warnings and errors in your log, and consider the type checking to have succeeded if it contains zero or more warnings, but no errors.

I've included a complete example of the technique below for a very simplified grammar. It only returns the top-level type instead of the typed tree, but this is just to keep the code simple -- returning a type-checked tree is not difficult. The hard part in adapting it to your grammar will be determining how to forge ahead (i.e., what valid type to supply) when an error occurs, and it will be highly dependent on the details of your program. Some general techniques are illustrated below:

• If a node always returns a particular type (e.g., Len below), always assume that type for the node, even if the node doesn't type-check.
• If a node combines compatible types to determine its result type (e.g, Plus below, or a BNF alternation), then when a type incompatibility is detected, take the type of the node to be determined by the type of its first argument.

Anyway, here is the complete example: