diff --git a/src/main/java/com/ezylang/evalex/data/conversion/ArrayConverter.java b/src/main/java/com/ezylang/evalex/data/conversion/ArrayConverter.java
index a1488772..fbef565b 100644
--- a/src/main/java/com/ezylang/evalex/data/conversion/ArrayConverter.java
+++ b/src/main/java/com/ezylang/evalex/data/conversion/ArrayConverter.java
@@ -19,19 +19,18 @@
 import com.ezylang.evalex.data.EvaluationValue;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.stream.Collectors;
 
 /** Converter to convert to the ARRAY data type. */
 public class ArrayConverter implements ConverterIfc {
   @Override
   public EvaluationValue convert(Object object, ExpressionConfiguration configuration) {
-    List<EvaluationValue> list = new ArrayList<>();
+    List<EvaluationValue> list;
 
     if (object.getClass().isArray()) {
-      for (Object element : (Object[]) object) {
-        list.add(new EvaluationValue(element, configuration));
-      }
+      list = convertArray(object, configuration);
     } else if (object instanceof List) {
-      ((List<?>) object).forEach(element -> list.add(new EvaluationValue(element, configuration)));
+      list = convertList((List<?>) object, configuration);
     } else {
       throw illegalArgument(object);
     }
@@ -43,4 +42,114 @@ public EvaluationValue convert(Object object, ExpressionConfiguration configurat
   public boolean canConvert(Object object) {
     return object instanceof List || object.getClass().isArray();
   }
+
+  private static List<EvaluationValue> convertList(
+      List<?> object, ExpressionConfiguration configuration) {
+    return object.stream()
+        .map(element -> new EvaluationValue(element, configuration))
+        .collect(Collectors.toList());
+  }
+
+  private List<EvaluationValue> convertArray(Object array, ExpressionConfiguration configuration) {
+    if (array instanceof int[]) {
+      return convertIntArray((int[]) array, configuration);
+    } else if (array instanceof long[]) {
+      return convertLongArray((long[]) array, configuration);
+    } else if (array instanceof double[]) {
+      return convertDoubleArray((double[]) array, configuration);
+    } else if (array instanceof float[]) {
+      return convertFloatArray((float[]) array, configuration);
+    } else if (array instanceof short[]) {
+      return convertShortArray((short[]) array, configuration);
+    } else if (array instanceof char[]) {
+      return convertCharArray((char[]) array, configuration);
+    } else if (array instanceof byte[]) {
+      return convertByteArray((byte[]) array, configuration);
+    } else if (array instanceof boolean[]) {
+      return convertBooleanArray((boolean[]) array, configuration);
+    } else {
+      return convertObjectArray((Object[]) array, configuration);
+    }
+  }
+
+  private List<EvaluationValue> convertIntArray(
+      int[] array, ExpressionConfiguration configuration) {
+    List<EvaluationValue> list = new ArrayList<>();
+    for (int i : array) {
+      list.add(new EvaluationValue(i, configuration));
+    }
+    return list;
+  }
+
+  private List<EvaluationValue> convertLongArray(
+      long[] array, ExpressionConfiguration configuration) {
+    List<EvaluationValue> list = new ArrayList<>();
+    for (long l : array) {
+      list.add(new EvaluationValue(l, configuration));
+    }
+    return list;
+  }
+
+  private List<EvaluationValue> convertDoubleArray(
+      double[] array, ExpressionConfiguration configuration) {
+    List<EvaluationValue> list = new ArrayList<>();
+    for (double d : array) {
+      list.add(new EvaluationValue(d, configuration));
+    }
+    return list;
+  }
+
+  private List<EvaluationValue> convertFloatArray(
+      float[] array, ExpressionConfiguration configuration) {
+    List<EvaluationValue> list = new ArrayList<>();
+    for (float f : array) {
+      list.add(new EvaluationValue(f, configuration));
+    }
+    return list;
+  }
+
+  private List<EvaluationValue> convertShortArray(
+      short[] array, ExpressionConfiguration configuration) {
+    List<EvaluationValue> list = new ArrayList<>();
+    for (short s : array) {
+      list.add(new EvaluationValue(s, configuration));
+    }
+    return list;
+  }
+
+  private List<EvaluationValue> convertCharArray(
+      char[] array, ExpressionConfiguration configuration) {
+    List<EvaluationValue> list = new ArrayList<>();
+    for (char c : array) {
+      list.add(new EvaluationValue(c, configuration));
+    }
+    return list;
+  }
+
+  private List<EvaluationValue> convertByteArray(
+      byte[] array, ExpressionConfiguration configuration) {
+    List<EvaluationValue> list = new ArrayList<>();
+    for (byte b : array) {
+      list.add(new EvaluationValue(b, configuration));
+    }
+    return list;
+  }
+
+  private List<EvaluationValue> convertBooleanArray(
+      boolean[] array, ExpressionConfiguration configuration) {
+    List<EvaluationValue> list = new ArrayList<>();
+    for (boolean b : array) {
+      list.add(new EvaluationValue(b, configuration));
+    }
+    return list;
+  }
+
+  private List<EvaluationValue> convertObjectArray(
+      Object[] array, ExpressionConfiguration configuration) {
+    List<EvaluationValue> list = new ArrayList<>();
+    for (Object o : array) {
+      list.add(new EvaluationValue(o, configuration));
+    }
+    return list;
+  }
 }
diff --git a/src/test/java/com/ezylang/evalex/data/conversion/ArrayConverterTest.java b/src/test/java/com/ezylang/evalex/data/conversion/ArrayConverterTest.java
index 6efe2f6b..66b664fa 100644
--- a/src/test/java/com/ezylang/evalex/data/conversion/ArrayConverterTest.java
+++ b/src/test/java/com/ezylang/evalex/data/conversion/ArrayConverterTest.java
@@ -85,11 +85,146 @@ void testArrayFromJavaArray() {
     assertThat(value.getArrayValue().get(4).getDateTimeValue()).isEqualTo(now);
   }
 
+  @Test
+  void testLongArray() {
+    long[] array = new long[] {1, 2, 3};
+    EvaluationValue value = converter.convert(array, defaultConfiguration);
+
+    assertThat(value.isArrayValue()).isTrue();
+    assertThat(value.getArrayValue()).hasSize(3);
+    assertThat(value.getArrayValue().get(0).isNumberValue()).isTrue();
+    assertThat(value.getArrayValue().get(0).getStringValue()).isEqualTo("1");
+    assertThat(value.getArrayValue().get(1).isNumberValue()).isTrue();
+    assertThat(value.getArrayValue().get(1).getStringValue()).isEqualTo("2");
+    assertThat(value.getArrayValue().get(2).isNumberValue()).isTrue();
+    assertThat(value.getArrayValue().get(2).getStringValue()).isEqualTo("3");
+  }
+
+  @Test
+  void testIntArray() {
+    int[] array = new int[] {1, 2, 3};
+    EvaluationValue value = converter.convert(array, defaultConfiguration);
+
+    assertThat(value.isArrayValue()).isTrue();
+    assertThat(value.getArrayValue()).hasSize(3);
+    assertThat(value.getArrayValue().get(0).isNumberValue()).isTrue();
+    assertThat(value.getArrayValue().get(0).getStringValue()).isEqualTo("1");
+    assertThat(value.getArrayValue().get(1).isNumberValue()).isTrue();
+    assertThat(value.getArrayValue().get(1).getStringValue()).isEqualTo("2");
+    assertThat(value.getArrayValue().get(2).isNumberValue()).isTrue();
+    assertThat(value.getArrayValue().get(2).getStringValue()).isEqualTo("3");
+  }
+
+  @Test
+  void testShortArray() {
+    short[] array = new short[] {1, 2, 3};
+    EvaluationValue value = converter.convert(array, defaultConfiguration);
+
+    assertThat(value.isArrayValue()).isTrue();
+    assertThat(value.getArrayValue()).hasSize(3);
+    assertThat(value.getArrayValue().get(0).isNumberValue()).isTrue();
+    assertThat(value.getArrayValue().get(0).getStringValue()).isEqualTo("1");
+    assertThat(value.getArrayValue().get(1).isNumberValue()).isTrue();
+    assertThat(value.getArrayValue().get(1).getStringValue()).isEqualTo("2");
+    assertThat(value.getArrayValue().get(2).isNumberValue()).isTrue();
+    assertThat(value.getArrayValue().get(2).getStringValue()).isEqualTo("3");
+  }
+
+  @Test
+  void testDoubleArray() {
+    double[] array = new double[] {1.0, 2.0, 3.0};
+    EvaluationValue value = converter.convert(array, defaultConfiguration);
+
+    assertThat(value.isArrayValue()).isTrue();
+    assertThat(value.getArrayValue()).hasSize(3);
+    assertThat(value.getArrayValue().get(0).isNumberValue()).isTrue();
+    assertThat(value.getArrayValue().get(0).getStringValue()).isEqualTo("1.0");
+    assertThat(value.getArrayValue().get(1).isNumberValue()).isTrue();
+    assertThat(value.getArrayValue().get(1).getStringValue()).isEqualTo("2.0");
+    assertThat(value.getArrayValue().get(2).isNumberValue()).isTrue();
+    assertThat(value.getArrayValue().get(2).getStringValue()).isEqualTo("3.0");
+  }
+
+  @Test
+  void testFloatArray() {
+    float[] array = new float[] {1.0f, 2.0f, 3.0f};
+    EvaluationValue value = converter.convert(array, defaultConfiguration);
+
+    assertThat(value.isArrayValue()).isTrue();
+    assertThat(value.getArrayValue()).hasSize(3);
+    assertThat(value.getArrayValue().get(0).isNumberValue()).isTrue();
+    assertThat(value.getArrayValue().get(0).getStringValue()).isEqualTo("1.0");
+    assertThat(value.getArrayValue().get(1).isNumberValue()).isTrue();
+    assertThat(value.getArrayValue().get(1).getStringValue()).isEqualTo("2.0");
+    assertThat(value.getArrayValue().get(2).isNumberValue()).isTrue();
+    assertThat(value.getArrayValue().get(2).getStringValue()).isEqualTo("3.0");
+  }
+
+  @Test
+  void testBooleanArray() {
+    boolean[] array = new boolean[] {true, false};
+    EvaluationValue value = converter.convert(array, defaultConfiguration);
+
+    assertThat(value.isArrayValue()).isTrue();
+    assertThat(value.getArrayValue()).hasSize(2);
+    assertThat(value.getArrayValue().get(0).isBooleanValue()).isTrue();
+    assertThat(value.getArrayValue().get(0).getBooleanValue()).isTrue();
+    assertThat(value.getArrayValue().get(1).isBooleanValue()).isTrue();
+    assertThat(value.getArrayValue().get(1).getBooleanValue()).isFalse();
+  }
+
+  @Test
+  void testByteArray() {
+    byte[] array = new byte[] {1, 2, 3};
+    EvaluationValue value = converter.convert(array, defaultConfiguration);
+
+    assertThat(value.isArrayValue()).isTrue();
+    assertThat(value.getArrayValue()).hasSize(3);
+    assertThat(value.getArrayValue().get(0).isNumberValue()).isTrue();
+    assertThat(value.getArrayValue().get(0).getStringValue()).isEqualTo("1");
+    assertThat(value.getArrayValue().get(1).isNumberValue()).isTrue();
+    assertThat(value.getArrayValue().get(1).getStringValue()).isEqualTo("2");
+    assertThat(value.getArrayValue().get(2).isNumberValue()).isTrue();
+    assertThat(value.getArrayValue().get(2).getStringValue()).isEqualTo("3");
+  }
+
+  @Test
+  void testCharArray() {
+    char[] array = new char[] {'a', 'b', 'c'};
+    EvaluationValue value = converter.convert(array, defaultConfiguration);
+
+    assertThat(value.isArrayValue()).isTrue();
+    assertThat(value.getArrayValue()).hasSize(3);
+    assertThat(value.getArrayValue().get(0).isStringValue()).isTrue();
+    assertThat(value.getArrayValue().get(0).getStringValue()).isEqualTo("a");
+    assertThat(value.getArrayValue().get(1).isStringValue()).isTrue();
+    assertThat(value.getArrayValue().get(1).getStringValue()).isEqualTo("b");
+    assertThat(value.getArrayValue().get(2).isStringValue()).isTrue();
+    assertThat(value.getArrayValue().get(2).getStringValue()).isEqualTo("c");
+  }
+
+  @Test
+  void testStringArray() {
+    String[] array = new String[] {"hello", "world"};
+    EvaluationValue value = converter.convert(array, defaultConfiguration);
+
+    assertThat(value.isArrayValue()).isTrue();
+    assertThat(value.getArrayValue()).hasSize(2);
+    assertThat(value.getArrayValue().get(0).isStringValue()).isTrue();
+    assertThat(value.getArrayValue().get(0).getStringValue()).isEqualTo("hello");
+    assertThat(value.getArrayValue().get(1).isStringValue()).isTrue();
+    assertThat(value.getArrayValue().get(1).getStringValue()).isEqualTo("world");
+  }
+
   @Test
   void testCanConvert() {
     assertThat(converter.canConvert(new String[] {"1", "2", "3"})).isTrue();
     assertThat(converter.canConvert(Collections.EMPTY_LIST)).isTrue();
     assertThat(converter.canConvert(Arrays.asList(1, 2, 3))).isTrue();
+    assertThat(converter.canConvert(new Integer[] {1, 2, 3})).isTrue();
+    assertThat(converter.canConvert(new int[] {1, 2, 3})).isTrue();
+    assertThat(converter.canConvert(new double[] {1.0, 2.0, 3.0})).isTrue();
+    assertThat(converter.canConvert(new boolean[] {true, false})).isTrue();
   }
 
   @Test