PreviousUpNext

15.3.556  src/lib/std/src/typelocked-rw-vector-slice.api

## typelocked-rw-vector-slice.api

# Compiled by:
#     src/lib/std/src/standard-core.sublib



# This api is implemented in:
#
#     src/lib/std/src/rw-vector-slice-of-chars.pkg
#     src/lib/std/src/rw-vector-slice-of-one-byte-unts.pkg
#     src/lib/std/src/rw-vector-slice-of-eight-byte-floats.pkg
#
api Typelocked_Rw_Vector_Slice {
    #
    Element;
    #
    Vector;
    Rw_Vector;
    #
    Slice;
    Vector_Slice;

    length:   Slice -> Int;

    get:     (Slice, Int) -> Element;
    set:     (Slice, Int, Element) -> Void;

    (_[]):     (Slice, Int) -> Element;                                         # Enables use of    foo = a[i];   syntax.
    (_[]:=):   (Slice, Int, Element) -> Void;                                   # Enables use of    a[i] := foo;  syntax;

    make_full_slice:  Rw_Vector                       -> Slice;
    make_slice:      (Rw_Vector, Int, Null_Or( Int )) -> Slice;
    make_subslice:   (Slice, Int, Null_Or( Int ))     -> Slice;

    burst_slice:    Slice -> (Rw_Vector, Int, Int);
    to_vector:  Slice -> Vector;

    copy:        { from: Slice,         into: Rw_Vector,  at: Int } -> Void;
    copy_vector: { from: Vector_Slice,  into: Rw_Vector,  at: Int } -> Void;

    is_empty:  Slice -> Bool;
    get_item:  Slice -> Null_Or( (Element, Slice) );

    keyed_apply:     ((Int, Element) -> Void) -> Slice -> Void;
    apply:      (Element -> Void) -> Slice -> Void;

    map_in_place:           (Element -> Element) -> Slice -> Void;
    keyed_map_in_place:  ((Int, Element) -> Element) -> Slice -> Void;

    keyed_fold_forward:   ((Int, Element, X) -> X) -> X -> Slice -> X;
    keyed_fold_backward:  ((Int, Element, X) -> X) -> X -> Slice -> X;

    fold_forward:   ((Element, X) -> X) -> X -> Slice -> X;
    fold_backward:   ((Element, X) -> X) -> X -> Slice -> X;

    keyed_find:   ((Int, Element) -> Bool) -> Slice -> Null_Or ((Int, Element));
    find:    (Element -> Bool) -> Slice -> Null_Or( Element );

    exists:  (Element -> Bool) -> Slice -> Bool;
    all:     (Element -> Bool) -> Slice -> Bool;

    compare_sequences: ((Element, Element) -> Order) -> (Slice, Slice) -> Order;

};


## Copyright (c) 2003 by The Fellowship of SML/NJ
## Subsequent changes by Jeff Prothero Copyright (c) 2010-2015,
## released per terms of SMLNJ-COPYRIGHT.


Comments and suggestions to: bugs@mythryl.org

PreviousUpNext