Discussion: add more idiomatic versions of catchJust and/or handleJust

newer
Proposal: Add Foldable helper to...

older
Proposal: add liftA4 and liftA5 to...

David Feuer

12 Jul 2016 12 Jul '16

12:23 a.m.

The catchJust and handleJust functions seem a bit weird and unidiomatic. catchJust :: Exception e => (e -> Maybe b) -- ^ Predicate to select exceptions -> IO a -- ^ Computation to run -> (b -> IO a) -- ^ Handler -> IO a catchJust p a handler = catch a handler' where handler' e = case p e of Nothing -> throwIO e Just b -> handler b This takes two functions and then puts them together. I would think the more natural API would be catchMaybe :: Exception e => IO a -> (e -> Maybe (IO a)) -> IO a catchMaybe m handler = catch m handler' where handler' e = fromMaybe (throwIO e) (handler e) This is exactly as powerful as catchJust: catchMaybe m handler = catchJust handler m id catchJust p m handler = catchMaybe m $ fmap handler . p But catchMaybe doesn't enforce the arbitrary separation between "selection" and "handling".

Attachments:

attachment.html (text/html — 1.3 KB)

Show replies by date

Andreas Abel

13 Jul 13 Jul

7:36 p.m.

I can only guess why catchJust was designed like it is. A type like b -> Maybe (IO a) is not as intuitive as the types e -> Maybe b -- ^ if you do not understand this, get back to Haskell school! b -> IO a -- ^ a continuation, we know this from >>= and friends A type like Maybe (IO a) is more unusual, requires more thinking. +-0. I have no opinion on what is better. On 12.07.2016 02:23, David Feuer wrote:

...

The catchJust and handleJust functions seem a bit weird and unidiomatic.

catchJust :: Exception e => (e -> Maybe b) -- ^ Predicate to select exceptions -> IO a -- ^ Computation to run -> (b -> IO a) -- ^ Handler -> IO a catchJust p a handler = catch a handler' where handler' e = case p e of Nothing -> throwIO e Just b -> handler b

This takes two functions and then puts them together. I would think the more natural API would be

catchMaybe :: Exception e => IO a -> (e -> Maybe (IO a)) -> IO a catchMaybe m handler = catch m handler' where handler' e = fromMaybe (throwIO e) (handler e)

This is exactly as powerful as catchJust:

catchMaybe m handler = catchJust handler m id catchJust p m handler = catchMaybe m $ fmap handler . p

But catchMaybe doesn't enforce the arbitrary separation between "selection" and "handling".

_______________________________________________ Libraries mailing list Libraries@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries

-- Andreas Abel <>< Du bist der geliebte Mensch. Department of Computer Science and Engineering Chalmers and Gothenburg University, Sweden andreas.abel@gu.se http://www2.tcs.ifi.lmu.de/~abel/

David Feuer

8:14 p.m.

I hate having to make arbitrary choices when writing code. With `catchJust`, I have to decide what to calculate in the selector and what to calculate in the handler. As far as I can tell, there's never any reason to leave any calculation for the handler. I don't think the `Maybe (IO a)` type is nearly as hard to think about as exceptions themselves are. The handler either provides a recovery action or it doesn't. The catchMaybe signature strikes me, personally, as easier to understand, because I don't need to use parametricity to string the pieces together. On Wed, Jul 13, 2016 at 3:36 PM, Andreas Abel wrote:

...

I can only guess why catchJust was designed like it is. A type like

b -> Maybe (IO a)

is not as intuitive as the types

e -> Maybe b -- ^ if you do not understand this, get back to Haskell school!

b -> IO a -- ^ a continuation, we know this from >>= and friends

A type like Maybe (IO a) is more unusual, requires more thinking.

+-0. I have no opinion on what is better.

On 12.07.2016 02:23, David Feuer wrote:

...
The catchJust and handleJust functions seem a bit weird and unidiomatic.

catchJust :: Exception e => (e -> Maybe b) -- ^ Predicate to select exceptions -> IO a -- ^ Computation to run -> (b -> IO a) -- ^ Handler -> IO a catchJust p a handler = catch a handler' where handler' e = case p e of Nothing -> throwIO e Just b -> handler b

This takes two functions and then puts them together. I would think the more natural API would be

catchMaybe :: Exception e => IO a -> (e -> Maybe (IO a)) -> IO a catchMaybe m handler = catch m handler' where handler' e = fromMaybe (throwIO e) (handler e)

This is exactly as powerful as catchJust:

catchMaybe m handler = catchJust handler m id catchJust p m handler = catchMaybe m $ fmap handler . p

But catchMaybe doesn't enforce the arbitrary separation between "selection" and "handling".

_______________________________________________ Libraries mailing list Libraries@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries

-- Andreas Abel <>< Du bist der geliebte Mensch.

Department of Computer Science and Engineering Chalmers and Gothenburg University, Sweden

andreas.abel@gu.se http://www2.tcs.ifi.lmu.de/~abel/

Theodore Lief Gannon

9:23 p.m.

+1 on catchMaybe from this corner of the peanut gallery, FWIW. It feels far more idiomatic, and provides the same power with fewer moving parts. On Jul 13, 2016 1:14 PM, "David Feuer" wrote:

...

I hate having to make arbitrary choices when writing code. With `catchJust`, I have to decide what to calculate in the selector and what to calculate in the handler. As far as I can tell, there's never any reason to leave any calculation for the handler.

I don't think the `Maybe (IO a)` type is nearly as hard to think about as exceptions themselves are. The handler either provides a recovery action or it doesn't. The catchMaybe signature strikes me, personally, as easier to understand, because I don't need to use parametricity to string the pieces together.

On Wed, Jul 13, 2016 at 3:36 PM, Andreas Abel wrote:

...
I can only guess why catchJust was designed like it is. A type like

b -> Maybe (IO a)

is not as intuitive as the types

e -> Maybe b -- ^ if you do not understand this, get back to Haskell school!

b -> IO a -- ^ a continuation, we know this from >>= and friends

A type like Maybe (IO a) is more unusual, requires more thinking.

+-0. I have no opinion on what is better.

On 12.07.2016 02:23, David Feuer wrote:

...
The catchJust and handleJust functions seem a bit weird and unidiomatic.

catchJust :: Exception e => (e -> Maybe b) -- ^ Predicate to select exceptions -> IO a -- ^ Computation to run -> (b -> IO a) -- ^ Handler -> IO a catchJust p a handler = catch a handler' where handler' e = case p e of Nothing -> throwIO e Just b -> handler b

