diff --git a/src/core/CCArray.ml b/src/core/CCArray.ml
index 76ed250a..3daf1e7e 100644
--- a/src/core/CCArray.ml
+++ b/src/core/CCArray.ml
@@ -468,6 +468,35 @@ let compare cmp a b =
   compare CCOrd.compare [| 1; 2; 3 |] [| 1; 2; |] > 0
 *)
 
+(* swap elements of array *)
+let swap a i j =
+  if i<>j then (
+    let tmp = a.(i) in
+    a.(i) <- a.(j);
+    a.(j) <- tmp;
+  )
+
+(*$T
+  let a = [| 1;2;3 |] in \
+    swap a 0 1; \
+    a = [| 2;1;3 |]
+  let a = [| 1;2;3 |] in \
+    swap a 0 2; \
+    a = [| 3;2;1 |]
+*)
+
+(*$QR
+  Q.(array small_int) (fun a ->
+    let b = Array.copy a in
+    for i = 0 to Array.length a-1 do
+      for j = i+1 to Array.length a-1 do
+        swap a i j; done; done;
+    for i = 0 to Array.length a-1 do
+      for j = i+1 to Array.length a-1 do
+        swap a i j; done; done;
+    a=b)
+*)
+
 (* shuffle a[i...j[ using the given int random generator
    See http://en.wikipedia.org/wiki/Fisher-Yates_shuffle *)
 let _shuffle _rand_int a i j =
diff --git a/src/core/CCArray.mli b/src/core/CCArray.mli
index 4511a56b..90dbb2b3 100644
--- a/src/core/CCArray.mli
+++ b/src/core/CCArray.mli
@@ -23,6 +23,10 @@ val equal : 'a equal -> 'a t equal
 
 val compare : 'a ord -> 'a t ord
 
+val swap : 'a t -> int -> int -> unit
+(** [swap arr i j] swaps elements at indices [i] and [j].
+    @since NEXT_RELEASE *)
+
 val get : 'a t -> int -> 'a
 
 val get_safe : 'a t -> int -> 'a option
@@ -71,10 +75,10 @@ val sorted : ('a -> 'a -> int) -> 'a t -> 'a array
 
 val sort_indices : ('a -> 'a -> int) -> 'a t -> int array
 (** [sort_indices cmp a] returns a new array [b], with the same length as [a],
-    such that [b.(i)] is the index at which the [i]-th element of [sorted cmp a] 
+    such that [b.(i)] is the index at which the [i]-th element of [sorted cmp a]
     appears in [a]. [a] is not modified.
 
-    In other words, [map (fun i -> a.(i)) (sort_indices cmp a) = sorted cmp a]. 
+    In other words, [map (fun i -> a.(i)) (sort_indices cmp a) = sorted cmp a].
     [sort_indices] yields the inverse permutation of {!sort_ranking}.
 
     @since 1.0 *)
@@ -84,7 +88,7 @@ val sort_ranking : ('a -> 'a -> int) -> 'a t -> int array
     such that [b.(i)] is the index at which the [i]-the element of [a] appears
     in [sorted cmp a]. [a] is not modified.
 
-    In other words, [map (fun i -> (sorted cmp a).(i)) (sort_ranking cmp a) = a]. 
+    In other words, [map (fun i -> (sorted cmp a).(i)) (sort_ranking cmp a) = a].
     [sort_ranking] yields the inverse permutation of {!sort_indices}.
 
     In the absence of duplicate elements in [a], we also have