3 ms·
For me personally that's the part of syntax I don't like and don't understand the value of.
by troupo 3y ago
For me personally that's the part of syntax I don't like and don't understand the value of.
- danappelxx 3y agoGenerally stems from the philosophy that code is read more than written, and this helps readability.
- troupo 3y agoDoes it? Instead of a single parameter you now have two names, and a type info to boot pub fn replace( in string: String, each pattern: String, with replacement: String, ) { // The variables `string`, `pattern`, and `replacement` are in scope here } replace(in: "A,B,C", each: ",", with: " ") vs pub fn replace( in: String, each: String, with: String, ) { } replace(in: "A,B,C", each: ",", with: " ")
- _glass 3y agoWouldn't you have replace("A,B,C", ",", " "), which is quite unreadable.
- troupo 3y agoNot if you go the C# way: https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/named-and-optional-arguments https://learn.microsoft.com/en-us/dotnet/csharp/programming-...
- lpil 3y agoWhen argument variable names and labels are combined you have two problems: 1. Labels are accidental. If all arguments automatically create labels then the programmer has not considered and deliberately designed the API. Gleam is designed to make sure that APIs are always carefully thought about and designed as appropriate. 2. Renaming a variable becomes a breaking change. We don't believe that renaming a variable should ever result in a semver major version bump.
- troupo 3y ago> Labels are accidental. If all arguments automatically create labels then the programmer has not considered and deliberately designed the API. 1. Not every code is an API. And APIs exist in multiple languages that don't have labels 2. If you wanted named parameters, you could go the C# way: https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/named-and-optional-arguments https://learn.microsoft.com/en-us/dotnet/csharp/programming-... 3. Since Gleam doesn't enforce labels or check labels in any way, it doesn't "make sure APIs are carefully thought out". Labels will be just as random and accidental as parameter names following the whims of the programmer who decides to use them > Renaming a variable becomes a breaking change. So does renaming a label.
- yaglo 3y ago1. Every class/method/function/whatever declaration is an API, doesn't matter if it's internal or which language it's written. 2. Why do you think it's better? It looks like it tries to cater to everyone, and leads to inconsistent API usage and requires teams to agree on linting rules and use tools to enforce consistent coding standards. 3. It's a tool for _you_ to design good APIs that are clear. Languages without named arguments don't give you this tool. > So does renaming a label. In languages without this feature, any renaming breaks the API, unlike the ones with distinct internal and external names. This is not the same.
- zem 3y agothe idea is that within the function body you would rather refer to the variables as e.g. `for s in string.match(pattern)` than `for s in in.match(each)`
- troupo 3y agoThen call them that. `replace(string, pattern)` is just as (if not more) readable as `replace(in, each)`. I was specifically replying to the claim about readability.
- dylukes 3y agoIt separates "names as public-facing API design decisions" from "names as developer conveniences for expressing intent and clarifying their code". These are often very at odds. And if you don't want to repeat yourself twice with two identical names... you don't have to. And unlike Smalltalk, in Swift at least, externally unnamed but internally named is easy (just make the external name _).
- troupo 3y ago> It separates "names as public-facing API design decisions" from "names as developer conveniences for expressing intent and clarifying their code" How often is this an issue? > And unlike Smalltalk, in Swift at least, externally unnamed but internally named is easy (just make the external name _). So, visual clutter for very little gain. IMO
- lpil 3y ago> How often is this an issue? In our opinion, almost always.
- troupo 3y agoAs wikipedia would say, [citation needed]. Having shipped code in nearly two dozen different programming languages, there were very few times when I wanted my internal parameter name to be different from my external parameter name. The reasons are very simple: - if your function is simple, you just use the params immediately, like in your `replace` example. It doesn't matter what they are called as long as their names make sense - if your function is not simple, the parameters are usually immediately transformed into something else (mapped to different data, split to different data etc.), and their original name doesn't matter. So this leaves a small weird case of "somehow parameter names don't make sense for the caller of the function", and I can't for the life of me come up with such an example (the example with replace in Gleam docs is not convincing, to say the least).
- dylukes 3y ago