In place reverses the list. Very expensive on large data sets.
            The reversed list will be persisted to the redis :prop:_client
            as well.
508207
def reverse(self):
        
        tmp_list = RedisList(
            randint(0, 100000000), prefix=self.key_prefix,
            client=self._client, serializer=self.serializer,
            serialized=self.serialized)
        cursor = '0'
        count = 1000
        start = (-1 * count)
        stop = -1
        _loads = self._loads
        while cursor:
            cursor = self._client.lrange(self.key_prefix, start, stop)
            if cursor:
                tmp_list.extend(map(_loads, reversed(cursor)))
            start -= count
            stop -= count
        self._client.rename(tmp_list.key_prefix, self.key_prefix)
        tmp_list.clear()
51778
function reverseObject(object) {
  const keys = Object.keys(object);

  let index = keys.length,
      newObject = {},
      key;

  while (index--) {
    key = keys[index];

    newObject[key] = object[key];
  }

  return newObject;
}
447553
def sort(self, by=None, reverse=False):
        
        if by is None:
            by = self.kdims
        elif not isinstance(by, list):
            by = [by]
        sorted_columns = self.interface.sort(self, by, reverse)
        return self.clone(sorted_columns)
442655
function defineReverse() {
    return Array.prototype.reverse ? function (x) {
      return x.reverse();
    } : function (x) {
      return x.reduceRight(function (agg, item) {
        agg.push(item);
        return agg;
      }, []);
    };
  }
533380
function reverse (arr) {
  const reversedArray = [];
  for (let i = arr.length - 1; i >= 0; i--) {
    reversedArray.push(arr[i]);
  }
  return reversedArray;
}
96722
def reverse(self):
        
        clone = self._clone()
        assert self._ordering, "You need to set an ordering for reverse"
        ordering = []
        for order in self._ordering:
            for k,v in order.items():
                if v=="asc":
                    ordering.append({k: "desc"})
                else:
                    ordering.append({k: "asc"})
        clone._ordering=ordering
        return clone
1221483
def _reversedict(d):
    
    return dict(list(zip(list(d.values()), list(d.keys()))))
18967
function reverse(combos) {
  const { offsuit, suited, pairs } = sortOut(combos)

  const ps = reversePairs(pairs)
  const os = reverseNonPairs(offsuit, 'o')
  const su = reverseNonPairs(suited, 's')
  const nonpairs = unsuitWhenPossible(new Set(os), new Set(su))

  return ps.concat(nonpairs).join(', ')
}
4786
private static Scriptable js_reverse(Context cx, Scriptable thisObj, Object[] args)
    {
        if (thisObj instanceof NativeArray) {
            NativeArray na = (NativeArray) thisObj;
            if (na.denseOnly) {
                for (int i=0, j=((int)na.length)-1; i < j; i++,j--) {
                    Object temp = na.dense[i];
                    na.dense[i] = na.dense[j];
                    na.dense[j] = temp;
                }
                return thisObj;
            }
        }
        long len = getLengthProperty(cx, thisObj, false);

        long half = len / 2;
        for(long i=0; i < half; i++) {
            long j = len - i - 1;
            Object temp1 = getRawElem(thisObj, i);
            Object temp2 = getRawElem(thisObj, j);
            setRawElem(cx, thisObj, i, temp2);
            setRawElem(cx, thisObj, j, temp1);
        }
        return thisObj;
    }
397278
private static void reverse(final byte[] arr, final int len) {
        for (int l = 0, r = 0 + len - 1; l < r; l++, r--) {
            final byte tmp = arr[l];
            arr[l] = arr[r];
            arr[r] = tmp;
        }
    }
158699
private void reverse(WritableDataStore<HashSetModifiableDBIDs> sampleNewHash, WritableDataStore<HashSetModifiableDBIDs> newReverseNeighbors, WritableDataStore<HashSetModifiableDBIDs> oldReverseNeighbors) {
    for(DBIDIter iditer = relation.iterDBIDs(); iditer.valid(); iditer.advance()) {
      KNNHeap heap = store.get(iditer);
      HashSetDBIDs newNeighbors = sampleNewHash.get(iditer);
      for(DoubleDBIDListIter heapiter = heap.unorderedIterator(); heapiter.valid(); heapiter.advance()) {
        (newNeighbors.contains(heapiter) ? newReverseNeighbors : oldReverseNeighbors).get(heapiter).add(iditer);
      }
    }
  }
259737
function reverse(collection) {
    if (typeof collection === 'string') {
        return collection.split('').reverse().join('');
    }
    if(_.isArray(collection)){
        return collection.concat().reverse();
    }
    return collection;
}
557585
@Override
    public ListT<W,T> reverse() {

        return (ListT<W,T>) FoldableTransformerSeq.super.reverse();
    }
846632
function reverse(input) {

  if(isString(input)) {
    return input.split('').reverse().join('');
  }

  return (isArray(input))
    ? input.slice().reverse()
    : input;
}
560114
def batch_reverse(self, points, **kwargs):
        
        fields = ",".join(kwargs.pop("fields", []))
        response = self._req(
            "post", verb="reverse", params={"fields": fields}, data=json_points(points)
        )
        if response.status_code != 200:
            return error_response(response)

        logger.debug(response)
        return LocationCollection(response.json()["results"])
275363
private static void reverse(int[] array, int start, int end) {
		for (int i = start, j = end; i < --j; ++i) {
			int t = array[i];
			array[i] = array[j];
			array[j] = t;
		}
	}
1342904
@Override
	public ParallelTransformation reversed(boolean reversed)
	{
		if (!reversed)
			return this;

		for (Transformation<?, ?> transformation : listTransformations)
			transformation.reversed(true);

		return this;
	}