[Feature Request] Array.join, Reverse Ranges

[toluschr]

My first request would be to create a .join method for the builtin Array-type.

Since the String object has a .split method, which splits a string into an Array, this would make sense to implement.
The method could join the Array to a String with the delimeter as a parameter.

Here is a reference implementation in TScript:

function join(arr, sep = "")
{
	var out = "";
	for var em in arr do {
		if out.size() > 0 then
			out += sep;
		out += em;
	}
	return out;
}

The function would make dealing with strings much more pleasant (And more akin to both c and c++), because it allows simple conversion between Strings and Arrays with member modification.

My second request would be iterating over reverse ranges (for x in 100:0), which could have been handy together with the .join method for base-conversion.

function base8(n)
{
	var out = Array(8, 0);
	for var x in out.size():0 do {
		out[x] = (n % 8); n //= 8;
		if n == 0 then
			break;
	}

	if n > 0 then error("number too large");
	return join(out);
}

[manuel-fischer]

Join function

The problem I might see is that the resulting type of the join function could be dependent of the element type in the array. Beginners might consider using the join function for joining strings and also for joining arrays. Both are sequence types.

I suggest to use a syntax like Python uses, which is explicit about the joiner/separator, so there is no ambiguity of the resulting sequence type, which would always be the same as the type of the joiner:

var strings = ["Hello", "world"];
var arrays = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
var mixed = ["My numbers are", [10, 42]];

print(" ".join(strings)); # -> "Hello world"
print("".join(strings)); # -> "Helloworld"
print([].join(arrays)); # -> [1, 2, 3, 4, 5, 6, 7, 8, 9]
print([0].join(arrays)); # -> [1, 2, 3, 0, 4, 5, 6, 0, 7, 8, 9]
print([0, 0].join(arrays)); # -> [1, 2, 3, 0, 0, 4, 5, 6, 0, 0, 7, 8, 9]
print("".join(arrays)); # -> "[1, 2, 3][4, 5, 6][7, 8, 9]", converted every item in arrays to string and concatenated them
print([].join(strings)); # -> error: cannot concatenate strings to arrays
print(" ".join(mixed)); # -> "My numbers are [10, 42]", like "My numbers are" + " " + [10, 42]

By using a symmetric syntax for both strings and arrays, it might be easier for beginners to understand that strings are just sequences of characters, and that these work similar to arrays.

[manuel-fischer]

Reversed iteration through numeric range -- Better: Steps for ranges

Currently ranges, where the starting number is larger than the ending number, are considered empty. The following example is a function that should find a given pair of adjacent elements in an array, if it couldn't be found, null should be returned.

function adjacentFind(array, a, b)
{
    for var i in 0:array.size()-1
    {
        if array[i] == a and array[i+1] == b then
            return i;
    }
    return null;
}

It always returns null, if the array contains 0 or 1 element. The resulting ranges are 0:-1 and 0:0 respectively, both ranges are empty.
If the change was made, that means the function always fails for an empty array, because 0:-1 would contain a number and the array would be indexed with that value. Then you would have to write an additional if statement to check if the array was empty. This and many other algorithms can be implemented in a more simpler way because of this property, that the resulting ranges are considered empty.

Instead I suggest to add an additional step parameter to ranges, that would revert the order of iteration, if it was negative. I suggest a similar syntax like the Pythons slice syntax:

for var i in 0:10:1 do print(i); # 0 1 2 3 4 5 6 7 8 9
# there are three possible ways how reversed ranges would work:
# 1.
for var i in 9:-1:-1 do print(i); # 9 8 7 6 5 4 3 2 1 0
# 2.
for var i in 10:0:-1 do print(i); # 9 8 7 6 5 4 3 2 1 0
# 3.
for var i in 0:10:-1 do print(i); # 9 8 7 6 5 4 3 2 1 0

The first way is similar how you would choose the parameters for ranges/slices in python, the first number is included, the last excluded, to reverse a given range, you have to swap and substract 1 from both sides.

In the second example, you still have to swap the minimum and maximum value.

The last way could be more intuitive, using the same minimum and maximum boundaries and adding :-1 to revert the order.

I think, the last would be the most consistent way to implement steps to ranges. Let me know what you think.

To clarify I will use the names lower:upper:step instead of begin:end:step, because for reversed ranges (step < 0) the lower value is the last value.

To implement this syntax, the :-operator could be extended to accept a range as its left operand and a number as its right operand. It would multiply the step value of that range with the right operand, and create a new range with this new step value. When the range operator is used with two integers it results in a range with step = 1.
So the range 0:10:-1:-1 would be parsed as ((0:10):-1):-1 and would result in 0:10:(-1*-1) = 0:10:1 = 0:10 again. It can be seen as reverting a reversed range to get the original range back.

When dealing with steps that are neither 1 or -1, the numbers, that satisfy the following condition, should be iterated through

i == lower + |step|*k : k ∈ ℕ ∪ {0} ∧ k < (upper-lower)/|step|

It results in the following equalities

0:10:3 -> [0, 3, 6, 9]
0:9:3 -> [0, 3, 6]

0:10:-3 = (0:10:3):-1 = (0:10:-1):3 -> [9, 6, 3, 0]
0:10:3 = 0:11:3 = 0:12:3 -> [0, 3, 6, 9]
generalized:
a:b:-s = (a:b:s):-1 = (a:b:-1):s
a:b+1:s = ... = a:b+k:s = ... = a:b+s:s,  b = a+s*i, i ∈ ℕ ∪ {0}, 1 ≤ k ≤ s

Note that a step of 0 results in a division by zero in the definition above. So a step value of 0 would not be allowed, this is also the case in python.

The following is the way you would express the behavior with a Javascript for loop

let lower, upper, step; // values in the range object

let size = max(0, (upper-lower)/Math.abs(step)|0); // a/b|0 is an integer division, alternatively: Math.floor((upper-lower)/Math.abs(step));

upper = lower+step*size; // might be calculated in the constructor

let begin = step < 0 ? upper+step : lower;
let end = step < 0 ? lower+step : upper;

for(let i = begin; i != end; i += step) // runned size times
{
    execute_block(i);
}

The values in step, begin and end might be used for the corresponding functions in the range object.

Going further

If the range:step notation could be used for ranges, why not add this property for arrays?

[1, 1, 2, 3, 5]:-1 = [5, 3, 2, 1, 1] # reversing the array
[1, 1, 2, 3, 5]:2 = [1, 2, 5] # each second element
[1, 1, 2, 3, 5]:-2 = [5, 2, 1] # each second element and reversed
[1, 2, 3, 4, 5, 6, 7, 8, 9]:3 = [1, 4, 7] # each 3rd element
[1, 2, 3, 4, 5, 6, 7, 8, 9]:2:2 = [1, 2, 3, 4, 5, 6, 7, 8, 9]:4 = [1, 5, 9] # each 2*2 = 4th element

[toluschr]

Reverse Ranges:

While I agree that your idea is much better than mine, and would improve for-loops a lot, I still think it should be possible to iterate over 'reverse' ranges, since I don't see a reason why it shouldn't work in the first place.

Join Function:

Pythons join-syntax never really made sense with me, but I'm happy with either implementations.

[Jartreg]

May I suggest splitting this up into separate issues for each feature?

[TGlas]

Split into separate threads: #35 (ranges) and #36 (Array.join)

[TGlas]

Closed - please continue the discussion in the separate threads.