Shuffle the deque

        Deques themselves do not support this, so this will make all items into
        a list, shuffle that list, clear the deque, and then re-init the deque.
501399
def shuffle(self):
        

        args = list(self)
        random.shuffle(args)

        self.clear()
        super(DogeDeque, self).__init__(args)
707237
def reset(self):
        
        for proxy in list(self.dead):
            self.dead.remove(proxy)
            self.unchecked.add(proxy)
969865
def clear_list_value(self, value):
        
        # Don't go any further: this value is empty.
        if not value:
            return self.empty_value
        # Clean empty items if wanted
        if self.clean_empty:
            value = [v for v in value if v]
        return value or self.empty_value
551942
def reset_all(self):
        
        for item in self.inputs:
            setattr(self, "_%s" % item, None)
        self.stack = []
36959
def set_items(self, items):
        
        self.adapter.clear()
        self.adapter.addAll(items)
1134570
def de_duplicate(items):
    
    result = []
    for item in items:
        if item not in result:
            result.append(item)
    return result
304002
public final void resetItemDecorations() {
        for (int i = 0; i < getRecyclerView().getItemDecorationCount(); i++) {
            try {
                getRecyclerView().removeItemDecoration(getRecyclerView().getItemDecorationAt(i));
            } catch (Exception ignored) {
            }
        }
    }
934713
public void redo() {
    if (isListChange()) {
      LOGGER.trace("Redoing list change: " + newList.get().toString());
      setting.valueProperty().setValue(newList.get());
    } else {
      setting.valueProperty().setValue(newValue.get());
    }
  }
708409
def remove_duplicates(items):
    
    if items is None:
        return items

    new_list = []
    for item in items:
        if item not in new_list:
            new_list.append(item)
    return new_list
381392
def freeze(self):
        
        self._lazy = False
        for k, v in self.items():
            if k in self._env:
                continue
            for _k, _v in v.items():
                if isinstance(_v, Lazy):
                    if self.writable:
                        _v.get()
                    else:
                        try:
                            v.__setitem__(_k, _v.get(), replace=True)
                        except:
                            print "Error ini key:", _k
                            raise
                        del _v
        self._globals = SortedDict()
492233
function dequeue(queue, item) {
    queue[SIZE] -= 1

    let done = false
    item.action(() => {
        if (done) {
            return
        }
        done = true

        if (item.next) {
            dequeue(queue, item.next)
        }
        else {
            assert(queue[TAIL] === item, "BROKEN")
            queue[TAIL] = null
        }
    })
}
1117726
def clear(self, exclude=None):
        
        if exclude is None:
            self.cache = {}
        else:
            self.cache = {k: v for k, v in self.cache.items()
                          if k in exclude}
7167
def remove_all(self, items):
        
        check_not_none(items, "Value can't be None")
        data_items = []
        for item in items:
            check_not_none(item, "Value can't be None")
            data_items.append(self._to_data(item))
        return self._encode_invoke(queue_compare_and_remove_all_codec, data_list=data_items)
211463
def remove(self, items):
        """"""
        items = coerce_to_list(items)
        new_options = {k: v for k, v in self.options.items() if v not in items}
        self.widget.options = new_options
        self.widget.param.trigger('options')
1155096
private static void shuffle(ArrayModifiableDBIDs ids, int ssize, int end, Random random) {
    ssize = ssize < end ? ssize : end; // Guard for choosing from tiny sets
    for(int i = 1; i < ssize; i++) {
      ids.swap(i - 1, i + random.nextInt(end - i));
    }
  }
1177291
def _tidy(self) -> None:
        
        if self.no_overlap:
            self.remove_overlap(self.no_contiguous)  # will sort
        else:
            self._sort()
170655
@Override
	public void reset() {
		this.priorityElements = Lists.newArrayList(originalElements);
		Collections.shuffle(priorityElements);
		this.currentElements = Lists.newArrayListWithExpectedSize(2 * originalElements.size());
		this.currentElements.addAll(originalElements);
	}