Strings

In string.cecil:

abstract object string isa indexed[char]; 
method copy_mutable(s@:string):m_string; 

The string type is an abstract class representing an indexed sequence of characters. Methods operating on generic strings that both take and return strings, in most cases produce a new string as a result.

method ||(s1@:string, s2@:string):string;
method ||(s1@:string, c@:char):string;
method ||(c@:char, s2@:string):string;
method to_upper_case(s@:string):string; 
method to_lower_case(s@:string):string; 

    In addition to all the operations available on other indexed collections, characters can be concatenated onto the front or back of a string using the || infix operator. (The || operator can also concatenate two strings. This behavior is inherited from sequences.)

method parse_as_int(s@:string):integer; 
method parse_as_int(s@:string, base@:int):integer; 
method parse_as_int(s@:string, fail@closure:&():integer):integer; 
method parse_as_int(s@:string, base@:int, fail:&():integer):integer; 
method parse_as_small_int(s@:string):int; 
method parse_as_small_int(s@:string, base@:int):int; 
method parse_as_small_int(s@:string, fail@closure:&():int):int; 
method parse_as_small_int(s@:string, base@:int, fail:&():int):int; 
method parse_as_float(s@:string):single_float; 
method parse_as_float(s@:string, if_error:&():single_float):single_float; 
method parse_as_float(s@:vstring, if_error:&():single_float):single_float; 
method parse_as_double(s@:string):double_float; 
method parse_as_double(s@:string, if_error:&():double_float):double_float; 
method parse_as_double(s@:vstring, if_error:&():double_float):double_float; 

The parse_as_int methods try to convert a string representation of an integer into the integer representation, calling the optional if_error closure if the string doesn't contain an integer. A similar set of functions supports converting a string representation of a floating point number into a float.

method copy_from(s@:string, start:int):string; 
method copy_from(s@:string, start:int, up_to:int):string; 
method has_prefix(s@:string, prefix@:string):bool; 
method has_suffix(s@:string, suffix@:string):bool; 
method remove_prefix(s@:string, prefix@:string):string; 
method remove_suffix(s@:string, suffix@:string):string; 

The copy_from method copies a portion of a string from a start index up to (but not including) a stop index (or the end of the string, if the stop index is not specified). The has_{prefix,suffix} functions test whether a string starts with or ends with a particular string; the remove_{prefix,suffix} functions return a new string with the specified prefix or suffix removed, if present, or the original string otherwise.

method pad(s@:string, len:int):string; 
method pad_right(s@:string, len:int):string; 
method pad_right(s@:string, len:int, padding:char):string; 
method pad_left(s@:string, len:int):string; 
method pad_left(s@:string, len:int, padding:char):string; 
method open_brace(@:string):string; 
method close_brace(@:string):string; 
method collection_name(@:string):string; 
method elem_print_string(@:string, char:char, :bool):string; 
method print(s@:string):void; 

The pad functions add either blanks or a specified padding character to either the front or the back of the string to make it be of at least the specified length.

abstract object i_string isa string, i_indexed[char]; 
abstract object m_string isa string, m_indexed[char]; 
method copy(s@:m_string):m_string; 
method write_into_string_at_pos(s1:string, s2:m_string, pos:int):void; 

As usual, there are immutable and mutable varieties of strings.

abstract object vstring isa string; 
method length(s@:vstring):int; 
method fetch(s@:vstring, index:int, if_absent:&():char):char; 
method as_vstring(s@:vstring):vstring; 
method print(s@:vstring):void; 
extend i_vstring isa i_string, vstring; 
method new_i_vstring(size@:int):i_vstring; 
method new_i_vstring(size@:int, filler_oop@:char):i_vstring; 
method new_i_vstring_init(size@:int, cl:&(int):char):i_vstring; 
method new_i_vstring_init_from(c@:ordered_collection[`T], 
cl:&(T):char):i_vstring;
method new_i_vstring_init_from(c@:indexed[`T], cl:&(T):char 
):i_vstring;
extend m_vstring isa m_string, vstring; 
method new_m_vstring(size@:int):m_vstring; 
method new_m_vstring_no_init(size@:int):m_vstring; 
method new_m_vstring(size@:int, filler_oop@:char):m_vstring; 
method new_m_vstring_init(size@:int, cl:&(int):char):m_vstring; 
method new_m_vstring_init_from(c@:ordered_collection[`T], 
cl:&(T):char):m_vstring;
method new_m_vstring_init_from(c@:indexed[`T], cl:&(T):char 
):m_vstring;
method store(s@:m_vstring, index:int, c:char, if_absent:&():void):void; 
method as_m_vstring(s@:m_vstring):m_vstring; 

The vstring class and its two concrete subclasses, i_vstring and m_vstring, provide a primitive fixed-length packed string implementation. Cecil string literals (e.g., "hello") are instances of i_vstring. Various constructors for vstrings are provided, analogously to vectors and arrays.