PreviousUpNext

15.3.535  src/lib/std/src/string.api

## string.api

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



###     "The string is a stark data package and
###      everywhere it is passed there is duplication.
###      It is a perfect vehicle for hiding information."
###
###                               -- Alan J Perlis


# This api is implemented in:
#     src/lib/std/src/string-guts.pkg

api String {

    eqtype Char;
    eqtype String;

    max_size:  Int;

    # Note:  The (_[])   enables   'vec[index]'           notation;

    length:       String -> Int;                                                # E.g.:   length "abcdef"                           -->  6
    get:         (String, Int) -> Char;                                         # E.g.:   string::get ("abcdef", 0)                 -->  'a'
    (_[]):       (String, Int) -> Char;
    extract:     (String, Int, Null_Or( Int )) -> String;                       # E.g.:   extract ("abcdef", 2, NULL)               -->   "cdef"
                                                                                # E.g.:   extract ("abcdef", 2, THE 1)               -->  "c"
    substring:   (String, Int, Int) -> String;                                  # E.g.:   substring ("abcdef", 1, 4);               -->   "bcde"
    +  :         (String, String) -> String;                                    # E.g.:   "abc" + "def"                             -->   "abcdef"
    cat:          List( String ) -> String;                                     # E.g.:   cat                   ["an", "example"]   -->   "anexample"
    join:         String -> List( String ) -> String;                           # E.g.:   join  " "             ["an", "example"]   -->   "an example"  
    join':        String -> String -> String -> List( String ) -> String;       # E.g.:   join'  "("  ", "  ")" ["an", "example"]   -->   "(an, example)"
    from_char:    Char   -> String;                                             # E.g.:   from_char 'a'                             -->   "a"   
    implode:      List(Char) -> String;                                         # E.g.:   implode ['a', 'b', 'c']                   -->   "abc"
    explode:      String -> List(Char);                                         # E.g.:   explode "abc"                             -->   ['a', 'b', 'c']
    chomp:        String -> String;                                             # E.g.:   chomp "abc\n"                             -->   "abc"    (Drops trailing newline if present, else is a no-op.)
    map:         (Char -> Char) -> String -> String;                            # E.g.:   string::map char::to_upper "abc"          -->   "ABC"

    translate:   (Char -> String) -> String -> String;
    tokens:      (Char -> Bool) -> String -> List(String);                      # E.g.:   string::tokens .{ #c == ','; } "a,b,,c";  -->   ["a", "b", "c"]
    fields:      (Char -> Bool) -> String -> List(String);                      # E.g.:   string::fields .{ #c == ','; } "a,b,,c";  -->   ["a", "b", "", "c"]

    is_prefix:    String -> String -> Bool;                                     # Is String1 is a prefix of String2.
    is_substring: String -> String -> Bool;
    is_suffix:    String -> String -> Bool;

    compare:     (String, String) -> Order;
    collate:    ((Char, Char) -> Order) -> (String, String) -> Order;

    to_lower: String -> String;                                                 # "THIS_is_tExt" -> "this_is_text"
    to_upper: String -> String;                                                 # "THIS_is_tExt" -> "THIS_IS_TEXT"
    to_mixed: String -> String;                                                 # "THIS_is_tExt" -> "This_Is_Text"

    has_alpha: String -> Bool;                                                  # fun has_alpha string =   list::exists  char::is_alpha  (explode string);
    has_lower: String -> Bool;                                                  # fun has_upper string =   list::exists  char::is_upper  (explode string);
    has_upper: String -> Bool;                                                  # fun has_lower string =   list::exists  char::is_lower  (explode string);

    is_alpha:  String -> Bool;                                                  # fun is_alpha  string =   length string > 0   and   list::all  char::is_alpha  (explode string);
    is_upper:  String -> Bool;                                                  # fun is_upper  string =   length string > 0   and   list::all  char::is_upper  (explode string);
    is_lower:  String -> Bool;                                                  # fun is_lower  string =   length string > 0   and   list::all  char::is_lower  (explode string);
    is_mixed:  String -> Bool;                                                  # fun is_mixed  string =   is_alpha string  and  has_upper string  and  has_lower string;

    # For is_alpha/is_space/etc predicates on
    # individual chars in a string see:
    #
    #     src/lib/std/src/string-chartype.api

    <  : ((String, String)) -> Bool;
    <= : ((String, String)) -> Bool;
    >  : ((String, String)) -> Bool;
    >= : ((String, String)) -> Bool;

    from_string:   string::String -> Null_Or( String );
    to_string:     String -> string::String;
    from_cstring:  string::String -> Null_Or( String );
    to_cstring:    String -> string::String;

 };


## COPYRIGHT (c) 1995 AT&T Bell Laboratories.
## Subsequent changes by Jeff Prothero Copyright (c) 2010-2012,
## released under Gnu Public Licence version 3.


Comments and suggestions to: bugs@mythryl.org

PreviousUpNext