12/30/2025 at 2:56:39 PM
Concurrency issues aside, I've been working on a greenfield iOS project recently and I've really been enjoying much of Swift's syntax.I’ve also been experimenting with Go on a separate project and keep running into the opposite feeling — a lot of relatively common code (fetching/decoding) seems to look so visually messy.
E.g., I find this Swift example from the article to be very clean:
func fetchUser(id: Int) async throws -> User {
let url = URL(string: "https://api.example.com/users/\(id)")!
let (data, _) = try await URLSession.shared.data(from: url)
return try JSONDecoder().decode(User.self, from: data)
}
func fetchUser(ctx context.Context, client *http.Client, id int) (User, error) {
req, err := http.NewRequestWithContext(
ctx,
http.MethodGet,
fmt.Sprintf("https://api.example.com/users/%d", id),
nil,
)
if err != nil {
return User{}, err
}
resp, err := client.Do(req)
if err != nil {
return User{}, err
}
defer resp.Body.Close()
var u User
if err := json.NewDecoder(resp.Body).Decode(&u); err != nil {
return User{}, err
}
return u, nil
}
This isn't to pick on Go or say Swift is a better language in practice — and certainly not in the same domains — but I do wish there were a strongly typed, compiled language with the maturity/performance of e.g. Go/Rust and a syntax a bit closer to Swift (or at least closer to how Swift feels in simple demos, or the honeymoon phase)
by scottmf
12/30/2025 at 5:04:54 PM
As someone who has been coding production Swift since 1.0 the Go example is a lot more what Swift in practice will look like. I suppose there are advantages to being able to only show the important parts.The first line won't crash but in practice it is fairly rare where you'd implicitly unwrap something like that. URLs might be the only case where it is somewhat safe. But a more fair example would be something like
func fetchUser(id: Int) async throws -> User {
guard let url = URL(string: "https://api.example.com/users/\(id)") else {
throw MyError.invalidURL
}
// you'll pretty much never see data(url: ...) in real life
let request = URLRequest(url: url)
// configure request
let (data, response) = try await URLSession.shared.data(for: request)
guard let httpResponse = response as? HTTPURLResponse,
200..<300 ~= httpResponse.statusCode else {
throw MyError.invalidResponseCode
}
// possibly other things you'd want to check
return try JSONDecoder().decode(User.self, from: data)
}
by tarentel
12/30/2025 at 11:14:00 PM
Oh, don't get me started on handling the same type of exception differently depending on what call actually threw the exception. I find the happy path in Swift to be lovely, but as soon as exceptions have to be handled or there's some details that have to be gotten right in terms of order of execution, everything turns into a massive mess.Still better than the 3 lines of if err is not nil that go gets you to do though.
by eptcyka
12/30/2025 at 5:19:08 PM
I'm not familiar with Swift's libraries, but what's the point of making this two lines instead of one: let request = URLRequest(url: url)
let (data, response) = try await URLSession.shared.data(for: request)
// vs
let (data, response) = try await URLSession.shared.data(from: url)
by Jtsummers
12/30/2025 at 5:29:32 PM
The first one you can configure and it is the default way you'd see this done in real life. You can add headers, change the request type, etc. Likely, if you were making an actual app the request configuration would be much longer than 1 line I used. I was mostly trying to show that the Swift example was hiding a lot of things.The second one is for downloading directly from a URL and I've never seen it used outside of examples in blog posts on the internet.
by tarentel
12/30/2025 at 10:26:37 PM
Thanks. What could possibly cause an invalid URL in this example though?by scottmf
12/31/2025 at 10:16:33 AM
Nothing. You would use `!` to force unwrap in this case.I think the point of the comment was that in many cases, when constructing a url, you can't be sure that the input will result in a valid url (e.g. when receiving a string instead of an int), so you have to be more defensive and the required code is more verbose.
by fainpul
12/30/2025 at 11:12:17 PM
Not OP, There is none as far as I can tell but still force unwrapping that way is something people try to avoid in Swift and often times have the linter warn about. Reason being people will copy the pattern elsewhere and make the assumption something is safe, ultimately be wrong and crash your app. It is admittedly an opinionated choice though.by mrbombastic
12/31/2025 at 2:06:52 AM
there has been some talk ofmusing macros ro validate at runtime; personally i'd love it if that got in officially.by andrekandre
12/31/2025 at 2:27:19 AM
Anything taking arbitrary values or user input could cause an invalid URL, especially on earlier OS versions. Newer OS versions will use a newer URL standard which is more flexible. You could wrap your URL encoding logic into a throwing or non-throwing init as well, the example just used the simple version provided by Foundation.by jshier
12/30/2025 at 11:54:12 PM
In my experience, migrating to a new API endpoint while your stubborn users just refused to update your app for some reason.by lawgimenez
12/31/2025 at 3:10:11 AM
Yes swift-format will say "never force-unwrap" because it is a potential crash.by willtemperley
12/31/2025 at 9:29:23 AM
No it will not.by saagarjha
12/31/2025 at 10:24:40 AM
Are you sure about that?let x: Int? = 0
let y: Int = x!
git ls-files -z -- '*.swift' | xargs -0 swift format lint --parallel
error: [NeverForceUnwrap] do not force unwrap 'x'
by willtemperley
12/31/2025 at 10:39:23 AM
You’ve turned that on; it’s off by default for good reasons: https://github.com/swiftlang/swift-format/blob/02c5a88a32719...by saagarjha
12/31/2025 at 10:50:55 AM
That's the standard for swiftlang CI which is what I use.by willtemperley
12/31/2025 at 2:52:20 PM
I don’t think it is?by saagarjha
12/30/2025 at 3:16:20 PM
Or this. func fetchUser(id int) (user User, err error) {
resp, err := http.Get(fmt.Sprintf("https://api.example.com/users/%d", id))
if err != nil {
return user, err
}
defer resp.Body.Close()
return user, json.NewDecoder(resp.Body).Decode(&user)
}by tidwall
12/30/2025 at 3:26:11 PM
I'm conflicted about the implicit named returns using this pattern in go. It's definitely tidier but I feel like the control flow is harder to follow: "I never defined `user` how can I return it?".Also those variables are returned even if you don't explicitly return them, which feels a little unintuitive.
by jtbaker
12/30/2025 at 4:03:59 PM
I haven't written any Go in many years (way before generics), but I'm shocked that something so implicit and magical is now valid Go syntax.I didn't look up this syntax or its rules, so I'm just reading the code totally naively. Am I to understand that the `user` variable in the final return statement is not really being treated as a value, but as a reference? Because the second part of the return (json.NewDecoder(resp.Body).Decode(&user)) sure looks like it's going to change the value of `user`. My brain wants to think it's "too late" to set `user` to anything by then, because the value was already read out (because I'm assuming the tuple is being constructed by evaluating its arguments left-to-right, like I thought Go's spec enforced for function arg evaluation). I would think that the returned value would be: `(nil, return-value-of-Decode-call)`.
I'm obviously wrong, of course, but whereas I always found Go code to at least be fairly simple--albeit tedious--to read, I find this to be very unintuitive and fairly "magical" for Go's typical design sensibilities.
No real point, here. Just felt so surprised that I couldn't resist saying so...
by ragnese
12/31/2025 at 9:46:45 AM
> I would think that the returned value would be: `(nil, return-value-of-Decode-call)`.`user` is typed as a struct, so it's always going to be a struct in the output, it can't be nil (it would have to be `*User`). And Decoder.Decode mutates the parameter in place. Named return values essentially create locals for you. And since the function does not use naked returns, it's essentially saving space (and adding some documentation in some cases though here the value is nil) for this:
func fetchUser(id int) (User, error) {
var user User
var err Error
resp, err := http.Get(fmt.Sprintf("https://api.example.com/users/%d", id))
if err != nil {
return user, err
}
defer resp.Body.Close()
return user, json.NewDecoder(resp.Body).Decode(&user)
}
However Go's named return values are definitely weird and spooky:
func foo() (i int) {
defer func() {
i = 2
}()
return 1
}
by masklinn
12/30/2025 at 5:26:33 PM
yeah, not really an expert but my understanding is that naming the return struct automatically allocates the object and places it into the scope.I think that for the user example it works because the NewDecoder is operating on the same memory allocation in the struct.
I like the idea of having named returns, since it's common to return many items as a tuple in go functions, and think it's clearer to have those named than leaving it to the user, especially if it's returning many of the same primitive type like ints/floats:
``` type IItem interface { Inventory(id int) (price float64, quantity int, err error) } ```
compared to
``` type IItem interface { Inventory(id int) (float64, int, error) } ```
but feel like the memory allocation and control flow implications make it hard to reason about at a glance for non-trivial functions.
by jtbaker
12/30/2025 at 6:09:41 PM
> My brain wants to think it's "too late" to set `user` to anything by then, because the value was already read outIt doesn’t set `user`, it returns the User passed to the function.
Computing the second return value modifies that value.
Looks weird indeed, but conceptually, both values get computed before they are returned.
by Someone
12/31/2025 at 8:07:24 AM
> I feel like the control flow is harder to follow: "I never defined `user` how can I return it?You defined user in the function signature. Once you know you can do that, there is nothing magic about it, and it makes it more explicit what the function will return.
by brabel
12/30/2025 at 3:58:39 PM
C# :) async Task<User> FetchUser(int id, HttpClient http, CancellationToken token)
{
var addr = $"https://api.example.com/users/{id}";
var user = await http.GetFromJsonAsync<User>(addr, token);
return user ?? throw new Exception("User not found");
}by neonsunset
12/30/2025 at 3:34:39 PM
Not defending Go's braindead error handling, but you'll note that Swift is doubly coloring the function here (async throws).by hocuspocus
12/30/2025 at 4:37:41 PM
What is the problem with that though? I honestly wish they moved the async key word to the front `async func ...` but given the relative newness of all of this I've yet to see anyone get confused by this. The compiler also ensures everything is used correctly anyway.by tarentel
12/30/2025 at 5:02:14 PM
The problem is that that the Swift function signature is telling you that someone else needs dealing with async suspension and exception handling, clearly not the same semantics.by hocuspocus
12/30/2025 at 5:15:33 PM
In a sense it is telling someone else that yes, but more importantly, it is telling the compiler. I am not sure what the alternative is here, is this not common in other languages? I know Java does this at least. In Python it is hidden and you have to know to catch the exception. I'm not sure how that is better as it can be easily forgotten or ignored. There may be another alternative I'm not aware of?by tarentel
12/30/2025 at 11:40:33 PM
Isn’t the Go version also forcing the callers to deal with the errors by returning them? The swift version just lets the compiler do it rather than manually returning them.by vips7L
12/30/2025 at 10:09:00 PM
And sometimes you even have to use the return value the way the function annoates as well instead of just pretending it's a string or whatever when it's not! Having the language tell me how to use things is so frustrating.by saghm