- Haskell-Cafe - Haskell.org

[ANN] wai-handler-hal-0.1.0.0 - Wrap a WAI Application to run on AWS Lambda
by Jack Kelly 15 Apr '21

15 Apr '21

I have just pushed an initial release of wai-handler-hal[1] to Hackage. This library lets you run `wai` `Application`s on AWS Lambda, using the proxy integration features of an API Gateway REST API. This allows you to write your APIs using tools like `servant`, test them locally using `warp`, and then build deployment binaries using `hal`. There's an especially nice payoff when you use `servant`: it's very easy to test the entire API locally using `warp`, but then split endpoints into individual Lambda binaries. This means you can assign minimal IAM policies to each Lambda when you deploy to AWS. The library code, an example API, example deployment code (in AWS CDK[2]), and extensive documentation are all available on GitHub[3]; bug reports and pull requests are welcome. Best, -- Jack [1]: https://hackage.haskell.org/package/wai-handler-hal-0.1.0.0 [2]: https://aws.amazon.com/cdk/ [3]: https://github.com/bellroy/wai-handler-hal

1 0

Re: [Haskell-cafe] Haskell function composition commutivity?
by Dominic Steinitz 15 Apr '21

15 Apr '21

I’d recommend *not* reading Categories for the Working Mathematician unless you are a mathematician (lots of background assumed) and even then it’s a bit of a dull read. Dominic Steinitz dominic(a)steinitz.org http://idontgetoutmuch.org Twitter: @idontgetoutmuch > From: Viktor Dukhovni <ietf-dane(a)dukhovni.org> > To: haskell-cafe(a)haskell.org > Subject: Re: [Haskell-cafe] Haskell function composition commutivity? > Message-ID: <YHYPMnJcYzdEolzl(a)straasha.imrryr.org> > Content-Type: text/plain; charset=us-ascii > > On Tue, Apr 13, 2021 at 02:19:46PM -0500, Galaxy Being wrote: > >> Your answers seem to originate outside of normal Haskell tutorials. Where >> can I start with this higher superset theory? > > There's a reason why the tutorials don't cover this, the categorical > foundations of Haskell types are not beginner material. It is perhaps > best to defer going down this rabbit hole until you're more comfortable > with the Haskell generally. > > You could start with: > > https://bartoszmilewski.com/2014/10/28/category-theory-for-programmers-the-… > https://bartoszmilewski.com/2015/04/07/natural-transformations/ > > For the Yoneda Lemma specifically, I'd recommend: > > http://blog.sigfpe.com/2006/11/yoneda-lemma.html > > Parametricity is covered in "Theorems for free": > > https://www2.cs.sfu.ca/CourseCentral/831/burton/Notes/July14/free.pdf > > but it is by no means elementary, though skimming it for the essential > facts and skipping the gory details is not too difficult. > > You could also read "Categories for the Working Mathematician" by > Saunders Mac Lane.

2 1

serialized data structures (Was: Generalized, named, and exportable default declarations)
by Olaf Klinke 14 Apr '21

14 Apr '21

> We have seen a lot of effort of better integrating Text into Haskell > programming. The only purpose of doing so is to replace String by > something more space and time efficient. What would happen if we invest > equally much time into making String as efficient as Text? At ICFP 2019 I > attended a talk about Gibbon: > > https://github.com/iu-parfunc/gibbon > > The idea of the project is to serialize (Haskell's) tree data structures > in memory as much as possible. Wouldn't this enable us to use String > instead of Text, again, maybe even lists instead of Vectors? No more Text > integration efforts, no more external library with GHC-specific manual > optimizations. Unfortunately, the project is still in an early stage. So > far, it only supports strict data structures. > > What if we would not complicate the language and generalize syntactic > sugar for Text, but instead improve data layout for all Haskell types and > eventually make a custom Text type unnecessary? So essentially Gibbon's aim is to make String work like Text under the hood, without me having to worry about it? +1 for that! Probably I should not comment on this, because I know too little about compilers and serialization. But having to expect something like OverloadedStrings for arbitrary type classes, plus which effect import statements have on this, puts extra cognitive load on the programmer. In contrast, the direction taken by Gibbon removes worries, namely: How much memory penalty do I pay by using this easy-to-understand algebraic data type instead of a more low-level compact representation? I love GHC specifically for its ability to perform many optimizations that Icould not have come up with. Indeed the GHC devs should strive to make the default [*] types work better, as this aligns with the mission of the Haskell Foundation to promote and widen adoption of Haskell. Olaf [*] "default" as dictated by the language report.

