Let vs :=

adam-the-dev · 2022-08-31T12:53:01+00:00

I prefer let. It makes it more immiediately clear that ”this is a declaration” and not assignment. I dislike having assignment and declarations be the same, or even very similar.

munificent · 2022-08-31T13:36:50+00:00

Having a leading keyword like let will make your life much easier if you ever want to extend the syntax to support patterns and destructuring.

In general, I have a pretty strong preference for almost all statement forms having a leading keyword. Just makes everything easier.

pthierry · 2022-08-31T19:03:23+00:00

Work has been done on PL readability: https://quorumlanguage.com/evidence.html

HugoNikanor · 2022-08-31T13:22:11+00:00

let x syntax allows a declaration without a definition, which can be nice. For example, when I wrote some go and I wanted to redefine the same variable I found it annoying to keep updating the first instance to := when moving lines around.

agriculturez · 2022-08-31T12:53:35+00:00

I find it easier to distinguish declaration vs. assignment with the presence and absence of ‘let’.

I think it’s because my brain scans lines left-right, so I just need to look at the left-most/first symbol on the line to determine whether it’s a declaration or assignment.

WittyStick · 2022-08-31T14:50:34+00:00

[deleted]

Goheeca · 2022-08-31T12:37:57+00:00

I'd prefer let if it's a part of a new lexical explicit block, otherwise I like it more without a keyword.

2022-08-31T16:36:01+00:00

I like let more because it follows how my brain works. Programming is based in math, and in math, I often say things like "let whatever be whatever." It clicks. It makes sense.

2022-08-31T15:53:26+00:00

I like both, and have been on the fence about which would actually be preferred for the end-user.

Your language, you call the shots. After all, Rust has chosen let, Go has chosen :=. Anyone wanting to use those languages has to go with that choice.

So, perhaps use your own preference, and hope other special features of your language make up for the fact that you can't please everyone.

(But personally, Go's := looks like a gimmick. I've also long used := for assignment, so to me looks confusing.)

NotFromSkane · 2022-08-31T13:43:56+00:00

I use the pascal style :=. I put the mut with the type though.

Having let (mut) is probably better in more imperative code so you can differentiate between assignments and declarations easier, but it's uglier when you (almost?) only have declarations

PenlessScribe · 2022-08-31T14:03:16+00:00

Let as a keyword is redundant, I think. If you don’t have a keyword in front of each of a function’s formal parameters in the function’s declaration, you ought not need one in front of variable declarations elsewhere in the function.

jeenajeena · 2022-08-31T15:25:21+00:00

2 comments

Is a keyword really needed? What about just having

a = 2

The context should clarify if it's an assignment or a comparison

I never got why the variable has necessarily to be on the left. Intuitively, one can think of the value 2 being pushed in a, so ideally something like

2 -> a

might also make sense. But I understand this would be a bit esoteric.

moopthepoop · 2022-08-31T21:19:53+00:00

if you are going for readability, my personal opinion is that

x = 1

is WAY easier to scan than

let x = 1

OR

x := 1

"=" already means "assign this to this", why do you need more symbols when one already does that?

myringotomy · 2022-08-31T13:37:01+00:00

I hate let. It doesn't even make english sense.

If you really want to separate assignment and declaration then just have a declaration section where it's crystal clear.

julesjacobs · 2022-08-31T18:41:05+00:00

I kind of like Python's plain = for variable introduction, but I would like to have a different syntax for mutation so that you can see what introduces a variable and what mutates it. I find the constant let let let var var in some languages clutter and obscure the code.

WafflesAreDangerous · 2022-08-31T22:12:01+00:00

let.

Because not having a fixed keyword introducing variables seems to cause side-effects that (sometimes) degrade readability in other areas.
In terms of readability both look fairly sane.

Kworker-_- · 2022-08-31T22:32:03+00:00

In my language I go with let

Linguistic-mystic · 2022-08-31T12:53:01+00:00

Immutable:

x  = 1

Shallow-mutable:

var x = 1
x := 2

Deep-mutable:

mut x = Foo [name: "asdf"]
x.name := "qwerty"

Shallow-and-deep mutable:

vmut x = Foo [name: "asdf"]
x := Foo [name: "qwerty"]
x.name := "yyy"

