this post was submitted on 15 Nov 2023

24 points (87.5% liked)

Python

6422 readers

13 users here now

Welcome to the Python community on the programming.dev Lemmy instance!

📅 Events

Past

November 2023

PyCon Ireland 2023, 11-12th
PyData Tel Aviv 2023 14th

October 2023

PyConES Canarias 2023, 6-8th
DjangoCon US 2023, 16-20th (!django 💬)

July 2023

PyDelhi Meetup, 2nd
PyCon Israel, 4-5th
DFW Pythoneers, 6th
Django Girls Abraka, 6-7th
SciPy 2023 10-16th, Austin
IndyPy, 11th
Leipzig Python User Group, 11th
Austin Python, 12th
EuroPython 2023, 17-23rd
Austin Python: Evening of Coding, 18th
PyHEP.dev 2023 - "Python in HEP" Developer's Workshop, 25th

August 2023

PyLadies Dublin, 15th
EuroSciPy 2023, 14-18th

September 2023

PyData Amsterdam, 14-16th
PyCon UK, 22nd - 25th

🐍 Python project:

💓 Python Community:

#python IRC for general questions
#python-dev IRC for CPython developers
PySlackers Slack channel
Python Discord server
Python Weekly newsletters
Mailing lists
Forum

✨ Python Ecosystem:

🌌 Fediverse

Communities

#python on Mastodon
c/django on programming.dev
c/pythorhead on lemmy.dbzer0.com

Projects

Pythörhead: a Python library for interacting with Lemmy
Plemmy: a Python package for accessing the Lemmy API
pylemmy pylemmy enables simple access to Lemmy's API with Python
mastodon.py, a Python wrapper for the Mastodon API

Feeds

founded 1 year ago

MODERATORS

[email protected]

A proposal for java's "throws" in python: Extend type hints to cover exceptions (discuss.python.org)

submitted 1 year ago by [email protected] to c/[email protected]

22 comments fedilink hide all child comments

This is a discussion on Python's forums about adding something akin to a throws keyword in python.

all 30 comments

sorted by: hot top controversial new old

[–] [email protected] 11 points 1 year ago (2 children)

Aren't checked exceptions in Java generally regarded as a bad mistake?

[–] [email protected] 9 points 1 year ago

Yes, but not because the goal of having exceptions in types is bad, rather Java's type system isn't advanced enough to support the ideal solution here.

Scala 3 is working on experimental capture checking capabilities, which allows functions to express certain capabilities (file access, networking, db, etc.), and CanThrow capabilities (e.g exceptions at the type level) are one reification of this.

The CanThrow docs I linked have a good introduction into why Java checked exceptions are bad, and how Scala's alternative is far better. Essentially it comes down to a lack of polymorphism in checked exceptions. In practice this means they're incredibly verbose outside of simple usecases, and with a very easy escape hatch (RuntimeException), you don't even get the guarantee of knowing a function without checked exceptions doesn't throw.

Python will also have this latter issue. Python's "typing" in general has this issue actually. Types aren't validated unless you use an external tool, and even then Any is a leaky abstraction that can hide any level of typing errors, unlike in properly typed languages where it's not leaky. You need it to be leaky in gradually typed environments, or you wouldn't be able to use a ton of the Python ecosystem, but this vastly reduces the effectiveness of the typing solution.

I don't know if Python's solution here will address the lack of polymorphism that Java's solution has, I'll have to look into it more.

[–] [email protected] 3 points 1 year ago (1 children)

I heard the same, but not sure why. Do you have a link?

[–] getseclectic 1 points 1 year ago

This post covers it pretty well https://phauer.com/2015/checked-exceptions-are-evil/

[–] [email protected] 6 points 1 year ago (2 children)

When I used to write Java and switched to Python, this was one of the things I missed. It was always quite clear which exceptions I had to catch (or not). Just today, I ran into the issue of trying to cover the exceptions a library could throw without using except: or except Exception as e, but finally gave up and gave in to it. The linter wasn't happy, but fuck it.

[–] [email protected] 9 points 1 year ago

@onlinepersona You just need pip install fuckit

https://pypi.org/project/fuckit/

[+] [email protected] -8 points 1 year ago (2 children)

It was always quite clear which exceptions I had to catch (or not)

Lol. You're literally the only one that likes checked exceptions. And, it seems you think that it actually gives you information about what exceptions to catch. It does not. Most things just catch and rethrow as a RuntimException

[–] [email protected] 8 points 1 year ago

Hey, I like checked exceptions too! I honestly think it's one of Javas's best features but it's hindered by the fact that try-catch is so verbose, libraries aren't always sensible about what exceptions they throw, and methods aren't exception-polymorphic for stuff like the Stream API. Which is to say, checked exceptions are a pain but that's the fault of the rest of the language around them and not the checked exceptions per se.

