Variable binding and assignment

[glhrmfrts]

The parser already accepts let, so I was thinking something like Rust's:

let foo: string = "bar"

With type inference the type annotation is optional.

Uninitialized variables are also allowed:

let foo: int
foo = 2 * 2
# or with type inference
let bar
bar = 2 * 2

However there's some decisions to be made:

• Should variables be mutable?
• What is the expected behaviour when someone uses undefined/uninitialized variables?
• Function scope vs block scope (since there's no explicit block in Luna, they would live inside if, for, while, etc).

I'm looking forward to discuss this so we can continue with Luna's development.

[aisk]

• I think immutable brings more complex like:
  • Wether the value is immutable or just the pointer to the value (exactly the value' RAM address) is immutable, or both?
  • If the value is immutable, the container and string types's performence will be more slow. But we can optimise them like Haskell and immutable.js dose.
• It's better to have no uninitialised value, like Golang dose. for example, if we defined a uninitialised variable, the value is already malloced on the heap (or just on the stack), and the value should be a instinct zero value, like 0 for a number, "" for a string, "[]" for a list.
• I like function scope because we can write if condition { let a = 1} else { let a =2 }; print(a).

[glhrmfrts]

• If we bring immutability, it would be good to let the variables mutate but not the data structures, @tj even mentioned this at #45, besides we can optimise like you said. The opposite doesn't make much sense and if both were immutable Luna would turn into a pure-functional language, which I think it's not it's target.
• That's true, but then the user would have to obligatory declare the type of the variable before the assignment, I find that very strict but it might be less error-prone than having a nil value.
• Yeah, function scope fits better with Luna style, another option is to let loops have their own scope but not the if statement.

[aisk]

Put it together:

if some_condition:
  let a = "foo"
else
  let a = 42
end

# what's the type of a? If we have a static linter, it's hard to lint the rest of code with operations to a.

So I think people will not write codes like this, declare the type of variable before assign value to it is acceptable in my opinion. And function scope is a bad choice I thought now (I think most static typed languages have block scope as I can remember).

And certainly the variables must be mutable above. Or we should write codes like this:

let a = if some_condition
  return "foo"
else
  return "bar"
end

This will hard to write code if we have a complex condition and multiple variable to assign, so I agree with you (mutable variable and immutable value like clojure dose).

[glhrmfrts]

I understand you now, it wouldn't be possible to analyze the program statically with uninitialized variables without a type or function scope.

So we have:

• Mutable variables
• Immutable values
• Block scope

I think that's pretty good. I will leave this open for now though, we got a lot of work haha.

[aisk]

Hi can you open some issues about what to do, so people can join this repo quickly, thank you 😊

I saw the issues about what to do, some were to generic ...

[glhrmfrts]

I've added the most urgent thing right now (#77), when I have some more time I will add the rest.

[aisk]

:+1: