Slightly updated JavaDoc.

Author: atsticks

src/main/java/javax/money/CurrencyUnit.java

@@ -26,6 +26,7 @@
  * concrete implementation type and currency code.
  * <li>are required to be thread-safe
  * <li>are required to be immutable
+ * <li>are required to be comparable
  * <li>are highly recommended to be serializable.
  * </ul>
  * 
@@ -48,11 +49,11 @@ public interface CurrencyUnit {
 	 * For ISO codes the 3-letter ISO code should be returned. For non ISO
 	 * currencies no constraints are defined.
 	 * 
-	 * @return the currency code, never {@code null}. For the ISO-4217
-	 *         namespace, this this will be the three letter ISO-4217 code.
-	 *         However, alternate currencies can have different codes. Also
-	 *         there is no constraint about the formatting of alternate codes,
-	 *         despite they fact that the currency codes must be unique.
+	 * @return the currency code, never {@code null}. For ISO-4217 this this
+	 *         will be the three letter ISO-4217 code. However, alternate
+	 *         currencies can have different codes. Also there is no constraint
+	 *         about the formatting of alternate codes, despite they fact that
+	 *         the currency codes must be unique.
 	 */
 	public String getCurrencyCode();
 

src/main/java/javax/money/MonetaryAdjuster.java

@@ -27,11 +27,11 @@
  * instead of the interface to support a fluent style:
  * 
  * <pre>
- * // these two lines are equivalent, but the second approach is recommended
+ * // these two variants are equivalent
  * monetary = thisAdjuster.adjustInto(monetary);
  * monetary = anotherAdjuster.adjustInto(monetary);
  * 
- * // second approach, using a fluent API
+ * // second, recommended, approach, using a fluent API
  * monetary = monetary.with(thisAdjuster).with(anotherAdjuster);
  * </pre>
  * 

src/main/java/javax/money/MonetaryAmount.java

@@ -34,8 +34,9 @@
  * <li>Monetary amounts should allow numbers as argument for arithmetic
  * operations like division and multiplication additionally to a MonetaryAmount.
  * Adding or subtracting of amounts must only be possible by passing instances
- * of MonetaryAmount. Arguments of type {@link Number} should be avoided, since
- * it does not allow to extract its numeric value in a feasible way.
+ * of MonetaryAmount.</li>
+ * <li>Arguments of type {@link Number} should be avoided, since
+ * it does not allow to extract its numeric value in a feasible way.</li>
  * <li>If the numeric representation of a {@code MonetaryAmount} exceeds the
  * numeric capabilities of the concrete type {@code T from(MonetaryAmount)}, an
  * implementation should throw an {@code ArithemticOperationException}.</li>
@@ -44,7 +45,7 @@
  * {@code ArithmeticException} should be thrown. Never should truncation be
  * performed implicitly.</li>
  * <li>Nevertheless truncation may be supported by passing additional parameters
- * or using <i>exact</i> methods, similar to {@link BigDecimal#longValueExact()}.
+ * or defining <i>exact</i> methods, similar to {@link BigDecimal#longValueExact()}.
  * <li>Rounding should never be done automatically, exception internal rounding
  * implied by the numeric implementation type.</li>
  * <li>Since implementations are recommended to be immutable, an operation

src/main/java/javax/money/MonetaryQuery.java

@@ -27,6 +27,7 @@
  * <pre>
  *   // these two lines are equivalent, but the second approach is recommended
  *   monetary = thisQuery.queryFrom(monetary);
+ *   // recommened approach
  *   monetary = monetary.query(thisQuery);
  * </pre>
  * It is recommended to use the second approach, {@code query(MonetaryQuery)},