- Haskell-Cafe - Haskell.org

Encrypting streamed data
by Ivan Lazar Miljenovic 11 Jul '17

11 Jul '17

I have a use case for needing to use public key cryptography to encrypt a large amount of data in a streaming fashion (get it out of a DB, encrypt, put into an AWS S3 bucket). The command-line gpg tool seems to be able to encrypt/decrypt data from stdin to stdout in a streaming fashion, but in my attempts to use it it seems very file-based for things like the keys to use (whereas I would prefer to be able to pass the public key as an actual value rather than a file; if nothing else because this is for tools that don't have email addresses to use and base their keys on for addressing). Is there an existing library that can achieve this using conduit/pipes/whatever? cryptonite-conduit only covers hashing, hOpenPGP is poorly documented and I can't work out how to use it ("just follow the types" is difficult when Haddock docs don't link to the required types (seems to be because it uses the "import Module as X" trick for re-exporting everything but then everything from those modules isn't available). Can anyone recommend a solution? -- Ivan Lazar Miljenovic Ivan.Miljenovic(a)gmail.com http://IvanMiljenovic.wordpress.com

8 17

Higher order functor package?
by Clinton Mead 11 Jul '17

11 Jul '17

Consider the illustrative code below: {-# LANGUAGE GADTs #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE KindSignatures #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE PolyKinds #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE UndecidableInstances #-} data Param = Param1 | Param2 data T (p :: Param) where TInt :: Int -> T Param1 TInteger :: Integer -> T Param1 TBool :: Bool -> T Param2 data U (p :: Param) where UDouble :: Double -> U Param1 UString :: String -> U Param2 data F (t :: Param -> *) where F :: t Param1 -> t Param2 -> F t f :: T a -> U a f (TInt x) = UDouble (fromIntegral x) f (TInteger x) = UDouble (fromIntegral x) f (TBool x) = UString (show x) class MyFunctor f where myFmap :: (forall a. t a -> u a) -> f t -> f u instance MyFunctor F where myFmap f (F x1 x2) = F (f x1) (f x2) deriving instance Show (U a) deriving instance (Show (t Param1), Show (t Param2)) => Show (F t) main = print $ myFmap f (F (TInt 42) (TBool False)) Basically this is a sort of "higher order" functor, but I can't seem to fit it into an ordinary functor. But it seems like I'm reinventing the wheel, as my code is suspiciously like `Functor` but only slightly different. Has this sort of class already been created and if so what package is it in?

8 10

I'm afraid of OverloadedLabels.
by Nikita Churaev 11 Jul '17

11 Jul '17

So gi-gtk is already using OverloadedLabels to fight the namespacing problem. What I'm afraid is that eventually people will pick up on this and stop using normal functions altogether. My problem with OverloadedLabels is that it is a class: if people start using it widely, the original modules of types are going to become even more privileged than they already are: only it will be canonically able to define functions which can be conveniently called, and everybody else will have to only define "second-class" normal functions or risk instance collisions. I mean yes, it's the same as in most OOP languages, but isn't it also bad? There must be a better way... Is there any alternative approach to name collisions coming?

7 11

Fwd: constraint inference
by Dmitry Olshansky 10 Jul '17

10 Jul '17

Sorry, I didn't copy to cafe... ---------- Forwarded message ---------- From: Dmitry Olshansky <olshanskydr(a)gmail.com> Date: 2017-07-07 9:24 GMT+03:00 Subject: Re: [Haskell-cafe] constraint inference To: Ivan Lazar Miljenovic <ivan.miljenovic(a)gmail.com> I am not sure why but when I didn't set RankNTypes I got an appropriate error. So I specified it. But if I write let { f :: (forall n. KnownSymbol n => Proxy n) -> String; f p = symbolVal p } then nothing is changed. 2017-07-07 9:11 GMT+03:00 Ivan Lazar Miljenovic <ivan.miljenovic(a)gmail.com>: > You've specified RankNTypes but aren't using it; did you mean "(forall > n. KnownSymbol n => Proxy n)" ? > > Typically in these situations you also can't partially apply it, so > you might need to make it "f p = symbolVal p". > > On 7 July 2017 at 15:50, Dmitry Olshansky <olshanskydr(a)gmail.com> wrote: > > Hello, cafe! > > > > If we have many constraints then compiling is sometimes too slow. > Especially > > if there are some type calculations. > > And I don't know how to divide this time among different source files > > because all constraints are checked only when we call a function. > > > > I tried to add constraint info into argument definition instead of the > > function signature but this trick is not working (see below). > > > > Is it (at least theoretically) possible to infer the constraint inside a > > function from the type of function's argument? > > > > ------------------------------------ > > $ stack ghci > > ---- GHCi, version 8.0.2: > > Prelude> import Data.Proxy > > Prelude Data.Proxy> import GHC.TypeLits > > Prelude Data.Proxy GHC.TypeLits> :set -XRankNTypes > > Prelude Data.Proxy GHC.TypeLits> let { f :: (KnownSymbol n => Proxy n) -> > > String; f = symbolVal } > > > > <interactive>:4:54: error: > > • No instance for (KnownSymbol n) arising from a use of ‘symbolVal’ > > Possible fix: > > add (KnownSymbol n) to the context of > > the type signature for: > > f :: (KnownSymbol n => Proxy n) -> String > > • In the expression: symbolVal > > In an equation for ‘f’: f = symbolVal > > ------------------------------------ > > > > Best regards, > > Dmitry > > > > > > _______________________________________________ > > Haskell-Cafe mailing list > > To (un)subscribe, modify options or view archives go to: > > http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe > > Only members subscribed via the mailman list are allowed to post. > > > > -- > Ivan Lazar Miljenovic > Ivan.Miljenovic(a)gmail.com > http://IvanMiljenovic.wordpress.com >

2 2

[ANN] [Reminder] Budapest Haskell Hackathon 2017, 29-30th July 2017
by Daniel Berecz 10 Jul '17

10 Jul '17

Hi everybody, Just a last reminder about our hackathon in Budapest at the end of July: Our local user group will hold a Haskell Hackathon in Budapest this year (this will be the second)! We will hold it from the 29th to the 30th of July (Saturday & Sunday). You can find out more on the following link: https://wiki.haskell.org/Budapest_Hackathon_2017 We will reguraly update the site with new information. If you decide to come, please fill out the following Google Form: https://goo.gl/forms/QjTNdXTD1aEOMEQU2 If you have a project, demo, or talk that you want to bring to the event please contact us, and we can talk about the details. You can find our contact info the events wiki site, or you can just contact me directly. The event will be open to people of all experience levels, from beginners to gurus. The only requisite is that you’re interested in the Haskell language, and want to hang out with us, and have a good time! Greetings from Daniel, and the other BP-HUG organizers.

1 0

Re: [Haskell-cafe] I'm afraid of OverloadedLabels.
by Anthony Clayden 10 Jul '17

10 Jul '17

> On Mon Jul 10 02:57:02 UTC 2017, Nikita Churaev wrote: > > You can maybe fix that up with FunDeps > > or TypeFamilies, but then you lose most of TDNR's > > benefits (esp not coping with existential quanted fields > > , which is typically a requirement to cope with > > OOP-style). > > What benefits exactly are lost? Hi Nikita, I'm not sure I (or anybody) has the energy for another round of the "records debate". The TDNR (ex-)proposal seems so attractive because it just doesn't consider in detail all the complexities. They're magically swept under the carpet with the special dot syntax. So you might expect TDNR would support all of the functionality with H98 field names, plus having multiple fields of the same name. But how? Note the comment on TDNR section 'The Proposal' "TDNR is not "overloading" in the sense of type classes." And there were plenty of complaints that it's confusingly similar-but-different to type classes. You could look at SPJ's re-working of TDNR [2010] as SORF [2013]: https://ghc.haskell.org/trac/ghc/wiki/Records/OverloadedRecordFields/SORF SORF took advantage of the new Symbol Kinds (not available in 2010), and tried to be more type-class-like, with the `Has` class. One of the motivations with SORF is "Records with polymorphic fields are very important in practice, so it would be a major wart not to support them." TDNR just didn't discuss higher-ranked types. It turned out that was just too hard, even for SORF. (Or rather for OverloadedRecordFields, which is what's being delivered from SORF.) SORF tries to tackle record update, for which TDNR said "However I propose not to apply it [TDNR] to record update. " I don't think our cousins in OOP would be impressed by a records system in which you can't write polymorphic record updates. (I.e. a method to update the `firstName` in any record that has that field.) Actually delivering improvements in GHC around records is being painfully slow. `DuplicateRecordFields` has eased the pain a little. Ironically `OverloadedRecordFields` doesn't tackle higher-ranked types, nor record updates. And needs special syntax `#firstName`. So perhaps TDNR's "benefits" were never achievable? ANtC

1 0

Re: [Haskell-cafe] I'm afraid of OverloadedLabels.
by Anthony Clayden 10 Jul '17

10 Jul '17

> On Mon Jul 10 00:16:02 UTC 2017, Richard A. O'Keefe wrote: > ... > As a native speaker of an SVO language (English) > in a country where one of the official languages is VSO (Māori), > I sometimes find the OVS structure of > "mainstream OO languages" a little uncomfortable... > "Backward ran sentences until reeled the mind." lol. That's a cute comparison. I don't think "mainstream OO" is OVS. In: > ... button.colour <- red Gloss: 'button's colour goes red'. `button's colour` is the grammatical Subject. (Yes it represents an OOP 'Object.method', but that's because everything in OOP is an 'Object'; and the only way to access is by methods.) > ... button.reset Again `button` is the grammatical Subject. (It must be, because there's no grammatical Object.) Then `reset` must be the verb, used intransitively. (In French you'd use a reflexive: `the button resets itself`.) This dot-suffixing is already in Haskell: Data.ByteString.Lazy.Builder.Extras 'Data's ByteString's Lazy's Builder's Extras'. To me it seemed natural to carry on ....Extras.untrimmedStrategy.buffSize That is, a field is just a component that might have (sub-)sub-component(s). The field 'belongs to' the structure, so dot represents English possessive. And that's just how lenses look, deliberately. (But that's a mystifying pun on use of the dot: the dot changes from compound name separator to function composition.) But the outcry against TDNR's proposal for dot really was voiciferous. (And nobody paid so much attention to the semantics. So the flaw in TDNR wasn't discovered for a long time.) AntC

3 2

Re: [Haskell-cafe] I'm afraid of OverloadedLabels.
by Anthony Clayden 10 Jul '17

10 Jul '17

> On Sun Jul 9 20:37:23 UTC 2017, Alexis King wrote: > > On Jul 9, 2017, at 10:36, Ertugrul Söylemez <esz at posteo.de> wrote: > > > AND PLEASE not the way an [existing proposal] suggests to do it! > > Please let's just do ad-hoc overloading. There is no reason to > > introduce new syntax, because syntax is completely orthogonal > > to this problem. > > > > [existing proposal]: > > https://prime.haskell.org/wiki/TypeDirectedNameResolution Folks, that is not an existing proposal. SPJ's write-up is seductive, but fatally flawed, as Edward Kmett pointed out during the OverLoadedRecordFields development work. Quite apart from its relying on special syntax, TDNR can't cope with nested records. In: > ... student.course.instructor ... the `.course.instructor` is irresolvably ambiguous, in exactly the same way as `(show . read)`. You can maybe fix that up with FunDeps or TypeFamilies, but then you lose most of TDNR's benefits (esp not coping with existential quanted fields, which is typically a requirement to cope with OOP-style). > If I understand correctly, what youre proposing is the syntax-free > variant of TDNR, which is already outlined here: > https://ghc.haskell.org/trac/ghc/wiki/SyntaxFreeTypeDirectedNameResolution I think everyone should read the accompanying discussion. That turned out to be not an 'outline' but just a piece of wishful thinking. It has all the flaws of the original TDNR, plus a few of its own. > I agree that would be a very nice feature to have, and I think doing it > without new syntax would be strongly preferable to adding new syntax. > The proposal outlines the basics of how it would work, but I have no > idea how difficult it would be to implement in practice. Quite. AntC

2 1

Re: [Haskell-cafe] I'm afraid of OverloadedLabels
by Anthony Clayden 10 Jul '17

10 Jul '17

> On Sun Jul 9 21:04:33 UTC 2017, MarLinn wrote: > ... > Isn't it about time to allow explicit imports, and more importantly, > explicit non-imports for instances? > Some time ago I fantasised about some special syntax for this, > calling the (very rough) idea "aspects" ... Sorry, I didn't realise that "aspects" thread was about controlling instance scope. I did try to start a thread on instance scope a few days ago https://mail.haskell.org/pipermail/haskell-cafe/2017-July/127435.html I am interested in use cases for scope-controlling instances. Specifically I'm not seeing how scoping instances (instances of what, exactly?) helps with the "record problem". Typically if you have several record types with the same-named field, you want all of those to be in scope, where the field-access gets resolved according to the record's type. The `DuplicateRecordFields` extension now provides reasonable support for that, doesn't it? AntC

1 0

Collision Detection
by Yotam Ohad 10 Jul '17

10 Jul '17

Dear Cafe, I am thinking about writing a small physics engine with collision detection and I wanted to go over my ideas with you to help me refine them. I want to express objects as a group of inequalities and their domain. For example, a sphere would be only one inequality: x^2+y^2+z^2 -1 <= 0 on the whole domain. That way, to check a collision between two objects, one needs to check if at least one pair of inequalities with overlapping domains has a solution. I am unsure about how to express the inequalities in a way that could still allow me to compare between two of them. To add forces in, I think I can express them by adding a time dimension to the inequalities. For example, a constant force in the x-dimension on the previous sphere could be represented as (C+dx/dt*t+0.5*a*t^2)^2+y^2+z^2 <= 0. But then I am not sure about how to treat non-integrable forces. Another approach is to calculate the displacement of the object after each time interval. I don't like this approach as I want to integrate it with FRP in the end, and FRP continues time is something I would like to preserve. After I'll have everything above sorted, the next things would be to run simulations. I think at the start I'll check every pair of objects and try to calculate whether or not the will collide in the future. I'll save all the results in ascending time order. and every iteration, update the movement after the closest collision and update the collision pair order. Thanks, Yotam

3 2