This takes two functions and then puts them together. I would think the more natural API would be

catchMaybe :: Exception e => IO a -> (e -> Maybe (IO a)) -> IO a catchMaybe m handler = catch m handler' where handler' e = fromMaybe (throwIO e) (handler e)

This is exactly as powerful as catchJust:

catchMaybe m handler = catchJust handler m id catchJust p m handler = catchMaybe m $ fmap handler . p

But catchMaybe doesn't enforce the arbitrary separation between "selection" and "handling".

_______________________________________________ Libraries mailing list Libraries@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries

-- Andreas Abel <>< Du bist der geliebte Mensch.

Department of Computer Science and Engineering Chalmers and Gothenburg University, Sweden

andreas.abel@gu.se http://www2.tcs.ifi.lmu.de/~abel/

Libraries mailing list Libraries@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries

Ben Millwood

14 Jul 14 Jul

3:56 p.m.

Am I right in thinking that `catch` is equivalent to `catchJust fromException`? Perhaps the intention is that if you have an implementation of `fromException` but haven't defined an instance of `Exception` for whatever reason, you can use `catchJust` directly? Or if you have a slight variant of `fromException` that isn't quite worth its own typeclass instance? Analogously to `sortBy` vs. `sort`, for example. I have no particular vote on the proposal and do not intend the above as a defence of `catchJust`, just a possible perspective on it. On Wed, Jul 13, 2016 at 02:23:04PM -0700, Theodore Lief Gannon wrote:

...

+1 on catchMaybe from this corner of the peanut gallery, FWIW. It feels far more idiomatic, and provides the same power with fewer moving parts. On Jul 13, 2016 1:14 PM, "David Feuer" wrote:

...
I hate having to make arbitrary choices when writing code. With `catchJust`, I have to decide what to calculate in the selector and what to calculate in the handler. As far as I can tell, there's never any reason to leave any calculation for the handler.

I don't think the `Maybe (IO a)` type is nearly as hard to think about as exceptions themselves are. The handler either provides a recovery action or it doesn't. The catchMaybe signature strikes me, personally, as easier to understand, because I don't need to use parametricity to string the pieces together.

On Wed, Jul 13, 2016 at 3:36 PM, Andreas Abel wrote:

...
I can only guess why catchJust was designed like it is. A type like

b -> Maybe (IO a)

is not as intuitive as the types

e -> Maybe b -- ^ if you do not understand this, get back to Haskell school!

b -> IO a -- ^ a continuation, we know this from >>= and friends

A type like Maybe (IO a) is more unusual, requires more thinking.

+-0. I have no opinion on what is better.

On 12.07.2016 02:23, David Feuer wrote:

...
The catchJust and handleJust functions seem a bit weird and unidiomatic.

catchJust :: Exception e => (e -> Maybe b) -- ^ Predicate to select exceptions -> IO a -- ^ Computation to run -> (b -> IO a) -- ^ Handler -> IO a catchJust p a handler = catch a handler' where handler' e = case p e of Nothing -> throwIO e Just b -> handler b

This takes two functions and then puts them together. I would think the more natural API would be

catchMaybe :: Exception e => IO a -> (e -> Maybe (IO a)) -> IO a catchMaybe m handler = catch m handler' where handler' e = fromMaybe (throwIO e) (handler e)

This is exactly as powerful as catchJust:

catchMaybe m handler = catchJust handler m id catchJust p m handler = catchMaybe m $ fmap handler . p

But catchMaybe doesn't enforce the arbitrary separation between "selection" and "handling".

_______________________________________________ Libraries mailing list Libraries@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries

-- Andreas Abel <>< Du bist der geliebte Mensch.

Department of Computer Science and Engineering Chalmers and Gothenburg University, Sweden

andreas.abel@gu.se http://www2.tcs.ifi.lmu.de/~abel/

Libraries mailing list Libraries@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries

...

_______________________________________________ Libraries mailing list Libraries@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries

David Menendez

4:11 p.m.

On Mon, Jul 11, 2016 at 8:23 PM, David Feuer wrote:

...

The catchJust and handleJust functions seem a bit weird and unidiomatic.

catchJust :: Exception e => (e -> Maybe b) -- ^ Predicate to select exceptions -> IO a -- ^ Computation to run -> (b -> IO a) -- ^ Handler -> IO a catchJust p a handler = catch a handler' where handler' e = case p e of Nothing -> throwIO e Just b -> handler b

This takes two functions and then puts them together. I would think the more natural API would be

catchMaybe :: Exception e => IO a -> (e -> Maybe (IO a)) -> IO a catchMaybe m handler = catch m handler' where handler' e = fromMaybe (throwIO e) (handler e)

This is exactly as powerful as catchJust:

catchMaybe m handler = catchJust handler m id catchJust p m handler = catchMaybe m $ fmap handler . p

But catchMaybe doesn't enforce the arbitrary separation between "selection" and "handling”.

I wouldn’t call it an arbitrary separation. I imagine that the separation is deliberate, because you will frequently want to catch the same set of exceptions, but want to do different things in different contexts. With the current API, you can write a selector like “fileNotFound” and re-use it with multiple handlers. In constrast, with a unified seletor/handler you have to write the same code to filter the exceptions you want with every handler which deals with them. You might as well just use catch. -- Dave Menendez http://www.eyrie.org/~zednenem/

David Feuer

5:10 p.m.

I expect it'd be more common to use something like catchMaybe m $ \e -> guard (isEOFException e) >> return "" catchJust only makes sense if you not only need the same set of exceptions, but also the same non-trivial calculation based on the exception, for multiple handlers. A hypothetical catchOnly taking a Boolean predicate would make more sense for the case you describe. On Jul 14, 2016 12:11 PM, "David Menendez" wrote:

...

On Mon, Jul 11, 2016 at 8:23 PM, David Feuer wrote:

...
The catchJust and handleJust functions seem a bit weird and unidiomatic.

catchJust :: Exception e => (e -> Maybe b) -- ^ Predicate to select exceptions -> IO a -- ^ Computation to run -> (b -> IO a) -- ^ Handler -> IO a catchJust p a handler = catch a handler' where handler' e = case p e of Nothing -> throwIO e Just b -> handler b

This takes two functions and then puts them together. I would think the more natural API would be