2 2

Generalized, named, and exportable default declarations (GHC Proposal)
by Eric Seidel 14 Apr '21

14 Apr '21

Hi Cafe, The GHC Steering Committee is considering a proposal that would expand the typeclass defaulting mechanism to support arbitrary (single-parameter) classes, and enable exporting defaulting rules. It's received very little input from the community so far, which is a shame because it's trying to address a common complaint about Haskell's String situation. Under the proposal Data.Text could export a rule defaulting IsString to Text. Client modules would automatically import defaulting rules just like class instances, which would make ambiguous string literals automatically default to Text. Please take a look at the proposal and leave your feedback, even if it's just "Yes, this would make my life meaningfully better" (reaction emoji are great for this level of feedback). Gauging the amount of pain caused by problems like this, and weighing that against the cost of new features, is one of the harder parts of being on the Committee. PR: https://github.com/ghc-proposals/ghc-proposals/pull/409 Rendered: https://github.com/blamario/ghc-proposals/blob/exportable-named-default/pro…

6 6

Haskell function composition commutivity?
by Galaxy Being 14 Apr '21

14 Apr '21

I'm in chapter 4 of Bird's very interesting *Thinking Functionally with Haskell *and he has a problem at the end of the chapter where he lists these equations map f . take n = take n . map f map f . reverse = reverse . map f map f . sort = sort . map f map f . filter p = map fst . filter snd . map (fork (f,p)) filter (p . g) = map (invertg) . filter p . map g reverse . concat = concat . reverse . map reverse filter p . concat = concat . map (filter p) adding this caveat for the 3rd equation iff x <= y <=> f x <= f y and this for the 4th equation fork (f,g) x = (f x, g x) and for the 5th invertg satisfies invertg . g = id My confusion is over the commutative-ness of most of this but only anecdotally. With the particularly dense map f . filter p = map fst . filter snd . map (fork (f,p)) We have > :t (map myF . filter myP) Integral b => [b] -> [b] > :t (map fst . filter snd . map (myFork (myF,myP))) Integral b => [b] -> [b] Is there anything universal to be drawn from these anecdotal examples of seeming commutativity? My breakdown of the third equation shows the same type definition for both sides. Is this a way to find equality? All in all, Bird doesn't indicate that there are any underlying truths, just "almost" commutativity. LB

3 6

Re: [Haskell-cafe] What's the modern way to apply a polymorphic function to a Dynamic value in GHC 8.8 and onwards?
by YueCompl 13 Apr '21

13 Apr '21