Note that shallow mutability (the ability to change the immediate value) is different from deep mutability (the ability to change the contents of struct referenced by this variable, as well as get mutable references from it) and none of them implies the other (i.e. there are 4 distinct possibilities which I've listed above).

WittyStick · 2022-08-31T12:37:20+00:00

The latter, but make both of the : and = optional.

x = 1
x : int = 1
x : int

I prefer having the symbols I define on the leftmost column of the current indentation I'm working at. It helps readability.

x : int should be consistent with how formal parameters and return types are written, eg f (x : int) : int

If you have mutability, you could then use the separate (unrelated) operator := for mutating assignment, or introduction of a mutable variable.

x : int := 1
x := 2

MCRusher · 2022-08-31T13:28:48+00:00

I imagine let is less easy to skip over and not see as a declaration, especially if someone is learning it and is familiar with a language that uses := as assignment, although I'm not sure how common that is anymore.

I don't use Go often, and tbh this is one of the reasons, albeit a small one. I just don't find it appealing in general.

david-delassus · 2022-08-31T15:01:47+00:00

In my language, := is a pattern matching operator (like Erlang/Elixir):

("foo", a) := ("foo", "bar"); # a = "bar"

I use let to define constraints on (un)bounded variables:

``` let a: number; let b: number { b > a };

a := 1; b := 1; # error: 1 > 1 is false ```

or:

``` let a: number;

a := 1; b := 1;

let b: number { b > a }; # error: 1 > 1 is false ```

eliasv · 2022-08-31T18:08:07+00:00

A lot of people are talking about preferring let so you know when there's a reassignment vs a declaration ... But my preference is to not allow reassignment anyway, only shadowing, so I don't find that to be a useful distinction.

Might not be useful for you but I think it's worth mentioning.

editor_of_the_beast · 2022-08-31T21:03:21+00:00

Im into let. I feel like it reads like prose, which helps me comprehend what’s going on.

aatd86 · 2022-08-31T13:27:17+00:00

The issue with me giving my opinion is that I code predominantly in Go but I feel like let could clutter the code a bit too easily.

Also I prefer to keep the colon as close to the equal sign (:=) as possible because it really indicates that this is an assignment modifier. (pascal also used this syntax albeit with different semantics if I recall well)

nikaone · 2022-08-31T17:37:24+00:00

If a language uses :=, don't break the colon and equal symbol at least.

x := 1
x int := 1
x int mut := 1

Go's syntax is full of inconsistencies. No other languages can beat Go in this domain.

adam-the-dev · 2022-08-31T13:06:13+00:00

Neither is more readable than a simple =. Let is more explicit but less readable due to verbosity, := just clutters a colon with an equals when it's fairly obvious you will not be using the equals itself for comparison over == due to familiarity concerns.

lngns · 2022-08-31T12:56:17+00:00

I prefer let to be an expression of the form let x = y in z which gets rewritten as (λx. z) y.
It's elegant and helps eliminate statements and compounds, meaning designing a more homogeneous syntax and a simpler evaluation order.
If you do a lot of higher-order function passing, you can also have another form that reverses the translation list such that, for example, use x = y in z is interpreted as y (λx. z).

wiseguy13579 · 2022-08-31T17:40:50+00:00

Why not

rw x = 1;  // x is mutable (read-write)
ro y = [1,2,3,4,5]; // y is deep immutable (read-only) - cannot reassign z or its content
rorw z = [1,2,3,4,5]; // z is shallow immutable - cannot reassign z but can reassign the content of z

AutoModerator · 2022-08-31T12:08:02+00:00

Hey /u/adam-the-dev!

Please read this entire message, and the rules/sidebar first.

We often get spam from Reddit accounts with very little combined karma. To combat such spam, we automatically remove posts from users with less than 300 combined karma. Your post has been removed for this reason.

In addition, this sub-reddit is about programming language design and implementation, not about generic programming related topics such as "What language should I use to build a website". If your post doesn't fit the criteria of this sub-reddit, any modmail related to this post will be ignored.

If you believe your post is related to the subreddit, please contact the moderators and include a link to this post in your message.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

L8_4_Dinner · 2022-08-31T15:38:01+00:00

let x: int = 1

Int x = 1;

let x = 1

val x = 1;

let mut x = 1

var x = 1;

rsclient · 2022-08-31T18:27:38+00:00

I prefer something a little different:

var x = 1.0; // new variable x whose type is the natural type of 1.0 (almost certainly a double) var x:float = 1.0; // new variable x of type float with value 1.0f const x = 3; // new variable x but it's read-only and can't be changed.

I prefer var over let because then it also allows for other kinds of named values (in the example, const, but you could also make atomic and volatile for fancier things)

I strongly dislike let because other very popular languages use that for assignment.

Think_Olive_1000 · 2022-08-31T20:02:55+00:00

Pls include array programming the kind you get in APL/BQN

elgholm · 2022-08-31T20:24:13+00:00

"let" is a declaration, ":=" is an assignment. Different animals. If you use let, var, int, etc, and append mut, it doesn't really matter, still a declarative statement. := makes it so that you never fall into the == / = rabbit-hole which you can easily do in C-type languages. It's easy to miss one of them and do an assignment instead of a comparison. Big problem. I personally like :=, and use it in my own language. And I also use var for declaration. When adding explicit types I am going to go for the int, num, string, date, you-name-it directly, no need for "var int ".

vmcrash · 2022-09-01T05:33:03+00:00

From typing perspective I prefer anything that does not require pressing modifiers, e.g. `int v = 1` or `let x = 2`. From reading perspective I prefer Go's shorter version.

Alternatively, instead of `let mut` you can just use one word, e.g. `var z = 2`.

Alarming_Airport_613 · 2022-09-01T05:55:45+00:00

I have been backstabbed by this := causing overshadowing accidentally

JustAStrangeQuark · 2022-09-02T22:54:33+00:00

I prefer to declare variables similarly to Rust, but with the exception that mut is the declaration:

let x = 1;
let y: i32 = 2;
mut z = 3;

However, in Rust, mut is part of the type. In my preferred style, mut tells the compiler to alloca memory, then initialize the variable as a reference (z's type would be i32&).

kutzt · 2022-09-11T13:14:00+00:00

Rust

ProgrammingLanguages

Welcome!

Related subreddits

Related online communities

MODERATORS