/* (non-Javadoc)
@see cyclops2.monads.transformers.values.ListT#reverse()
557585
@Override
    public ListT<W,T> reverse() {

        return (ListT<W,T>) FoldableTransformerSeq.super.reverse();
    }
184234
public static void reverse(final Object[] arr, final int pos, final int len) {
        for (int l = pos, r = pos + len - 1; l < r; l++, r--) {
            final Object tmp = arr[l];
            arr[l] = arr[r];
            arr[r] = tmp;
        }
    }
743269
public BeanComparator<T> reverse() {
        BeanComparator<T> bc = new BeanComparator<T>(this);
        bc.mOrderByName = mOrderByName;
        bc.mUsingComparator = mUsingComparator;
        bc.mFlags = mFlags ^ 0x01;
        return bc;
    }
73643
function reverse() {
    var upperIndex,
        value,
        index = -1,
        object = Object(this),
        length = object.length >>> 0,
        middle = floor(length / 2);

    if (length > 1) {
      while (++index < middle) {
        upperIndex = length - index - 1;
        value = upperIndex in object ? object[upperIndex] : uid;
        if (index in object) {
          object[upperIndex] = object[index];
        } else {
          delete object[upperIndex];
        }
        if (value != uid) {
          object[index] = value;
        } else {
          delete object[index];
        }
      }
    }
    return object;
  }
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;
      }, []);
    };
  }
35332
public void reverse() {
		for (int i = 0; i < size / 2; i++) {
			T tmp = data[i];
			data[i] = data[size - i - 1];
			data[size - i - 1] = tmp;
		}
	}
747045
public static <T> void reverseForEach(List<T> list, Procedure<? super T> procedure)
    {
        if (!list.isEmpty())
        {
            ListIterate.forEach(list, list.size() - 1, 0, procedure);
        }
    }
297525
def reverse(self):
        
        for key in six.iterkeys(self._map):
            self._map[key].reverse()
        self._items.reverse()
        return self
570757
private void reverseAfter(int i) {
		int start = i+1;
		int end = n-1;
		while (start < end) {
			swap(index,start,end);
			start++;
			end--;
		}
	}
1156253
public function reverse()
    {
        return static::of(
            ArrayList::of($this->split())->reverse()->join(),
            $this->encoding
        );
    }
843110
public SparseGraph reversed() {
        SparseGraph reverse = new SparseGraph();
        for (Entry<Integer, Set<Integer>> entryFrom : edges.entrySet())
            for (Integer to : entryFrom.getValue())
                reverse.addEdge(to, entryFrom.getKey());
        return reverse;
    }
715967
public static <T> void reverse(final T array) {

        if (ArrayUtils.isArray(array)) {
            int mlength = Array.getLength(array) - 1;
            Object temp = null;
            for (int i = 0, j = mlength; i < mlength; i++, j--) {
                Object arg0 = Array.get(array, i);
                Object arg1 = Array.get(array, j);
                temp = arg0;
                Array.set(array, i, arg1);
                Array.set(array, j, temp);
            }
        }
    }
222854
def reverse(d):
    """"""
    r={}
    for k in d:
        r[d[k]]=k
    return r
114409
public T reverse() {
        String id = getId();
        String REVERSE = "_REVERSE";
        if (id.endsWith(REVERSE)) {
            setId(id.substring(0, id.length() - REVERSE.length()));
        }

        float start = mStart;
        float end = mEnd;
        mStart = end;
        mEnd = start;
        mReverse = !mReverse;
        return self();
    }
1009739
public static String reverse(final String value) {
        validate(value, NULL_STRING_PREDICATE, NULL_STRING_MSG_SUPPLIER);
        return new StringBuilder(value).reverse().toString();
    }
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
696027
public Converter<B, A> reverse() {
		Converter<B, A> result = reverse;
		return (result == null) ? reverse = new ReverseConverter<A, B>(this) : result;
	}