reflex 0.7.1a4__py3-none-any.whl → 0.7.2a1__py3-none-any.whl

reflex/vars/sequence.py

@@ -2,23 +2,24 @@
 
 from __future__ import annotations
 
+import collections.abc
 import dataclasses
 import inspect
 import json
 import re
-import typing
 from typing import (
     TYPE_CHECKING,
     Any,
-    Dict,
+    Iterable,
     List,
     Literal,
+    Mapping,
     NoReturn,
     Sequence,
-    Tuple,
     Type,
     TypeVar,
     Union,
+    get_args,
     overload,
 )
 
@@ -27,6 +28,7 @@ from typing_extensions import TypeVar as TypingExtensionsTypeVar
 from reflex import constants
 from reflex.constants.base import REFLEX_VAR_OPENING_TAG
 from reflex.constants.colors import Color
+from reflex.utils import types
 from reflex.utils.exceptions import VarTypeError
 from reflex.utils.types import GenericType, get_origin
 
@@ -58,1279 +60,1275 @@ if TYPE_CHECKING:
     from .function import FunctionVar
     from .object import ObjectVar
 
+ARRAY_VAR_TYPE = TypeVar("ARRAY_VAR_TYPE", bound=Sequence, covariant=True)
+OTHER_ARRAY_VAR_TYPE = TypeVar("OTHER_ARRAY_VAR_TYPE", bound=Sequence, covariant=True)
+MAPPING_VAR_TYPE = TypeVar("MAPPING_VAR_TYPE", bound=Mapping, covariant=True)
 
-STRING_TYPE = TypingExtensionsTypeVar("STRING_TYPE", default=str)
+OTHER_TUPLE = TypeVar("OTHER_TUPLE")
+
+INNER_ARRAY_VAR = TypeVar("INNER_ARRAY_VAR")
 
 
-class StringVar(Var[STRING_TYPE], python_types=str):
-    """Base class for immutable string vars."""
+KEY_TYPE = TypeVar("KEY_TYPE")
+VALUE_TYPE = TypeVar("VALUE_TYPE")
+
+
+class ArrayVar(Var[ARRAY_VAR_TYPE], python_types=(Sequence, set)):
+    """Base class for immutable array vars."""
 
     @overload
-    def __add__(self, other: StringVar | str) -> ConcatVarOperation: ...
+    def join(self, sep: StringVar | str = "") -> StringVar: ...
 
     @overload
