☰
Java_String
fuzion.java.Java_String
Java's 'java.lang.String' type
Reference Constructors
Functions
convert this string into a Sequence of codepoint and errors for encoding problems
found in the underlying utf8 bytes
found in the underlying utf8 bytes
converting a string to a string is just returning string.this
convert this string into a list of codepoint and errors for encoding problems
found in the underlying utf8 bytes
found in the underlying utf8 bytes
does this string contain the given 'substring'
returns true if string contains whitespace
count number of occurrences of given 'substring' in this string
NYI: string.reverse causes a conflict with Const_String.reverse since visibility is not supported
public string.reverse => terminal.reverse + string.this + terminal.reset
public string.reverse => terminal.reverse + string.this + terminal.reset
Cuts out the first appearance of the string sep from this string, in other words,
returns a tuple of two strings and a bool, the first string is the substring before
the first appreance of sep, the second string is the substring after the first
appearance of sep. The bool result is true iff sep appears in this string.
If sep does not appear in this string at all, return this string as the first string,
the empty string as the second, and false as the bool.
returns a tuple of two strings and a bool, the first string is the substring before
the first appreance of sep, the second string is the substring after the first
appearance of sep. The bool result is true iff sep appears in this string.
If sep does not appear in this string at all, return this string as the first string,
the empty string as the second, and false as the bool.
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierachy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierachy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
check if this string ends with given suffix
Splits this string at codepoints where p is true and returns the result as a
list of strings. In case multiple, neighboring codepoints in the string are
evaluated to be true by p, this does not cause empty strings to be added to
the result list, rather this case is being treated as being one big separator.
list of strings. In case multiple, neighboring codepoints in the string are
evaluated to be true by p, this does not cause empty strings to be added to
the result list, rather this case is being treated as being one big separator.
find (utf8-byte-) index of 'substring' witin this string.
find (utf8-byte-) index of 'substring' witin this string.
find (utf8-byte-) index of last occurrence of 'substring'
within this string.
within this string.
concatenate string with string representation of another object
is `this` contained in `Set` `s`?
This should usually be called using type inference as in
my_set := set_of ["A","B","C"]
say ("B" ∈ my_set)
say ("D" ∈ my_set)
This should usually be called using type inference as in
my_set := set_of ["A","B","C"]
say ("B" ∈ my_set)
say ("D" ∈ my_set)
is `this` not contained in `Set` `s`?
This should usually be called using type inference as in
my_set := set_of ["A","B","C"]
say ("B" ∉ my_set)
say ("D" ∉ my_set)
This should usually be called using type inference as in
my_set := set_of ["A","B","C"]
say ("B" ∉ my_set)
say ("D" ∉ my_set)
Does this String consist of nothing but ascii codepoints?
returns true if string is empty or contains whitespace only
name of this type, including type parameters, e.g. 'option (list i32)'.
pad this string at the end with spaces such that its `codepoint_length` is at least `n`.
pad this string at the end with `p` such that its `codepoint_length` is at least `n`.
pad this string at the beginning and at the end with spaces such that its `codepoint_length` is at least `n`.
In case the required number of codepoints to add is odd, the padding at the end will be longer.
In case the required number of codepoints to add is odd, the padding at the end will be longer.
pad this string at the beginning and at the end with `p` such that its `codepoint_length` is at least `n`.
In case the required number of copies of `p` is odd, the padding at the end will be longer.
In case the required number of copies of `p` is odd, the padding at the end will be longer.
return string of at least length l by
padding codepoint s to start of string
padding codepoint s to start of string
pad this string at the beginning with spaces such that its `codepoint_length` is at least `n`.
pad this string at the beginning with `p` such that its `codepoint_length` is at least `n`.
parse this string as a signed 32-bit integer value
parse this string as a signed 64-bit integer value
parse this string as an int value of arbitrary size
§(T type, base String.parse_integer.T):Any => outcome String.parse_integer.T [Inherited from String]
§(T
type
, base String.parse_integer.T):
Any =>
outcome String.parse_integer.T [Inherited from String]
parse this string as a integer value given as type parameter
parse this string as an unsigned 32-bit integer value
parse this string as an unsigned 64-bit integer value
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
replace all occurrences of old by new
replace the first n occurrences of old by new
Split string separated by (ASCII) white space
Leading and trailing white space is ignored, repeated white space is treated
like a single white space
The result is a, possibly empty, list of separate non-empty strings.
Leading and trailing white space is ignored, repeated white space is treated
like a single white space
The result is a, possibly empty, list of separate non-empty strings.
split string after s, that is do the same thing as split but
include the separator s in the resulting strings
include the separator s in the resulting strings
split string after s, for at most n occurrences of s
if s occurs in the string less than n times, the resulting list will have
less than n elements
if s occurs in the string less than n times, the resulting list will have
less than n elements
split string at s, for at most n occurrences of s
if s occurs in the string less than n times, the resulting list will have
less than n elements
if s occurs in the string less than n times, the resulting list will have
less than n elements
check if this string starts with given prefix
create substring of this string consisting of bytes from (inclusive) .. byte_length (exclusive).
create substring of this string consisting of bytes from (inclusive) .. to (exclusive).
create substring of this string consisting of codepoints from (inclusive) .. codepoint_length (exclusive).
create substring of this string consisting of codepoints from (inclusive) .. to (exclusive).
remove leading and trailing white space from this string
Reference Types
Value Types
helper type for the result of the cut feature
Type Features
monoid of strings with infix + operation.
concat strings a and b by
concatenating their byte sequences.
concatenating their byte sequences.
monoid of strings with infix '+ sep +' operation, i.e., concatenate with
given separator
given separator
equality implements the default equality relation for values of this type.
This relation must be
- reflexive (equality a b),
- symmetric (equality a b = equality b a), and
- transitive ((equality a b && equality b c) : equality a c).
result is true iff 'a' is considered to represent the same abstract value
as 'b'.
This relation must be
- reflexive (equality a b),
- symmetric (equality a b = equality b a), and
- transitive ((equality a b && equality b c) : equality a c).
result is true iff 'a' is considered to represent the same abstract value
as 'b'.
create string from the given utf8 bytes
create string from the given codepoints
§(E type, a container.Mutable_Array Any String.type.from_mutable_array.E) ref:String is [Inherited from String]
§(E
type
, a container.Mutable_Array Any String.type.from_mutable_array.E) ref
:
String is
[Inherited from String]
create string by concatenating the results of $a[a.indices].
This uses a growing array if further strings are appended using 'infix +',
so it avoids quadratic runtime caused if each 'infix +' would create its
own concatenation-string.
The performance of creating a string a0+a1+a2+...+a<n> is in O(n) since the
backing array is shared and doubled in size when full (so the final array size
is less than 2n in size and the sum of all arrays is less than 4n = 2n + n +
n/2+n/4+...).
The performance of iterating the utf8 bytes of a string is O(l+n) for an
array of length l created by concatenating n sub-strings.
This uses a growing array if further strings are appended using 'infix +',
so it avoids quadratic runtime caused if each 'infix +' would create its
own concatenation-string.
The performance of creating a string a0+a1+a2+...+a<n> is in O(n) since the
backing array is shared and doubled in size when full (so the final array size
is less than 2n in size and the sum of all arrays is less than 4n = 2n + n +
n/2+n/4+...).
The performance of iterating the utf8 bytes of a string is O(l+n) for an
array of length l created by concatenating n sub-strings.
create hash code from a string
Takes a sequence of strings and concatenates its elements.
In case an empty sequence is given, returns the empty string.
In case an empty sequence is given, returns the empty string.
Takes a sequence of strings and concatenates its elements, while adding the separator
sep in between its elements. In case an empty sequence is given, returns the empty string.
sep in between its elements. In case an empty sequence is given, returns the empty string.
§(a property.partially_orderable.this.type, b property.partially_orderable.this.type):Any is [Inherited from partially_orderable]
§(a property.partially_orderable.this.type, b property.partially_orderable.this.type)
:
Any is
[Inherited from partially_orderable]
does a come before b or is equal to b?
NYI: remove the convenience functions when Fuzion supports char literals
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.