- Haskell-Cafe - Haskell.org

Fwd: Re: 123
by Dmitriy Matrosov 24 Aug '17

24 Aug '17

And even sent the answer not to the list.. Huh. -------- Forwarded Message -------- Oops, i forgot to change the subject. Sorry! On 08/16/2017 09:01 PM, Jack Henahan wrote: > > Some mostly unrelated thoughts: > > An instance head has the form `T a_1 ... a_n`, and the constraint can only > apply to the `a_i`s. Consider the Show instance for > pairs. > > instance (Show a, Show b) => Show (a, b) -- Show ((,) a b) > > The constraints only act on the parameters of the type. > > It looks like you're taking the constraint to mean "whenever I have a Showable > `f String`, this is how to define a Show instance", but a constraint > actually means "use this rule to make a Show instance for any `A f`, and > it is an error if a Show instance for `f String` is not in scope". > > In the second error, you are making the strong claim that your Show > instance for `A f` holds for any `f` and `a`. Even if you could trick > the compiler into allowing that, I don't think it would actually express > the constraint that you want it to. > > Is there something a Show instance gets you that a pretty-print function wouldn't? Well, the `Show` was just an example. And examples with `A` was just a simplified versions, but perhaps oversimplified and hiding original intention. > {-# LANGUAGE RankNTypes #-} > {-# LANGUAGE GADTs #-} > {-# LANGUAGE StandaloneDeriving #-} > > import Control.Applicative > import Data.Monoid > import Data.Typeable I want to have a type with many records: > data Volume t = Volume > { _volName :: t String > , _volSize :: t Int > } > > showVolume :: (Show (t String), Show (t Int)) => Volume t -> String > showVolume x = "Volume " ++ show (_volName x) ++ ", " ++ show (_volSize x) with instances parametrized by some other type. E.g. i want to define a `Monoid` based on that other type properties: > instance Alternative t => Monoid (Volume t) where > mempty = Volume {_volName = empty, _volSize = empty} > x `mappend` y = Volume > { _volName = _volName x <|> _volName y > , _volSize = _volSize x <|> _volSize y > } and i may use this like > v1 :: Alternative t => Volume t > v1 = Volume {_volName = pure "vol1", _volSize = empty} > v2 :: Alternative t => Volume t > v2 = Volume {_volName = pure "vol2", _volSize = pure 200} *Main> showVolume (v1 <> v2 :: Volume Maybe) "Volume Just \"vol1\", Just 200" *Main> showVolume (v1 <> v2 :: Volume []) "Volume [\"vol1\",\"vol2\"], [200]" But then i want to define a GADT, which has different behaviors depending on argument type. So different records, depending on their type, will behave differently. > data Config a where > Empty :: Config a > Name :: Last String -> Config String > Size :: Num a => Sum a -> Config a > deriving instance Show a => Show (Config a) > instance Monoid (Config a) where > mempty = Empty > (Name x) `mappend` (Name y) = Name (x `mappend` y) > (Size x) `mappend` (Size y) = Size (x `mappend` y) > x `mappend` Empty = x > Empty `mappend` y = y but i can't even define a `Functor` instance for this type, because `case` branches have different type and `Functor` laws won't hold.. Hm.. instance Functor Config where fmap f Empty = Empty --fmap f (Name s) = case cast f of -- Just g -> case (g s) of -- Just s' -> Name s' -- _ -> Empty -- Nothing -> Empty The other problem is with instances for classes requiring type of kind `*`. I'll end up with what i've asked before: instance (Show a, Show (t a)) => Show (Volume t) where Well, i didn't write that before asking, so i realize all these problems only now (i even forgot to change the subject, what else to say?). And now i don't even sure what the proper subject should be. So thanks and never mind, i need to try more to figure out what to ask. > > Dmitriy Matrosov <sgf.dma(a)gmail.com> writes: > >> Hi. >> >> Is there a way to avoid `UndecidableInstances` in following code: >> >> data A f = A {_a1 :: f String} >> >> instance Show (f String) => Show (A f) where >> >> it does not compile with >> >> 1.hs:4:10: error: >> • The constraint ‘Show (f String)’ >> is no smaller than the instance head >> (Use UndecidableInstances to permit this) >> • In the instance declaration for ‘Show (A f)’ >> >> Though, initially, this was >> >> {-# LANGUAGE RankNTypes #-} >> >> data A f = A {_a1 :: f String} >> >> instance forall f a. Show (f a) => Show (A f) where >> >> which also does not compile with >> >> 1.hs:5:10: error: >> • Variable ‘a’ occurs more often >> in the constraint ‘Show (f a)’ than in the instance head >> (Use UndecidableInstances to permit this) >> • In the instance declaration for ‘Show (A f)’ >> >> The error is different and i don't sure, that this two cases are related. >> >> I want these instances to make a type with many records parametrized by >> `Alternative` type, e.g. >> >> data Volume t = Volume >> { _volName :: t Name >> , _volSize :: t Size >> , _volPath :: t Path >> , _pool :: t Pool >> } >> >> When i try to make instances, which require `*` type, i will end with >> above cases. > > > -- > Jack >

