On Thursday, 8 February 2024 at 16:54:36 UTC, Kevin Bailey wrote:
Additionally, it doesn't address the issue. It still requires
me to both realize the issue with comparing an int to length's
mystery type, as well as to fix it for the compiler.
(And it's beside the fact that the start value could just as
easily be an int (parameter for example) that could take a
negative value. This was the case for one of my cases.)
It appears that some strongly typed languages like Rust
necessitate explicit casting similar to D in this particular
case. And some extremely strongly typed languages like Ada
requires it to another level.
```rust
fn main() {
let something = vec!['a', 'b', 'c'];
println!("len: {}", something.len()); // 3
for i in -1..=something.len() as i32 {
println!("i: {}", i);
}
}
```
Like D, Rust's 'len()' function returns an unsigned integer
`usize`. It has to be cast to `int` to deal with the `-1` index
or it will not compile.
```
for i in -1..=something.len() {
| ^^ the trait `Neg` is not implemented for `usize`
```
But there are some modern languages in which the length function
returns a signed integer by default .. such as Odin. [`len ::
proc(v: Array_Type) -> int
{…}`](https://pkg.odin-lang.org/base/builtin/#len). So there is
no requirement for casting in Odin in this particular case. An
experienced Odin programmer replied to me on the Odin Discord
stated: "It is int in the default context, but if the type system
sees it is being used in the context of something that wants a
uint it will return that."
```c
package main
import "core:fmt"
main :: proc() {
something := []byte{'a', 'b', 'c'}
fmt.println("length of 'len(something): ", len(something))
fmt.printf("type of 'len(something)': %T\n", len(something))
// int
for i := -1; i < len(something); i += 1 {
fmt.println("i: ", i)
}
}
```
Thank you everyone for this interesting discussion on languages
and language design.
