- Haskell-Cafe - Haskell.org

category design approach for inconvenient concepts
by Christopher Howard 22 Dec '12

22 Dec '12

Recently I read this article I happened across, about the categorical design pattern: http://www.haskellforall.com/2012/08/the-category-design-pattern.html Barely understood it, of course, but it was a rather intriguing concept. So now I'm looking at all my programming problems trying to make types that can be composed and that seem to fit the idea of a "category". However, what I'm wondering about is ideas that can be "composed" but that don't seem to fit the idea of "category", because they don't obey the associativity law. To give a specific example (pseudo code like, without any idea here of implementation or proper syntax): Say you created a type called "Component" (C for short), the idea being to compose Components out of other Components. Every C has zero or more connectors on it. Two Cs can be connected to form a new C using some kind of composition operator (say, <.>), provided there are enough connectors (one on each). Presumably you would need a "Fail" constructor of some kind to represent the situation when there is not enough connectors. Say you had a C (coupler) with two connectors, a C (thing) with one connector, and a C (gadget) with one connector. So you could have... (coupler <.> thing) <.> gadget Because the coupler and the thing would combine to create a component with one spare connector. This would then combine with the gadget to make the final component. However, if you did... coupler <.> (thing <.> gadget) Then thing and gadget combine to make a component with no spare connectors. And so the new component and the coupler then fail to combine. Associativity law broken. So, can I adjust my idea to fit the "category" concept? Or is it just not applicable here? Or am I just misunderstanding the whole concept? -- frigidcode.com

10 20

arr considered harmful
by Ryan Ingram 21 Dec '12

21 Dec '12

I know it's a bit of an 'intentionally provocative' title, but with the recent discussions on Arrows I thought it timely to bring this up. Most of the conversion from arrow syntax into arrows uses 'arr' to move components around. However, arr is totally opaque to the arrow itself, and prevents describing some very useful objects as arrows. For example, I would love to be able to use the arrow syntax to define objects of this type: data Circuit a b where Const :: Bool -> Circuit () Bool Wire :: Circuit a a Delay :: Circuit a a And :: Circuit (Bool,Bool) Bool Or :: Circuit (Bool,Bool) Bool Not :: Circuit Bool Bool Then :: Circuit a b -> Circuit b c -> Circuit a c Pair :: Circuit a c -> Circuit b d -> Circuit (a,b) (c,d) First :: Circuit a b -> Circuit (a,c) (b,c) Swap :: Circuit (a,b) (b,a) AssocL :: Circuit ((a,b),c) (a,(b,c)) AssocR :: Circuit (a,(b,c)) ((a,b),c) Loop :: Circuit (a,b) (a,c) -> Circuit b c etc. Then we can have code that examines this concrete data representation, converts it to VHDL, optimizes it, etc. However, due to the presence of the opaque 'arr', there's no way to make this type an arrow without adding an 'escape hatch' Arr :: (a -> b) -> Circuit a b which breaks the abstraction: circuit is supposed to represent an actual boolean circuit; (Arr not) is not a valid circuit because we've lost the information about the existence of a 'Not' gate. The arrow syntax translation uses arr to do plumbing of variables. I think a promising project would be to figure out exactly what plumbing is needed, and add those functions to a sort of 'PrimitiveArrow' class. All of these plumbing functions are trivially implemented in terms of 'arr', when it exists, but if it doesn't, it should be possible to use the arrow syntax regardless. -- ryan

9 13

MPTC or functional dependencies?
by Petr P 21 Dec '12

21 Dec '12

Dear Haskellers, I'm working on a small library for representing semigroup (or monoid) actions on a set <http://hackage.haskell.org/package/semigroups-actions>. The MultiParamTypeClasses extension seems to be best suited for the task, as a group can act on many sets, and a set can be acted on by different groups: -- | Represents an action of semigroup @g@ to set @a@. -- -- Laws: @'Endo' . 'act'@ must be a homomorphism of semigroups. class Semigroup g => SemigroupAct g a where act :: g -> (a -> a) But soon I realized that with MPTC the compiler has problems inferring types and I had to explicitly specify types when using `act` in many places. Because it seems that in most cases a set will have only a single group acting on it, I was thinking about using FDs: class Semigroup g => SemigroupAct g a | a -> g where But on the other hand, this can limit the generality of the type class. I cannot decide which one I should choose. What would you suggest? According to your experience, would you choose plain MPTC or FD? Best regards, Petr Pudlak

3 3

monoid pair of monoids?
by Christopher Howard 21 Dec '12

21 Dec '12

In my current pondering of the compose-able objects them, I was thinking it would be useful to have the follow abstractions: Monoids, which were themselves tuples of Monoids. The idea was something like so: code: -------- import Data.Monoid instance Monoid (Socket2 a b) where mempty = Socket2 (mempty, mempty) Socket2 (a, b) `mappend` Socket2 (w, x) = Socket2 (a `mappend` w, b `mappend` x) data Socket2 a b = Socket2 (a, b) -------- However, this does not compile because of errors like so: code: -------- Sockets.hs:9:21: No instance for (Monoid a) arising from a use of `mempty' In the expression: mempty In the first argument of `Socket2', namely `(mempty, mempty)' In the expression: Socket2 (mempty, mempty) -------- This makes sense, but I haven't figured out a way to rewrite this to make it work. One approach I tried was to encode Monoid constraints into the data declaration (which I heard was a bad idea) but this didn't work, even using forall. Also I tried to encode it into the instance declaration, but the compiler kept complaining about errant or illegal syntax. -- frigidcode.com

