Fixing up javadocs

jnape · jnape · commit c6ef16768236 · 2017-05-29T18:28:27.000-05:00
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/Either.java b/src/main/java/com/jnape/palatable/lambda/adt/Either.java
@@ -53,8 +53,8 @@ public final R recover(Function<? super L, ? extends R> recoveryFn) {
     }
 
     /**
-     * Inverse of recover. If this is a right value, apply the wrapped value to forfeitFn and return it; otherwise,
-     * return the wrapped left value;
+     * Inverse of recover. If this is a right value, apply the wrapped value to <code>forfeitFn</code> and return it;
+     * otherwise, return the wrapped left value.
      *
      * @param forfeitFn a function from R to L
      * @return either the wrapped value (if left) or the result of the right value applied to forfeitFn
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/GroupBy.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/GroupBy.java
@@ -12,7 +12,7 @@
 import static com.jnape.palatable.lambda.functions.builtin.fn3.FoldLeft.foldLeft;
 
 /**
- * Given an <code>Iterable&lt;V&gt;</code> <code>vs</code> and a key function <code>V -> K</code> <code>f</code>, fold
+ * Given an <code>Iterable&lt;V&gt;</code> <code>vs</code> and a key function <code>V -&gt; K</code> <code>f</code>, fold
  * <code>vs</code> into a <code>Map&lt;K, List&lt;V&gt;&gt;</code> by applying <code>f</code> to each element of
  * <code>vs</code>, retaining values that map to the same key in a list, in the order they were iterated in.
  *
diff --git a/src/main/java/com/jnape/palatable/lambda/functor/Applicative.java b/src/main/java/com/jnape/palatable/lambda/functor/Applicative.java
@@ -15,7 +15,7 @@
  * <li>identity: <code>v.zip(pureId).equals(v)</code></li>
  * <li>composition: <code>w.zip(v.zip(u.zip(pureCompose))).equals((w.zip(v)).zip(u))</code></li>
  * <li>homomorphism: <code>pureX.zip(pureF).equals(pureFx)</code></li>
- * <li>interchange: <code>pureY.zip(u).equals(u.zip(pure(f -> f.apply(y))))</code></li>
+ * <li>interchange: <code>pureY.zip(u).equals(u.zip(pure(f -&gt; f.apply(y))))</code></li>
  * </ul>
  * As with <code>Functor</code>, <code>Applicative</code> instances that do not satisfy all of the functor laws, as well
  * as the above applicative laws, are not well-behaved and often break down in surprising ways.
diff --git a/src/main/java/com/jnape/palatable/lambda/lens/Lens.java b/src/main/java/com/jnape/palatable/lambda/lens/Lens.java
@@ -144,6 +144,7 @@ <F extends Functor, FT extends Functor<T, F>, FB extends Functor<B, F>> FT apply
      * Although the Java type system does not allow enforceability, the functor instance FT should be the same as FB,
      * only differentiating in their parameters.
      *
+     * @param <F>  the common functor type of FT and FB
      * @param <FT> the type of the lifted T
      * @param <FB> the type of the lifted B
      * @return the lens, "fixed" to the functor
diff --git a/src/main/java/com/jnape/palatable/lambda/traversable/Traversable.java b/src/main/java/com/jnape/palatable/lambda/traversable/Traversable.java
@@ -15,13 +15,12 @@
  * <ul>
  * <li>naturality: <code>t.apply(trav.traverse(f, pure).&lt;Object&gt;fmap(id()).coerce())
  * .equals(trav.traverse(t.compose(f), pure2).&lt;Object&gt;fmap(id()).coerce())</code></li>
- * <li>identity: <code>trav.traverse(Identity::new, x -> new Identity&lt;&gt;(x)).equals(new
+ * <li>identity: <code>trav.traverse(Identity::new, x -&gt; new Identity&lt;&gt;(x)).equals(new
  * Identity&lt;&gt;(trav)</code></li>
- * <li>composition: <code>trav.traverse(f.andThen(x -> x.fmap(g)).andThen(Compose::new), x ->
+ * <li>composition: <code>trav.traverse(f.andThen(x -&gt; x.fmap(g)).andThen(Compose::new), x -&gt;
  * new Compose&lt;&gt;(new Identity&lt;&gt;(new Identity&lt;&gt;(x)))).equals(new Compose&lt;Identity, Identity,
- * Traversable&lt;Object, Trav&gt;&gt;(trav.traverse(f, x -> new Identity&lt;&gt;(x)).fmap(t ->
- * t.traverse(g, x -> new Identity&lt;&gt;(x)))))</code></li>
- * <p>
+ * Traversable&lt;Object, Trav&gt;&gt;(trav.traverse(f, x -&gt; new Identity&lt;&gt;(x)).fmap(t -&gt;
+ * t.traverse(g, x -&gt; new Identity&lt;&gt;(x)))))</code></li>
  * </ul>
  * <p>
  * For more information, read about

Original file line number	Diff line number	Diff line change
`@@ -53,8 +53,8 @@ public final R recover(Function<? super L, ? extends R> recoveryFn) {`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`/**`
`56`		`- * Inverse of recover. If this is a right value, apply the wrapped value to forfeitFn and return it; otherwise,`
`57`		`- * return the wrapped left value;`
	`56`	`+ * Inverse of recover. If this is a right value, apply the wrapped value to <code>forfeitFn</code> and return it;`
	`57`	`+ * otherwise, return the wrapped left value.`
`58`	`58`	`*`
`59`	`59`	`* @param forfeitFn a function from R to L`
`60`	`60`	`* @return either the wrapped value (if left) or the result of the right value applied to forfeitFn`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@`
`12`	`12`	`import static com.jnape.palatable.lambda.functions.builtin.fn3.FoldLeft.foldLeft;`
`13`	`13`
`14`	`14`	`/**`
`15`		`- * Given an <code>Iterable<V></code> <code>vs</code> and a key function <code>V -> K</code> <code>f</code>, fold`
	`15`	`+ * Given an <code>Iterable<V></code> <code>vs</code> and a key function <code>V -> K</code> <code>f</code>, fold`
`16`	`16`	`* <code>vs</code> into a <code>Map<K, List<V>></code> by applying <code>f</code> to each element of`
`17`	`17`	`* <code>vs</code>, retaining values that map to the same key in a list, in the order they were iterated in.`
`18`	`18`	`*`
Original file line number	Diff line number	Diff line change
`@@ -144,6 +144,7 @@ <F extends Functor, FT extends Functor<T, F>, FB extends Functor<B, F>> FT apply`
`144`	`144`	`* Although the Java type system does not allow enforceability, the functor instance FT should be the same as FB,`
`145`	`145`	`* only differentiating in their parameters.`
`146`	`146`	`*`
	`147`	`+ * @param <F> the common functor type of FT and FB`
`147`	`148`	`* @param <FT> the type of the lifted T`
`148`	`149`	`* @param <FB> the type of the lifted B`
`149`	`150`	`* @return the lens, "fixed" to the functor`