New syntax suggestion: catch with type specs

[jar1]

@anon91151494

To say Julia shouldn’t support something that most other languages support because some Python programmers might bring their bad habits with them really doesn’t make a lot of sense imo.

I don’t think that’s my argument but I’m gonna take care of some other things and maybe if this proposal picks up steam I’ll think about it again at that time.

[stevengj]

@anon91151494

To say Julia shouldn’t support something that most other languages support

To be clear, Julia supports this just fine (via if statements in a catch block). It just doesn’t have a specialized syntax.

The question of whether specialized syntax is worth the cost (e.g. of complicating the language) depends on how widely it is used. Julia has been around for > 10 years — do we see a lot of real-world code that uses catch blocks with if statements to filter the exceptions, which could be simplified with specialized syntax? Should this pattern be used more frequently?

The fact that try–catch is not widely used for control flow in Julia (as opposed to e.g. Python), in part for performance reasons, is relevant here because it reduces the demand for a dedicated syntax.

[DNF]

@anon91151494

The claim here is that because some authors of Python code use of exceptions wherever possible (something which is already bad design practice) and because specifically in the case of Python there is no performance penalty for the use of exceptions, therefore Julia should not support them.

The claim is just that using exceptions for control flow is a bad idea, and that’s worth mentioning because people who come from Python may be used to that style.

It’s mentioned because it’s common in Python. The judgement that it’s a bad idea is independent of Python.

[Yuan-Ru-Lin]

I am dealing with the same situation and I found a mixture of @mkitti’s and @HanD’s approach clear and useful, that is, dispatching errors to functions whose bodies may span multiple lines.

try
catch e
    f(e::AssertionError) = println("AssertionError")
    f(e::InexactError) = println("InexactError")
    f(e::DomainError) = begin
        println("Slightly longer implementation here")
   end
   f(e::Exception) = rethrow(e) # rethrow any other kinds of exceptions
   f(e)
end

I would like to point out some advantages of the implementation.

1. The appearance of f’s doesn’t create cognitive dissonance but people will know they are methods to be dispatched to.
2. The functions remain local in the catch-block, but can be factored out and reused elsewhere anytime you find it appropriate; for example,

try
catch e
    f(e::AssertionError) = println("error")
    f(e)
end
# f(AssertionError())
# ERROR: UndefVarError: `f` not defined in `Main`

reusable_handle(e::AssertionError) = println("ready to be used in multiple places")
try
catch e
    reusable_handle(e)
end

3. No 3rd-party package needed.
4. No new syntax needed

---

EDIT: add handling of any other kinds of errors
EDIT2: fix typo