- Libraries - Haskell.org

[core libraries] Call for Nominations
by George Wilson 16 Jan '20

16 Jan '20

Dear Haskellers, We're putting out a call for new nominations (typically but not necessarily self-nominations) to the Core Libraries Committee. We have one open slot, as Ryan Scott has chosen to step down from the committee. At the same time, Edward Kmett is stepping down from his role as chair. Edward will remain on the committee as a regular member for the duration of his term. Once we have filled Ryan's seat, the committee will decide on a new chair. To nominate yourself to the committee, please send an email to core-libraries-committee at haskell.org by the 17th of February, 2020. Please feel free to include any information about yourself that you think will help us to make a decision. Being a member of the committee does not necessarily require a significant amount of time, but committee members should aim to be responsive during discussions when the committee is called upon to make a decision. Strong leadership, communication, and judgement are very important characteristics for committee members. The core libraries committee acts as the maintainer of the core libraries mentioned on https://wiki.haskell.org/Library_submissions For the most part members maintain individual libraries under the maintainer guidelines for Haskell, but there are occasional "barn-raising" style calls for discussion and decision whenever things need a broad enough mandate. We seek a broad representation from different segments of the Haskell world -- including but not limited to those focused on education, those focused on industrial applications, those with a background in organising users-groups, and those focused directly on our technical infrastructure. More details about the committee's roles and responsibilities are on https://wiki.haskell.org/Core_Libraries_Committee If you have any questions about the process, please feel free to e-mail us at core-libraries-committee at haskell.org (cc'd), or contact one of us individually. Kind regards, George Wilson on behalf of the Core Libraries Committee

1 0

Who is on the core libraries committee (CLC)?
by Simon Jakobi 16 Jan '20

16 Jan '20

Hi! Recent emails [1] [2] indicate that the CLC member list [3] is outdated. Could someone clarify who the current members are and who the current Chair is? Cheers, Simon [1] https://groups.google.com/forum/#!topic/haskell-core-libraries/InkZtGOyCgA [2] https://groups.google.com/forum/#!topic/haskell-core-libraries/fTmt22wP6Zg [3] https://wiki.haskell.org/Core_Libraries_Committee#Current_members

4 5

Re: deepseq: Add more instances. #50
by Travis Whitaker 15 Jan '20

15 Jan '20

If the Control.DeepSeq module exports an error-yielding instance, then one would need to newtype all their ForeignPtrs in order to define their own correct NFData instance. Naturally I’m biased, but that seems like quite a hoop to jump through to get correct but subtle behavior. I’m not sure the core libraries go to such lengths to hide correct-but-tricky behavior anywhere else; I’d be interested in seeing existing examples of this. On Wed, Jan 15, 2020 at 1:13 AM Henning Thielemann < lemming(a)henning-thielemann.de> wrote: > > On Wed, 15 Jan 2020, Travis Whitaker wrote: > > > If such an error-yielding instance were added, how would users who need > > the correct-but-potentially-confusing behaving NFData instance cope with > > this? > > In the criterion/record example they would manually implement the NFData > instance for the record, as you already suggested. >

1 0

unix: Improve baud rate handling. #135
by Travis Whitaker 14 Jan '20

14 Jan '20

Greetings Haskellers, I am writing to draw your attention to https://github.com/haskell/unix/pull/135. The unix library conditionally supports the common baud rate extensions 57600 and 115200. Modern POSIX systems support a much wider set of extensions, and this PR adds additional extended baud rates that have been available on MacOS and Linux for several years. The same CPP mechanism for conditionally enabling these extensions is used. The PR has been open for a few months and I am interested in moving it forward. Thanks for your time, Travis Whitaker

1 0

WARNING pragmas in `Prelude.undefined` and `Prelude.error`
by Vilem Liepelt 14 Jan '20

14 Jan '20

Has there been any discussion about adding WARNING pragmas to `Prelude.undefined` and `Prelude.error`, as done in some custom preludes? I suppose this hasn't been done yet to avoid breaking existing code which makes "legitimate" use of those helpers?

13 21

haskell/bytestring stalled?
by Fumiaki Kinoshita 13 Jan '20

13 Jan '20

I noticed that issues and PRs on bytestring repository[0] have received no feedback in past 6 months. Does anyone know what's going on? If I can help moving things along, I definitely would like to. [0] https://github.com/haskell/bytestring

6 12

Discussion: forM for Data.Set
by hasufell＠posteo.de 12 Jan '20

12 Jan '20