catchMaybe :: Exception e => IO a -> (e -> Maybe (IO a)) -> IO a catchMaybe m handler = catch m handler' where handler' e = fromMaybe (throwIO e) (handler e)

This is exactly as powerful as catchJust:

catchMaybe m handler = catchJust handler m id catchJust p m handler = catchMaybe m $ fmap handler . p

But catchMaybe doesn't enforce the arbitrary separation between "selection" and "handling”.

I wouldn’t call it an arbitrary separation. I imagine that the separation is deliberate, because you will frequently want to catch the same set of exceptions, but want to do different things in different contexts. With the current API, you can write a selector like “fileNotFound” and re-use it with multiple handlers.

In constrast, with a unified seletor/handler you have to write the same code to filter the exceptions you want with every handler which deals with them. You might as well just use catch.

-- Dave Menendez http://www.eyrie.org/~zednenem/

Oliver Charles

4:56 p.m.

On Tue, 12 Jul 2016, 1:23 a.m. David Feuer, wrote:

...

The catchJust and handleJust functions seem a bit weird and unidiomatic.

catchJust :: Exception e => (e -> Maybe b) -- ^ Predicate to select exceptions -> IO a -- ^ Computation to run -> (b -> IO a) -- ^ Handler -> IO a catchJust p a handler = catch a handler' where handler' e = case p e of Nothing -> throwIO e Just b -> handler b

This takes two functions and then puts them together. I would think the more natural API would be

catchMaybe :: Exception e => IO a -> (e -> Maybe (IO a)) -> IO a catchMaybe m handler = catch m handler' where handler' e = fromMaybe (throwIO e) (handler e)

A point don't feel super strongly about, but feel I should raise, is that Nothing seems to be somewhat confusing. catchJust (\FileNotFound -> Nothing) seems to suggest that if FileNotFound occurs then nothing will happen, that is - the exception is ignored. However, that is not the case, rather than Nothing happening something certainly happens - an exception is (re)thrown! Whether or not this confusion is likely to happen in practice I don't know, but it suggests a type isomorphic to Maybe is a better fit. Ollie

David Feuer

5:12 p.m.

That makes sense, I guess. Something like data Handle a = Rethrow | Catch (IO a) I suppose? My names are awful though. On Jul 14, 2016 12:56 PM, "Oliver Charles" wrote:

...

On Tue, 12 Jul 2016, 1:23 a.m. David Feuer, wrote:

...
The catchJust and handleJust functions seem a bit weird and unidiomatic.

catchJust :: Exception e => (e -> Maybe b) -- ^ Predicate to select exceptions -> IO a -- ^ Computation to run -> (b -> IO a) -- ^ Handler -> IO a catchJust p a handler = catch a handler' where handler' e = case p e of Nothing -> throwIO e Just b -> handler b

This takes two functions and then puts them together. I would think the more natural API would be

catchMaybe :: Exception e => IO a -> (e -> Maybe (IO a)) -> IO a catchMaybe m handler = catch m handler' where handler' e = fromMaybe (throwIO e) (handler e)

A point don't feel super strongly about, but feel I should raise, is that Nothing seems to be somewhat confusing. catchJust (\FileNotFound -> Nothing) seems to suggest that if FileNotFound occurs then nothing will happen, that is - the exception is ignored. However, that is not the case, rather than Nothing happening something certainly happens - an exception is (re)thrown!

Whether or not this confusion is likely to happen in practice I don't know, but it suggests a type isomorphic to Maybe is a better fit.

Ollie

Andreas Abel

5:53 p.m.

Maybe rather data Handle a = Rethrow | Handle (IO a) !? On 14.07.2016 19:12, David Feuer wrote:

...

That makes sense, I guess. Something like

data Handle a = Rethrow | Catch (IO a)

I suppose? My names are awful though.

On Jul 14, 2016 12:56 PM, "Oliver Charles" mailto:ollie@ocharles.org.uk> wrote:

On Tue, 12 Jul 2016, 1:23 a.m. David Feuer, mailto:david.feuer@gmail.com> wrote:

The catchJust and handleJust functions seem a bit weird and unidiomatic.

catchJust :: Exception e => (e -> Maybe b) -- ^ Predicate to select exceptions -> IO a -- ^ Computation to run -> (b -> IO a) -- ^ Handler -> IO a catchJust p a handler = catch a handler' where handler' e = case p e of Nothing -> throwIO e Just b -> handler b

This takes two functions and then puts them together. I would think the more natural API would be

catchMaybe :: Exception e => IO a -> (e -> Maybe (IO a)) -> IO a catchMaybe m handler = catch m handler' where handler' e = fromMaybe (throwIO e) (handler e)

A point don't feel super strongly about, but feel I should raise, is that Nothing seems to be somewhat confusing. catchJust (\FileNotFound -> Nothing) seems to suggest that if FileNotFound occurs then nothing will happen, that is - the exception is ignored. However, that is not the case, rather than Nothing happening something certainly happens - an exception is (re)thrown!

Whether or not this confusion is likely to happen in practice I don't know, but it suggests a type isomorphic to Maybe is a better fit.

Ollie

_______________________________________________ Libraries mailing list Libraries@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries

-- Andreas Abel <>< Du bist der geliebte Mensch. Department of Computer Science and Engineering Chalmers and Gothenburg University, Sweden andreas.abel@gu.se http://www2.tcs.ifi.lmu.de/~abel/

Bardur Arantsson

6 p.m.

On 07/14/2016 07:53 PM, Andreas Abel wrote:

...

Maybe rather

data Handle a = Rethrow | Handle (IO a)

David Feuer

8:52 p.m.

Handle is no good because it clashes with file handles. How about Reaction? On Jul 14, 2016 1:53 PM, "Andreas Abel" wrote:

...

Maybe rather

data Handle a = Rethrow | Handle (IO a)

!? On 14.07.2016 19:12, David Feuer wrote:

...
That makes sense, I guess. Something like

data Handle a = Rethrow | Catch (IO a)

I suppose? My names are awful though.

On Jul 14, 2016 12:56 PM, "Oliver Charles" mailto:ollie@ocharles.org.uk> wrote:

On Tue, 12 Jul 2016, 1:23 a.m. David Feuer, mailto:david.feuer@gmail.com> wrote:

The catchJust and handleJust functions seem a bit weird and unidiomatic.

