April 2017 - Haskell-Cafe

Archival of community.haskell.org
by Mario Rogic 19 May '18

19 May '18

Hi all As announced back in 2015 <http://blog.haskell.org/post/7/the_future_of_community.haskell.org/> we have started archiving community.haskell.org services. We've created https://archives.haskell.org/, and the old projects mailing lists have been the first to be archived. Next on the list is the remainder of projects.haskell.org, and the code.haskell.org site. As always, you can email admin(a)h.o or hop on the #haskell-infrastructure freenode channel to provide feedback / concerns. Thanks - Mario

1 2

Join a transformer
by Michael Snoyman 11 Apr '18

11 Apr '18

I'm wondering if this pattern exists and has a name. We have the concept of joining a Monad: join :: Monad m => m (m a) -> ma How about joining a monad transformer? joinT :: (Monad m, MonadTrans t) => t (t m) a -> t m a I believe implementing this in terms of MonadTransControl[1] might be possible, but I was wondering if there's an already existing idiom for this. Michael [1] http://haddocks.fpcomplete.com/fp/7.4.2/20130301-40/monad-control/Control-M…

5 5

PatternSignatures (rant)
by Johannes Waldmann 06 Apr '18

06 Apr '18

Dear all, (this is a rant - please ignore) why has "PatternSignatures" been renamed to "ScopedTypeVariables" (in ghc-6.10)? show me the alleged "type variable" in this code: do x :: Int <- [ 1 .. 10 ] ; return $ x^2 and why on earth do I need to use a language extension at all to get to the most basic thing of declarative programming: to declare the type of an identifier? This seriously hurts (me, at least) when teaching Haskell. Thanks - J.W.

4 4

Source code location in IO?
by Tom Ellis 30 Jun '17

30 Jun '17

Is it compatible with the semantics of Haskell to have a function sourceLocation :: IO String which when run returns the source file location at which it is used? For example, suppose Main.hs is module Main where main = do putStrLn =<< sourceLocation putStrLn "Hello" putStrLn =<< sourceLocation It would print the following when run Main.hs:4 Hello Main.hs:6 and module Main where main = do let s = sourceLocation putStrLn =<< s putStrLn "Hello" putStrLn =<< s It would print the following when run Main.hs:4 Hello Main.hs:4 If this is not compatible with the semantics of Haskell, why not? I agree that the two programs must have the same denotation, but is there anything that requires them to have the same output when run? Tom

6 7

Why is Megaparsec treating these two operators differently?
by Jeffrey Brown 14 May '17

14 May '17

I used Text.Megaparsec.Expr to write a minimal (56 lines) 2-operator recursive parser. It's on github[1]. It outputs a binary tree of the following form: data AExpr = Var String | Pair AExpr AExpr deriving (Show) The operator table supplied to makeExprParser defines two operators, # and ##. ## binds after #, but both of them refer to the same function, the Pair constructor of the AExpr data type: aOperators :: [[Operator Parser AExpr]] aOperators = [ [ InfixN # symbol "#" *> pure (Pair) ] , [ InfixN # symbol "##" *> pure (Pair) ] ] The # operator works in isolation: > parseMaybe aExpr "a # b" Just (Pair (Var "a") (Var "b")) Parentheses work with the # operator: > parseMaybe aExpr "(a # b) # (c # d)" Just (Pair (Pair (Var "a") (Var "b")) -- whitespace added by hand (Pair (Var "c") (Var "d"))) And the # and ## operators work together as intended: > parseMaybe aExpr "a # b ## c # d" Just (Pair (Pair (Var "a") (Var "b")) -- whitespace added by hand (Pair (Var "c") (Var "d"))) But the ## operator in isolation does not parse! > parseMaybe aExpr "a ## b" Nothing [1] https://github.com/JeffreyBenjaminBrown/digraphs-with-text/blob/master/howt… -- Jeff Brown | Jeffrey Benjamin Brown Website <https://msu.edu/~brown202/> | Facebook <https://www.facebook.com/mejeff.younotjeff> | LinkedIn <https://www.linkedin.com/in/jeffreybenjaminbrown>(I often miss messages here) | Github <https://github.com/jeffreybenjaminbrown>

3 6

GHC cross compilation survey
by Moritz Angermann 10 May '17

10 May '17

Dear friends, as some of you might have noticed, together with obsidian.systems, I’m trying to make cross compiling GHC a bit easier. To that extend, I’d like to invite you to fill out a short survey[1], so we understand the needs of the community better. Please follow the attached link and fill out the survey! Cheers, Moritz [1]: https://medium.com/@zw3rk/hello-world-a-cross-compilation-survey-890cb95029…

