for with open-ended range interpreted as expression

[tmssngr]

I have following code:

fn determine_file(prefix: string) -> string {
	if let Err(err) = os.Stat(prefix) {
		return prefix
	}

	for i in 2.. {
		let name = prefix + strconv.Itoa(i)
		if let Err(err) = os.Stat(name) {
			return name
		}
	}
}

and it fails to compile:

  🔴 Type mismatch
    ╭─[src/main.lis:71:2]
 70 │
 71 │ ╭─▶     for i in 2.. {
 72 │ │           let name = prefix + strconv.Itoa(i)
 73 │ │           if let Err(err) = os.Stat(name) {
 74 │ │               return name
 75 │ │           }
 76 │ ├─▶     }
    · ╰──── expected string, found ()
 77 │     }
    ╰────
  help: Change the type annotation to () or convert the value to string · code: [infer.type_mismatch]

IMHO, it should be treated as a loop, not an ending for. Am I wrong?

[stormpat]

The loop has type Never unless it terminates with a break. The break can have a payload that is then inferred as the loops return type. The loop is also an expression, meaning you can assign it to a variable or just return it (the last expression is always implicitly returned) as is.

fn looping() -> string {
  let mut i = 0
  loop {
    if i > 3 { break "Exited" }
    i += 1
  }
}

You can also do this:

fn looping() -> string {
  let mut i = 0
  let result = loop {
    if i > 3 { break "Exited" }
    i += 1
  }
  fmt.Println("Loop returned:", result)
  result
}

The basic for loop is simply of type Unit, displayed as (). It always returns just (), and if in tail position, the function also returns ()

That means that this will compile:

fn foring() {
  for _ in 0..5 {}
}

But this wont

fn foring() -> string {
  for n in 0..5 {
    if n == 30 { return "Exited" }
  }
}

You need to provide a default value if you want to "exit early"

fn foring() -> string {
  let s = "Default return value"
  for n in 0..5 {
    if n == 3 { return "Exited" }
  }
  s
}

In practice for is only for side-effects and mutation.

[tmssngr]

I don't know the internals, but the for loop with open-ended range is IMHO actually a loop with auto-incrementing, isn't it? Could it be that I can't use the for-loop with open-ended range as last statement in a block?

[stormpat]

loop and an open-ended for are indeed very similar, but the compiler treats them differently. One has an actual return type, while the latter is only ever unit. I guess you could argue that a loop must break or loop forever, while a for always loops n times (not counting the open ended one) and can exit without an explicit condition.