Discussion: add more idiomatic versions of catchJust and/or handleJust
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 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/
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 <andreas.abel@ifi.lmu.de> 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/
+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" <david.feuer@gmail.com> 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 <andreas.abel@ifi.lmu.de> 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
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" <david.feuer@gmail.com> 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 <andreas.abel@ifi.lmu.de> 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
On Mon, Jul 11, 2016 at 8:23 PM, David Feuer <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)
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 <dave@zednenem.com> <http://www.eyrie.org/~zednenem/>
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" <dave@zednenem.com> wrote:
On Mon, Jul 11, 2016 at 8:23 PM, David Feuer <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)
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 <dave@zednenem.com> <http://www.eyrie.org/~zednenem/>
On Tue, 12 Jul 2016, 1:23 a.m. David Feuer, <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
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" <ollie@ocharles.org.uk> wrote:
On Tue, 12 Jul 2016, 1:23 a.m. David Feuer, <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
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" <ollie@ocharles.org.uk <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/
Handle is no good because it clashes with file handles. How about Reaction? On Jul 14, 2016 1:53 PM, "Andreas Abel" <andreas.abel@ifi.lmu.de> 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" <ollie@ocharles.org.uk <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/
data ExceptionHandler a = Rethrow | HandleException (IO a) would be my offering of paint. On Thu, Jul 14, 2016 at 9:52 PM David Feuer <david.feuer@gmail.com> wrote:
Handle is no good because it clashes with file handles. How about Reaction?
On Jul 14, 2016 1:53 PM, "Andreas Abel" <andreas.abel@ifi.lmu.de> 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" <ollie@ocharles.org.uk <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/
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" <ollie@ocharles.org.uk> 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 <david.feuer@gmail.com> wrote:
Handle is no good because it clashes with file handles. How about Reaction?
On Jul 14, 2016 1:53 PM, "Andreas Abel" <andreas.abel@ifi.lmu.de> 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" <ollie@ocharles.org.uk <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
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 <carter.schonwald@gmail.com> 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" <ollie@ocharles.org.uk> 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 <david.feuer@gmail.com> wrote:
Handle is no good because it clashes with file handles. How about Reaction?
On Jul 14, 2016 1:53 PM, "Andreas Abel" <andreas.abel@ifi.lmu.de> 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" <ollie@ocharles.org.uk <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
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 <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 :)
On Thu, Jul 14, 2016 at 3:20 PM, Carter Schonwald <carter.schonwald@gmail.com <javascript:;>> 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" <ollie@ocharles.org.uk <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 <david.feuer@gmail.com
<javascript:;>> wrote:
Handle is no good because it clashes with file handles. How about Reaction?
On Jul 14, 2016 1:53 PM, "Andreas Abel" <andreas.abel@ifi.lmu.de
<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" <ollie@ocharles.org.uk
<javascript:;>
<mailto:ollie@ocharles.org.uk <javascript:;>>> wrote:
On Tue, 12 Jul 2016, 1:23 a.m. David Feuer, < david.feuer@gmail.com <javascript:;> <mailto:david.feuer@gmail.com <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
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" <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 <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 :)
On Thu, Jul 14, 2016 at 3:20 PM, Carter Schonwald <carter.schonwald@gmail.com> 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" <ollie@ocharles.org.uk> 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 <david.feuer@gmail.com>
wrote:
Handle is no good because it clashes with file handles. How about Reaction?
On Jul 14, 2016 1:53 PM, "Andreas Abel" <andreas.abel@ifi.lmu.de>
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" <ollie@ocharles.org.uk > <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
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 <david.feuer@gmail.com> 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" <carter.schonwald@gmail.com <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 <davidleothomas@gmail.com <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 :)
On Thu, Jul 14, 2016 at 3:20 PM, Carter Schonwald <carter.schonwald@gmail.com> 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" <ollie@ocharles.org.uk> 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 <david.feuer@gmail.com>
wrote:
Handle is no good because it clashes with file handles. How about Reaction?
On Jul 14, 2016 1:53 PM, "Andreas Abel" <andreas.abel@ifi.lmu.de>
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" <ollie@ocharles.org.uk >> <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
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" <carter.schonwald@gmail.com> 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 <david.feuer@gmail.com> 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" <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 <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 :)
On Thu, Jul 14, 2016 at 3:20 PM, Carter Schonwald <carter.schonwald@gmail.com> 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" <ollie@ocharles.org.uk> 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 <david.feuer@gmail.com>
wrote:
> > Handle is no good because it clashes with file handles. How about > Reaction? > > > On Jul 14, 2016 1:53 PM, "Andreas Abel" <andreas.abel@ifi.lmu.de> 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" <ollie@ocharles.org.uk >>> <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
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" <carter.schonwald@gmail.com> 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 <david.feuer@gmail.com> 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" <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 <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 :)
On Thu, Jul 14, 2016 at 3:20 PM, Carter Schonwald <carter.schonwald@gmail.com> 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" <ollie@ocharles.org.uk> 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 <david.feuer@gmail.com>
wrote:
> > Handle is no good because it clashes with file handles. How about > Reaction? > > > On Jul 14, 2016 1:53 PM, "Andreas Abel" <andreas.abel@ifi.lmu.de> 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" <ollie@ocharles.org.uk >>> <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
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 <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)
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
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.)
participants (11)
-
Andreas Abel -
Bardur Arantsson -
Ben Millwood -
Carter Schonwald -
davean -
David Feuer -
David Menendez -
David Thomas -
Oleg Grenrus -
Oliver Charles -
Theodore Lief Gannon