5 5

Hoogle index completeness
by Radical 21 Dec '12

21 Dec '12

Searching Hoogle for symbols like `rstrip` or `lstrip` produces "No results found" for me, even though they exist in the MissingH library. To wit: http://hackage.haskell.org/packages/archive/MissingH/1.2.0.0/doc/html/Data-… Is this behavior intentional, or a regression of some sort? I could have sworn the above symbols showed up at some point. Thanks! Alvaro

7 10

GHC shows wrong line number in error?
by Niklas Hambüchen 20 Dec '12

20 Dec '12

Hello, I have some code like this (the contents don't really matter): 42 data TestChain next = ChainEntry (forall b . TestG b) next 43 | ChainDescribe String (Free TestChain... 44 deriving (Functor) 45 46 -- deriving instance Show a => Show (TestChain a) 47 48 it :: (SomeT typ, Partition t typ) => String -> t -> ... 49 it desc test = liftF (ChainEntry (mkTestG test) ()) And get the error: Clean.hs:49:43: Could not deduce (t ~ b) from the context (SomeT typ, Partition t typ) bound by the type signature for it :: (SomeT typ, Partition t typ) => String -> t -> Free TestChain () at Clean.hs:49:1-51 `t' is a rigid type variable bound by the type signature for it :: (SomeT typ, Partition t typ) => String -> t -> Free TestChain () at Clean.hs:49:1 `b' is a rigid type variable bound by a type expected by the context: TestG b at Clean.hs:49:23 [...] In that last error line, should that not be "Clean.hs:42:..." (as it references the 'b', which I only really have there), or is that intended, and if yes, why? I'm using GHC 7.4.2. Thanks Niklas

3 2

An assembly DSL example.
by Tom Hawkins 20 Dec '12

20 Dec '12

A few folks have asked me about building EDSLs in Haskell for assembly programming, so I've posted an example of the approach we have had success using at BAE Systems. It's a bit rough, so if anyone's motivated to polish it up, by all means. https://github.com/tomahawkins/asm-dsl-example/ -Tom

2 1

Observer pattern in haskell FRP
by Nathan Hüsken 19 Dec '12

19 Dec '12

Hey, When writing games in other (imperative) languages, I like to separate the game logic from the rendering. For this I use something similar to the observer pattern. With rendering I mean anything only related to how objects are drawn to the screen. Animation state for example. On my journey of exploring game programming with haskell (and FRP), I wonder what a good way of archiving something similar would be. If the rendering has no internal state, one can just write a function draw :: GameLogicState -> IO () But when the rendering of an object has an internal state (e.g. animation frame) than this is not possible. Now I could write a Wire/Signal (whatever FRP implementation I use) that translates to a RenderingState: render :: Signal GameLogicState RenderingState draw :: RenderingState -> IO () which is fine, except when my game is made of many objects. Than I need to associate the state of one object in GameLogicState with a sub-signal in render. That could be done by giving every object an ID and letting GameLogicState contain a map from IDs to ObjectLogicState. I fear that when I really have a lot of objects, assembling and decomposing the map could become a major bottleneck. So I am wondering: Is there (or can someone think of) a different pattern by which this could be archived? Or asked different: How would you do it? Thanks! Nathan

5 17

containers license issue
by Dmitry Kulagin 19 Dec '12

19 Dec '12

Hi Cafe, I am faced with unpleasant problem. The lawyer of my company checked sources of containers package and found out that it refers to some GPL-library. Here is quote: "The algorithm is derived from Jorg Arndt's FXT library" in file Data/IntMap/Base.hs The problem is that FXT library is GPL and thus containers package can not be considered as BSD3. And it means that it can not be used in my case (closed source software). Is this logic actually correct and containers should be considered as GPL? The package is widely used by other packages and the only way I see right now is to fix sources to reimplement this functionality, which is not good option. Thank you!

15 45

Re: [Haskell-cafe] Tail recursive
by J.W. Krol 19 Dec '12

19 Dec '12

From: jkrzzz(a)live.com To: haskell-cafe(a)haskell.org Subject: Tail recursive Date: Wed, 19 Dec 2012 17:07:14 +0100 Hello, I need a non tail recursive version of scanl, to produce a large enough list of >100K vectors (vectors defined as a list) I have following code: scanl'::(a -> a -> a) -> a -> [a] -> [a]scanl' f q ls = scanl'' ls (q:[]) where scanl'' (x:xs) ys = let h = head ys x' = f x h ys' = x':ys in h `seq` x' `seq` ys' `seq` scanl'' xs ys' scanl'' [] ys = ys If I call this function as below I still got stack-overflow error: head (scanl' (zipWith (+)) ([0,0]) (take 100000 (repeat [0,1]))) What do I wrong. I am not an experienced Haskell programmer, but find the behavior quite unexplainable. Thank for your answer. RegardsJacq

2 1