catchJust :: Exception e => (e -> Maybe b) -- ^ Predicate to select exceptions -> IO a -- ^ Computation to run -> (b -> IO a) -- ^ Handler -> IO a catchJust p a handler = catch a handler' where handler' e = case p e of Nothing -> throwIO e Just b -> handler b

This takes two functions and then puts them together. I would think the more natural API would be

catchMaybe :: Exception e => IO a -> (e -> Maybe (IO a)) -> IO a catchMaybe m handler = catch m handler' where handler' e = fromMaybe (throwIO e) (handler e)

A point don't feel super strongly about, but feel I should raise, is that Nothing seems to be somewhat confusing. catchJust (\FileNotFound -> Nothing) seems to suggest that if FileNotFound occurs then nothing will happen, that is - the exception is ignored. However, that is not the case, rather than Nothing happening something certainly happens - an exception is (re)thrown!

Whether or not this confusion is likely to happen in practice I don't know, but it suggests a type isomorphic to Maybe is a better fit.

Ollie

_______________________________________________ Libraries mailing list Libraries@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries

-- Andreas Abel <>< Du bist der geliebte Mensch.

Department of Computer Science and Engineering Chalmers and Gothenburg University, Sweden

andreas.abel@gu.se http://www2.tcs.ifi.lmu.de/~abel/

Oliver Charles

9:42 p.m.

data ExceptionHandler a = Rethrow | HandleException (IO a) would be my offering of paint. On Thu, Jul 14, 2016 at 9:52 PM David Feuer wrote:

...

Handle is no good because it clashes with file handles. How about Reaction?

On Jul 14, 2016 1:53 PM, "Andreas Abel" wrote:

...
Maybe rather

data Handle a = Rethrow | Handle (IO a)

!? On 14.07.2016 19:12, David Feuer wrote:

...
That makes sense, I guess. Something like

data Handle a = Rethrow | Catch (IO a)

I suppose? My names are awful though.

On Jul 14, 2016 12:56 PM, "Oliver Charles" mailto:ollie@ocharles.org.uk> wrote:

On Tue, 12 Jul 2016, 1:23 a.m. David Feuer, mailto:david.feuer@gmail.com> wrote:

The catchJust and handleJust functions seem a bit weird and unidiomatic.

catchJust :: Exception e => (e -> Maybe b) -- ^ Predicate to select exceptions -> IO a -- ^ Computation to run -> (b -> IO a) -- ^ Handler -> IO a catchJust p a handler = catch a handler' where handler' e = case p e of Nothing -> throwIO e Just b -> handler b

This takes two functions and then puts them together. I would think the more natural API would be

catchMaybe :: Exception e => IO a -> (e -> Maybe (IO a)) -> IO a catchMaybe m handler = catch m handler' where handler' e = fromMaybe (throwIO e) (handler e)

A point don't feel super strongly about, but feel I should raise, is that Nothing seems to be somewhat confusing. catchJust (\FileNotFound -> Nothing) seems to suggest that if FileNotFound occurs then nothing will happen, that is - the exception is ignored. However, that is not the case, rather than Nothing happening something certainly happens - an exception is (re)thrown!

Whether or not this confusion is likely to happen in practice I don't know, but it suggests a type isomorphic to Maybe is a better fit.

Ollie

_______________________________________________ Libraries mailing list Libraries@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries

-- Andreas Abel <>< Du bist der geliebte Mensch.

Department of Computer Science and Engineering Chalmers and Gothenburg University, Sweden

andreas.abel@gu.se http://www2.tcs.ifi.lmu.de/~abel/

Carter Schonwald

10:20 p.m.

At this point maybe it'd be better to write out these ideas as a library and implement a bunch of example codes for different approaches. Changing the interfaces for exception handling code is subtle stuff! On Jul 14, 2016 5:42 PM, "Oliver Charles" wrote:

...

data ExceptionHandler a = Rethrow | HandleException (IO a)

would be my offering of paint.

On Thu, Jul 14, 2016 at 9:52 PM David Feuer wrote:

...
Handle is no good because it clashes with file handles. How about Reaction?

On Jul 14, 2016 1:53 PM, "Andreas Abel" wrote:

...
Maybe rather

data Handle a = Rethrow | Handle (IO a)

!? On 14.07.2016 19:12, David Feuer wrote:

...
That makes sense, I guess. Something like

data Handle a = Rethrow | Catch (IO a)

I suppose? My names are awful though.

On Jul 14, 2016 12:56 PM, "Oliver Charles" mailto:ollie@ocharles.org.uk> wrote:

On Tue, 12 Jul 2016, 1:23 a.m. David Feuer, mailto:david.feuer@gmail.com> wrote:

The catchJust and handleJust functions seem a bit weird and unidiomatic.

catchJust :: Exception e => (e -> Maybe b) -- ^ Predicate to select exceptions -> IO a -- ^ Computation to run -> (b -> IO a) -- ^ Handler -> IO a catchJust p a handler = catch a handler' where handler' e = case p e of Nothing -> throwIO e Just b -> handler b

This takes two functions and then puts them together. I would think the more natural API would be

catchMaybe :: Exception e => IO a -> (e -> Maybe (IO a)) -> IO a catchMaybe m handler = catch m handler' where handler' e = fromMaybe (throwIO e) (handler e)

A point don't feel super strongly about, but feel I should raise, is that Nothing seems to be somewhat confusing. catchJust (\FileNotFound -> Nothing) seems to suggest that if FileNotFound occurs then nothing will happen, that is - the exception is ignored. However, that is not the case, rather than Nothing happening something certainly happens - an exception is (re)thrown!

Whether or not this confusion is likely to happen in practice I don't know, but it suggests a type isomorphic to Maybe is a better fit.

Ollie

_______________________________________________ Libraries mailing list Libraries@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries

-- Andreas Abel <>< Du bist der geliebte Mensch.

Department of Computer Science and Engineering Chalmers and Gothenburg University, Sweden

andreas.abel@gu.se http://www2.tcs.ifi.lmu.de/~abel/

_______________________________________________ Libraries mailing list Libraries@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries

David Thomas

15 Jul 15 Jul

4:55 a.m.

I kinda like "ExceptionDisposition" for the type, no particular ideas on the constructors. Offered only in the spirit of tossing out ideas - feel free to ignore me if it's not helpful :) On Thu, Jul 14, 2016 at 3:20 PM, Carter Schonwald wrote:

...

