Loop enhancements

[edemaine]

for.value

For loop expressions, let's expose the array where values get accumulated, so you can add extra items, remove items, reset the entire value, etc. This gives you pretty full control on adding items within the loop.

function f(list)
  for item of list
    continue unless item
    if special item
      for.value = 'special'
      break
    for.value.push "," if for.value.length
    item
---
function f(list) {
  return (() => {var results = []; for (item of list) {
    if (!item) continue
    if (special(item)) {
      results = 'special'
      break
    }
    if (results.length) results.push(",")
    results.push(item)
  }; return results)()
}

• for.value, while.value, until.value, loop.value, do.value to access the value from the nearest ancestor loop of the given type
• for:label.value and maybe :label.value to get the value of a labeled loop
• for:label item of list as more symmetric alternative for :label for item of list
• Possible shorthand like for.push for for.value.push
• Allow for typing the results object:

  for item of list : number[] | string

• Allow for initializing the results object to something other than []:

  for item of list : MyList = new MyList

  (Not sure whether this should be = or .=)

Open question: Would if.value be useful to access the argument to if? Maybe not, as that seems pretty different (if's argument instead of return value).

Postfix clause

We still would like control on the loop's value at the end of the loop. We could support a postfix clause that always runs at the end. I think then is a decent name. (It's like try's finally clause, but finally clauses get run not returned, so then seems like a better name.)

function f(list)
  for item of list
    item * 2
  then
    for.value.reverse()
---
function f(list) {
  return (() => {var results = []; for (item of list) {
    results.push(item)
  }; return results.reverse())()
}

Admittedly, this example could also be written as

function f(list)
  for item of list
    item * 2
  .reverse()

or more generally with pipe syntax:

function f(list)
  for item of list
    item * 2
  |> .reverse()

So this feature may not be important. The next one is more interesting.

Postfix conditionals

It's common (e.g. in Python) to distinguish whether the loop breaked or not. We propose a postfix conditional using break? to enable distinguishing. More generally, allow assigning a break.value via break = ..., similar to #361.

function f(list)
  for item of list
    if special item
      break = item
    item
  if break?
    break.value + '!!!'
---
function f(list) {
  return (() => {var results = [], breakValue; for (item of list) {
    if (special(item)) {
      breakValue = item
      break
    }
    results.push(item)
  }; return breakValue != null ? breakValue + '!!!' : results)()
}

Perhaps more interesting when we're not accumulating a results array:

function f(list)
  for item of list
    if special item
      break = item
  if break?
    console.log break.value, '!!!'
  else
    console.log 'not found'
---
function f(list) {
  var breakValue;
  for (item of list) {
    if (special(item)) {
      breakValue = item
      break
    }
  }
  if (breakValue != null) {
    return console.log(breakValue, '!!!')
  } else {
    return console.log('not found')
  }
}

I think we only want to a conditional after a loop as a postfix conditional when it uses break? or break.value. Otherwise, we'd get surprising results where we build and even return the results array but just expected a regular if/else expression:

function f(list)
  for item of list
    console.log item
  if list.length
    `${list.length} items`
---
function f(list) {
  for (item of list) {
    console.log(item)
  }
  if (list.length) {
    return `${list.length} items`
  }
  return  // not results array from for loop
}

• break sets break.value to true
• break = value sets break.value to value
• Postfix if/unless when they use break.value or break? (shorthand for break.value?)

(transcribing last night's conversation with @STRd6)

[edemaine]

We now have break with ... and continue with ... from #1395 and as described in docs.

I think this replaces break = ..., but we can still consider for.value and/or :label.value for finer control.

I'm also curious about if break. Now that we don't assign to break, I'm not sure break.value makes sense. So instead of if break? and break.value, perhaps we should just use if break and use for.value if we want to modify. Possible examples:

for item of list
  if match item
    break with item
unless break
  'not found'  // more likely, throw or return or something

for item of list
  if match item
    break with item
if break
  console.log 'found', for.value

I also think we should consider the for...else design, like Python and proposed in #1247, because break with gives a way to override the return value in the breaking case, but what's missing now is a way to override the return value in the non-breaking case. So I'd consider these alternatives for how to write the loops above:

for item of list
  if match item
    break with item
else
  'not found'  // more likely, throw or return or something

item :=
  for item of list
    if match item
      break with item
  else
    null  // instead of getting an array of results
if item?
  console.log 'found', for.value

Note: if we break (no with ...), the else case still wouldn't trigger. This enables non-expressionized uses such as

for item of list
  if match item
    console.log 'found', item
    break
else
  console.log 'not found'