Use pattern variables

Author: 7h3kk1d

src/main/java/com/jnape/palatable/lambda/adt/hlist/HList.java

@@ -263,8 +263,7 @@ public Tail tail() {
 
         @Override
         public final boolean equals(Object other) {
-            if (other instanceof HCons) {
-                HCons<?, ?> that = (HCons<?, ?>) other;
+            if (other instanceof HCons<?, ?> that) {
                 return this.head.equals(that.head)
                         && this.tail.equals(that.tail);
             }

src/main/java/com/jnape/palatable/lambda/adt/hmap/HMap.java

@@ -162,8 +162,7 @@ public Collection<Object> values() {
 
     @Override
     public boolean equals(Object other) {
-        if (other instanceof HMap) {
-            HMap that = (HMap) other;
+        if (other instanceof HMap that) {
             return Objects.equals(this.table, that.table);
         }
         return false;

src/main/java/com/jnape/palatable/lambda/functor/builtin/Lazy.java

@@ -182,8 +182,7 @@ public A value() {
                     tuple((Lazy<Object>) this, new LinkedList<>());
             @SuppressWarnings("unchecked")
             A a = (A) trampoline(into((source, flatMaps) -> {
-                if (source instanceof Compose<?>) {
-                    Compose<?> nested = (Compose<?>) source;
+                if (source instanceof Compose<?> nested) {
                     flatMaps.push(nested.flatMap);
                     return recurse(tuple(nested.source, flatMaps));
                 }

src/main/java/com/jnape/palatable/lambda/internal/iteration/DroppingIterable.java

@@ -7,8 +7,7 @@ public final class DroppingIterable<A> implements Iterable<A> {
     private final Iterable<A> as;
 
     public DroppingIterable(int n, Iterable<A> as) {
-        while (as instanceof DroppingIterable) {
-            DroppingIterable<A> nested = (DroppingIterable<A>) as;
+        while (as instanceof DroppingIterable<A> nested) {
             as = nested.as;
             n += nested.n;
         }

src/main/java/com/jnape/palatable/lambda/internal/iteration/FilteringIterable.java

@@ -15,8 +15,7 @@ public final class FilteringIterable<A> implements Iterable<A> {
 
     public FilteringIterable(Fn1<? super A, ? extends Boolean> predicate, Iterable<A> as) {
         List<Fn1<? super A, ? extends Boolean>> predicates = new ArrayList<>(singletonList(predicate));
-        while (as instanceof FilteringIterable) {
-            FilteringIterable<A> nested = (FilteringIterable<A>) as;
+        while (as instanceof FilteringIterable<A> nested) {
             predicates.addAll(0, nested.predicates);
             as = nested.as;
         }

src/main/java/com/jnape/palatable/lambda/internal/iteration/MappingIterable.java

@@ -16,8 +16,7 @@ public final class MappingIterable<A, B> implements Iterable<B> {
     @SuppressWarnings("unchecked")
     public MappingIterable(Fn1<? super A, ? extends B> fn, Iterable<A> as) {
         List<Fn1<?, ?>> mappers = new ArrayList<>(singletonList(fn));
-        while (as instanceof MappingIterable<?, ?>) {
-            MappingIterable<?, ?> nested = (MappingIterable<?, ?>) as;
+        while (as instanceof MappingIterable<?, ?> nested) {
             as = (Iterable<A>) nested.as;
             mappers.addAll(0, nested.mappers);
         }

src/main/java/com/jnape/palatable/lambda/internal/iteration/PredicatedDroppingIterable.java

@@ -11,8 +11,7 @@ public final class PredicatedDroppingIterable<A> implements Iterable<A> {
 
     public PredicatedDroppingIterable(Fn1<? super A, ? extends Boolean> predicate, Iterable<A> as) {
         ImmutableQueue<Fn1<? super A, ? extends Boolean>> predicates = ImmutableQueue.singleton(predicate);
-        while (as instanceof PredicatedDroppingIterable) {
-            PredicatedDroppingIterable<A> nested = (PredicatedDroppingIterable<A>) as;
+        while (as instanceof PredicatedDroppingIterable<A> nested) {
             as = nested.as;
             predicates = nested.predicates.concat(predicates);
         }

src/main/java/com/jnape/palatable/lambda/internal/iteration/PredicatedTakingIterable.java

@@ -15,8 +15,7 @@ public final class PredicatedTakingIterable<A> implements Iterable<A> {
 
     public PredicatedTakingIterable(Fn1<? super A, ? extends Boolean> predicate, Iterable<A> as) {
         List<Fn1<? super A, ? extends Boolean>> predicates = new ArrayList<>(singletonList(predicate));
-        while (as instanceof PredicatedTakingIterable) {
-            PredicatedTakingIterable<A> nested = (PredicatedTakingIterable<A>) as;
+        while (as instanceof PredicatedTakingIterable<A> nested) {
             predicates.addAll(0, nested.predicates);
             as = nested.as;
         }

src/main/java/com/jnape/palatable/lambda/internal/iteration/RateLimitingIterable.java

@@ -15,8 +15,7 @@ public final class RateLimitingIterable<A> implements Iterable<A> {
 
     public RateLimitingIterable(Iterable<A> as, Set<Tuple3<Long, Duration, Fn0<Instant>>> rateLimits) {
         Set<Tuple3<Long, Duration, Fn0<Instant>>> combinedRateLimits = new HashSet<>(rateLimits);
-        if (as instanceof RateLimitingIterable) {
-            RateLimitingIterable<A> inner = (RateLimitingIterable<A>) as;
+        if (as instanceof RateLimitingIterable<A> inner) {
             combinedRateLimits.addAll(inner.rateLimits);
             as = inner.as;
         }

src/main/java/com/jnape/palatable/lambda/internal/iteration/ReversingIterable.java

@@ -8,8 +8,7 @@ public final class ReversingIterable<A> implements Iterable<A> {
 
     public ReversingIterable(Iterable<A> as) {
         boolean reverse = true;
-        while (as instanceof ReversingIterable) {
-            ReversingIterable<A> nested = (ReversingIterable<A>) as;
+        while (as instanceof ReversingIterable<A> nested) {
             as = nested.as;
             reverse = !nested.reverse;
         }