At this point maybe it'd be better to write out these ideas as a library and implement a bunch of example codes for different approaches. Changing the interfaces for exception handling code is subtle stuff!

On Jul 14, 2016 5:42 PM, "Oliver Charles" wrote:

...
data ExceptionHandler a = Rethrow | HandleException (IO a)

would be my offering of paint.

On Thu, Jul 14, 2016 at 9:52 PM David Feuer wrote:

...
Handle is no good because it clashes with file handles. How about Reaction?

On Jul 14, 2016 1:53 PM, "Andreas Abel" wrote:

...
Maybe rather

data Handle a = Rethrow | Handle (IO a)

!? On 14.07.2016 19:12, David Feuer wrote:

...
That makes sense, I guess. Something like

data Handle a = Rethrow | Catch (IO a)

I suppose? My names are awful though.

On Jul 14, 2016 12:56 PM, "Oliver Charles" mailto:ollie@ocharles.org.uk> wrote:

On Tue, 12 Jul 2016, 1:23 a.m. David Feuer, mailto:david.feuer@gmail.com> wrote:

The catchJust and handleJust functions seem a bit weird and unidiomatic.

catchJust :: Exception e => (e -> Maybe b) -- ^ Predicate to select exceptions -> IO a -- ^ Computation to run -> (b -> IO a) -- ^ Handler -> IO a catchJust p a handler = catch a handler' where handler' e = case p e of Nothing -> throwIO e Just b -> handler b

This takes two functions and then puts them together. I would think the more natural API would be

catchMaybe :: Exception e => IO a -> (e -> Maybe (IO a)) -> IO a catchMaybe m handler = catch m handler' where handler' e = fromMaybe (throwIO e) (handler e)

A point don't feel super strongly about, but feel I should raise, is that Nothing seems to be somewhat confusing. catchJust (\FileNotFound -> Nothing) seems to suggest that if FileNotFound occurs then nothing will happen, that is - the exception is ignored. However, that is not the case, rather than Nothing happening something certainly happens - an exception is (re)thrown!

Whether or not this confusion is likely to happen in practice I don't know, but it suggests a type isomorphic to Maybe is a better fit.

Ollie

_______________________________________________ Libraries mailing list Libraries@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries

-- Andreas Abel <>< Du bist der geliebte Mensch.

Department of Computer Science and Engineering Chalmers and Gothenburg University, Sweden

andreas.abel@gu.se http://www2.tcs.ifi.lmu.de/~abel/

_______________________________________________ Libraries mailing list Libraries@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries

_______________________________________________ Libraries mailing list Libraries@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries

Carter Schonwald

1:23 p.m.

Again, at this juncture it sounds like effort would be better spent first writing out an alternative userland lib to understand these design ideas / articulate their impact better On Friday, July 15, 2016, David Thomas wrote:

...

I kinda like "ExceptionDisposition" for the type, no particular ideas on the constructors. Offered only in the spirit of tossing out ideas - feel free to ignore me if it's not helpful :)

...
At this point maybe it'd be better to write out these ideas as a library and implement a bunch of example codes for different approaches. Changing

On Thu, Jul 14, 2016 at 3:20 PM, Carter Schonwald javascript:;> wrote: the

...
interfaces for exception handling code is subtle stuff!

On Jul 14, 2016 5:42 PM, "Oliver Charles" javascript:;> wrote:

...
data ExceptionHandler a = Rethrow | HandleException (IO a)

would be my offering of paint.

On Thu, Jul 14, 2016 at 9:52 PM David Feuer
javascript:;> wrote:

...
...
Handle is no good because it clashes with file handles. How about Reaction?

On Jul 14, 2016 1:53 PM, "Andreas Abel"
javascript:;> wrote:

...
...
Maybe rather

data Handle a = Rethrow | Handle (IO a)

!? On 14.07.2016 19:12, David Feuer wrote:

...
That makes sense, I guess. Something like

data Handle a = Rethrow | Catch (IO a)

I suppose? My names are awful though.

On Jul 14, 2016 12:56 PM, "Oliver Charles"
javascript:;

...
...
javascript:;>> wrote:

On Tue, 12 Jul 2016, 1:23 a.m. David Feuer, < david.feuer@gmail.com javascript:; javascript:;>> wrote:

The catchJust and handleJust functions seem a bit weird and unidiomatic.

catchJust :: Exception e => (e -> Maybe b) -- ^ Predicate to select exceptions -> IO a -- ^ Computation to run -> (b -> IO a) -- ^ Handler -> IO a catchJust p a handler = catch a handler' where handler' e = case p e of Nothing -> throwIO e Just b -> handler b

This takes two functions and then puts them together. I would think the more natural API would be

catchMaybe :: Exception e => IO a -> (e -> Maybe (IO a)) -> IO a catchMaybe m handler = catch m handler' where handler' e = fromMaybe (throwIO e) (handler e)

A point don't feel super strongly about, but feel I should raise, is that Nothing seems to be somewhat confusing. catchJust (\FileNotFound -> Nothing) seems to suggest that if FileNotFound occurs then nothing will happen, that is - the exception is ignored. However, that is not the case, rather than Nothing happening something certainly happens - an exception is (re)thrown!

Whether or not this confusion is likely to happen in practice I don't know, but it suggests a type isomorphic to Maybe is a better fit.

Ollie

_______________________________________________ Libraries mailing list Libraries@haskell.org javascript:; http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries

-- Andreas Abel <>< Du bist der geliebte Mensch.

Department of Computer Science and Engineering Chalmers and Gothenburg University, Sweden

andreas.abel@gu.se javascript:; http://www2.tcs.ifi.lmu.de/~abel/

_______________________________________________ Libraries mailing list Libraries@haskell.org javascript:; http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries

_______________________________________________ Libraries mailing list Libraries@haskell.org javascript:; http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries

David Feuer

1:44 p.m.

You are very welcome to do so if you don't think further discussion will be useful. Those who feel otherwise may continue to discuss it. On Jul 15, 2016 9:23 AM, "Carter Schonwald" wrote:

...

Again, at this juncture it sounds like effort would be better spent first writing out an alternative userland lib to understand these design ideas / articulate their impact better

On Friday, July 15, 2016, David Thomas wrote:

...
I kinda like "ExceptionDisposition" for the type, no particular ideas on the constructors. Offered only in the spirit of tossing out ideas - feel free to ignore me if it's not helpful :)

...
At this point maybe it'd be better to write out these ideas as a