2 2

Experience Report (and [Hiring])
by David Turner 23 Aug '17

23 Aug '17

Hi all, In answer to @snoyberg's call to action a few months back ( https://www.snoyman.com/blog/2017/04/haskell-success-stories) I have written up an experience report and survey results from Tracsis where I currently work: https://davecturner.github.io/2017/08/21/haskell-experience.html Also if you are interested in developer jobs in sunny Leeds and fancy joining our growing team of Haskell developers then there are links in the post with contact information and more details. We're hiring at all levels from fresh graduates up to a new Principal Developer. Please get in touch with me and/or Andrew Handley (CCd) if you'd like to ask any questions. Cheers, David

1 0

Haskell - convert postfix expression to binary tree
by Martin Studna 22 Aug '17

22 Aug '17

Hello, I am trying to convert postfix expression to binary tree. My function takes as argument a list of tokens (strings). Everytime I give the function any input, debugger writes a message: Non-exhaustive patterns in function "add". My idea was: read a token after token and determine, if it is an operator or an operand. If it is operand, don't save any node to the tree and store the number to the stack. Otherwise I create a node with an operator, pop symbols from stack, set them as children of new node and push the operator to stack. If the list of strings is empty, functions print the binary tree. Would someone explain to me, why the function gives non-exhaustive patterns error and how can I fix the function? data Tree = Leaf String | Empty | Node Tree String Tree deriving (Show) add :: Tree -> [String] -> [Tree] -> Tree add (Node l v p) [] stack = (Node l v p) add Empty (x:xs) [] | x `elem` ["*","-","+"] = add (Leaf x) xs [Leaf x] | otherwise = add Empty xs [Leaf x] add Empty (x:xs) (a:b:bs) | x `elem` ["*","-","+"] = add (Node b x a) xs (Leaf x:a:b:bs) | otherwise = add Empty xs (Leaf x:a:b:bs) add (Leaf x) token (a:b:bs) | x `elem` ["*","-","+"] = add (Node b x a) token (Leaf x:bs) | otherwise = Leaf x add (Node l v p) (x:xs) (a:b:bs) | x `elem` ["*","-","+"] = add (Node b x a) xs (Leaf x:bs) | otherwise = add (Node l v p) xs (Leaf x:a:b:bs) parse :: String -> Tree parse input = add Empty (words (toPostfix input)) []

2 1

[ANN] arrowp-qq: an arrowp refresh
by Jose Iborra López 22 Aug '17

22 Aug '17

Dear all, In case anyone finds it useful, there is a new version of arrowp in Hackage that improves the original with a much needed coat of fresh paint. Notable features include a new parser based on haskell-src-exts, a quasi quoter for arrow syntax, and improved desugaring for static choices. https://github.com/pepeiborra/arrowp <https://github.com/pepeiborra/arrowp> The package is in Hackage as **arrowp-qq** due to the impossibility to contact with Ross Paterson (Ross, if you are reading this, please send email!). https://hackage.haskell.org/package/arrowp-qq <https://hackage.haskell.org/package/arrowp-qq> For those of you reading this and wondering why would you want to use a preprocessor for something that GHC can already do, the short answer is that you probably don’t. Using the `proc` quasi quoter --------------------------- ``` addA :: Arrow a => a b Int -> a b Int -> a b Int addA f g = [proc| x -> do y <- f -< x z <- g -< x returnA -< y + z |] ``` Comparison with **arrowp** ----------------------- **arrowp-qq** extends the original **arrowp** in three dimensions: 1. It replaces the `haskell-src` based parser with one based on `haskell-src-exts`, which handles most of GHC 8.0.2 Haskell syntax. 2. It provides not only a preprocessor but also a quasiquoter, which is a better option in certain cases. 3. It extends the desugaring to handle static conditional expressions (currently only if-then-else). Example: ``` proc inputs -> do results <- processor -< inputs if outputResultsArg then outputSink -< results else returnA -< () returnA -< results ``` The standard **arrowp** (and GHC) desugaring for this code is: ``` = ((processor >>> arr (\ results -> (results, results))) >>> (first (arr (\ results -> if outputResultsArg then Left results else Right ()) >>> (outputSink ||| returnA)) >>> arr (\ (_, results) -> results))) ``` This requires an `ArrowChoice`, but there is a more efficient desugaring which performs the choice at compile time and thus an `Arrow` suffices: ``` ((processor >>> arr (\ results -> (results, results))) >>> (first (if outputResultsArg then outputSink else arr (\ results -> ())) >>> arr (\ (_, results) -> results))) ``` Comparison with **GHC** ----------------------- The GHC desugarer does not do a very good job of minimizing the number of `first` calls inserted. In certain `Arrow` instances, this can have a material effect on performance. Example: ``` trivial = proc inputs -> do chunked <- chunk -< inputs results <- process -< chunked returnA -< results ``` This code ought to desugar to a chain of arrows, and indeed, both arrowp and arrowp-qq desugar this to: ``` trivial = chunk >>> process ``` However GHC will produce (approximately) the following code: ``` arr(\inputs -> (inputs,inputs)) >>> first chunk >>> first process >>> arr fst ``` Thanks, Jose Iborra