1 1

Partial type family application
by mniip 06 May '17

06 May '17

So I've been thinking of a type system extension: partial type family application. If we look at the type system used by modern GHC, in it, type family application is very distinct from constructor/constraint application: it is somewhat opaque in the sense that a type family must always appear fully applied. As such, it doesn't make sense to talk about a type family's kind, if we have: type family Id (a :: *) :: * where Id x = x then saying that 'Id :: * -> *' would be wrong, because Id cannot be used interchangeably with things that are truly of kind * -> *, such as Maybe or []. The reason for the "fully applied" restriction is that if we allowed partially applied type functions, then their equality would be undecidable. Still, I think, in a lot of cases we could benefit from partially applied type functions, even without extensional equality. Writing type level list folds, filters, zips, you name it. As stated above, we can't add the proposition 'Id :: * -> *' to our type system, so, what if, instead, we added a different kind of arrow kind for type families? I like the look of (~>), so 'Id :: * ~> *'. (~>) :: * -> * -> * This rule of inference, similar to the usual, would supersede all the type family kinding rules: f :: k ~> l, x :: k ------------------- f x :: l As such, the juxtaposition operator would very clearly have two different "kinds": (k -> l) --> k --> l and (k ~> l) --> k --> l, and there is no N-ary "type family application" operator. In order for the type checker to not fall apart, we need to have at least intesional (structural) equality on (~>), which we can have because it is decidable. We could then write stuff like type family Foldr (f :: k ~> l ~> l) (z :: l) (xs :: [k]) :: l where Foldr f z '[] = z Foldr f z (x ': xs) = f x (Foldr f z xs)

4 8

Cabal and IPv6
by Serguey Zefirov 02 May '17

02 May '17

I have found that Cabal does not work on IPv6-only networks (which my machine happen to be part of). The problem is basically this: "ping hackage.haskell.org" does not resolve host while "ping6 hackage.haskell.org" does. Thus cabal cannot do anything useful on that machine. Do anyone have a solution for that? I was unable to find any on the internet. ;)

6 9

hash map/associative structure
by Ketil Malde 30 Apr '17

30 Apr '17

Hi, I've been using Judy arrays as a fast and even more importatnly, compact associative structure. Infortunately, I'm getting occasional segfaults, and I'm unable to find anything wrong with my code. Others also report something similar. The Debian maintainer of libjudy made a version without some dubious optimizations, but that didn't help...at least not substantially. So the question is, what is a good replacement? I just need Word64 -> Integral, but again, I expect to fill all of main memory with data, so memory compactness is important. Anything using trees and boxed values (e.g. Data.IntMap and friends) out. I only need to be able to insert, modify (add one), and finally extract the key-value pairs (e.g. 'elems'). Any suggestions? -k -- If I haven't seen further, it is by standing in the footprints of giants

2 1

How can I find out which functions can be run on an expression?
by Julian Leviston 30 Apr '17

30 Apr '17

I'd like to programmatically find out which functions in a module could possibly apply to a particular expression. I also posted this to stack overflow. To make this concrete: {-# LANGUAGE TemplateHaskell #-} module Test where -- we'll import template-haskell from Lens -- so we can create prisms automatically for our 'AST' import qualified Control.Lens.TH as LTH --- some 'AST' in a toy language data CExp = CLit Int -- a literal integer | CAdd CExp CExp -- addition | CMul CExp CExp -- multiplication | CSub CExp CExp -- subtraction deriving Show -- an eval for our AST eval :: CExp -> Int eval exp = case exp of CLit i -> i CAdd e1 e2 -> eval e1 + eval e2 CMul e1 e2 -> eval e1 * eval e2 CSub e1 e2 -> eval e1 - eval e2 -- a function to build a sum using add with our AST, from a list of Int values listToSums :: [Int] -> CExp listToSums = foldr CAdd (CLit 0) . fmap CLit -- here we make prisms for looking at particular values -- in the CExp AST LTH.makePrisms ''CExp -- let's have an expression: theList1 :: CExp theList1 = listToSums [1..38] Now, at this point, I'd like a function that can give me a list of all the top level functions of a particular module (including this one) that are able to be applied to the expression theList1. This will include the prisms that were created with makePrisms. It would be fine if it uses the hint library's Interpreter monad. I've been experimenting with it a bit, and while I can get a list of all of the definitions at the top level of any module, and I can find the types of them, too (more or less), I'm a bit lost about how to pass an expression in as an argument to these functions then check if that exprssions will typecheck. If I can do that, I can run filter across all of the functions in a module, which lets me find out which ones are applicable. Many thanks in advance.

1 0