...
implement a bunch of example codes for different approaches. Changing

On Thu, Jul 14, 2016 at 3:20 PM, Carter Schonwald wrote: library and the

...
interfaces for exception handling code is subtle stuff!

On Jul 14, 2016 5:42 PM, "Oliver Charles" wrote:

...
data ExceptionHandler a = Rethrow | HandleException (IO a)

would be my offering of paint.

On Thu, Jul 14, 2016 at 9:52 PM David Feuer

wrote:

...
...
Handle is no good because it clashes with file handles. How about Reaction?

On Jul 14, 2016 1:53 PM, "Andreas Abel"

wrote:

...
...
Maybe rather

data Handle a = Rethrow | Handle (IO a)

!? On 14.07.2016 19:12, David Feuer wrote: > > That makes sense, I guess. Something like > > data Handle a = Rethrow | Catch (IO a) > > I suppose? My names are awful though. > > > On Jul 14, 2016 12:56 PM, "Oliver Charles" mailto:ollie@ocharles.org.uk> wrote: > > > > On Tue, 12 Jul 2016, 1:23 a.m. David Feuer, <

david.feuer@gmail.com

...
> mailto:david.feuer@gmail.com> wrote: > > The catchJust and handleJust functions seem a bit weird and > unidiomatic. > > catchJust > :: Exception e > => (e -> Maybe b) -- ^ Predicate to select > exceptions > -> IO a -- ^ Computation to run > -> (b -> IO a) -- ^ Handler > -> IO a > catchJust p a handler = catch a handler' > where handler' e = case p e of > Nothing -> throwIO e > Just b -> handler b > > This takes two functions and then puts them together. I would > think the more natural API would be > > catchMaybe :: Exception e => IO a -> (e -> Maybe (IO a)) -> IO > a > catchMaybe m handler = catch m handler' where > handler' e = fromMaybe (throwIO e) (handler e) > > A point don't feel super strongly about, but feel I should raise, > is > that Nothing seems to be somewhat confusing. catchJust > (\FileNotFound -> Nothing) seems to suggest that if FileNotFound > occurs then nothing will happen, that is - the exception is > ignored. > However, that is not the case, rather than Nothing happening > something certainly happens - an exception is (re)thrown! > > Whether or not this confusion is likely to happen in practice I > don't know, but it suggests a type isomorphic to Maybe is a better > fit. > > Ollie > > > > _______________________________________________ > Libraries mailing list > Libraries@haskell.org > http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries >

-- Andreas Abel <>< Du bist der geliebte Mensch.

Department of Computer Science and Engineering Chalmers and Gothenburg University, Sweden

andreas.abel@gu.se http://www2.tcs.ifi.lmu.de/~abel/

_______________________________________________ Libraries mailing list Libraries@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries

_______________________________________________ Libraries mailing list Libraries@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries

_______________________________________________ Libraries mailing list Libraries@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries

Carter Schonwald

2:46 p.m.

Respectfully I disagree. You are pushing a breaking change to functionality in the base exception Api without a) demonstrating the Api is better b) understanding the impact on preexisting code that would needlessly break c) without doing a prototype outside of base to demonstrate that this alternative is better both in terms of the underlying library complexity and how the resulting application complexity changes. I am voicing an opinion other readers on the libraries list have on this matter but are too polite or wise to air this feedback publicly. The onus is on the proposer to demonstrate validity. Cheers -Carter On Friday, July 15, 2016, David Feuer wrote:

...

You are very welcome to do so if you don't think further discussion will be useful. Those who feel otherwise may continue to discuss it.

On Jul 15, 2016 9:23 AM, "Carter Schonwald" javascript:_e(%7B%7D,'cvml','carter.schonwald@gmail.com');> wrote:

...
Again, at this juncture it sounds like effort would be better spent first writing out an alternative userland lib to understand these design ideas / articulate their impact better

On Friday, July 15, 2016, David Thomas javascript:_e(%7B%7D,'cvml','davidleothomas@gmail.com');> wrote:

...
I kinda like "ExceptionDisposition" for the type, no particular ideas on the constructors. Offered only in the spirit of tossing out ideas - feel free to ignore me if it's not helpful :)

...
At this point maybe it'd be better to write out these ideas as a

...
implement a bunch of example codes for different approaches. Changing

On Thu, Jul 14, 2016 at 3:20 PM, Carter Schonwald wrote: library and the

...
interfaces for exception handling code is subtle stuff!

On Jul 14, 2016 5:42 PM, "Oliver Charles" wrote:

...
data ExceptionHandler a = Rethrow | HandleException (IO a)

would be my offering of paint.

On Thu, Jul 14, 2016 at 9:52 PM David Feuer

wrote:

...
...
Handle is no good because it clashes with file handles. How about Reaction?

On Jul 14, 2016 1:53 PM, "Andreas Abel"

wrote:

...
> > Maybe rather > > data Handle a = Rethrow | Handle (IO a) > > !? > On 14.07.2016 19:12, David Feuer wrote: >> >> That makes sense, I guess. Something like >> >> data Handle a = Rethrow | Catch (IO a) >> >> I suppose? My names are awful though. >> >> >> On Jul 14, 2016 12:56 PM, "Oliver Charles" > mailto:ollie@ocharles.org.uk> wrote: >> >> >> >> On Tue, 12 Jul 2016, 1:23 a.m. David Feuer, < david.feuer@gmail.com >> mailto:david.feuer@gmail.com> wrote: >> >> The catchJust and handleJust functions seem a bit weird and >> unidiomatic. >> >> catchJust >> :: Exception e >> => (e -> Maybe b) -- ^ Predicate to select >> exceptions >> -> IO a -- ^ Computation to run >> -> (b -> IO a) -- ^ Handler >> -> IO a >> catchJust p a handler = catch a handler' >> where handler' e = case p e of >> Nothing -> throwIO e >> Just b -> handler b >> >> This takes two functions and then puts them together. I would >> think the more natural API would be >> >> catchMaybe :: Exception e => IO a -> (e -> Maybe (IO a)) -> IO >> a >> catchMaybe m handler = catch m handler' where >> handler' e = fromMaybe (throwIO e) (handler e) >> >> A point don't feel super strongly about, but feel I should raise, >> is >> that Nothing seems to be somewhat confusing. catchJust >> (\FileNotFound -> Nothing) seems to suggest that if FileNotFound >> occurs then nothing will happen, that is - the exception is >> ignored. >> However, that is not the case, rather than Nothing happening >> something certainly happens - an exception is (re)thrown! >> >> Whether or not this confusion is likely to happen in practice I >> don't know, but it suggests a type isomorphic to Maybe is a better >> fit. >> >> Ollie >> >> >> >> _______________________________________________ >> Libraries mailing list >> Libraries@haskell.org >> http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries >> > > > -- > Andreas Abel <>< Du bist der geliebte Mensch. > > Department of Computer Science and Engineering > Chalmers and Gothenburg University, Sweden > > andreas.abel@gu.se > http://www2.tcs.ifi.lmu.de/~abel/

