- Haskell-Cafe - Haskell.org

What is a Haskell way to implement flags?
by Branimir Maksimovic 19 Feb '13

19 Feb '13

In C usual way is to set some bit in integer variable by shifting or oring,and than check flag integer variable by anding with particular flag value.What is Haskell way? Thanks.

5 4

Free lunch with GADTs
by Tristan Ravitch 19 Feb '13

19 Feb '13

Hi cafe, I'm playing around with GADTs and was hoping they would let me have my cake and eat it too. I am trying to use GADTs to tag a type with some extra information. This information is very useful in a few cases, but the more common case is that I just have a list of items without the tags. Ideally I'll be able to recover the tags from the common case via pattern matching. What I have right now is: {-# LANGUAGE GADTs, ExistentialQuantification, EmptyDataDecls, RankNTypes, LiberalTypeSynonyms #-} data Tag1 data Tag2 data T tag where T1 :: Int -> T Tag1 T2 :: Double -> T Tag2 f1 :: [T t] -> Int f1 = foldr worker 0 where worker (T1 i) a = i+a worker _ a = a f2 :: [T Tag1] -> Int f2 = foldr worker 0 where worker :: T Tag1 -> Int -> Int worker (T1 i) a = a + i In f2 I can work with just values with one tag, but f1 is also important to me (working with the untagged values). f1 type checks but I do not know how to make a list [T t]. If I try the naive thing in ghci, it understandably tells me: > let l = [T1 5, T2 6.0] <interactive>:6:16: Couldn't match type `Tag2' with `Tag1' Expected type: T Tag1 Actual type: T Tag2 In the return type of a call of `T2' In the expression: T2 6.0 In the expression: [T1 5, T2 6.0] Fair enough. Is there any magical way to make this possible? I am hoping to avoid making a separate existential wrapper around my type. I know that approach works, but that would make the more common case much less convenient. I also remember trying to use a type synonym with -XLiberalTypeSynonyms: type SimpleT = forall tag . T tag I managed to basically get that working with another variant of my list processing function, but it required -XImpredicativeTypes, which apparently did very unfortunate things to type inference. Thanks

2 1

layers: A prototypical 2d platform game
by Daniel Trstenjak 19 Feb '13

19 Feb '13

Hi all, also if there's not that much to see and only a few minutes of gameplay, but after spending quite a few hours writing it, getting a feeling for Haskell and it's usage, perhaps it's in some way useful for someone, even if just for a few minutes of distraction. https://github.com/dan-t/layers Greetings, Daniel

4 6

Subject: ANNOUNCE: grid-3.0.1 (tile maps for board games or maths)
by Amy de Buitléir 19 Feb '13

19 Feb '13

I'm happy to announce a new major release of the grid package: http://hackage.haskell.org/package/grid https://github.com/mhwombat/grid/wiki (wiki) WHAT'S NEW: Functions for reporting the boundary and centre of bounded grid have been added, along with some miscellaneous new utility functions. IMPORTANT: The order of parameters for some functions has changed to make it easier to use them with map and fold operations. ABOUT GRID: Grid provides tools for working with regular arrangements of tiles, such as might be used in a board game or self-organising map (SOM). Grid currently supports triangular, square, and hexagonal tiles, with various 2D and toroidal layouts. If you need a tile shape or layout that isn't currently provided, please let me know. See Math.Geometry.Grid for an example of how to use the package. Suggestions for improvement are welcome.

2 2

FunPtr to C function with #arguments determined at runtime?
by Ryan Newton 19 Feb '13

19 Feb '13

Hello cafe, I've been poking around and I haven't seen this addressed anywhere except obliquely in the end of section 8.5.1 of the report, where it says that variable argument C functions aren't supported: http://www.haskell.org/onlinereport/haskell2010/haskellch8.html The scenario is pretty simple. I generate C code at runtime. I compile it to a .so. I know how many arguments it expects (but only at runtime), and I get a FunPtr back from 'dlsym'. How do I call it? I was hoping there would be some "Raw" lower level FFI layer that I could use to invoke a C function without automagic marshaling and all the other goodness provided by the normal "foreign import" mechanism. Failing that, will I just have to generate complex wrappers on the C side which I call N times to load up N arguments into some stateful container before finally launching the function? Thanks, -Ryan

5 6

adding recursion to a DSL
by fritsch＠joerg.cc 19 Feb '13

19 Feb '13

I have a tiny DSL that actually works quite well. When I say import language.CWMWL main = runCWMWL $ do out (matrixMult, A, 1, row, matrix-row) then runCWMWL is a function that is exported by language.CWMWL. This parses the experession and takes some action. Now, A is the name of the matrix and the third tuple element would represent the numbe of the row. For example 1 to 10000. I want to achieve some sort of "elegant" (means readable code, a good representation) recursion that would let me do something like sequence [ out (matrixMult, A, n, row, matrix-row) | n <- [1..1000] ] but in a nicer manner an without expending this to 10000 lines of code at compile time. How can I best introduce recursion into my DSL or borrow this from the host language Haskell "effectively"? --Joerg

3 2

Aeson + MongoDB, how to effortlessly store and retrieve json?
by Alfredo Di Napoli 19 Feb '13

19 Feb '13

Good evening guys, suppose I write a very simple parser using Aeson with these types and ToJSON / FromJSON instances: https://github.com/cakesolutions/the-pragmatic-haskeller/blob/master/01-jso… https://github.com/cakesolutions/the-pragmatic-haskeller/blob/master/01-jso… My question is simple: is it possible to "automagically" store the haskell data structure produced from the aeson encoding using http://hackage.haskell.org/packages/archive/mongoDB/1.3.2/doc/html/Database… Any tip/suggestion is welcome, Thanks, Alfredo

2 2

~ operator ?
by briand＠aracnet.com 18 Feb '13

18 Feb '13

Hi all, I was creating "bigger" uncurries which I am simply extending from an existing uncurry I found some where, e.g. uncurry4 :: (a -> b -> c -> d -> e) -> ((a, b, c, d) -> e) uncurry4 f ~(a,b,c,d) = f a b c d when I realized, what's the "~" for ? I've only been able to find a partial explanation that it involves preserving laziness, or something, maybe ? I was hoping someone could enlighten me. Thanks Brian

3 3

generalized, tail-recursive left fold that can finish tne computation prematurely
by Petr Pudlák 18 Feb '13

18 Feb '13

Dear Haskellers, while playing with folds and trying to implement `!!` by folding, I came to the conclusion that: - `foldr` is unsuitable because it counts the elements from the end, while `!!` needs counting from the start (and it's not tail recursive). - `foldl` is also unsuitable, because it always traverses the whole list. I came up with the following tail-recursive generalization of `foldl` that allows exiting the computation prematurely: foldlE :: (a -> c) -> (a -> b -> Either c a) -> Either c a -> [b] -> c foldlE f g = fld where fld (Left c) _ = c fld (Right a) [] = f a fld (Right a) (x:xs) = fld (g a x) xs `foldl` can be defined from it as foldl'' :: (a -> b -> a) -> a -> [b] -> a foldl'' f z = foldlE id ((Right .) . f) (Right z) and `!!` as: -- Checks for a negative index omitted for brevity. index :: Int -> [a] -> a index i = foldlE (error $ "No such index") f (Right i) where f 0 x = Left x f n _ = Right (n - 1) Is something like that already available somewhere? Best regards, Petr Pudlak

4 5

generalized, tail-recursive left fold that can finish tne computation prematurely
by Petr Pudlák 18 Feb '13

18 Feb '13

Dear Haskellers, while playing with folds and trying to implement `!!` by folding, I came to the conclusion that: - `foldr` is unsuitable because it counts the elements from the end, while `!!` needs counting from the start (and it's not tail recursive). - `foldl` is also unsuitable, because it always traverses the whole list. I came up with the following tail-recursive generalization of `foldl` that allows exiting the computation prematurely: foldlE :: (a -> c) -> (a -> b -> Either c a) -> Either c a -> [b] -> c foldlE f g = fld where fld (Left c) _ = c fld (Right a) [] = f a fld (Right a) (x:xs) = fld (g a x) xs `foldl` can be defined from it as foldl'' :: (a -> b -> a) -> a -> [b] -> a foldl'' f z = foldlE id ((Right .) . f) (Right z) and `!!` as: -- Checks for a negative index omitted for brevity. index :: Int -> [a] -> a index i = foldlE (error $ "No such index") f (Right i) where f 0 x = Left x f n _ = Right (n - 1) Is something like that already available somewhere? Best regards, Petr Pudlak

1 0