Syntax for Single Parse Collection Transformations

[AjaniBilby]

For discussion of possible ideas for the optimal syntax to make single parse collection transformers clear to understand in both data manipulation behaviour and execution behaviour (being feed-forward, cache-less). #6 #7 #8 #9

Example of Cache-Full Collection Transformer

A cache-full transformer is ones more akin to methods used in most languages, where each stage of transformation yields all results, before continuing to the next stage.

/* javascript */
arr                                           // Takes whole array
  .filter( (val) => { return val % 2 == 0 } ) // Produces filtered array
  .reduce( (acc, cur) => acc + curr, 0 )      // Reduces results to single value

Example of Cache-Less Collection Transformer

arr |
  filter#[ (val) => { return val % 2 == 0 } ] |
  fold#[ (acc, cur) => { return acc + curr }, 0 ]

The language would iterate through the array, any values which parse the filter, are then passed on to the fold.
This whole expression produces a single value output, with no temporary container intermediaries.

[AjaniBilby]

If 1 + ... is added to the beginning or ... + 1 to the end, readability will become much harder. Hence some form of parentheses should be surrounding any collection of transformation actions to ensure clean readability.

[AjaniBilby]

Proposal 1

Collection.Group#[
  Collection.Filter#[func1],
  Collection.Fold#[func2](0)
](arr)

Issues

For the folder operation which requires a default accumulator/state, it needs to be parsed dynamically (as a not static value), hence there will be confusion as to whether the fold is being executed and the result parsed to the group, or if the group is triggering that statement. By pure syntax and grammar, the behaviour is unknown.

Hence extra syntax will need to be implemented for collection transformations.

[AjaniBilby]

Possibly syntax should closely resemble the usage of CLI tool pipes.

enumerate arr -> filter -> fold 0

This syntax could lend itself to using generators which would allow more expensive and less language-driven behaviour. For instance, if each operation was a generator, where each generator is parsed control of the generator preceding it;

• a map is a generator which yields the same number of times
• a filter is simply a generator which either yields a value or nothing
• a fold is simply a generator which only yields a single results
• a unfold is simply a generator which produces multiple results from the same input

Psudo-Code Examples

generator<int> map(generator<int> gen) {
  while (term = gen.next()) {
    if (term.final) {
      return term.value;
    } else {
      yield term.value;
    }
  }
}

generator<int> filter(generator<int> gen) {
  while (term = gen.next()) {
    if (term.value % 2 == 0) {
      continue;
    }
  
    if (term.final) {
      return term.value;
    } else {
      yield term.value;
    }
  }
}

generator<int> fold(generator<int> gen) {
  int acc = 0;
  while (term = gen.next()) {
    acc = acc + term.value;
  }
  
  return term.value;
}

generator<int> unfold(generator<int> gen) {
  while (term = gen.next()) {
    while (term.value > 0) {
      term.value /= 3;
      yield term.value;
    }
  }
  
  return;
}

Note however that these examples break the view once nature of uni-view, and hence should be abstracted to lambda-functions or similar inline functions where the recursion is not visible.

[AjaniBilby]

Due to simplifying the lending mechanics to make it easier for people to understand, we want to be able to avoid all looping behaviour.
Hence the unfold mechanics is currently unviable.

[AjaniBilby]

A method Python Inspired List Comprehension.
Here are a few examples, note this will require the implementation of being able to lend all possible types, including non-linear.

Example 1

// Take an array of ints
// Multiply each value by three
// Only take values which are now a multiple of two
// Then take the sum of the array
fn process(arr: Array#[int]) {
	let state = 0;
	[arr map a into a*3
		filter b into mod(floor(b), 2) == 0
		fold c with @state into {
			// Note this scope can only access;
			//   - The borrowed value state
			//   - The owned value x
			x = c + state;
			state = state + c;
			
			return state;
		}
	]
}

Example 2

// Take an array of ints
// Return the result of each value added with itself and the sum of all previous values
fn process(arr: Array#[int]): Array#[int] {
	let output = new Array#[int]();
	let state = 0;
	[arr map x with @state into {
		state = state + x
		return x + state;		
	} store @output]

	return output;
}

Example 3

// Take a single value
// Will return an array starting from x decreasing by 10 until a value less than 10 is reached
fn process(val: int): Array#[int] {
	let output = new Array#[int]();
	if (val > 10) {
		output.push(val);
	}

	[val unfold x {
		if (x > 10) {
			yield x-10;
		} else {
			return x;
		}
	} store @output]
}

Example 4

// Take a single value
// Returns an array of length (val/10)+1
// Where the first val/10 elements are all ten
// And the (val/10+1)th element is the remainder
fn process(val: int): Array#[int] {
	let output = new Array#[int]();
	let state = int;
	if (state > 10) {
		output.push(state);
	}

	[val unfold _ with @state {
		state = state - 10;
		if (state > 10) {
			yield 10;
		} else {
			return state;
		}
	} store @output]
}

Example 5

// Take an input number
// Unfold it into an array from x-1 to 0 where each value is multiplied by 2
fn process(val: int): Array#[int] {
	let output = new Array#[int]();
	[val unfold x into {
		if (x > 1) {
			yield x-1;
		} else {
			return x-1;
		}
	} map x into x*2 store @output]
}

Notes

I do not think the yield/return method is best for the unfold operation, however, I think this is a good start for a solid syntax that fits with the current language design