_______________________________________________ Libraries mailing list Libraries@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries

_______________________________________________ Libraries mailing list Libraries@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries

_______________________________________________ Libraries mailing list Libraries@haskell.org javascript:_e(%7B%7D,'cvml','Libraries@haskell.org'); http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries

davean

3:57 p.m.

I'm -1 on changing the currently named functions. Which you only imply doing to my reading but I think Carter takes you as proposing given your use of said names in proposing the signatures. Overall I'm +0. I see code the alternative signature could be nicer for, but I'm not sure I'd use it or why this is starting as a library discussion instead of on hackage. I just would prefer not to lose the existing signature's availability. On Jul 15, 2016 10:46 AM, "Carter Schonwald" wrote:

...

Respectfully I disagree.

You are pushing a breaking change to functionality in the base exception Api without a) demonstrating the Api is better b) understanding the impact on preexisting code that would needlessly break c) without doing a prototype outside of base to demonstrate that this alternative is better both in terms of the underlying library complexity and how the resulting application complexity changes.

I am voicing an opinion other readers on the libraries list have on this matter but are too polite or wise to air this feedback publicly.

The onus is on the proposer to demonstrate validity.

Cheers -Carter

On Friday, July 15, 2016, David Feuer wrote:

...
You are very welcome to do so if you don't think further discussion will be useful. Those who feel otherwise may continue to discuss it.

On Jul 15, 2016 9:23 AM, "Carter Schonwald" wrote:

...
Again, at this juncture it sounds like effort would be better spent first writing out an alternative userland lib to understand these design ideas / articulate their impact better

On Friday, July 15, 2016, David Thomas wrote:

...
I kinda like "ExceptionDisposition" for the type, no particular ideas on the constructors. Offered only in the spirit of tossing out ideas - feel free to ignore me if it's not helpful :)

...
At this point maybe it'd be better to write out these ideas as a

On Thu, Jul 14, 2016 at 3:20 PM, Carter Schonwald wrote: library and

...
implement a bunch of example codes for different approaches. Changing the interfaces for exception handling code is subtle stuff!

On Jul 14, 2016 5:42 PM, "Oliver Charles" wrote:

...
data ExceptionHandler a = Rethrow | HandleException (IO a)

would be my offering of paint.

On Thu, Jul 14, 2016 at 9:52 PM David Feuer

wrote:

...
> > Handle is no good because it clashes with file handles. How about > Reaction? > > > On Jul 14, 2016 1:53 PM, "Andreas Abel" wrote: >> >> Maybe rather >> >> data Handle a = Rethrow | Handle (IO a) >> >> !? >> On 14.07.2016 19:12, David Feuer wrote: >>> >>> That makes sense, I guess. Something like >>> >>> data Handle a = Rethrow | Catch (IO a) >>> >>> I suppose? My names are awful though. >>> >>> >>> On Jul 14, 2016 12:56 PM, "Oliver Charles" >> mailto:ollie@ocharles.org.uk> wrote: >>> >>> >>> >>> On Tue, 12 Jul 2016, 1:23 a.m. David Feuer, < david.feuer@gmail.com >>> mailto:david.feuer@gmail.com> wrote: >>> >>> The catchJust and handleJust functions seem a bit weird and >>> unidiomatic. >>> >>> catchJust >>> :: Exception e >>> => (e -> Maybe b) -- ^ Predicate to select >>> exceptions >>> -> IO a -- ^ Computation to run >>> -> (b -> IO a) -- ^ Handler >>> -> IO a >>> catchJust p a handler = catch a handler' >>> where handler' e = case p e of >>> Nothing -> throwIO e >>> Just b -> handler b >>> >>> This takes two functions and then puts them together. I would >>> think the more natural API would be >>> >>> catchMaybe :: Exception e => IO a -> (e -> Maybe (IO a)) -> IO >>> a >>> catchMaybe m handler = catch m handler' where >>> handler' e = fromMaybe (throwIO e) (handler e) >>> >>> A point don't feel super strongly about, but feel I should raise, >>> is >>> that Nothing seems to be somewhat confusing. catchJust >>> (\FileNotFound -> Nothing) seems to suggest that if FileNotFound >>> occurs then nothing will happen, that is - the exception is >>> ignored. >>> However, that is not the case, rather than Nothing happening >>> something certainly happens - an exception is (re)thrown! >>> >>> Whether or not this confusion is likely to happen in practice I >>> don't know, but it suggests a type isomorphic to Maybe is a better >>> fit. >>> >>> Ollie >>> >>> >>> >>> _______________________________________________ >>> Libraries mailing list >>> Libraries@haskell.org >>> http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries >>> >> >> >> -- >> Andreas Abel <>< Du bist der geliebte Mensch. >> >> Department of Computer Science and Engineering >> Chalmers and Gothenburg University, Sweden >> >> andreas.abel@gu.se >> http://www2.tcs.ifi.lmu.de/~abel/

_______________________________________________ Libraries mailing list Libraries@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries

_______________________________________________ Libraries mailing list Libraries@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries

_______________________________________________ Libraries mailing list Libraries@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries

David Feuer

5:50 p.m.

No one is proposing removing or changing the current functions. Maybe you should re-read the thread. Unnamed people who don't voice their own opinions don't count for much. On Jul 15, 2016 10:46 AM, "Carter Schonwald" wrote:

...

Respectfully I disagree.

You are pushing a breaking change to functionality in the base exception Api without a) demonstrating the Api is better b) understanding the impact on preexisting code that would needlessly break c) without doing a prototype outside of base to demonstrate that this alternative is better both in terms of the underlying library complexity and how the resulting application complexity changes.

I am voicing an opinion other readers on the libraries list have on this matter but are too polite or wise to air this feedback publicly.

