I wish switch patterns worked with jabel...

src/main/java/com/ezylang/evalex/data/conversion/ArrayConverter.java

···
 */
 package com.ezylang.evalex.data.conversion;
 
+import static com.ezylang.evalex.data.EvaluationValue.arrayValue;
+
 import com.ezylang.evalex.config.ExpressionConfiguration;
 import com.ezylang.evalex.data.EvaluationValue;
 import java.util.ArrayList;
···
 public class ArrayConverter implements ConverterIfc {
   @Override
   public EvaluationValue convert(Object object, ExpressionConfiguration configuration) {
-    if (object.getClass().isArray()) {
-      return EvaluationValue.arrayValue(convertArray(object, configuration));
-    }
-    if (object instanceof List<?> list) {
-      return EvaluationValue.arrayValue(convertList(list, configuration));
-    }
+    if (object.getClass().isArray()) return arrayValue(convertArray(object, configuration));
+    if (object instanceof List<?> list) return arrayValue(convertList(list, configuration));
     throw illegalArgument(object);
   }
 
···
   }
 
   private List<EvaluationValue> convertArray(Object array, ExpressionConfiguration configuration) {
-    if (array instanceof int[] arr) {
-      return convertIntArray(arr, configuration);
-    } else if (array instanceof long[] arr) {
-      return convertLongArray(arr, configuration);
-    } else if (array instanceof double[] arr) {
-      return convertDoubleArray(arr, configuration);
-    } else if (array instanceof float[] arr) {
-      return convertFloatArray(arr, configuration);
-    } else if (array instanceof short[] arr) {
-      return convertShortArray(arr, configuration);
-    } else if (array instanceof char[] arr) {
-      return convertCharArray(arr, configuration);
-    } else if (array instanceof byte[] arr) {
-      return convertByteArray(arr, configuration);
-    } else if (array instanceof boolean[] arr) {
-      return convertBooleanArray(arr, configuration);
-    } else {
-      return convertObjectArray((Object[]) array, configuration);
-    }
+    if (array instanceof int[] arr) return convertIntArray(arr, configuration);
+    if (array instanceof long[] arr) return convertLongArray(arr, configuration);
+    if (array instanceof double[] arr) return convertDoubleArray(arr, configuration);
+    if (array instanceof float[] arr) return convertFloatArray(arr, configuration);
+    if (array instanceof short[] arr) return convertShortArray(arr, configuration);
+    if (array instanceof char[] arr) return convertCharArray(arr, configuration);
+    if (array instanceof byte[] arr) return convertByteArray(arr, configuration);
+    if (array instanceof boolean[] arr) return convertBooleanArray(arr, configuration);
+    return convertObjectArray((Object[]) array, configuration);
   }
 
   private List<EvaluationValue> convertIntArray(
       int[] array, ExpressionConfiguration configuration) {
     List<EvaluationValue> list = new ArrayList<>();
-    for (int i : array) {
-      list.add(EvaluationValue.of(i, configuration));
-    }
+    for (int i : array) list.add(EvaluationValue.of(i, configuration));
     return list;
   }
 
   private List<EvaluationValue> convertLongArray(
       long[] array, ExpressionConfiguration configuration) {
     List<EvaluationValue> list = new ArrayList<>();
-    for (long l : array) {
-      list.add(EvaluationValue.of(l, configuration));
-    }
+    for (long l : array) list.add(EvaluationValue.of(l, configuration));
     return list;
   }
 
   private List<EvaluationValue> convertDoubleArray(
       double[] array, ExpressionConfiguration configuration) {
     List<EvaluationValue> list = new ArrayList<>();
-    for (double d : array) {
-      list.add(EvaluationValue.of(d, configuration));
-    }
+    for (double d : array) list.add(EvaluationValue.of(d, configuration));
     return list;
   }
 
   private List<EvaluationValue> convertFloatArray(
       float[] array, ExpressionConfiguration configuration) {
     List<EvaluationValue> list = new ArrayList<>();
-    for (float f : array) {
-      list.add(EvaluationValue.of(f, configuration));
-    }
+    for (float f : array) list.add(EvaluationValue.of(f, configuration));
     return list;
   }
 
   private List<EvaluationValue> convertShortArray(
       short[] array, ExpressionConfiguration configuration) {
     List<EvaluationValue> list = new ArrayList<>();
-    for (short s : array) {
-      list.add(EvaluationValue.of(s, configuration));
-    }
+    for (short s : array) list.add(EvaluationValue.of(s, configuration));
     return list;
   }
 
   private List<EvaluationValue> convertCharArray(
       char[] array, ExpressionConfiguration configuration) {
     List<EvaluationValue> list = new ArrayList<>();
-    for (char c : array) {
-      list.add(EvaluationValue.of(c, configuration));
-    }
+    for (char c : array) list.add(EvaluationValue.of(c, configuration));
     return list;
   }
 
   private List<EvaluationValue> convertByteArray(
       byte[] array, ExpressionConfiguration configuration) {
     List<EvaluationValue> list = new ArrayList<>();
-    for (byte b : array) {
-      list.add(EvaluationValue.of(b, configuration));
-    }
+    for (byte b : array) list.add(EvaluationValue.of(b, configuration));
     return list;
   }
 
   private List<EvaluationValue> convertBooleanArray(
       boolean[] array, ExpressionConfiguration configuration) {
     List<EvaluationValue> list = new ArrayList<>();
-    for (boolean b : array) {
-      list.add(EvaluationValue.of(b, configuration));
-    }
+    for (boolean b : array) list.add(EvaluationValue.of(b, configuration));
     return list;
   }
 
   private List<EvaluationValue> convertObjectArray(
       Object[] array, ExpressionConfiguration configuration) {
     List<EvaluationValue> list = new ArrayList<>();
-    for (Object o : array) {
-      list.add(EvaluationValue.of(o, configuration));
-    }
+    for (Object o : array) list.add(EvaluationValue.of(o, configuration));
     return list;
   }
 }