[–] [email protected] 7 points 1 year ago

I also like checked exceptions. I like having a compile time check that I thought through error scenarios.

Is it perfect? No, but it should be iterated upon, not discarded.

FYI, catching and rethrowing as an unchecked exception is a pretty bad anti-patern (and a foul code smell).

[–] sugar_in_your_tea 3 points 1 year ago* (last edited 1 year ago) (2 children)

I disagree, I'd instead like to move toward handling errors as logic, and keeping exceptions for actually exceptional cases. If you're expecting an exception, that's data.

So here's my proposal:

introduce monads like Maybe/Result that forces the dev to handle expected errors in logic
make an easy way to return errors early without interrupting logic flow
simplify checking for None values in chaining

For the first (not exactly a monad, may need a new type to wrap things):

def maybe_err(val: int) -> Result[int, ValueError]:
    if val &lt; 0:
        return ValueError("cannot be negative")
    return val

match (val := maybe_err(-1)):
    case int():
    case ValueError():

For the second:

val = maybe_error(-1)?  # special handling to return instances of Error early

And the third:

val = x?.y?.z ?? DEFAULT

I like this much better than having try/except blocks throughout the code, and reserve those only for logging and whatnot at the top level. If you document exceptions, people will use them even more as data instead of exceptions.

So only raise if you want it to bubble all the way up, return errors if it's just data for the caller. Libraries should almost never raise.

[+] [email protected] 2 points 1 year ago (1 children)

[deleted]

[–] sugar_in_your_tea 3 points 1 year ago (1 children)

My point is that I don't like using exceptions for communicating regular errors, only unrecoverable faults. So adding features to document exceptions better just doesn't feel like the right direction.

Maybe that's un-Pythonic of me, idk. From the zen of Python:

Errors should never pass silently.
Unless explicitly silenced.

Using monads could let programmers silently pass errors.

I just really don't like the exception model after years of using other languages (mostly Rust and Go), I much prefer to be forced to contend with errors as they happen instead of just bubbling them up by default.

[+] [email protected] 1 points 1 year ago (1 children)

[deleted]

[–] sugar_in_your_tea 1 points 1 year ago* (last edited 1 year ago) (1 children)

Handling can mean a lot of things. You can use a sigil to quickly return early from the function without cluttering up your code. For example, in Rust (code somewhat invalid because I couldn't post the generic arg to Result because lemmy formatting rules):

fn my_func() -> Result {
    let val = some_func_that_can_error()?;
    return Some(val.operation_that_can_error());
}

let val = match my_func() {
    Err(err) => {
        println!("Your error: {err}");
        return;
    }
    Some(val) => val,
};
// use val here

That question mark inside my_func shows the programmer that there's a potential error, but that the caller will handle it.

I'm suggesting something similar for Python, where you can easily show that there's a potential error in the code, without having to do much to deal with it when it happens if the only thing you want to do is bubble it up.

If we use exceptions, it isn't obvious where the errors could occur, and it's easy to defer handling it much too late unless you want to clutter your code.

[+] [email protected] 1 points 1 year ago (1 children)

[deleted]

[–] sugar_in_your_tea 1 points 1 year ago (1 children)

That's where the difference between exceptional cases comes in. Rust and Go both have the concept of a panic, which is an error that can only be caught with a special mechanism (not a try/except).

So that'll cover unexpected errors like divide by zero, out of memory, etc, and you'd handle other errors as data (e.g. record not found, validation error, etc).

I don't think Python should necessarily go as far as Go or Rust, just that handling errors like data should be an option instead of being forced to use try/except, which I find to be gross. In general, I want to use try/except if I want a stack trace, and error values when I don't.

[+] [email protected] 1 points 1 year ago* (last edited 1 year ago) (1 children)

[deleted]

[–] sugar_in_your_tea 1 points 1 year ago (1 children)

divide by zero should be data as well

I disagree. You should be checking your input data so the divide by zero is impossible. An invalid input error is data and it can probably be recovered from, whereas a divide by zero is something your program should never do.

If having the error is expected behavior (e.g. records/files can not exist, user data can be invalid, external service is down, etc), it's data. If it's a surprise, it's an exception and should crash.

doesn't seem to improve usability

I'm proposing that the programmer chooses. The whole design ethos around Python is that it should look like pseudocode. Pseudocode generally ignores errors, but if it doesn't, it's reasonable to express it as either an exception or data.

Documenting functions with "throws" isn't something I'd do in pseudocode because enumerating the ways something can fail generally isn't interesting. However, knowing that a function call can fail is interesting, so I think error passing in the Rust way is an interesting, subtle way of doing that.

I'm not saying we should absolutely go with monadic error returns, I'm saying that if we change error handling, I'd prefer to go that route than Java's throws, because I think documenting exceptions encourages bad use of exceptions. The code I work on already has way too many try/except blocks, I'm concerned this would cement that practice.

[+] [email protected] 1 points 1 year ago (2 children)

[deleted]

[–] sugar_in_your_tea 1 points 1 year ago (1 children)

It's not an explicit design goal, but it explains a lot of the Zen of Python and other pushback on PIPs, so to me it's always been an unwritten design goal (be as close to pseudocode as practical, but no closer). It's also how I generally write code (start with Python "pseudocode," then decide what to use in production).

For example, from the Zen of Python:

There should be one-- and preferably only one --obvious way to do it.

Being clever in Python is a bad thing, just as it is in pseudocode. Python will never win awards for performance, so if you need that, you drop in something non-Python to do the expensive operations to keep the rest of the code clean and obvious.

If you think of Python as pseudocode, everything else makes a ton more sense.

You can test for values being 0 before dividing, or catching an exception when it is.

Ideally, you just test for input variables outside of the function and do neither. Something like:

def calc(x, y):
    assert x > 0
    assert y != 0
    ...

This throw exceptions if the preconditions fail, but those can (and should) be removed for production since their primary purpose is to inform the developer of the preconditions and catch mistakes in development. In production, you'd rely on some kind of schema validation to ensure the asserts never trigger (I'm partial to Pydantic).