-    def __add__(self, other: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
+    def join(self, sep: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
 
-    def __add__(self, other: Any) -> ConcatVarOperation:
-        """Concatenate two strings.
+    def join(self, sep: Any = "") -> StringVar:
+        """Join the elements of the array.
 
         Args:
-            other: The other string.
+            sep: The separator between elements.
 
         Returns:
-            The string concatenation operation.
+            The joined elements.
         """
-        if not isinstance(other, (StringVar, str)):
-            raise_unsupported_operand_types("+", (type(self), type(other)))
+        if not isinstance(sep, (StringVar, str)):
+            raise_unsupported_operand_types("join", (type(self), type(sep)))
+        if (
+            isinstance(self, LiteralArrayVar)
+            and (
+                len(
+                    args := [
+                        x
+                        for x in self._var_value
+                        if isinstance(x, (LiteralStringVar, str))
+                    ]
+                )
+                == len(self._var_value)
+            )
+            and isinstance(sep, (LiteralStringVar, str))
+        ):
+            sep_str = sep._var_value if isinstance(sep, LiteralStringVar) else sep
+            return LiteralStringVar.create(
+                sep_str.join(
+                    i._var_value if isinstance(i, LiteralStringVar) else i for i in args
+                )
+            )
+        return array_join_operation(self, sep)
 
-        return ConcatVarOperation.create(self, other)
+    def reverse(self) -> ArrayVar[ARRAY_VAR_TYPE]:
+        """Reverse the array.
+
+        Returns:
+            The reversed array.
+        """
+        return array_reverse_operation(self)
 
     @overload
-    def __radd__(self, other: StringVar | str) -> ConcatVarOperation: ...
+    def __add__(self, other: ArrayVar[ARRAY_VAR_TYPE]) -> ArrayVar[ARRAY_VAR_TYPE]: ...
 
     @overload
-    def __radd__(self, other: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
+    def __add__(self, other: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
 
-    def __radd__(self, other: Any) -> ConcatVarOperation:
-        """Concatenate two strings.
+    def __add__(self, other: Any) -> ArrayVar[ARRAY_VAR_TYPE]:
+        """Concatenate two arrays.
 
-        Args:
-            other: The other string.
+        Parameters:
+            other: The other array to concatenate.
 
         Returns:
-            The string concatenation operation.
+            ArrayConcatOperation: The concatenation of the two arrays.
         """
-        if not isinstance(other, (StringVar, str)):
-            raise_unsupported_operand_types("+", (type(other), type(self)))
+        if not isinstance(other, ArrayVar):
+            raise_unsupported_operand_types("+", (type(self), type(other)))
 
-        return ConcatVarOperation.create(other, self)
+        return array_concat_operation(self, other)
 
     @overload
-    def __mul__(self, other: NumberVar | int) -> StringVar: ...
+    def __getitem__(self, i: slice) -> ArrayVar[ARRAY_VAR_TYPE]: ...
 
     @overload
-    def __mul__(self, other: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
+    def __getitem__(
+        self: (
+            ArrayVar[tuple[int, OTHER_TUPLE]]
+            | ArrayVar[tuple[float, OTHER_TUPLE]]
+            | ArrayVar[tuple[int | float, OTHER_TUPLE]]
+        ),
+        i: Literal[0, -2],
+    ) -> NumberVar: ...
 
-    def __mul__(self, other: Any) -> StringVar:
-        """Multiply the sequence by a number or an integer.
+    @overload
+    def __getitem__(
+        self: ArrayVar[tuple[Any, bool]], i: Literal[1, -1]
+    ) -> BooleanVar: ...
 
-        Args:
-            other: The number or integer to multiply the sequence by.
+    @overload
+    def __getitem__(
+        self: (
+            ArrayVar[tuple[Any, int]]
+            | ArrayVar[tuple[Any, float]]
+            | ArrayVar[tuple[Any, int | float]]
+        ),
+        i: Literal[1, -1],
+    ) -> NumberVar: ...
 
-        Returns:
-            StringVar: The resulting sequence after multiplication.
-        """
-        if not isinstance(other, (NumberVar, int)):
-            raise_unsupported_operand_types("*", (type(self), type(other)))
+    @overload
+    def __getitem__(  # pyright: ignore [reportOverlappingOverload]
+        self: ArrayVar[tuple[str, Any]], i: Literal[0, -2]
+    ) -> StringVar: ...
 
-        return (self.split() * other).join()
+    @overload
+    def __getitem__(
+        self: ArrayVar[tuple[Any, str]], i: Literal[1, -1]
+    ) -> StringVar: ...
 
     @overload
-    def __rmul__(self, other: NumberVar | int) -> StringVar: ...
+    def __getitem__(
+        self: ArrayVar[tuple[bool, Any]], i: Literal[0, -2]
+    ) -> BooleanVar: ...
 
     @overload
-    def __rmul__(self, other: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
+    def __getitem__(
+        self: ArrayVar[Sequence[bool]], i: int | NumberVar
+    ) -> BooleanVar: ...
 
-    def __rmul__(self, other: Any) -> StringVar:
-        """Multiply the sequence by a number or an integer.
+    @overload
+    def __getitem__(
+        self: (
+            ArrayVar[Sequence[int]]
+            | ArrayVar[Sequence[float]]
+            | ArrayVar[Sequence[int | float]]
+        ),
+        i: int | NumberVar,
+    ) -> NumberVar: ...
 
-        Args:
-            other: The number or integer to multiply the sequence by.
+    @overload
+    def __getitem__(self: ArrayVar[Sequence[str]], i: int | NumberVar) -> StringVar: ...
 
-        Returns:
-            StringVar: The resulting sequence after multiplication.
-        """
-        if not isinstance(other, (NumberVar, int)):
-            raise_unsupported_operand_types("*", (type(other), type(self)))
+    @overload
+    def __getitem__(
+        self: ArrayVar[Sequence[OTHER_ARRAY_VAR_TYPE]],
+        i: int | NumberVar,
+    ) -> ArrayVar[OTHER_ARRAY_VAR_TYPE]: ...
 
-        return (self.split() * other).join()
+    @overload
+    def __getitem__(
+        self: ArrayVar[Sequence[MAPPING_VAR_TYPE]],
+        i: int | NumberVar,
+    ) -> ObjectVar[MAPPING_VAR_TYPE]: ...
 
     @overload
-    def __getitem__(self, i: slice) -> StringVar: ...
+    def __getitem__(
+        self: ArrayVar[Sequence[BASE_TYPE]],
+        i: int | NumberVar,
+    ) -> ObjectVar[BASE_TYPE]: ...
 
     @overload
-    def __getitem__(self, i: int | NumberVar) -> StringVar: ...
+    def __getitem__(
+        self: ArrayVar[Sequence[SQLA_TYPE]],
+        i: int | NumberVar,
+    ) -> ObjectVar[SQLA_TYPE]: ...
 
-    def __getitem__(self, i: Any) -> StringVar:
-        """Get a slice of the string.
+    @overload
+    def __getitem__(
+        self: ArrayVar[Sequence[DATACLASS_TYPE]],
+        i: int | NumberVar,
+    ) -> ObjectVar[DATACLASS_TYPE]: ...
+
+    @overload
+    def __getitem__(self, i: int | NumberVar) -> Var: ...
+
+    def __getitem__(self, i: Any) -> ArrayVar[ARRAY_VAR_TYPE] | Var:
+        """Get a slice of the array.
 
         Args:
             i: The slice.
 
         Returns:
-            The string slice operation.
+            The array slice operation.
         """
         if isinstance(i, slice):
-            return self.split()[i].join()
+            return ArraySliceOperation.create(self, i)
         if not isinstance(i, (int, NumberVar)) or (
             isinstance(i, NumberVar) and i._is_strict_float()
         ):
             raise_unsupported_operand_types("[]", (type(self), type(i)))
-        return string_item_operation(self, i)
+        return array_item_operation(self, i)
 
-    def length(self) -> NumberVar:
-        """Get the length of the string.
+    def length(self) -> NumberVar[int]:
+        """Get the length of the array.
 
         Returns:
-            The string length operation.
+            The length of the array.
         """
-        return self.split().length()
+        return array_length_operation(self)
 
-    def lower(self) -> StringVar:
-        """Convert the string to lowercase.
+    @overload
+    @classmethod
+    def range(cls, stop: int | NumberVar, /) -> ArrayVar[List[int]]: ...
 
-        Returns:
-            The string lower operation.
-        """
-        return string_lower_operation(self)
+    @overload
+    @classmethod
+    def range(
+        cls,
+        start: int | NumberVar,
+        end: int | NumberVar,
+        step: int | NumberVar = 1,
+        /,
+    ) -> ArrayVar[List[int]]: ...
 
-    def upper(self) -> StringVar:
-        """Convert the string to uppercase.
+    @overload
+    @classmethod
+    def range(
+        cls,
+        first_endpoint: int | NumberVar,
+        second_endpoint: int | NumberVar | None = None,
+        step: int | NumberVar | None = None,
+    ) -> ArrayVar[List[int]]: ...
 
-        Returns:
-            The string upper operation.
-        """
-        return string_upper_operation(self)
+    @classmethod
+    def range(
+        cls,
+        first_endpoint: int | NumberVar,
+        second_endpoint: int | NumberVar | None = None,
+        step: int | NumberVar | None = None,
+    ) -> ArrayVar[List[int]]:
+        """Create a range of numbers.
 
-    def title(self) -> StringVar:
-        """Convert the string to title case.
+        Args:
+            first_endpoint: The end of the range if second_endpoint is not provided, otherwise the start of the range.
+            second_endpoint: The end of the range.
+            step: The step of the range.
 
         Returns:
-            The string title operation.
+            The range of numbers.
         """
-        return string_title_operation(self)
+        if any(
+            not isinstance(i, (int, NumberVar))
+            for i in (first_endpoint, second_endpoint, step)
+            if i is not None
+        ):
+            raise_unsupported_operand_types(
+                "range", (type(first_endpoint), type(second_endpoint), type(step))
+            )
+        if second_endpoint is None:
+            start = 0
+            end = first_endpoint
+        else:
+            start = first_endpoint
+            end = second_endpoint
 
-    def capitalize(self) -> StringVar:
-        """Capitalize the string.
+        return array_range_operation(start, end, step or 1)
 
-        Returns:
-            The string capitalize operation.
-        """
-        return string_capitalize_operation(self)
+    @overload
+    def contains(self, other: Any) -> BooleanVar: ...
 
-    def strip(self) -> StringVar:
-        """Strip the string.
+    @overload
+    def contains(self, other: Any, field: StringVar | str) -> BooleanVar: ...
 
-        Returns:
-            The string strip operation.
-        """
-        return string_strip_operation(self)
-
-    def reversed(self) -> StringVar:
-        """Reverse the string.
-
-        Returns:
-            The string reverse operation.
-        """
-        return self.split().reverse().join()
-
-    @overload
-    def contains(
-        self, other: StringVar | str, field: StringVar | str | None = None
-    ) -> BooleanVar: ...
-
-    @overload
-    def contains(  # pyright: ignore [reportOverlappingOverload]
-        self, other: NoReturn, field: StringVar | str | None = None
-    ) -> NoReturn: ...
-
-    def contains(self, other: Any, field: Any = None) -> BooleanVar:
-        """Check if the string contains another string.
+    def contains(self, other: Any, field: Any = None) -> BooleanVar:
+        """Check if the array contains an element.
 
         Args:
-            other: The other string.
+            other: The element to check for.
             field: The field to check.
 
         Returns:
-            The string contains operation.
+            The array contains operation.
         """
-        if not isinstance(other, (StringVar, str)):
-            raise_unsupported_operand_types("contains", (type(self), type(other)))
         if field is not None:
             if not isinstance(field, (StringVar, str)):
                 raise_unsupported_operand_types("contains", (type(self), type(field)))
-            return string_contains_field_operation(self, other, field)
-        return string_contains_operation(self, other)
-
-    @overload
-    def split(self, separator: StringVar | str = "") -> ArrayVar[List[str]]: ...
-
-    @overload
-    def split(self, separator: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
+            return array_contains_field_operation(self, other, field)
+        return array_contains_operation(self, other)
 
-    def split(self, separator: Any = "") -> ArrayVar[List[str]]:
-        """Split the string.
+    def pluck(self, field: StringVar | str) -> ArrayVar:
+        """Pluck a field from the array.
 
         Args:
-            separator: The separator.
+            field: The field to pluck from the array.
 
         Returns:
-            The string split operation.
+            The array pluck operation.
         """
-        if not isinstance(separator, (StringVar, str)):
-            raise_unsupported_operand_types("split", (type(self), type(separator)))
-        return string_split_operation(self, separator)
+        return array_pluck_operation(self, field)
 
     @overload
-    def startswith(self, prefix: StringVar | str) -> BooleanVar: ...
+    def __mul__(self, other: NumberVar | int) -> ArrayVar[ARRAY_VAR_TYPE]: ...
 
     @overload
-    def startswith(self, prefix: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
+    def __mul__(self, other: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
 
-    def startswith(self, prefix: Any) -> BooleanVar:
-        """Check if the string starts with a prefix.
+    def __mul__(self, other: Any) -> ArrayVar[ARRAY_VAR_TYPE]:
+        """Multiply the sequence by a number or integer.
 
-        Args:
-            prefix: The prefix.
+        Parameters:
+            other: The number or integer to multiply the sequence by.
 
         Returns:
-            The string starts with operation.
+            ArrayVar[ARRAY_VAR_TYPE]: The result of multiplying the sequence by the given number or integer.
         """
-        if not isinstance(prefix, (StringVar, str)):
-            raise_unsupported_operand_types("startswith", (type(self), type(prefix)))
-        return string_starts_with_operation(self, prefix)
-
-    @overload
-    def endswith(self, suffix: StringVar | str) -> BooleanVar: ...
-
-    @overload
-    def endswith(self, suffix: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
-
-    def endswith(self, suffix: Any) -> BooleanVar:
-        """Check if the string ends with a suffix.
+        if not isinstance(other, (NumberVar, int)) or (
+            isinstance(other, NumberVar) and other._is_strict_float()
+        ):
+            raise_unsupported_operand_types("*", (type(self), type(other)))
 
-        Args:
-            suffix: The suffix.
+        return repeat_array_operation(self, other)
 
-        Returns:
-            The string ends with operation.
-        """
-        if not isinstance(suffix, (StringVar, str)):
-            raise_unsupported_operand_types("endswith", (type(self), type(suffix)))
-        return string_ends_with_operation(self, suffix)
+    __rmul__ = __mul__
 
     @overload
-    def __lt__(self, other: StringVar | str) -> BooleanVar: ...
+    def __lt__(self, other: ArrayVar[ARRAY_VAR_TYPE]) -> BooleanVar: ...
 
     @overload
-    def __lt__(self, other: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
+    def __lt__(self, other: list | tuple) -> BooleanVar: ...
 
     def __lt__(self, other: Any):
-        """Check if the string is less than another string.
+        """Check if the array is less than another array.
 
         Args:
-            other: The other string.
+            other: The other array.
 
         Returns:
-            The string less than operation.
+            The array less than operation.
         """
-        if not isinstance(other, (StringVar, str)):
+        if not isinstance(other, (ArrayVar, list, tuple)):
             raise_unsupported_operand_types("<", (type(self), type(other)))
 
-        return string_lt_operation(self, other)
+        return array_lt_operation(self, other)
 
     @overload
-    def __gt__(self, other: StringVar | str) -> BooleanVar: ...
+    def __gt__(self, other: ArrayVar[ARRAY_VAR_TYPE]) -> BooleanVar: ...
 
     @overload
-    def __gt__(self, other: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
+    def __gt__(self, other: list | tuple) -> BooleanVar: ...
 
     def __gt__(self, other: Any):
-        """Check if the string is greater than another string.
+        """Check if the array is greater than another array.
 
         Args:
-            other: The other string.
+            other: The other array.
 
         Returns:
-            The string greater than operation.
+            The array greater than operation.
         """
-        if not isinstance(other, (StringVar, str)):
+        if not isinstance(other, (ArrayVar, list, tuple)):
             raise_unsupported_operand_types(">", (type(self), type(other)))
 
-        return string_gt_operation(self, other)
+        return array_gt_operation(self, other)
 
     @overload
-    def __le__(self, other: StringVar | str) -> BooleanVar: ...
+    def __le__(self, other: ArrayVar[ARRAY_VAR_TYPE]) -> BooleanVar: ...
 
     @overload
-    def __le__(self, other: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
+    def __le__(self, other: list | tuple) -> BooleanVar: ...
 
     def __le__(self, other: Any):
-        """Check if the string is less than or equal to another string.
+        """Check if the array is less than or equal to another array.
 
         Args:
-            other: The other string.
+            other: The other array.
 
         Returns:
-            The string less than or equal operation.
+            The array less than or equal operation.
         """
-        if not isinstance(other, (StringVar, str)):
+        if not isinstance(other, (ArrayVar, list, tuple)):
             raise_unsupported_operand_types("<=", (type(self), type(other)))
 
-        return string_le_operation(self, other)
+        return array_le_operation(self, other)
 
     @overload
-    def __ge__(self, other: StringVar | str) -> BooleanVar: ...
+    def __ge__(self, other: ArrayVar[ARRAY_VAR_TYPE]) -> BooleanVar: ...
 
     @overload
-    def __ge__(self, other: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
+    def __ge__(self, other: list | tuple) -> BooleanVar: ...
 
     def __ge__(self, other: Any):
-        """Check if the string is greater than or equal to another string.
+        """Check if the array is greater than or equal to another array.
 
         Args:
-            other: The other string.
+            other: The other array.
 
         Returns:
-            The string greater than or equal operation.
+            The array greater than or equal operation.
         """
-        if not isinstance(other, (StringVar, str)):
+        if not isinstance(other, (ArrayVar, list, tuple)):
             raise_unsupported_operand_types(">=", (type(self), type(other)))
 
-        return string_ge_operation(self, other)
-
-    @overload
-    def replace(  # pyright: ignore [reportOverlappingOverload]
-        self, search_value: StringVar | str, new_value: StringVar | str
-    ) -> StringVar: ...
-
-    @overload
-    def replace(
-        self, search_value: Any, new_value: Any
-    ) -> CustomVarOperationReturn[StringVar]: ...
+        return array_ge_operation(self, other)
 
-    def replace(self, search_value: Any, new_value: Any) -> StringVar:  # pyright: ignore [reportInconsistentOverload]
-        """Replace a string with a value.
+    def foreach(self, fn: Any):
+        """Apply a function to each element of the array.
 
         Args:
-            search_value: The string to search.
-            new_value: The value to be replaced with.
+            fn: The function to apply.
 
         Returns:
-            The string replace operation.
-        """
-        if not isinstance(search_value, (StringVar, str)):
-            raise_unsupported_operand_types("replace", (type(self), type(search_value)))
-        if not isinstance(new_value, (StringVar, str)):
-            raise_unsupported_operand_types("replace", (type(self), type(new_value)))
-
-        return string_replace_operation(self, search_value, new_value)
+            The array after applying the function.
 
+        Raises:
+            VarTypeError: If the function takes more than one argument.
+        """
+        from .function import ArgsFunctionOperation
 
-@var_operation
-def string_lt_operation(lhs: StringVar[Any] | str, rhs: StringVar[Any] | str):
-    """Check if a string is less than another string.
+        if not callable(fn):
+            raise_unsupported_operand_types("foreach", (type(self), type(fn)))
+        # get the number of arguments of the function
+        num_args = len(inspect.signature(fn).parameters)
+        if num_args > 1:
+            raise VarTypeError(
+                "The function passed to foreach should take at most one argument."
+            )
 
-    Args:
-        lhs: The left-hand side string.
-        rhs: The right-hand side string.
+        if num_args == 0:
+            return_value = fn()
+            function_var = ArgsFunctionOperation.create((), return_value)
+        else:
+            # generic number var
+            number_var = Var("").to(NumberVar, int)
 
-    Returns:
-        The string less than operation.
-    """
-    return var_operation_return(js_expression=f"{lhs} < {rhs}", var_type=bool)
+            first_arg_type = self[number_var]._var_type
 
+            arg_name = get_unique_variable_name()
 
-@var_operation
-def string_gt_operation(lhs: StringVar[Any] | str, rhs: StringVar[Any] | str):
-    """Check if a string is greater than another string.
+            # get first argument type
+            first_arg = Var(
+                _js_expr=arg_name,
+                _var_type=first_arg_type,
+            ).guess_type()
 
-    Args:
-        lhs: The left-hand side string.
-        rhs: The right-hand side string.
+            function_var = ArgsFunctionOperation.create(
+                (arg_name,),
+                Var.create(fn(first_arg)),
+            )
 
-    Returns:
-        The string greater than operation.
-    """
-    return var_operation_return(js_expression=f"{lhs} > {rhs}", var_type=bool)
+        return map_array_operation(self, function_var)
 
 
-@var_operation
-def string_le_operation(lhs: StringVar[Any] | str, rhs: StringVar[Any] | str):
-    """Check if a string is less than or equal to another string.
+@dataclasses.dataclass(
+    eq=False,
+    frozen=True,
+    slots=True,
+)
+class LiteralArrayVar(CachedVarOperation, LiteralVar, ArrayVar[ARRAY_VAR_TYPE]):
+    """Base class for immutable literal array vars."""
 
-    Args:
-        lhs: The left-hand side string.
-        rhs: The right-hand side string.
+    _var_value: Sequence[Union[Var, Any]] = dataclasses.field(default=())
 
-    Returns:
-        The string less than or equal operation.
-    """
-    return var_operation_return(js_expression=f"{lhs} <= {rhs}", var_type=bool)
+    @cached_property_no_lock
+    def _cached_var_name(self) -> str:
+        """The name of the var.
 
+        Returns:
+            The name of the var.
+        """
+        return (
+            "["
+            + ", ".join(
+                [str(LiteralVar.create(element)) for element in self._var_value]
+            )
+            + "]"
+        )
 
-@var_operation
-def string_ge_operation(lhs: StringVar[Any] | str, rhs: StringVar[Any] | str):
-    """Check if a string is greater than or equal to another string.
+    @cached_property_no_lock
+    def _cached_get_all_var_data(self) -> VarData | None:
+        """Get all the VarData associated with the Var.
 
-    Args:
-        lhs: The left-hand side string.
-        rhs: The right-hand side string.
-
-    Returns:
-        The string greater than or equal operation.
-    """
-    return var_operation_return(js_expression=f"{lhs} >= {rhs}", var_type=bool)
+        Returns:
+            The VarData associated with the Var.
+        """
+        return VarData.merge(
+            *[
+                LiteralVar.create(element)._get_all_var_data()
+                for element in self._var_value
+            ],
+            self._var_data,
+        )
 
+    def __hash__(self) -> int:
+        """Get the hash of the var.
 
-@var_operation
-def string_lower_operation(string: StringVar[Any]):
-    """Convert a string to lowercase.
+        Returns:
+            The hash of the var.
+        """
+        return hash((self.__class__.__name__, self._js_expr))
 
-    Args:
-        string: The string to convert.
+    def json(self) -> str:
+        """Get the JSON representation of the var.
 
-    Returns:
-        The lowercase string.
-    """
-    return var_operation_return(js_expression=f"{string}.toLowerCase()", var_type=str)
+        Returns:
+            The JSON representation of the var.
 
+        Raises:
+            TypeError: If the array elements are not of type LiteralVar.
+        """
+        elements = []
+        for element in self._var_value:
+            element_var = LiteralVar.create(element)
+            if not isinstance(element_var, LiteralVar):
+                raise TypeError(
+                    f"Array elements must be of type LiteralVar, not {type(element_var)}"
+                )
+            elements.append(element_var.json())
 
-@var_operation
-def string_upper_operation(string: StringVar[Any]):
-    """Convert a string to uppercase.
+        return "[" + ", ".join(elements) + "]"
 
-    Args:
-        string: The string to convert.
+    @classmethod
+    def create(
+        cls,
+        value: OTHER_ARRAY_VAR_TYPE,
+        _var_type: Type[OTHER_ARRAY_VAR_TYPE] | None = None,
+        _var_data: VarData | None = None,
+    ) -> LiteralArrayVar[OTHER_ARRAY_VAR_TYPE]:
+        """Create a var from a string value.
 
-    Returns:
-        The uppercase string.
-    """
-    return var_operation_return(js_expression=f"{string}.toUpperCase()", var_type=str)
+        Args:
+            value: The value to create the var from.
+            _var_type: The type of the var.
+            _var_data: Additional hooks and imports associated with the Var.
 
+        Returns:
+            The var.
+        """
+        return LiteralArrayVar(
+            _js_expr="",
+            _var_type=figure_out_type(value) if _var_type is None else _var_type,
+            _var_data=_var_data,
+            _var_value=value,
+        )
 
-@var_operation
-def string_title_operation(string: StringVar[Any]):
-    """Convert a string to title case.
 
-    Args:
-        string: The string to convert.
+STRING_TYPE = TypingExtensionsTypeVar("STRING_TYPE", default=str)
 
-    Returns:
-        The title case string.
-    """
-    return var_operation_return(
-        js_expression=f"{string}.split(' ').map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(' ')",
-        var_type=str,
-    )
 
+class StringVar(Var[STRING_TYPE], python_types=str):
+    """Base class for immutable string vars."""
 
-@var_operation
-def string_capitalize_operation(string: StringVar[Any]):
-    """Capitalize a string.
+    @overload
+    def __add__(self, other: StringVar | str) -> ConcatVarOperation: ...
 
-    Args:
-        string: The string to capitalize.
+    @overload
+    def __add__(self, other: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
 
-    Returns:
-        The capitalized string.
-    """
-    return var_operation_return(
-        js_expression=f"(((s) => s.charAt(0).toUpperCase() + s.slice(1).toLowerCase())({string}))",
-        var_type=str,
-    )
+    def __add__(self, other: Any) -> ConcatVarOperation:
+        """Concatenate two strings.
 
+        Args:
+            other: The other string.
 
-@var_operation
-def string_strip_operation(string: StringVar[Any]):
-    """Strip a string.
+        Returns:
+            The string concatenation operation.
+        """
+        if not isinstance(other, (StringVar, str)):
+            raise_unsupported_operand_types("+", (type(self), type(other)))
 
-    Args:
-        string: The string to strip.
+        return ConcatVarOperation.create(self, other)
 
-    Returns:
-        The stripped string.
-    """
-    return var_operation_return(js_expression=f"{string}.trim()", var_type=str)
+    @overload
+    def __radd__(self, other: StringVar | str) -> ConcatVarOperation: ...
 
+    @overload
+    def __radd__(self, other: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
 
-@var_operation
-def string_contains_field_operation(
-    haystack: StringVar[Any], needle: StringVar[Any] | str, field: StringVar[Any] | str
-):
-    """Check if a string contains another string.
+    def __radd__(self, other: Any) -> ConcatVarOperation:
+        """Concatenate two strings.
 
-    Args:
-        haystack: The haystack.
-        needle: The needle.
-        field: The field to check.
+        Args:
+            other: The other string.
 
-    Returns:
-        The string contains operation.
-    """
-    return var_operation_return(
-        js_expression=f"{haystack}.some(obj => obj[{field}] === {needle})",
-        var_type=bool,
-    )
+        Returns:
+            The string concatenation operation.
+        """
+        if not isinstance(other, (StringVar, str)):
+            raise_unsupported_operand_types("+", (type(other), type(self)))
 
+        return ConcatVarOperation.create(other, self)
 
-@var_operation
-def string_contains_operation(haystack: StringVar[Any], needle: StringVar[Any] | str):
-    """Check if a string contains another string.
+    @overload
+    def __mul__(self, other: NumberVar | int) -> StringVar: ...
 
-    Args:
-        haystack: The haystack.
-        needle: The needle.
+    @overload
+    def __mul__(self, other: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
 
-    Returns:
-        The string contains operation.
-    """
-    return var_operation_return(
-        js_expression=f"{haystack}.includes({needle})", var_type=bool
-    )
+    def __mul__(self, other: Any) -> StringVar:
+        """Multiply the sequence by a number or an integer.
 
+        Args:
+            other: The number or integer to multiply the sequence by.
 
-@var_operation
-def string_starts_with_operation(
-    full_string: StringVar[Any], prefix: StringVar[Any] | str
-):
-    """Check if a string starts with a prefix.
+        Returns:
+            StringVar: The resulting sequence after multiplication.
+        """
+        if not isinstance(other, (NumberVar, int)):
+            raise_unsupported_operand_types("*", (type(self), type(other)))
 
-    Args:
-        full_string: The full string.
-        prefix: The prefix.
+        return (self.split() * other).join()
 
-    Returns:
-        Whether the string starts with the prefix.
-    """
-    return var_operation_return(
-        js_expression=f"{full_string}.startsWith({prefix})", var_type=bool
-    )
+    @overload
+    def __rmul__(self, other: NumberVar | int) -> StringVar: ...
 
+    @overload
+    def __rmul__(self, other: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
 
-@var_operation
-def string_ends_with_operation(
-    full_string: StringVar[Any], suffix: StringVar[Any] | str
-):
-    """Check if a string ends with a suffix.
+    def __rmul__(self, other: Any) -> StringVar:
+        """Multiply the sequence by a number or an integer.
 
-    Args:
-        full_string: The full string.
-        suffix: The suffix.
+        Args:
+            other: The number or integer to multiply the sequence by.
 
-    Returns:
-        Whether the string ends with the suffix.
-    """
-    return var_operation_return(
-        js_expression=f"{full_string}.endsWith({suffix})", var_type=bool
-    )
+        Returns:
+            StringVar: The resulting sequence after multiplication.
+        """
+        if not isinstance(other, (NumberVar, int)):
+            raise_unsupported_operand_types("*", (type(other), type(self)))
 
+        return (self.split() * other).join()
 
-@var_operation
-def string_item_operation(string: StringVar[Any], index: NumberVar | int):
-    """Get an item from a string.
+    @overload
+    def __getitem__(self, i: slice) -> StringVar: ...
 
-    Args:
-        string: The string.
-        index: The index of the item.
+    @overload
+    def __getitem__(self, i: int | NumberVar) -> StringVar: ...
 
-    Returns:
-        The item from the string.
-    """
-    return var_operation_return(js_expression=f"{string}.at({index})", var_type=str)
+    def __getitem__(self, i: Any) -> StringVar:
+        """Get a slice of the string.
 
+        Args:
+            i: The slice.
 
-@var_operation
-def array_join_operation(array: ArrayVar, sep: StringVar[Any] | str = ""):
-    """Join the elements of an array.
+        Returns:
+            The string slice operation.
+        """
+        if isinstance(i, slice):
+            return self.split()[i].join()
+        if not isinstance(i, (int, NumberVar)) or (
+            isinstance(i, NumberVar) and i._is_strict_float()
+        ):
+            raise_unsupported_operand_types("[]", (type(self), type(i)))
+        return string_item_operation(self, i)
 
-    Args:
-        array: The array.
-        sep: The separator.
+    def length(self) -> NumberVar:
+        """Get the length of the string.
 
-    Returns:
-        The joined elements.
-    """
-    return var_operation_return(js_expression=f"{array}.join({sep})", var_type=str)
+        Returns:
+            The string length operation.
+        """
+        return self.split().length()
 
+    def lower(self) -> StringVar:
+        """Convert the string to lowercase.
 
-@var_operation
-def string_replace_operation(
-    string: StringVar[Any], search_value: StringVar | str, new_value: StringVar | str
-):
-    """Replace a string with a value.
+        Returns:
+            The string lower operation.
+        """
+        return string_lower_operation(self)
 
-    Args:
-        string: The string.
-        search_value: The string to search.
-        new_value: The value to be replaced with.
+    def upper(self) -> StringVar:
+        """Convert the string to uppercase.
 
-    Returns:
-        The string replace operation.
-    """
-    return var_operation_return(
-        js_expression=f"{string}.replaceAll({search_value}, {new_value})",
-        var_type=str,
-    )
+        Returns:
+            The string upper operation.
+        """
+        return string_upper_operation(self)
 
+    def title(self) -> StringVar:
+        """Convert the string to title case.
 
-# Compile regex for finding reflex var tags.
-_decode_var_pattern_re = (
-    rf"{constants.REFLEX_VAR_OPENING_TAG}(.*?){constants.REFLEX_VAR_CLOSING_TAG}"
-)
-_decode_var_pattern = re.compile(_decode_var_pattern_re, flags=re.DOTALL)
+        Returns:
+            The string title operation.
+        """
+        return string_title_operation(self)
 
+    def capitalize(self) -> StringVar:
+        """Capitalize the string.
 
-@dataclasses.dataclass(
-    eq=False,
-    frozen=True,
-    slots=True,
-)
-class LiteralStringVar(LiteralVar, StringVar[str]):
-    """Base class for immutable literal string vars."""
+        Returns:
+            The string capitalize operation.
+        """
+        return string_capitalize_operation(self)
 
-    _var_value: str = dataclasses.field(default="")
+    def strip(self) -> StringVar:
+        """Strip the string.
 
-    @classmethod
-    def create(
-        cls,
-        value: str,
-        _var_type: GenericType | None = None,
-        _var_data: VarData | None = None,
-    ) -> StringVar:
-        """Create a var from a string value.
+        Returns:
+            The string strip operation.
+        """
+        return string_strip_operation(self)
 
-        Args:
-            value: The value to create the var from.
-            _var_type: The type of the var.
-            _var_data: Additional hooks and imports associated with the Var.
+    def reversed(self) -> StringVar:
+        """Reverse the string.
 
         Returns:
-            The var.
+            The string reverse operation.
         """
-        # Determine var type in case the value is inherited from str.
-        _var_type = _var_type or type(value) or str
+        return self.split().reverse().join()
 
-        if REFLEX_VAR_OPENING_TAG in value:
-            strings_and_vals: list[Var | str] = []
-            offset = 0
+    @overload
+    def contains(
+        self, other: StringVar | str, field: StringVar | str | None = None
+    ) -> BooleanVar: ...
 
-            # Find all tags
-            while m := _decode_var_pattern.search(value):
-                start, end = m.span()
+    @overload
+    def contains(  # pyright: ignore [reportOverlappingOverload]
+        self, other: NoReturn, field: StringVar | str | None = None
+    ) -> NoReturn: ...
 
-                strings_and_vals.append(value[:start])
+    def contains(self, other: Any, field: Any = None) -> BooleanVar:
+        """Check if the string contains another string.
 
-                serialized_data = m.group(1)
+        Args:
+            other: The other string.
+            field: The field to check.
 
-                if serialized_data.isnumeric() or (
-                    serialized_data[0] == "-" and serialized_data[1:].isnumeric()
-                ):
-                    # This is a global immutable var.
-                    var = _global_vars[int(serialized_data)]
-                    strings_and_vals.append(var)
-                    value = value[(end + len(var._js_expr)) :]
+        Returns:
+            The string contains operation.
+        """
+        if not isinstance(other, (StringVar, str)):
+            raise_unsupported_operand_types("contains", (type(self), type(other)))
+        if field is not None:
+            if not isinstance(field, (StringVar, str)):
+                raise_unsupported_operand_types("contains", (type(self), type(field)))
+            return string_contains_field_operation(self, other, field)
+        return string_contains_operation(self, other)
 
-                offset += end - start
+    @overload
+    def split(self, separator: StringVar | str = "") -> ArrayVar[list[str]]: ...
 
-            strings_and_vals.append(value)
+    @overload
+    def split(self, separator: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
 
-            filtered_strings_and_vals = [
-                s for s in strings_and_vals if isinstance(s, Var) or s
-            ]
-            if len(filtered_strings_and_vals) == 1:
-                only_string = filtered_strings_and_vals[0]
-                if isinstance(only_string, str):
-                    return LiteralVar.create(only_string).to(StringVar, _var_type)
-                else:
-                    return only_string.to(StringVar, only_string._var_type)
+    def split(self, separator: Any = "") -> ArrayVar[list[str]]:
+        """Split the string.
 
-            if len(
-                literal_strings := [
-                    s
-                    for s in filtered_strings_and_vals
-                    if isinstance(s, (str, LiteralStringVar))
-                ]
-            ) == len(filtered_strings_and_vals):
-                return LiteralStringVar.create(
-                    "".join(
-                        s._var_value if isinstance(s, LiteralStringVar) else s
-                        for s in literal_strings
-                    ),
-                    _var_type=_var_type,
-                    _var_data=VarData.merge(
-                        _var_data,
-                        *(
-                            s._get_all_var_data()
-                            for s in filtered_strings_and_vals
-                            if isinstance(s, Var)
-                        ),
-                    ),
-                )
+        Args:
+            separator: The separator.
 
-            concat_result = ConcatVarOperation.create(
-                *filtered_strings_and_vals,
-                _var_data=_var_data,
-            )
+        Returns:
+            The string split operation.
+        """
+        if not isinstance(separator, (StringVar, str)):
+            raise_unsupported_operand_types("split", (type(self), type(separator)))
+        return string_split_operation(self, separator)
 
-            return (
-                concat_result
-                if _var_type is str
-                else concat_result.to(StringVar, _var_type)
-            )
+    @overload
+    def startswith(self, prefix: StringVar | str) -> BooleanVar: ...
 
-        return LiteralStringVar(
-            _js_expr=json.dumps(value),
-            _var_type=_var_type,
-            _var_data=_var_data,
-            _var_value=value,
-        )
+    @overload
+    def startswith(self, prefix: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
 
-    def __hash__(self) -> int:
-        """Get the hash of the var.
+    def startswith(self, prefix: Any) -> BooleanVar:
+        """Check if the string starts with a prefix.
+
+        Args:
+            prefix: The prefix.
 
         Returns:
-            The hash of the var.
+            The string starts with operation.
         """
-        return hash((type(self).__name__, self._var_value))
+        if not isinstance(prefix, (StringVar, str)):
+            raise_unsupported_operand_types("startswith", (type(self), type(prefix)))
+        return string_starts_with_operation(self, prefix)
 
-    def json(self) -> str:
-        """Get the JSON representation of the var.
+    @overload
+    def endswith(self, suffix: StringVar | str) -> BooleanVar: ...
+
+    @overload
+    def endswith(self, suffix: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
+
+    def endswith(self, suffix: Any) -> BooleanVar:
+        """Check if the string ends with a suffix.
+
+        Args:
+            suffix: The suffix.
 
         Returns:
-            The JSON representation of the var.
+            The string ends with operation.
         """
-        return json.dumps(self._var_value)
+        if not isinstance(suffix, (StringVar, str)):
+            raise_unsupported_operand_types("endswith", (type(self), type(suffix)))
+        return string_ends_with_operation(self, suffix)
 
+    @overload
+    def __lt__(self, other: StringVar | str) -> BooleanVar: ...
 
-@dataclasses.dataclass(
-    eq=False,
-    frozen=True,
-    slots=True,
-)
-class ConcatVarOperation(CachedVarOperation, StringVar[str]):
-    """Representing a concatenation of literal string vars."""
+    @overload
+    def __lt__(self, other: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
 
-    _var_value: Tuple[Var, ...] = dataclasses.field(default_factory=tuple)
+    def __lt__(self, other: Any):
+        """Check if the string is less than another string.
 
-    @cached_property_no_lock
-    def _cached_var_name(self) -> str:
-        """The name of the var.
+        Args:
+            other: The other string.
 
         Returns:
-            The name of the var.
+            The string less than operation.
         """
-        list_of_strs: List[Union[str, Var]] = []
-        last_string = ""
-        for var in self._var_value:
-            if isinstance(var, LiteralStringVar):
-                last_string += var._var_value
-            else:
-                if last_string:
-                    list_of_strs.append(last_string)
-                    last_string = ""
-                list_of_strs.append(var)
+        if not isinstance(other, (StringVar, str)):
+            raise_unsupported_operand_types("<", (type(self), type(other)))
 
-        if last_string:
-            list_of_strs.append(last_string)
-
-        list_of_strs_filtered = [
-            str(LiteralVar.create(s)) for s in list_of_strs if isinstance(s, Var) or s
-        ]
-
-        if len(list_of_strs_filtered) == 1:
-            return list_of_strs_filtered[0]
-
-        return "(" + "+".join(list_of_strs_filtered) + ")"
+        return string_lt_operation(self, other)
 
-    @cached_property_no_lock
-    def _cached_get_all_var_data(self) -> VarData | None:
-        """Get all the VarData asVarDatae Var.
+    @overload
+    def __gt__(self, other: StringVar | str) -> BooleanVar: ...
 
-        Returns:
-            The VarData associated with the Var.
-        """
-        return VarData.merge(
-            *[
-                var._get_all_var_data()
-                for var in self._var_value
-                if isinstance(var, Var)
-            ],
-            self._var_data,
-        )
+    @overload
+    def __gt__(self, other: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
 
-    @classmethod
-    def create(
-        cls,
-        *value: Var | str,
-        _var_data: VarData | None = None,
-    ) -> ConcatVarOperation:
-        """Create a var from a string value.
+    def __gt__(self, other: Any):
+        """Check if the string is greater than another string.
 
         Args:
-            *value: The values to concatenate.
-            _var_data: Additional hooks and imports associated with the Var.
+            other: The other string.
 
         Returns:
-            The var.
+            The string greater than operation.
         """
-        return cls(
-            _js_expr="",
-            _var_type=str,
-            _var_data=_var_data,
-            _var_value=tuple(map(LiteralVar.create, value)),
-        )
+        if not isinstance(other, (StringVar, str)):
+            raise_unsupported_operand_types(">", (type(self), type(other)))
 
+        return string_gt_operation(self, other)
 
-ARRAY_VAR_TYPE = TypeVar("ARRAY_VAR_TYPE", bound=Sequence, covariant=True)
-OTHER_ARRAY_VAR_TYPE = TypeVar("OTHER_ARRAY_VAR_TYPE", bound=Sequence)
+    @overload
+    def __le__(self, other: StringVar | str) -> BooleanVar: ...
 
-OTHER_TUPLE = TypeVar("OTHER_TUPLE")
+    @overload
+    def __le__(self, other: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
 
-INNER_ARRAY_VAR = TypeVar("INNER_ARRAY_VAR")
+    def __le__(self, other: Any):
+        """Check if the string is less than or equal to another string.
 
-KEY_TYPE = TypeVar("KEY_TYPE")
-VALUE_TYPE = TypeVar("VALUE_TYPE")
+        Args:
+            other: The other string.
 
+        Returns:
+            The string less than or equal operation.
+        """
+        if not isinstance(other, (StringVar, str)):
+            raise_unsupported_operand_types("<=", (type(self), type(other)))
 
-class ArrayVar(Var[ARRAY_VAR_TYPE], python_types=(list, tuple, set)):
-    """Base class for immutable array vars."""
+        return string_le_operation(self, other)
 
     @overload
-    def join(self, sep: StringVar | str = "") -> StringVar: ...
+    def __ge__(self, other: StringVar | str) -> BooleanVar: ...
 
     @overload
-    def join(self, sep: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
+    def __ge__(self, other: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
 
-    def join(self, sep: Any = "") -> StringVar:
-        """Join the elements of the array.
+    def __ge__(self, other: Any):
+        """Check if the string is greater than or equal to another string.
 
         Args:
-            sep: The separator between elements.
+            other: The other string.
 
         Returns:
-            The joined elements.
+            The string greater than or equal operation.
         """
-        if not isinstance(sep, (StringVar, str)):
-            raise_unsupported_operand_types("join", (type(self), type(sep)))
-        if (
-            isinstance(self, LiteralArrayVar)
-            and (
-                len(
-                    args := [
-                        x
-                        for x in self._var_value
-                        if isinstance(x, (LiteralStringVar, str))
-                    ]
-                )
-                == len(self._var_value)
-            )
-            and isinstance(sep, (LiteralStringVar, str))
-        ):
-            sep_str = sep._var_value if isinstance(sep, LiteralStringVar) else sep
-            return LiteralStringVar.create(
-                sep_str.join(
-                    i._var_value if isinstance(i, LiteralStringVar) else i for i in args
-                )
-            )
-        return array_join_operation(self, sep)
-
-    def reverse(self) -> ArrayVar[ARRAY_VAR_TYPE]:
-        """Reverse the array.
+        if not isinstance(other, (StringVar, str)):
+            raise_unsupported_operand_types(">=", (type(self), type(other)))
 
-        Returns:
-            The reversed array.
-        """
-        return array_reverse_operation(self)
+        return string_ge_operation(self, other)
 
     @overload
-    def __add__(self, other: ArrayVar[ARRAY_VAR_TYPE]) -> ArrayVar[ARRAY_VAR_TYPE]: ...
+    def replace(  # pyright: ignore [reportOverlappingOverload]
+        self, search_value: StringVar | str, new_value: StringVar | str
+    ) -> StringVar: ...
 
     @overload
-    def __add__(self, other: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
+    def replace(
+        self, search_value: Any, new_value: Any
+    ) -> CustomVarOperationReturn[StringVar]: ...
 
-    def __add__(self, other: Any) -> ArrayVar[ARRAY_VAR_TYPE]:
-        """Concatenate two arrays.
+    def replace(self, search_value: Any, new_value: Any) -> StringVar:  # pyright: ignore [reportInconsistentOverload]
+        """Replace a string with a value.
 
-        Parameters:
-            other: The other array to concatenate.
+        Args:
+            search_value: The string to search.
+            new_value: The value to be replaced with.
 
         Returns:
-            ArrayConcatOperation: The concatenation of the two arrays.
+            The string replace operation.
         """
-        if not isinstance(other, ArrayVar):
-            raise_unsupported_operand_types("+", (type(self), type(other)))
+        if not isinstance(search_value, (StringVar, str)):
+            raise_unsupported_operand_types("replace", (type(self), type(search_value)))
+        if not isinstance(new_value, (StringVar, str)):
+            raise_unsupported_operand_types("replace", (type(self), type(new_value)))
 
-        return array_concat_operation(self, other)
+        return string_replace_operation(self, search_value, new_value)
 
-    @overload
-    def __getitem__(self, i: slice) -> ArrayVar[ARRAY_VAR_TYPE]: ...
 
-    @overload
-    def __getitem__(
-        self: (
-            ArrayVar[Tuple[int, OTHER_TUPLE]]
-            | ArrayVar[Tuple[float, OTHER_TUPLE]]
-            | ArrayVar[Tuple[int | float, OTHER_TUPLE]]
-        ),
-        i: Literal[0, -2],
-    ) -> NumberVar: ...
+@var_operation
+def string_lt_operation(lhs: StringVar[Any] | str, rhs: StringVar[Any] | str):
+    """Check if a string is less than another string.
 
-    @overload
-    def __getitem__(
-        self: ArrayVar[Tuple[Any, bool]], i: Literal[1, -1]
-    ) -> BooleanVar: ...
+    Args:
+        lhs: The left-hand side string.
+        rhs: The right-hand side string.
 
-    @overload
-    def __getitem__(
-        self: (
-            ArrayVar[Tuple[Any, int]]
-            | ArrayVar[Tuple[Any, float]]
-            | ArrayVar[Tuple[Any, int | float]]
-        ),
-        i: Literal[1, -1],
-    ) -> NumberVar: ...
+    Returns:
+        The string less than operation.
+    """
+    return var_operation_return(js_expression=f"{lhs} < {rhs}", var_type=bool)
 
-    @overload
-    def __getitem__(
-        self: ArrayVar[Tuple[str, Any]], i: Literal[0, -2]
-    ) -> StringVar: ...
 
-    @overload
-    def __getitem__(
-        self: ArrayVar[Tuple[Any, str]], i: Literal[1, -1]
-    ) -> StringVar: ...
+@var_operation
+def string_gt_operation(lhs: StringVar[Any] | str, rhs: StringVar[Any] | str):
+    """Check if a string is greater than another string.
 
-    @overload
-    def __getitem__(
-        self: ArrayVar[Tuple[bool, Any]], i: Literal[0, -2]
-    ) -> BooleanVar: ...
+    Args:
+        lhs: The left-hand side string.
+        rhs: The right-hand side string.
 
-    @overload
-    def __getitem__(
-        self: ARRAY_VAR_OF_LIST_ELEMENT[bool], i: int | NumberVar
-    ) -> BooleanVar: ...
+    Returns:
+        The string greater than operation.
+    """
+    return var_operation_return(js_expression=f"{lhs} > {rhs}", var_type=bool)
 
-    @overload
-    def __getitem__(
-        self: (
-            ARRAY_VAR_OF_LIST_ELEMENT[int]
-            | ARRAY_VAR_OF_LIST_ELEMENT[float]
-            | ARRAY_VAR_OF_LIST_ELEMENT[int | float]
-        ),
-        i: int | NumberVar,
-    ) -> NumberVar: ...
 
-    @overload
-    def __getitem__(
-        self: ARRAY_VAR_OF_LIST_ELEMENT[str], i: int | NumberVar
-    ) -> StringVar: ...
+@var_operation
+def string_le_operation(lhs: StringVar[Any] | str, rhs: StringVar[Any] | str):
+    """Check if a string is less than or equal to another string.
 
-    @overload
-    def __getitem__(
-        self: ARRAY_VAR_OF_LIST_ELEMENT[List[INNER_ARRAY_VAR]],
-        i: int | NumberVar,
-    ) -> ArrayVar[List[INNER_ARRAY_VAR]]: ...
+    Args:
+        lhs: The left-hand side string.
+        rhs: The right-hand side string.
 
-    @overload
-    def __getitem__(
-        self: ARRAY_VAR_OF_LIST_ELEMENT[Tuple[KEY_TYPE, VALUE_TYPE]],
-        i: int | NumberVar,
-    ) -> ArrayVar[Tuple[KEY_TYPE, VALUE_TYPE]]: ...
+    Returns:
+        The string less than or equal operation.
+    """
+    return var_operation_return(js_expression=f"{lhs} <= {rhs}", var_type=bool)
 
-    @overload
-    def __getitem__(
-        self: ARRAY_VAR_OF_LIST_ELEMENT[Tuple[INNER_ARRAY_VAR, ...]],
-        i: int | NumberVar,
-    ) -> ArrayVar[Tuple[INNER_ARRAY_VAR, ...]]: ...
 
-    @overload
-    def __getitem__(
-        self: ARRAY_VAR_OF_LIST_ELEMENT[Dict[KEY_TYPE, VALUE_TYPE]],
-        i: int | NumberVar,
-    ) -> ObjectVar[Dict[KEY_TYPE, VALUE_TYPE]]: ...
+@var_operation
+def string_ge_operation(lhs: StringVar[Any] | str, rhs: StringVar[Any] | str):
+    """Check if a string is greater than or equal to another string.
 
-    @overload
-    def __getitem__(
-        self: ARRAY_VAR_OF_LIST_ELEMENT[BASE_TYPE],
-        i: int | NumberVar,
-    ) -> ObjectVar[BASE_TYPE]: ...
+    Args:
+        lhs: The left-hand side string.
+        rhs: The right-hand side string.
 
-    @overload
-    def __getitem__(
-        self: ARRAY_VAR_OF_LIST_ELEMENT[SQLA_TYPE],
-        i: int | NumberVar,
-    ) -> ObjectVar[SQLA_TYPE]: ...
+    Returns:
+        The string greater than or equal operation.
+    """
+    return var_operation_return(js_expression=f"{lhs} >= {rhs}", var_type=bool)
 
-    @overload
-    def __getitem__(
-        self: ARRAY_VAR_OF_LIST_ELEMENT[DATACLASS_TYPE],
-        i: int | NumberVar,
-    ) -> ObjectVar[DATACLASS_TYPE]: ...
 
-    @overload
-    def __getitem__(self, i: int | NumberVar) -> Var: ...
+@var_operation
+def string_lower_operation(string: StringVar[Any]):
+    """Convert a string to lowercase.
 
-    def __getitem__(self, i: Any) -> ArrayVar[ARRAY_VAR_TYPE] | Var:
-        """Get a slice of the array.
+    Args:
+        string: The string to convert.
 
-        Args:
-            i: The slice.
+    Returns:
+        The lowercase string.
+    """
+    return var_operation_return(js_expression=f"{string}.toLowerCase()", var_type=str)
 
-        Returns:
-            The array slice operation.
-        """
-        if isinstance(i, slice):
-            return ArraySliceOperation.create(self, i)
-        if not isinstance(i, (int, NumberVar)) or (
-            isinstance(i, NumberVar) and i._is_strict_float()
-        ):
-            raise_unsupported_operand_types("[]", (type(self), type(i)))
-        return array_item_operation(self, i)
 
-    def length(self) -> NumberVar[int]:
-        """Get the length of the array.
+@var_operation
+def string_upper_operation(string: StringVar[Any]):
+    """Convert a string to uppercase.
 
-        Returns:
-            The length of the array.
-        """
-        return array_length_operation(self)
+    Args:
+        string: The string to convert.
 
-    @overload
-    @classmethod
-    def range(cls, stop: int | NumberVar, /) -> ArrayVar[List[int]]: ...
+    Returns:
+        The uppercase string.
+    """
+    return var_operation_return(js_expression=f"{string}.toUpperCase()", var_type=str)
 
-    @overload
-    @classmethod
-    def range(
-        cls,
-        start: int | NumberVar,
-        end: int | NumberVar,
-        step: int | NumberVar = 1,
-        /,
-    ) -> ArrayVar[List[int]]: ...
 
-    @overload
-    @classmethod
-    def range(
-        cls,
-        first_endpoint: int | NumberVar,
-        second_endpoint: int | NumberVar | None = None,
-        step: int | NumberVar | None = None,
-    ) -> ArrayVar[List[int]]: ...
+@var_operation
+def string_title_operation(string: StringVar[Any]):
+    """Convert a string to title case.
 
-    @classmethod
-    def range(
-        cls,
-        first_endpoint: int | NumberVar,
-        second_endpoint: int | NumberVar | None = None,
-        step: int | NumberVar | None = None,
-    ) -> ArrayVar[List[int]]:
-        """Create a range of numbers.
+    Args:
+        string: The string to convert.
 
-        Args:
-            first_endpoint: The end of the range if second_endpoint is not provided, otherwise the start of the range.
-            second_endpoint: The end of the range.
-            step: The step of the range.
+    Returns:
+        The title case string.
+    """
+    return var_operation_return(
+        js_expression=f"{string}.split(' ').map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(' ')",
+        var_type=str,
+    )
 
-        Returns:
-            The range of numbers.
-        """
-        if any(
-            not isinstance(i, (int, NumberVar))
-            for i in (first_endpoint, second_endpoint, step)
-            if i is not None
-        ):
-            raise_unsupported_operand_types(
-                "range", (type(first_endpoint), type(second_endpoint), type(step))
-            )
-        if second_endpoint is None:
-            start = 0
-            end = first_endpoint
-        else:
-            start = first_endpoint
-            end = second_endpoint
 
-        return array_range_operation(start, end, step or 1)
+@var_operation
+def string_capitalize_operation(string: StringVar[Any]):
+    """Capitalize a string.
 
-    @overload
-    def contains(self, other: Any) -> BooleanVar: ...
+    Args:
+        string: The string to capitalize.
 
-    @overload
-    def contains(self, other: Any, field: StringVar | str) -> BooleanVar: ...
+    Returns:
+        The capitalized string.
+    """
+    return var_operation_return(
+        js_expression=f"(((s) => s.charAt(0).toUpperCase() + s.slice(1).toLowerCase())({string}))",
+        var_type=str,
+    )
 
-    def contains(self, other: Any, field: Any = None) -> BooleanVar:
-        """Check if the array contains an element.
 
-        Args:
-            other: The element to check for.
-            field: The field to check.
+@var_operation
+def string_strip_operation(string: StringVar[Any]):
+    """Strip a string.
 
-        Returns:
-            The array contains operation.
-        """
-        if field is not None:
-            if not isinstance(field, (StringVar, str)):
-                raise_unsupported_operand_types("contains", (type(self), type(field)))
-            return array_contains_field_operation(self, other, field)
-        return array_contains_operation(self, other)
+    Args:
+        string: The string to strip.
 
-    def pluck(self, field: StringVar | str) -> ArrayVar:
-        """Pluck a field from the array.
+    Returns:
+        The stripped string.
+    """
+    return var_operation_return(js_expression=f"{string}.trim()", var_type=str)
 
-        Args:
-            field: The field to pluck from the array.
 
-        Returns:
-            The array pluck operation.
-        """
-        return array_pluck_operation(self, field)
+@var_operation
+def string_contains_field_operation(
+    haystack: StringVar[Any], needle: StringVar[Any] | str, field: StringVar[Any] | str
+):
+    """Check if a string contains another string.
 
-    @overload
-    def __mul__(self, other: NumberVar | int) -> ArrayVar[ARRAY_VAR_TYPE]: ...
+    Args:
+        haystack: The haystack.
+        needle: The needle.
+        field: The field to check.
 
-    @overload
-    def __mul__(self, other: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
+    Returns:
+        The string contains operation.
+    """
+    return var_operation_return(
+        js_expression=f"{haystack}.some(obj => obj[{field}] === {needle})",
+        var_type=bool,
+    )
 
-    def __mul__(self, other: Any) -> ArrayVar[ARRAY_VAR_TYPE]:
-        """Multiply the sequence by a number or integer.
 
-        Parameters:
-            other: The number or integer to multiply the sequence by.
+@var_operation
+def string_contains_operation(haystack: StringVar[Any], needle: StringVar[Any] | str):
+    """Check if a string contains another string.
 
-        Returns:
-            ArrayVar[ARRAY_VAR_TYPE]: The result of multiplying the sequence by the given number or integer.
-        """
-        if not isinstance(other, (NumberVar, int)) or (
-            isinstance(other, NumberVar) and other._is_strict_float()
-        ):
-            raise_unsupported_operand_types("*", (type(self), type(other)))
+    Args:
+        haystack: The haystack.
+        needle: The needle.
 
-        return repeat_array_operation(self, other)
+    Returns:
+        The string contains operation.
+    """
+    return var_operation_return(
+        js_expression=f"{haystack}.includes({needle})", var_type=bool
+    )
 
-    __rmul__ = __mul__
 
-    @overload
-    def __lt__(self, other: ArrayVar[ARRAY_VAR_TYPE]) -> BooleanVar: ...
+@var_operation
+def string_starts_with_operation(
+    full_string: StringVar[Any], prefix: StringVar[Any] | str
+):
+    """Check if a string starts with a prefix.
 
-    @overload
-    def __lt__(self, other: list | tuple) -> BooleanVar: ...
+    Args:
+        full_string: The full string.
+        prefix: The prefix.
 
-    def __lt__(self, other: Any):
-        """Check if the array is less than another array.
+    Returns:
+        Whether the string starts with the prefix.
+    """
+    return var_operation_return(
+        js_expression=f"{full_string}.startsWith({prefix})", var_type=bool
+    )
 
-        Args:
-            other: The other array.
 
-        Returns:
-            The array less than operation.
-        """
-        if not isinstance(other, (ArrayVar, list, tuple)):
-            raise_unsupported_operand_types("<", (type(self), type(other)))
+@var_operation
+def string_ends_with_operation(
+    full_string: StringVar[Any], suffix: StringVar[Any] | str
+):
+    """Check if a string ends with a suffix.
 
-        return array_lt_operation(self, other)
+    Args:
+        full_string: The full string.
+        suffix: The suffix.
 
-    @overload
-    def __gt__(self, other: ArrayVar[ARRAY_VAR_TYPE]) -> BooleanVar: ...
+    Returns:
+        Whether the string ends with the suffix.
+    """
+    return var_operation_return(
+        js_expression=f"{full_string}.endsWith({suffix})", var_type=bool
+    )
 
-    @overload
-    def __gt__(self, other: list | tuple) -> BooleanVar: ...
 
-    def __gt__(self, other: Any):
-        """Check if the array is greater than another array.
+@var_operation
+def string_item_operation(string: StringVar[Any], index: NumberVar | int):
+    """Get an item from a string.
 
-        Args:
-            other: The other array.
+    Args:
+        string: The string.
+        index: The index of the item.
 
-        Returns:
-            The array greater than operation.
-        """
-        if not isinstance(other, (ArrayVar, list, tuple)):
-            raise_unsupported_operand_types(">", (type(self), type(other)))
+    Returns:
+        The item from the string.
+    """
+    return var_operation_return(js_expression=f"{string}.at({index})", var_type=str)
 
-        return array_gt_operation(self, other)
 
-    @overload
-    def __le__(self, other: ArrayVar[ARRAY_VAR_TYPE]) -> BooleanVar: ...
+@var_operation
+def array_join_operation(array: ArrayVar, sep: StringVar[Any] | str = ""):
+    """Join the elements of an array.
 
-    @overload
-    def __le__(self, other: list | tuple) -> BooleanVar: ...
+    Args:
+        array: The array.
+        sep: The separator.
 
-    def __le__(self, other: Any):
-        """Check if the array is less than or equal to another array.
+    Returns:
+        The joined elements.
+    """
+    return var_operation_return(js_expression=f"{array}.join({sep})", var_type=str)
+
+
+@var_operation
+def string_replace_operation(
+    string: StringVar[Any], search_value: StringVar | str, new_value: StringVar | str
+):
+    """Replace a string with a value.
+
+    Args:
+        string: The string.
+        search_value: The string to search.
+        new_value: The value to be replaced with.
+
+    Returns:
+        The string replace operation.
+    """
+    return var_operation_return(
+        js_expression=f"{string}.replaceAll({search_value}, {new_value})",
+        var_type=str,
+    )
 
-        Args:
-            other: The other array.
 
-        Returns:
-            The array less than or equal operation.
-        """
-        if not isinstance(other, (ArrayVar, list, tuple)):
-            raise_unsupported_operand_types("<=", (type(self), type(other)))
+# Compile regex for finding reflex var tags.
+_decode_var_pattern_re = (
+    rf"{constants.REFLEX_VAR_OPENING_TAG}(.*?){constants.REFLEX_VAR_CLOSING_TAG}"
+)
+_decode_var_pattern = re.compile(_decode_var_pattern_re, flags=re.DOTALL)
 
-        return array_le_operation(self, other)
 
-    @overload
-    def __ge__(self, other: ArrayVar[ARRAY_VAR_TYPE]) -> BooleanVar: ...
+@dataclasses.dataclass(
+    eq=False,
+    frozen=True,
+    slots=True,
+)
+class LiteralStringVar(LiteralVar, StringVar[str]):
+    """Base class for immutable literal string vars."""
 
-    @overload
-    def __ge__(self, other: list | tuple) -> BooleanVar: ...
+    _var_value: str = dataclasses.field(default="")
 
-    def __ge__(self, other: Any):
-        """Check if the array is greater than or equal to another array.
+    @classmethod
+    def create(
+        cls,
+        value: str,
+        _var_type: GenericType | None = None,
+        _var_data: VarData | None = None,
+    ) -> StringVar:
+        """Create a var from a string value.
 
         Args:
-            other: The other array.
+            value: The value to create the var from.
+            _var_type: The type of the var.
+            _var_data: Additional hooks and imports associated with the Var.
 
         Returns:
-            The array greater than or equal operation.
+            The var.
         """
-        if not isinstance(other, (ArrayVar, list, tuple)):
-            raise_unsupported_operand_types(">=", (type(self), type(other)))
+        # Determine var type in case the value is inherited from str.
+        _var_type = _var_type or type(value) or str
 
-        return array_ge_operation(self, other)
+        if REFLEX_VAR_OPENING_TAG in value:
+            strings_and_vals: list[Var | str] = []
+            offset = 0
 
-    def foreach(self, fn: Any):
-        """Apply a function to each element of the array.
+            # Find all tags
+            while m := _decode_var_pattern.search(value):
+                start, end = m.span()
 
-        Args:
-            fn: The function to apply.
+                strings_and_vals.append(value[:start])
 
-        Returns:
-            The array after applying the function.
+                serialized_data = m.group(1)
 
-        Raises:
-            VarTypeError: If the function takes more than one argument.
-        """
-        from .function import ArgsFunctionOperation
+                if serialized_data.isnumeric() or (
+                    serialized_data[0] == "-" and serialized_data[1:].isnumeric()
+                ):
+                    # This is a global immutable var.
+                    var = _global_vars[int(serialized_data)]
+                    strings_and_vals.append(var)
+                    value = value[(end + len(var._js_expr)) :]
 
-        if not callable(fn):
-            raise_unsupported_operand_types("foreach", (type(self), type(fn)))
-        # get the number of arguments of the function
-        num_args = len(inspect.signature(fn).parameters)
-        if num_args > 1:
-            raise VarTypeError(
-                "The function passed to foreach should take at most one argument."
-            )
+                offset += end - start
 
-        if num_args == 0:
-            return_value = fn()
-            function_var = ArgsFunctionOperation.create((), return_value)
-        else:
-            # generic number var
-            number_var = Var("").to(NumberVar, int)
+            strings_and_vals.append(value)
 
-            first_arg_type = self[number_var]._var_type
+            filtered_strings_and_vals = [
+                s for s in strings_and_vals if isinstance(s, Var) or s
+            ]
+            if len(filtered_strings_and_vals) == 1:
+                only_string = filtered_strings_and_vals[0]
+                if isinstance(only_string, str):
+                    return LiteralVar.create(only_string).to(StringVar, _var_type)
+                else:
+                    return only_string.to(StringVar, only_string._var_type)
 
-            arg_name = get_unique_variable_name()
+            if len(
+                literal_strings := [
+                    s
+                    for s in filtered_strings_and_vals
+                    if isinstance(s, (str, LiteralStringVar))
+                ]
+            ) == len(filtered_strings_and_vals):
+                return LiteralStringVar.create(
+                    "".join(
+                        s._var_value if isinstance(s, LiteralStringVar) else s
+                        for s in literal_strings
+                    ),
+                    _var_type=_var_type,
+                    _var_data=VarData.merge(
+                        _var_data,
+                        *(
+                            s._get_all_var_data()
+                            for s in filtered_strings_and_vals
+                            if isinstance(s, Var)
+                        ),
+                    ),
+                )
 
-            # get first argument type
-            first_arg = Var(
-                _js_expr=arg_name,
-                _var_type=first_arg_type,
-            ).guess_type()
+            concat_result = ConcatVarOperation.create(
+                *filtered_strings_and_vals,
+                _var_data=_var_data,
+            )
 
-            function_var = ArgsFunctionOperation.create(
-                (arg_name,),
-                Var.create(fn(first_arg)),
+            return (
+                concat_result
+                if _var_type is str
+                else concat_result.to(StringVar, _var_type)
             )
 
-        return map_array_operation(self, function_var)
+        return LiteralStringVar(
+            _js_expr=json.dumps(value),
+            _var_type=_var_type,
+            _var_data=_var_data,
+            _var_value=value,
+        )
+
+    def __hash__(self) -> int:
+        """Get the hash of the var.
 
+        Returns:
+            The hash of the var.
+        """
+        return hash((type(self).__name__, self._var_value))
 
-LIST_ELEMENT = TypeVar("LIST_ELEMENT")
+    def json(self) -> str:
+        """Get the JSON representation of the var.
 
-ARRAY_VAR_OF_LIST_ELEMENT = ArrayVar[Sequence[LIST_ELEMENT]]
+        Returns:
+            The JSON representation of the var.
+        """
+        return json.dumps(self._var_value)
 
 
 @dataclasses.dataclass(
@@ -1338,10 +1336,10 @@ ARRAY_VAR_OF_LIST_ELEMENT = ArrayVar[Sequence[LIST_ELEMENT]]
     frozen=True,
     slots=True,
 )
-class LiteralArrayVar(CachedVarOperation, LiteralVar, ArrayVar[ARRAY_VAR_TYPE]):
-    """Base class for immutable literal array vars."""
+class ConcatVarOperation(CachedVarOperation, StringVar[str]):
+    """Representing a concatenation of literal string vars."""
 
-    _var_value: Sequence[Union[Var, Any]] = dataclasses.field(default=())
+    _var_value: tuple[Var, ...] = dataclasses.field(default_factory=tuple)
 
     @cached_property_no_lock
     def _cached_var_name(self) -> str:
@@ -1350,79 +1348,65 @@ class LiteralArrayVar(CachedVarOperation, LiteralVar, ArrayVar[ARRAY_VAR_TYPE]):
         Returns:
             The name of the var.
         """
-        return (
-            "["
-            + ", ".join(
-                [str(LiteralVar.create(element)) for element in self._var_value]
-            )
-            + "]"
-        )
+        list_of_strs: list[str | Var] = []
+        last_string = ""
+        for var in self._var_value:
+            if isinstance(var, LiteralStringVar):
+                last_string += var._var_value
+            else:
+                if last_string:
+                    list_of_strs.append(last_string)
+                    last_string = ""
+                list_of_strs.append(var)
+
+        if last_string:
+            list_of_strs.append(last_string)
+
+        list_of_strs_filtered = [
+            str(LiteralVar.create(s)) for s in list_of_strs if isinstance(s, Var) or s
+        ]
+
+        if len(list_of_strs_filtered) == 1:
+            return list_of_strs_filtered[0]
+
+        return "(" + "+".join(list_of_strs_filtered) + ")"
 
     @cached_property_no_lock
     def _cached_get_all_var_data(self) -> VarData | None:
-        """Get all the VarData associated with the Var.
+        """Get all the VarData asVarDatae Var.
 
         Returns:
             The VarData associated with the Var.
         """
         return VarData.merge(
             *[
-                LiteralVar.create(element)._get_all_var_data()
-                for element in self._var_value
+                var._get_all_var_data()
+                for var in self._var_value
+                if isinstance(var, Var)
             ],
             self._var_data,
         )
 
-    def __hash__(self) -> int:
-        """Get the hash of the var.
-
-        Returns:
-            The hash of the var.
-        """
-        return hash((self.__class__.__name__, self._js_expr))
-
-    def json(self) -> str:
-        """Get the JSON representation of the var.
-
-        Returns:
-            The JSON representation of the var.
-
-        Raises:
-            TypeError: If the array elements are not of type LiteralVar.
-        """
-        elements = []
-        for element in self._var_value:
-            element_var = LiteralVar.create(element)
-            if not isinstance(element_var, LiteralVar):
-                raise TypeError(
-                    f"Array elements must be of type LiteralVar, not {type(element_var)}"
-                )
-            elements.append(element_var.json())
-
-        return "[" + ", ".join(elements) + "]"
-
     @classmethod
     def create(
         cls,
-        value: OTHER_ARRAY_VAR_TYPE,
-        _var_type: Type[OTHER_ARRAY_VAR_TYPE] | None = None,
+        *value: Var | str,
         _var_data: VarData | None = None,
-    ) -> LiteralArrayVar[OTHER_ARRAY_VAR_TYPE]:
+    ) -> ConcatVarOperation:
         """Create a var from a string value.
 
         Args:
-            value: The value to create the var from.
-            _var_type: The type of the var.
+            *value: The values to concatenate.
             _var_data: Additional hooks and imports associated with the Var.
 
         Returns:
             The var.
         """
-        return LiteralArrayVar(
+        return cls(
             _js_expr="",
-            _var_type=figure_out_type(value) if _var_type is None else _var_type,
+            _var_type=str,
             _var_data=_var_data,
-            _var_value=value,
+            _var_value=tuple(map(LiteralVar.create, value)),
         )
 
 
@@ -1438,7 +1422,7 @@ def string_split_operation(string: StringVar[Any], sep: StringVar | str = ""):
         The split string.
     """
     return var_operation_return(
-        js_expression=f"{string}.split({sep})", var_type=List[str]
+        js_expression=f"{string}.split({sep})", var_type=list[str]
     )
 
 
@@ -1638,11 +1622,50 @@ def is_tuple_type(t: GenericType) -> bool:
     Returns:
         Whether the type is a tuple type.
     """
-    if inspect.isclass(t):
-        return issubclass(t, tuple)
     return get_origin(t) is tuple
 
 
+def _determine_value_of_array_index(
+    var_type: GenericType, index: int | float | None = None
+):
+    """Determine the value of an array index.
+
+    Args:
+        var_type: The type of the array.
+        index: The index of the array.
+
+    Returns:
+        The value of the array index.
+    """
+    origin_var_type = get_origin(var_type) or var_type
+    if origin_var_type in types.UnionTypes:
+        return unionize(
+            *[
+                _determine_value_of_array_index(t, index)
+                for t in get_args(var_type)
+                if t is not type(None)
+            ]
+        )
+    if origin_var_type in [
+        Sequence,
+        Iterable,
+        list,
+        set,
+        collections.abc.Sequence,
+        collections.abc.Iterable,
+    ]:
+        args = get_args(var_type)
+        return args[0] if args else Any
+    if origin_var_type is tuple:
+        args = get_args(var_type)
+        return (
+            args[int(index) % len(args)]
+            if args and index is not None
+            else (unionize(*args) if args else Any)
+        )
+    return Any
+
+
 @var_operation
 def array_item_operation(array: ArrayVar, index: NumberVar | int):
     """Get an item from an array.
@@ -1654,12 +1677,14 @@ def array_item_operation(array: ArrayVar, index: NumberVar | int):
     Returns:
         The item from the array.
     """
-    args = typing.get_args(array._var_type)
-    if args and isinstance(index, LiteralNumberVar) and is_tuple_type(array._var_type):
-        index_value = int(index._var_value)
-        element_type = args[index_value % len(args)]
-    else:
-        element_type = unionize(*args)
+    element_type = _determine_value_of_array_index(
+        array._var_type,
+        (
+            index
+            if isinstance(index, int)
+            else (index._var_value if isinstance(index, LiteralNumberVar) else None)
+        ),
+    )
 
     return var_operation_return(
         js_expression=f"{array!s}.at({index!s})",
@@ -1683,7 +1708,7 @@ def array_range_operation(
     """
     return var_operation_return(
         js_expression=f"Array.from({{ length: Math.ceil(({stop!s} - {start!s}) / {step!s}) }}, (_, i) => {start!s} + i * {step!s})",
-        var_type=List[int],
+        var_type=list[int],
     )
 
 
@@ -1749,7 +1774,7 @@ def repeat_array_operation(
 def map_array_operation(
     array: ArrayVar[ARRAY_VAR_TYPE],
     function: FunctionVar,
-) -> CustomVarOperationReturn[List[Any]]:
+) -> CustomVarOperationReturn[list[Any]]:
     """Map a function over an array.
 
     Args:
@@ -1760,7 +1785,7 @@ def map_array_operation(
         The mapped array.
     """
     return var_operation_return(
-        js_expression=f"{array}.map({function})", var_type=List[Any]
+        js_expression=f"{array}.map({function})", var_type=list[Any]
     )