src/main/java/com/ezylang/evalex/data/conversion/DateTimeConverter.java

···
 */
 package com.ezylang.evalex.data.conversion;
 
+import static com.ezylang.evalex.data.EvaluationValue.dateTimeValue;
+
 import com.ezylang.evalex.config.ExpressionConfiguration;
 import com.ezylang.evalex.data.EvaluationValue;
 import java.time.*;
···
 
   @Override
   public EvaluationValue convert(Object object, ExpressionConfiguration configuration) {
-
-    if (object instanceof Instant instant) {
-      return EvaluationValue.dateTimeValue(instant);
-    } else if (object instanceof ZonedDateTime dateTime) {
-      return EvaluationValue.dateTimeValue(dateTime.toInstant());
-    } else if (object instanceof OffsetDateTime dateTime) {
-      return EvaluationValue.dateTimeValue(dateTime.toInstant());
-    } else if (object instanceof LocalDate localDate) {
-      return EvaluationValue.dateTimeValue(
-          localDate.atStartOfDay().atZone(configuration.getZoneId()).toInstant());
-    } else if (object instanceof LocalDateTime dateTime) {
-      return EvaluationValue.dateTimeValue(dateTime.atZone(configuration.getZoneId()).toInstant());
-    } else if (object instanceof Date date) {
-      return EvaluationValue.dateTimeValue(date.toInstant());
-    } else if (object instanceof Calendar calendar) {
-      return EvaluationValue.dateTimeValue(calendar.toInstant());
-    } else {
-      throw illegalArgument(object);
-    }
+    if (object instanceof Instant instant) return dateTimeValue(instant);
+    if (object instanceof ZonedDateTime dateTime) return dateTimeValue(dateTime.toInstant());
+    if (object instanceof OffsetDateTime dateTime) return dateTimeValue(dateTime.toInstant());
+    if (object instanceof LocalDate localDate)
+      return dateTimeValue(localDate.atStartOfDay().atZone(configuration.getZoneId()).toInstant());
+    if (object instanceof LocalDateTime dateTime)
+      return dateTimeValue(dateTime.atZone(configuration.getZoneId()).toInstant());
+    if (object instanceof Date date) return dateTimeValue(date.toInstant());
+    if (object instanceof Calendar calendar) return dateTimeValue(calendar.toInstant());
+    throw illegalArgument(object);
   }
 
   /**
···
    * @return A parsed {@link Instant} if parsing was successful, else <code>null</code>.
    */
   public Instant parseDateTime(String value, ZoneId zoneId, List<DateTimeFormatter> formatters) {
-    for (DateTimeFormatter formatter : formatters) {
+    for (DateTimeFormatter formatter : formatters)
       try {
         return parseToInstant(value, zoneId, formatter);
       } catch (DateTimeException ignored) {
         // ignore
       }
-    }
     return null;
   }
 
