Crate sorting

This crate provides an implementation of various quality sorting methods. Only the most useless or inefficient sorting algorithms are implemented. You may use them in your production application, altough I would strongly advise against that. Currently, the following sorting algorithms are implemented:

Panicsort

This sorting method kind of follows the principle of check and surrender and simply panics when the array or vector is not sorted:

let unsorted = vec![5, 7, 8, 2, 1, 0];
unsorted.panicsort();   // will panic

Slowsort

This sorting algorithm recursively sorts the input array by finding the maximum of the sorted array, placing that maximum at the end and sorting the remaining array.

let mut unsorted = vec![5, 7, 8, 2, 1, 0];
unsorted.slowsort();

Bogosort

This highly inefficient algorithm scrambles the input vector until it is sorted. Depending on your luck and the length of the input vector this might never return.

let mut unsorted = vec![5, 7, 8, 2, 1, 0];
unsorted.bogosort();    // might take a while...

Sleepsort

This algorithm uses the operating system's scheduler for sorting by putting every value into its own thread and putting that thread to sleep for a time determined by the value.

let unsorted = vec![5i8, -7, 8, 2, 1, 0, -9];
let sorted: Vec<_> = unsorted.sleepsort().collect();

Miraclesort

A sorting algorithm that waits for a miracle that automatically makes your vector sorted. Does nothing on its own.

let unsorted = vec![5i8, -7, 8, 2, 1, 0, -9];
let sorted: Vec<_> = unsorted.miraclesort();

Structs

SleepsortIter

An iterator over a sleepsorted collection.

Enums

SleepsortSpeed

Adjusts how long sleepsort threads sleep.

Traits

Bogosort	This trait provides the bogosort functionality.
Miraclesort	This trait provides the miraclesort functionality.
Panicsort	This trait provides the panicsort functionality.
Sleepsort	This trait provides the sleepsort functionality
SleepsortItem	Marks a trait that can be sleepsorted.
Slowsort	This trait provides the slowsort functionality.