14.4.108  Typelocked_Rw_Vector_Sort

The standard library Typelocked_Rw_Vector_Sort api defines access to sort algorithms defined over mutable vectors specialized to hold a particular value type.

Implementations of the Typelocked_Rw_Vector_Sort api may be generated using rw_vector_quicksort_g from src/lib/src/rw-vector-quicksort-g.pkg.

The Typelocked_Rw_Vector_Sort api source code is in src/lib/src/typelocked-rw-vector-sort.api.

The above information is manually maintained and may contain errors.

api {    package a : api {
                    eqtype Rw_Vector ;
                    Element ;
                    Vector ;
                    maximum_vector_length : Int;
                    make_rw_vector : (Int , Element) -> Rw_Vector;
                    from_list : List(Element ) -> Rw_Vector;
                    from_fn : (Int , (Int -> Element)) -> Rw_Vector;
                    length : Rw_Vector -> Int;
                    get : (Rw_Vector , Int) -> Element;
                    _[] : (Rw_Vector , Int) -> Element;
                    set : (Rw_Vector , Int , Element) -> Void;
                    _[]:= : (Rw_Vector , Int , Element) -> Void;
                    to_vector : Rw_Vector -> Vector;
                    copy : {at:Int,  from:Rw_Vector,  into:Rw_Vector} -> Void;
                    copy_vector : {at:Int,  from:Vector,  into:Rw_Vector} -> Void;
                    keyed_apply : ((Int , Element) -> Void) -> Rw_Vector -> Void;
                    apply : (Element -> Void) -> Rw_Vector -> Void;
                    keyed_map_in_place : ((Int , Element) -> Element) -> Rw_Vector -> Void;
                    map_in_place : (Element -> Element) -> Rw_Vector -> Void;
                    keyed_fold_forward : ((Int , Element , X) -> X) -> X -> Rw_Vector -> X;
                    keyed_fold_backward : ((Int , Element , X) -> X) -> X -> Rw_Vector -> X;
                    fold_forward : ((Element , X) -> X) -> X -> Rw_Vector -> X;
                    fold_backward : ((Element , X) -> X) -> X -> Rw_Vector -> X;
                    keyed_find : ((Int , Element) -> Bool)
                                 -> Rw_Vector -> Null_Or(((Int , Element)) );
                    find : (Element -> Bool)
                           -> Rw_Vector -> Null_Or(Element );
                    exists : (Element -> Bool) -> Rw_Vector -> Bool;
                    all : (Element -> Bool) -> Rw_Vector -> Bool;
                    compare_sequences : ((Element , Element) -> Order)
                                        -> (Rw_Vector , Rw_Vector) -> Order;
                };;
    sort : ((a::Element , a::Element) -> Order)
           -> a::Rw_Vector -> Void;
    sorted : ((a::Element , a::Element) -> Order)
             -> a::Rw_Vector -> Bool;
};