···
     if (parsedZoneId == null) {
       LocalDate parsedDate = ta.query(TemporalQueries.localDate());
       LocalTime parsedTime = ta.query(TemporalQueries.localTime());
-      if (parsedTime == null) {
-        parsedTime = parsedDate.atStartOfDay().toLocalTime();
-      }
+      if (parsedTime == null) parsedTime = parsedDate.atStartOfDay().toLocalTime();
       ta = ZonedDateTime.of(parsedDate, parsedTime, zoneId);
     }
     return Instant.from(ta);

src/main/java/com/ezylang/evalex/data/conversion/NumberConverter.java

···
 */
 package com.ezylang.evalex.data.conversion;
 
+import static com.ezylang.evalex.data.EvaluationValue.numberValue;
+
 import com.ezylang.evalex.config.ExpressionConfiguration;
 import com.ezylang.evalex.data.EvaluationValue;
 import java.math.BigDecimal;
···
 
   @Override
   public EvaluationValue convert(Object object, ExpressionConfiguration configuration) {
-    if (object instanceof BigDecimal decimal) {
-      return EvaluationValue.numberValue(decimal);
-    } else if (object instanceof BigInteger integer) {
-      return EvaluationValue.numberValue(new BigDecimal(integer, configuration.getMathContext()));
-    } else if (object instanceof Double d) {
-      return EvaluationValue.numberValue(
-          new BigDecimal(Double.toString(d), configuration.getMathContext()));
-    } else if (object instanceof Float f) {
-      return EvaluationValue.numberValue(BigDecimal.valueOf(f));
-    } else if (object instanceof Integer i) {
-      return EvaluationValue.numberValue(BigDecimal.valueOf(i));
-    } else if (object instanceof Long l) {
-      return EvaluationValue.numberValue(BigDecimal.valueOf(l));
-    } else if (object instanceof Short s) {
-      return EvaluationValue.numberValue(BigDecimal.valueOf(s));
-    } else if (object instanceof Byte b) {
-      return EvaluationValue.numberValue(BigDecimal.valueOf(b));
-    } else {
-      throw illegalArgument(object);
-    }
+    if (object instanceof BigDecimal decimal) return numberValue(decimal);
+    if (object instanceof BigInteger integer)
+      return numberValue(new BigDecimal(integer, configuration.getMathContext()));
+    if (object instanceof Double d)
+      return numberValue(new BigDecimal(Double.toString(d), configuration.getMathContext()));
+    if (object instanceof Float f) return numberValue(BigDecimal.valueOf(f));
+    if (object instanceof Integer i) return numberValue(BigDecimal.valueOf(i));
+    if (object instanceof Long l) return numberValue(BigDecimal.valueOf(l));
+    if (object instanceof Short s) return numberValue(BigDecimal.valueOf(s));
+    if (object instanceof Byte b) return numberValue(BigDecimal.valueOf(b));
+    throw illegalArgument(object);
   }
 
   @Override

src/main/java/com/ezylang/evalex/data/conversion/StringConverter.java

···
 */
 package com.ezylang.evalex.data.conversion;
 
+import static com.ezylang.evalex.data.EvaluationValue.stringValue;
+
 import com.ezylang.evalex.config.ExpressionConfiguration;
 import com.ezylang.evalex.data.EvaluationValue;
 
···
 
   @Override
   public EvaluationValue convert(Object object, ExpressionConfiguration configuration) {
-    if (object instanceof CharSequence sequence) {
-      return EvaluationValue.stringValue(sequence.toString());
-    } else if (object instanceof Character character) {
-      return EvaluationValue.stringValue(character.toString());
-    } else {
-      throw illegalArgument(object);
-    }
+    if (object instanceof CharSequence sequence) return stringValue(sequence.toString());
+    if (object instanceof Character character) return stringValue(character.toString());
+    throw illegalArgument(object);
   }
 
   @Override