This was posted a year ago already, but without many comments: https://mail.haskell.org/pipermail/libraries/2019-January/029335.html So after cleaning up the PR a bit, adding tests and benchmarks, let's give it another go. PR is at: https://github.com/haskell/containers/pull/592 New functions are: forM, mapM, for, traverse This follows the other Data.Set exported functions, overwriting Prelude ones like foldr etc, so I think that's exactly what we want. Cheers, Julian Ospald

3 2

Augmented sequence deletion
by David Feuer 29 Dec '19

29 Dec '19

Data.Sequence offers deleteAt :: Int -> Seq a -> Seq a which deletes the element at the given index. Today, I ran into a situation where I wanted to know what was deleted. deleteLookup :: Int -> Seq a -> Maybe (a, Seq a) The closest thing I can find in `containers` is in Data.Map: updateLookupWithKey :: Ord k => (k -> a -> Maybe a) -> k -> Map k a -> (Maybe a,Map k a) Unfortunately, that function is ugly and strange. A better one, whose name I can't guess at the moment: flabbergast :: (a -> (b, Maybe a)) -> Int -> Seq a -> Maybe (b, Seq a) where a Nothing result means the index was out of bounds. There's also a potential flabbergastF :: Functor f => (a -> f (Maybe a)) -> Int -> Seq a -> Maybe (f (Seq a)) I'm not sure if flabbergast can be made as fast as deleteLookup, so it's possible we may want both. Any opinions?

4 5

Update Read1 NonEmpty and Read1 Down
by Dannyu NDos 18 Dec '19

18 Dec '19

It would be better if liftReadPrec is used instead of liftReadsPrec. instance Read1 NonEmpty where liftReadPrec rp rl = paren $ prec 5 $ do x <- rp Symbol ":|" <- lexP xs <- rl pure (x :| xs)

1 0

joinAtomicallyWithMask, and a potential resource leak in http-client
by Leon Smith 13 Dec '19

13 Dec '19

I'm going to propose four new functions to add to the STM library, and would be interested in getting some feedback for this idea. The basic idea is that we implement these two functions, along with their WithUninterruptibleMask counterparts: {-# LANGUAGE RankNTypes, ImpredicativeTypes #-} import Control.Monad(join) import Control.Concurrent.STM(STM, atomically) import Control.Exception(mask, mask_) joinAtomicallyWithMask :: STM ((forall a. (IO a -> IO a)) -> IO b) -> IO b joinAtomicallyWithMask transaction = mask $ \unmask -> do join . atomically $ do ioCont <- transaction return $ do ioCont unmask joinAtomicallyWithMask_ :: STM (IO b) -> IO b joinAtomicallyWithMask_ = mask_ . join . atomically However, the entire point of this endeavor is to implement these functions better than this. What we really want to do is to mask asynchronous exceptions in conjunction with an STM commit: a conservative implementation would upgrade the masking state shortly before we know if the transaction will commit or retry: if it retries, we restore the old masking state; if we commit, then we leave it alone. A perhaps more daring implementation would find a place immediately after commit before async exceptions could possibly appear, but this probably isn't necessary if the approach turns out to be too difficult/problematic. joinAtomicallyWithUninterruptibleMask actually allows us to express some programs that we couldn't before: will complete the STM transaction in an uninterruptible masking state, but we don't have to worry about blocking in the transaction because we won't have upgraded the masking state. I actually noticed this pattern twice recently: once in some code I was writing, and a second time within a week or two later, I noticed this would fix a potential resource leak in http-client, namely: https://github.com/snoyberg/http-client/blob/master/http-client/Data/KeyedP… reap destroy var = loop where loop = do threadDelay (5 * 1000 * 1000) join $ atomically $ do m'' <- readTVar var case m'' of PoolClosed -> return (return ()) PoolOpen idleCount m | Map.null m -> retry | otherwise -> do (m', toDestroy) <- findStale idleCount m writeTVar var m' return $ do mask_ (mapM_ (ignoreExceptions . destroy) toDestroy) loop It looks like to me that we really want to ensure that we call "destroy" on every resource taken out of the pool, but it would appear that the mask_ is somewhat misplaced: while perhaps it removes the most likely places that an asynchronous exception could break that invariant, it looks like there's still a possibility that an asynchronous exception that happens after the transaction commits but before the call to `mask_`. And lastly, I know I independently came up with the join . atomically idiom, but I know I'm not the first nor the last to do so. It's an idiom that does deserve to be more widely appreciated, and this could be a way to do it. Best, Leon

1 0