The onus is on the proposer to demonstrate validity.

Cheers -Carter

On Friday, July 15, 2016, David Feuer wrote:

...
You are very welcome to do so if you don't think further discussion will be useful. Those who feel otherwise may continue to discuss it.

On Jul 15, 2016 9:23 AM, "Carter Schonwald" wrote:

...
Again, at this juncture it sounds like effort would be better spent first writing out an alternative userland lib to understand these design ideas / articulate their impact better

On Friday, July 15, 2016, David Thomas wrote:

...
I kinda like "ExceptionDisposition" for the type, no particular ideas on the constructors. Offered only in the spirit of tossing out ideas - feel free to ignore me if it's not helpful :)

...
At this point maybe it'd be better to write out these ideas as a

On Thu, Jul 14, 2016 at 3:20 PM, Carter Schonwald wrote: library and

...
implement a bunch of example codes for different approaches. Changing the interfaces for exception handling code is subtle stuff!

On Jul 14, 2016 5:42 PM, "Oliver Charles" wrote:

...
data ExceptionHandler a = Rethrow | HandleException (IO a)

would be my offering of paint.

On Thu, Jul 14, 2016 at 9:52 PM David Feuer

wrote:

...
> > Handle is no good because it clashes with file handles. How about > Reaction? > > > On Jul 14, 2016 1:53 PM, "Andreas Abel" wrote: >> >> Maybe rather >> >> data Handle a = Rethrow | Handle (IO a) >> >> !? >> On 14.07.2016 19:12, David Feuer wrote: >>> >>> That makes sense, I guess. Something like >>> >>> data Handle a = Rethrow | Catch (IO a) >>> >>> I suppose? My names are awful though. >>> >>> >>> On Jul 14, 2016 12:56 PM, "Oliver Charles" >> mailto:ollie@ocharles.org.uk> wrote: >>> >>> >>> >>> On Tue, 12 Jul 2016, 1:23 a.m. David Feuer, < david.feuer@gmail.com >>> mailto:david.feuer@gmail.com> wrote: >>> >>> The catchJust and handleJust functions seem a bit weird and >>> unidiomatic. >>> >>> catchJust >>> :: Exception e >>> => (e -> Maybe b) -- ^ Predicate to select >>> exceptions >>> -> IO a -- ^ Computation to run >>> -> (b -> IO a) -- ^ Handler >>> -> IO a >>> catchJust p a handler = catch a handler' >>> where handler' e = case p e of >>> Nothing -> throwIO e >>> Just b -> handler b >>> >>> This takes two functions and then puts them together. I would >>> think the more natural API would be >>> >>> catchMaybe :: Exception e => IO a -> (e -> Maybe (IO a)) -> IO >>> a >>> catchMaybe m handler = catch m handler' where >>> handler' e = fromMaybe (throwIO e) (handler e) >>> >>> A point don't feel super strongly about, but feel I should raise, >>> is >>> that Nothing seems to be somewhat confusing. catchJust >>> (\FileNotFound -> Nothing) seems to suggest that if FileNotFound >>> occurs then nothing will happen, that is - the exception is >>> ignored. >>> However, that is not the case, rather than Nothing happening >>> something certainly happens - an exception is (re)thrown! >>> >>> Whether or not this confusion is likely to happen in practice I >>> don't know, but it suggests a type isomorphic to Maybe is a better >>> fit. >>> >>> Ollie >>> >>> >>> >>> _______________________________________________ >>> Libraries mailing list >>> Libraries@haskell.org >>> http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries >>> >> >> >> -- >> Andreas Abel <>< Du bist der geliebte Mensch. >> >> Department of Computer Science and Engineering >> Chalmers and Gothenburg University, Sweden >> >> andreas.abel@gu.se >> http://www2.tcs.ifi.lmu.de/~abel/

_______________________________________________ Libraries mailing list Libraries@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries

_______________________________________________ Libraries mailing list Libraries@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries

_______________________________________________ Libraries mailing list Libraries@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries

Oleg Grenrus

14 Jul 14 Jul

6:06 p.m.

Maybe pointing out the obvious, but when used with lens, catchJust approach is handy: — | here catchJust is from `exceptions` though catching :: MonadCatch m => Getting (First a) SomeException a -> m r -> (a -> m r) -> m r catching l = catchJust (preview l) http://hackage.haskell.org/package/lens-4.14/docs/src/Control.Exception.Lens... +/- 0 on catchMaybe - Oleg

...

On 12 Jul 2016, at 03:23, David Feuer wrote:

The catchJust and handleJust functions seem a bit weird and unidiomatic.

catchJust :: Exception e => (e -> Maybe b) -- ^ Predicate to select exceptions -> IO a -- ^ Computation to run -> (b -> IO a) -- ^ Handler -> IO a catchJust p a handler = catch a handler' where handler' e = case p e of Nothing -> throwIO e Just b -> handler b

This takes two functions and then puts them together. I would think the more natural API would be

catchMaybe :: Exception e => IO a -> (e -> Maybe (IO a)) -> IO a catchMaybe m handler = catch m handler' where handler' e = fromMaybe (throwIO e) (handler e)

This is exactly as powerful as catchJust:

catchMaybe m handler = catchJust handler m id catchJust p m handler = catchMaybe m $ fmap handler . p

But catchMaybe doesn't enforce the arbitrary separation between "selection" and "handling".

_______________________________________________ Libraries mailing list Libraries@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries

Bardur Arantsson

8:24 p.m.

On 07/14/2016 08:06 PM, Oleg Grenrus wrote:

...

Maybe pointing out the obvious, but when used with lens, catchJust approach is handy:

— | here catchJust is from `exceptions` though catching :: MonadCatch m => Getting (First a) SomeException a -> m r -> (a -> m r) -> m r catching l = catchJust (preview l)

http://hackage.haskell.org/package/lens-4.14/docs/src/Control.Exception.Lens...

lens is not a very appealing to have as a dependency if one is oneself writing a library for others to consume. (Because of the huge set of dependencies.)

3278

Age (days ago)

3281

Last active (days ago)

List overview

Download

21 comments

11 participants

participants (11)

Andreas Abel
Bardur Arantsson
Ben Millwood
Carter Schonwald
davean
David Feuer
David Menendez
David Thomas
Oleg Grenrus
Oliver Charles
Theodore Lief Gannon

Discussion: add more idiomatic versions of catchJust and/or handleJust

tags

participants (11)