Const_String

helper type for the result of the cut feature

repeat string given number of times

convert this string into a Sequence of codepoint and errors for encoding problems
found in the underlying utf8 bytes

converting a string to a string is just returning string.this

length of this string in bytes

splits this string in chunks of codepoint length n, the last part might be shorter

length of this string in codepoints

convert this string into a list of codepoint and errors for encoding problems
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

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.

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 hierarchy 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.

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.

concatenate string with string representation of another object

Does this String consist of nothing but ascii codepoints?

returns true if string is empty or contains whitespace only

is this string empty?

convert this string to lower case

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.

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.

return string of at least length l by
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 128-bit integer value

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

parse this string as a integer value given as type parameter

parse this string as an unsigned 128-bit integer value

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.

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.

split string at s

split string after s, that is do the same thing as split but
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

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

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

convert this string to upper case

string representation of this type to be used for debugging.

result has the form "Type of '<name>'", but this might change in the future

monoid of strings with infix + operation.

concat strings a and b by
concatenating their byte sequences.

monoid of strings with infix '+ sep +' operation, i.e., concatenate with
given separator

There is no dynamic type of a type instance since this would result in an
endless hierarchy of types, so dynamic_type is redefined to just return
Type.type here.

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'.

create string from the given utf8 bytes

create string from the given codepoints

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.

create hash code from a string

Is this type assignable to a type parameter with constraint `T`?

The result of this is a compile-time constant that can be used to specialize
code for a particular type.

is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false

it is most useful in conjunction preconditions or `if` statements as in

pair(a,b T) is

=>

or

val(n T) is

additional restrictions on when equality is permitted,
e.g., `option T` might require `T : property.equatable`.
to implement `equality`

Takes a sequence of strings and concatenates its elements.
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.

does a come before b or is equal to b?

NYI: remove the convenience functions when Fuzion supports char literals

name of this type, including type parameters, e.g. 'option (list i32)'.

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.

NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913

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`.