- Libraries - Haskell.org

Add missing Monad/Traversable instances to tuples
by Fumiaki Kinoshita 09 Apr '19

09 Apr '19

I submitted https://gitlab.haskell.org/ghc/ghc/merge_requests/644 but it might be still controversial. I'd like to get more opinions again. Here's the list of proposed instances: Foldable ((,,) a b) Foldable ((,,,) a b c) Traversable ((,,) a b) Traversable ((,,,) a b c) Functor ((,,) a b) (Monoid a, Monoid b) => Applicative ((,,) a b) (Monoid a, Monoid b) => Monad ((,,) a b) Functor ((,,,) a b c) (Monoid a, Monoid b, Monoid c) => Applicative ((,,,) a b c) (Monoid a, Monoid b, Monoid c) => Monad ((,,,) a b c) The absence of Traversable instances for tuples feels quite inconsistent given that there are Bitraversable instances already.

22 29

Re: Adding more instances to Kleisli: Generic, Monad, etc
by Ryan Scott 08 Apr '19

08 Apr '19

+1 from me, although I find it somewhat curious that this proposes adding a Generic instance, but not a Generic1 instance. Perhaps that should be included in the patch as well? Ryan S.

2 1

Adding more instances to Kleisli: Generic, Monad, etc
by Fumiaki Kinoshita 07 Apr '19

07 Apr '19

This is another part of https://gitlab.haskell.org/ghc/ghc/merge_requests/644, which is presumably much less controversial: Generic (Kleisli m a b) Functor m => Functor (Kleisli m a) Applicative m => Applicative (Kleisli m a) Alternative m => Alternative (Kleisli m a) Monad m => Monad (Kleisli m a) (Alternative m, Monad m) => MonadPlus (Kleisli m a)

5 7

Data.Map.mapKeysMonotonic is a misleading name
by Elliot Cameron 04 Apr '19

04 Apr '19

Hello! In some recent analysis I ran into a subtlety that caught me by surprise: Data.Map.mapKeysMonotonic has a misleading name. A monotonic function is not a strictly *increasing* function, but merely non-decreasing. However, mapKeysMonotonic requires that it's mapping function be injective, which means it really only supports *increasing* functions. valid (mapKeysMonotonic (\x -> if x `elem` [1,2] then 2 else x) (fromList [(1, "a"), (2, "b"), (3, "c")])) == False The docs hint at this with "This means that @f <https://github.com/f>@ maps distinct original keys to distinct resulting keys." However, I'd propose that we deprecate this name and rename to something like mapKeysIncreasingor mapKeysAsc (to follow the pattern of other *Asc functions). We should also clarify the docs. >From https://github.com/haskell/containers/issues/617

4 9

Proposol: make Data.Bits algebraic
by Johnson-Freyd, Philip Alden 12 Mar '19

12 Mar '19

Hello, The current version of Data.Bits is non-algebraic, in so far as the Bits class has 1. a superclass constraint on `Eq` 2. operations `testBit` and `isSigned` which return `Bool`. This is quite annoying, as myriad potential uses of the Bits class cover types for which these concrete observations are not possible. It leads to comments like the following in SBV: -- | This instance is only defined so that we can define an instance for -- 'Data.Bits.Bits'. '==' and '/=' simply throw an error. Use -- 'Data.SBV.EqSymbolic' instead. We had this same issue for `Num` for years, until it eventually got fixed. And it would be nice to fix the situation for `Bits` as well. There are other aspects of the Bits API which are pretty clunky, but this is the one that is often a show stopper. Philip

3 2

Add 'e' to Floating typeclass
by chessai . 22 Feb '19

22 Feb '19

We have the 'pi' constant in the floating typeclass and some trigonometric functions, as well as things like exp/log/expm1/log1p. Why not provide an 'e' constant? A default implementation could just be 'exp 1'.

11 31

Add newtype for Alternative using QuantifiedConstraints in base-4.13
by theindigamer 19 Feb '19

19 Feb '19

Thoughts on adding a newtype with the following Alternative instance? (The name chosen is a placeholder, I don't have any particular preference). newtype Mon f a = Mon { unMon :: f a } instance (forall a. Monoid (f a)) => Alternative (Mon f) where empty = Mon mempty (<|>) (Mon m1) (Mon m2) = Mon (m1 <> m2)

5 5

ANNOUNCE: eccrypto 0.1.0, timing attack safe cryptography in Haskell
by Marcel Fourné 19 Feb '19

19 Feb '19

Dear Haskell Community! I'd like to introduce some new cryptographic code, containing a verified[*] timing-attack safe pure Haskell[**] implementation of Ed25519 and as of yet unverified implementations of textbook ECDH and ECDSA on the NIST prime curves. Install it by $ cabal install eccrypto or download it from Hackage[0]. Also contained are test vectors, usable by the trusty $ cabal test as well as benchmarking code which you can invoke by $ cabal bench if you want to try my code before using it. Please note that this is a one person project, so there is still much room for optimization. The intended focus groups are implementors of cryptographic protocols as well as other cryptographers and interested third parties. My code uses no[**] embedded C code or assembly to achieve timing attack resistance, only careful Haskell constructions in the internal modules, the obligatory hackers footgun included only in those. ;-) Security sketch: The timing attack safety is built on the constant time criterion, namely, that no branches or memory access indices may be based on the content of the secret key bits. The name of this criterion is from the strict evaluation world of cryptography, but does not prohibit non-strict evaluation semantics per se. The API is only slightly different from contemporary libraries like "ed25519"[1], but the content of the signatures is just the same. The number of dependencies are also in the same ballpark, if you'd like to use the code for infrastructure - but in that case, please talk to me to not use unverified/insecure operations! Best of wishes to a thriving community, Marcel Fourné [*]: paper upcoming but as of now it only exists in my notes; analysis was done "by hand" on assembly generated by GHC 8.4.4, mechanization based on established proofs is planned [**]: using integer-gmp, might change in the future to low-level Haskell [0]: https://hackage.haskell.org/package/eccrypto-0.1.0 [1]: https://hackage.haskell.org/package/ed25519

1 0

Fwd: Add newtype for Alternative using QuantifiedConstraints in base-4.13
by Ruben Astudillo 17 Feb '19

17 Feb '19

Forwarding the replies sent incorrectly to -cafe. -------- Forwarded Message -------- Subject: Re: Add newtype for Alternative using QuantifiedConstraints in base-4.13 Date: Sun, 17 Feb 2019 21:05:12 -0300 From: Ruben Astudillo <ruben.astud(a)gmail.com> To: theindigamer <theindigamer15(a)gmail.com>, Haskell Cafe <haskell-cafe(a)haskell.org> I wonder if it is useful at all. If `f a` already has a Monoid instance, you can use `(<>)` already instead of (<|>) with pretty much the same laws. Plus you don't have to import `(<>)` as it comes from the Prelude where `(<|>)` doesn't. Does this have an use case or is just for aesthetic completeness? -- -- Ruben -- pgp: 4EE9 28F7 932E F4AD

1 0

Taking over haskell-src-meta
by Dan Burton 11 Feb '19

11 Feb '19

I, Dan Burton, intend to take over maintenance of haskell-src-meta. -- Dan Burton

1 0