I wasn't sure if anyone was allowed to review, but if so, then all of my questions have been answered: Library Review:

- What is your evaluation of the design?

I can't comment on it as a generic library designer, but as a library user it appears to be an excellent framework. However, the use cases for bounds checking of variables are much more thought through than the more interesting mathematics/set theory and numerics use cases. I think the library seems to be close to supporting these use cases but needs to explicitly address: 1) Floating Points: Enough has been said about this, but it needs to be resolved before the library is completed. Otherwise, all mathematics/numerics use cases are impossible. As a pragmatist about this issue, I would say that a worst case "solution" is to write caveats in the "rationale" section about this problem when using this library. This library is useful for querying bounds on a type, even if it doesn't do any bounds checking. 2) Dynamic Bounded Types: Right now the static bounds are associated globally with a type, and the dynamic bounds are associated with an instance of a type. Since many use cases involve setting dynamic sets and then creating instances, it is crucial that this type of set is implemented. See Robert's rough notes in: http://lists.boost.org/boost-users/2008/12/42959.php 3) Representing Disjoint Sets: Because most of the use cases have been thinking about predicates and bounds checking, the key use cases of unions of bounds has not been addressed. In most of the discussions, people talk about layering constraints on top of each other, which is an intersection. This library needs to also have ways to easily create sets like: (-infinity, 0] union [1,2] union [3,infinity) This would be a union of constraints which could be set or accessed on the type (at runtime or compiletime), hopefully with simple iterators to access this type information. I think that thinking through closed/open/halfopen/etc. intervals as separate objects in themselves is critical, especially to layer this type of bound on. Perhaps it could be integrated with the interval template library in the sandbox for example. 4) Testing with Numerics: This library needs to be tested with key boost numeric packages such as ublas, boost math, accumulators, etc. The key here will also be to verify that it compiles with the static and dynamic bounded types, the storage is identical to the underlying type, and the operations it generates are not any slower. Also that all of the elementary operators on intrinsic types in C++ work as normal for by value/ref/pointer, numeric_limits is thought through, etc. All of the former is performance/storage testing would be conditional on a good compiler of course (gnu and Intel seem to be the main ones to worry about)

- What is your evaluation of the implementation? For the existing constraint types, it looks good.

- What is your evaluation of the documentation? Good for the simple cases here and the bounds checking. Incomplete for the key math/numerics use cases which is where this would be at its best. And the floating point section would need to be rewritten after it is "solved".

- What is your evaluation of the potential usefulness of the library? Extraordinarily useful for generic mathematics/numerics. Even without any bounds checking, managing subsets of intrinsic types with runtime bounds information has a huge value. And having domains/ranges associated with functions would save a huge number of bugs in numeric processing, as well as make the translation from blackboard to program much more elegant. This could be a cornerstone of allowing for safe implementations of mathematical models in disciplines such as economics. For example, an optimizer operating on bounded values could create a grid from just the passed in type, validate if a solution is converging to an open set bound, etc. And higher order functors such as derivatives could generate domain/range information for the functions they are operating on dynamically.

- Did you try to use the library? With what compiler? Did you have any problems? No. It doesn't yet have the main constraint type I am interested in.

- How much effort did you put into your evaluation? A glance? A quick reading? In-depth study? I had previously been writing notes on a library to manage domain/range information for functors that this becomes a superset of, so I have thought through a large number of those use cases. A great deal of time was spent trying to see how this library could fit the use cases I am interested in.

- Are you knowledgeable about the problem domain?

Please state in your review, whether you think the library should be accepted as a Boost library. Yes, conditional on solving the 1) to 4) design questions above. Robert has

For generic library design: little knowledge. For the bounds-checking, value monitoring use cases: little knowledge. For the mathematics/numerics use cases: A good deal of knowledge as I am working through many of these issues in projects/research and trying to build out domain specific libraries to make future research easier.. posted excellent starting points for many of these topics.