So ideally you'd never expect a divide by zero or clutter your code with zero checks outside of those asserts (which shouldn't be relied on) because you've already prevented those cases from happening.

[+] [email protected] 1 points 1 year ago (1 children)

[deleted]

[–] sugar_in_your_tea 1 points 1 year ago

Assertion errors should never fire, they're merely there for documentation and catching mistakes in development. Any assertion is merely a sanity check (the value should've been checked before calling the function), which is why they're disabled in production.

In fact, I conceptually like the way D makes checking preconditions and postconditions explicit. However, it's clunky in practice imo, so asserts are usually elegant enough. I honestly only use asserts when it's the clearest way to document the usage constraints.

you're seriously underusing the power of exceptions

No, I use them for communicating data errors and whatnot and have a bunch of custom exceptions in my code. It's the current Pythonic way, so that's what I do.

However, I don't like that pattern and find it to either hide errors or clutter my code. I much prefer the Rust style of error handling where errors are always acknowledged when they can happen, but usually handled at a higher level (like you'd do in Python, but with explicit syntax to acknowledge a call could error). I find this gives me, the programmer, a chance to consider the error case to correct logical mistakes before actually running any code, and it also improves code reviews because it's obvious to the reviewer that the code could error. I've had far too many bugs caused by not knowing or forgetting a call could raise an error.

you don't even want to use Python

When did I say that? I use it at my day job and actually argued against using Rust for our project because Python maps really well to our problem domain. Our project is hundreds of thousands of lines of Python across a dozen or more microservices, and it has served us well.

Criticizing a language doesn't necessarily mean I don't like it, it just means I think it could be better. Python is generally my first choice unless I know I need top performance and correctness out of the gate. For example, I'm writing a distributed lemmy competitor in Rust in my free time for various reasons (mostly I don't want to deal with Python installers, and there's no server component), and also building a game in Godot in GDScript (very similar to Python, even worse in perf). There are very few languages I actively dislike.

That said, in general, I prefer functional-style programming, and exceptions are one glaring wart that makes FP in Python feel bad. I want that to be better.

[–] Gallardo994 1 points 1 year ago (1 children)

Anything but over9000 variations of nullables like in C#

[–] sugar_in_your_tea 1 points 1 year ago* (last edited 1 year ago)

I'm not too familiar with C# (last used it like a decade ago), but I think the rules here would be pretty simple:

x? - if x is None or an Error, return from the function early, otherwise use the value and continue
x?.y - same as above, but with an attribute of x
x ?? y - instead of returning as in the first, use y as the default value

And maybe add an option to convert exceptions from a function to an Error value (maybe some_func?() to convert to error values? IDK, I haven't thought through that part as much).

Hopefully that's simple enough to be useful.

If I were proposing this, I'd limit it to optional chaining since that's far more annoying to me currently.

[–] [email protected] 0 points 1 year ago (1 children)

My counter: let's throw Java into a pit

[–] [email protected] 1 points 1 year ago

@Maoo @onlinepersona
That's unfair. Java did everyone a huge favour by giving a practical demonstration of why (mandatory) checked exceptions are awful.

[–] [email protected] -2 points 1 year ago

Yeah, let's not. This is not a good idea