1 0

Prevent a type parameter from sharing some of its parameters with another parameter
by Timotej Tomandl 21 Aug '17

21 Aug '17

As the title says. Motivation: in a mutable code I want to keep some parameters strictly immutable, i.e. not sharing s with the whole mutable type I think this is best illustrated by 2 examples: 1. abstract example: imagine I have a type X a b c and another type Y a b and I want to prevent any case where the first parameter of X "a" is shared with it's third parameter "c" i.e. X a b (Y a a), X a b (Y a b), X a b (Y b a), X a b (Y a d) etc., any nestings in Y referencing a etc. but allow X a b (Y b b), X a b (Y b c) and any other combination not ruled out above 2. concrete example: imagine I have a type: Item s element key where s is used in the same way as in STRef s a, i.e. it cannot leak outside of a certain context, but I want the key to be immutable i.e. independent of s under any circumstences, so I can't write a type like: Item s element (STRef s refType) this is equivalent to disallowing X a b (Y a d) in 1. Is there any way to write a restriction like this in Haskell? -- Timo

3 3

Ternary infix expression parser
by Jeffrey Brown 20 Aug '17

20 Aug '17

I want to write a parser that lets someone write "(a #uses b) #because (c #needs d)" and read it into a tree: data Tree = Tree String Tree Tree | Leaf String magic "(a #uses b) #because (c #needs d)" = Tree "because" (Tree "uses" (Leaf "a") (Leaf "b")) (Tree "needs" (Leaf "c") (Leaf "d")) I thought I could use Text.Megaparsec.Expr for it, but now I realize it hadnles binary operations, and this is a ternary one. Suggestions? -- Jeff Brown | Jeffrey Benjamin Brown Website <https://msu.edu/~brown202/> | Facebook <https://www.facebook.com/mejeff.younotjeff> | LinkedIn <https://www.linkedin.com/in/jeffreybenjaminbrown>(spammy, so I often miss messages here) | Github <https://github.com/jeffreybenjaminbrown>

3 3

haskell-src-exts 8.2 compatible release
by Matthew Pickering 18 Aug '17

18 Aug '17

Hi all, I realise that people will be starting to use haskell-src-exts libaries with the new GHC 8.2 release. However, I do not have time in the foreseeable future (~ 1-2 months) to be able to implement the necessary parts to support the new language features. The way to make an 8.2 compatible release happen sooner is to send me some patches! There are some pull requests which I would like to merge but require minor changes or rebasing and also a few language features which need implementing. https://github.com/haskell-suite/haskell-src-exts/milestones/1.18 None of them look very difficult to implement unlike other language changes in past releases. I started to work on what was necessary a few months ago but didn't make a large amount of progress. https://github.com/haskell-suite/haskell-src-exts/tree/ghc-8.2 Anyone's help contributing to this important but menial library would be greatly appreciated. Thanks, Matt

2 1

[ANN] Speculate: automatically discover properties about Haskell functions generalization of counter-examples
by Rudy Matela 17 Aug '17

17 Aug '17

Hello, I am happy to announce Speculate. A library to automatically discover properties about Haskell functions. https://hackage.haskell.org/package/speculate Quick example -- discovering properties about addition and multiplication: $ cabal update $ cabal install speculate $ ghci > import Test.Speculate > speculate args{constants = [constant "+" (+), constant "*" (*)]} _ :: Integer (+) :: Integer -> Integer -> Integer (*) :: Integer -> Integer -> Integer x + y == y + x x * y == y * x (x + y) + z == x + (y + z) (x * y) * z == x * (y * z) (x + x) * y == x * (y + y) x <= x * x Speculate is similar to QuickSpec, but uses a different algorithm to produce inequalities and coditional equations -- see README for details. Speculate is available on both Stackage (nightly) and Hackage. -- Rudy

1 0

Re: [Haskell-cafe] cabal update problem?
by Jonathon Delgado 17 Aug '17

17 Aug '17

01-index.tar.gz is also 4 times the size of 00-index.tar.gz

2 2

DataHaskell impromptu workshop at ICFP'17 ?
by Marco Zocca 17 Aug '17

17 Aug '17

Dear all, among those that will attend the last three days of ICFP (i.e. the Haskell symposium and CUFP), are there people who would be interested in meeting to discuss possible future directions for the DataHaskell project? Looking forward to your feedback; Best, Marco

2 1