Thanks to Vlad and Jaro, your solution of `apD` compiles, I think it should work. But unfortunately my real case is a little different / more complex, a MWE appears like this: ```hs holdEvent :: Dynamic -> Dynamic holdEvent (Dynamic t evs') = withTypeable t $ Dynamic typeRep (hcHoldEvent evs') where hcHoldEvent :: forall a. EventSink a -> IO (TimeSeries a) hcHoldEvent !evs = do !holder <- newIORef Nothing listenEvents evs $ writeIORef holder . Just return $ TimeSeries $ readIORef holder data EventSink a = EventSink { listenEvents :: (a -> IO ()) -> IO (), closeStream :: IO () } instance Functor EventSink where fmap = undefined newtype TimeSeries a = TimeSeries {readTimeSeries :: IO (Maybe a)} instance Functor TimeSeries where fmap = undefined ``` Now I'm clueless how to use the `withTypeable` trick to apply my polymorphic `hcHoldEvent` to `Dynamic`, naively written as in above, the error is: ```log src/PoC/DynPoly.hs:20:49: error: • Couldn't match expected type ‘EventSink a0’ with actual type ‘a’ ‘a’ is a rigid type variable bound by a pattern with constructor: Dynamic :: forall a. base-4.13.0.0:Data.Typeable.Internal.TypeRep a -> a -> Dynamic, in an equation for ‘holdEvent’ at src/PoC/DynPoly.hs:19:12-25 • In the first argument of ‘hcHoldEvent’, namely ‘evs'’ In the second argument of ‘Dynamic’, namely ‘(hcHoldEvent evs')’ In the second argument of ‘($)’, namely ‘Dynamic typeRep (hcHoldEvent evs')’ • Relevant bindings include evs' :: a (bound at src/PoC/DynPoly.hs:19:22) t :: base-4.13.0.0:Data.Typeable.Internal.TypeRep a (bound at src/PoC/DynPoly.hs:19:20) | 20 | withTypeable t $ Dynamic typeRep (hcHoldEvent evs') | ^^^^ ``` Thanks with best regards, Compl > On 2021-04-12, at 22:04, Jaro Reinders <jaro.reinders(a)gmail.com> wrote: > > I have no experience in this area, but this compiles: > > ``` > {-# LANGUAGE RankNTypes, ScopedTypeVariables #-} > import Type.Reflection > import Data.Dynamic > > appD :: forall f. Typeable f => (forall a. a -> f a) -> Dynamic -> Dynamic > appD f (Dynamic rep (x :: a)) = withTypeable rep (toDyn (f x)) > ``` > > Cheers, > > Jaro > On 2021-04-12, at 21:06, Vladislav Zavialov <vladislav(a)serokell.io> wrote: > > Would something like this work for you? > > import Type.Reflection > import Data.Dynamic > > apD :: Typeable f => (forall a. a -> f a) -> Dynamic -> Dynamic > apD f (Dynamic t a) = withTypeable t $ Dynamic typeRep (f a) > > - Vlad > >> On 12 Apr 2021, at 14:34, YueCompl via ghc-devs <ghc-devs(a)haskell.org> wrote: >> >> Dear Cafe and GHC devs, >> >> >> There used to be a "principled way with pattern match on the constructor": >> >> ```hs >> data Dynamic where >> Dynamic :: Typeable a => a -> Dynamic >> >> apD :: Typeable f => (forall a. a -> f a) -> Dynamic -> Dynamic >> apD f (Dynamic a) = Dynamic $ f a >> ``` >> Source: https://www.reddit.com/r/haskell/comments/2kdcca/q_how_to_apply_a_polymorph… >> >> >> But now with GHC 8.8 as in my case, `Dynamic` constructor has changed its signature to: >> >> ```hs >> Dynamic :: forall a. TypeRep a -> a -> Dynamic >> ``` >> >> Which renders the `apD` not working anymore. >> >> >> And it seems missing dependencies now for an older solution Edward KMETT provides: >> >> ```hs >> apD :: forall f. Typeable1 f => (forall a. a -> f a) -> Dynamic -> Dynamic >> apD f a = dynApp df a >> where t = dynTypeRep a >> df = reify (mkFunTy t (typeOf1 (undefined :: f ()) `mkAppTy` t)) $ >> \(_ :: Proxy s) -> toDyn (WithRep f :: WithRep s (() -> f ())) >> ``` >> Source: https://stackoverflow.com/questions/10889682/how-to-apply-a-polymorphic-fun… >> >> >> So, how can I do that nowadays? >> >> Thanks, >> Compl >> >> _______________________________________________ >> ghc-devs mailing list >> ghc-devs(a)haskell.org >> http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-devs >

2 6

What's the modern way to apply a polymorphic function to a Dynamic value in GHC 8.8 and onwards?
by YueCompl 12 Apr '21

12 Apr '21

Dear Cafe and GHC devs, There used to be a "principled way with pattern match on the constructor": ```hs data Dynamic where Dynamic :: Typeable a => a -> Dynamic apD :: Typeable f => (forall a. a -> f a) -> Dynamic -> Dynamic apD f (Dynamic a) = Dynamic $ f a ``` Source: https://www.reddit.com/r/haskell/comments/2kdcca/q_how_to_apply_a_polymorph… But now with GHC 8.8 as in my case, `Dynamic` constructor has changed its signature to: ```hs Dynamic :: forall a. TypeRep a -> a -> Dynamic ``` Which renders the `apD` not working anymore. And it seems missing dependencies now for an older solution Edward KMETT provides: ```hs apD :: forall f. Typeable1 f => (forall a. a -> f a) -> Dynamic -> Dynamic apD f a = dynApp df a where t = dynTypeRep a df = reify (mkFunTy t (typeOf1 (undefined :: f ()) `mkAppTy` t)) $ \(_ :: Proxy s) -> toDyn (WithRep f :: WithRep s (() -> f ())) ``` Source: https://stackoverflow.com/questions/10889682/how-to-apply-a-polymorphic-fun… So, how can I do that nowadays? Thanks, Compl

2 1

[ANN] tasty-bench-0.2.5: featherlight benchmark framework
by Andrew Lelechenko 12 Apr '21

12 Apr '21

I'm happy to announce a release of tasty-bench-0.2.5. It is a featherlight benchmark framework with API mimicking criterion and gauge. https://github.com/Bodigrim/tasty-bench#readme https://hackage.haskell.org/package/tasty-bench-0.2.5 * It supports GHCs from 7.0 to 9.2 alpha. Running benchmarks on a bleeding edge GHC is important to identify potential performance degradation before a compiler is released. * A build on a clean machine is 16 times faster than criterion and 4 times faster than gauge. A build without dependencies is 6 times faster than criterion and 8 times faster than gauge. One can build benchmarks on CI without wasting excessive resources. * Benchmarks can be written together with tests, and can itself be turned into a performance regression test suite. In fact our benchmarks are just regular tasty tests. * Comparisons between benchmarks are readily available out of the box: no external tools (like criterion-compare or bench-show) are required. One can compare results between runs and between individual benchmarks instead of squinting at absolute numbers. Best regards, Andrew

1 0

Taking over scenegraph
by Pippijn van Steenhoven 10 Apr '21

10 Apr '21

Hi all, I've revived http://hackage.haskell.org/package/scenegraph: https://github.com/homectl/lambdaray/tree/main/scenegraph. I'd like to take over maintenance of that package. I can't reach the original author (email address no longer exists). Also, I'm looking for people who would like to join me in working on it and a 3D rendering pipeline based on GPipe. Currently hanging out in #implicitcad on freenode. Cheers, Pippijn

2 1

[ANN] network-packet-linux 0.1.1.0
by Mads Rolsdorph 10 Apr '21

10 Apr '21

Dear Cafe, The network package [0] provides an extensible API for working with sockets. I'm pleased to announce network-packet-linux [1], a small helper package containing the types needed to use the network package with Linux packet sockets [2]. The documentation [3] provides a short example of using network and network-packet-linux for a simple packet sniffer. Have a great weekend! Mads [0] https://hackage.haskell.org/package/network [1] https://hackage.haskell.org/package/network-packet-linux [2] https://man7.org/linux/man-pages/man7/packet.7.html [3] https://hackage.haskell.org/package/network-packet-linux-0.1.1.0/docs/Netwo…

1 0