- Haskell-Cafe - Haskell.org

Re: [Haskell-cafe] rip in the class-abstraction continuum
by oleg＠okmij.org 21 May '13

21 May '13

Type classes are the approach to constrain type variables, to bound polymorphism and limit the set of types the variables can be instantiated with. If we have two type variables to constrain, multi-parameter type classes are the natural answer then. Let's take this solution and see where it leads to. Here is the original type class > class XyConv a where > toXy :: a b -> [Xy b] and the problematic instance > data CircAppr a b = CircAppr a b b -- number of points, rotation angle, radius > deriving (Show) > > instance Integral a => XyConv (CircAppr a) where > toXy (CircAppr divns ang rad) = > let dAng = 2 * pi / (fromIntegral divns) in > let angles = map ((+ ang) . (* dAng) . fromIntegral) [0..divns] in > map (\a -> am2xy a rad) angles To be more explicit, the type class declaration has the form > class XyConv a where > toXy :: forall b. a b -> [Xy b] with the type variable 'b' universally quantified without any constraints. That means the user of (toXy x) is free to choose any type for 'b' whatsoever. Obviously that can't be true for (toXy (CircAppr x y)) since we can't instantiate pi to any type. It has to be a Floating type. Hence we have to constrain b. As I said, the obvious solution is to make it a parameter of the type class. We get the first solution: > class XYConv1 a b where > toXy1 :: a b -> [Xy b] > > instance (Floating b, Integral a) => XYConv1 (CircAppr a) b where > toXy1 (CircAppr divns ang rad) = > let dAng = 2 * pi / (fromIntegral divns) in > let angles = map ((+ ang) . (* dAng) . fromIntegral) [0..divns] in > map (\a -> am2xy a rad) angles The type class declaration proclaims that only certain combinations of 'a' and 'b' are admitted to the class XYConv1. In particular, 'a' is (CircAppr a) and 'b' is Floating. This reminds us of collections (with Int keys, for simplicity) > class Coll c where > empty :: c b > insert :: Int -> b -> c b -> c b > > instance Coll M.IntMap where > empty = M.empty > insert = M.insert The Coll declaration assumes that a collection is suitable for elements of any type. Later on one notices that if elements are Bools, they can be stuffed quite efficiently into an Integer. If we wish to add ad hoc, efficient collections to the framework, we have to restrict the element type as well: > class Coll1 c b where > empty1 :: c > insert1 :: Int -> b -> c -> c Coll1 is deficient since there is no way to specify the type of elements for the empty collection. When the type checker sees 'empty1', how can it figure out which instance for Coll1 (with the same c but different element types) to choose? We can help the type-checker by declaring (by adding the functional dependency c -> b) that for each collection type c, there can be only one instance of Coll1. In other words, the collection type determines the element type. Exactly the same principle works for XYConv. > class XYConv2 a b | a -> b where > toXy2 :: a -> [Xy b] > > instance (Floating b, Integral a) => XYConv2 (CircAppr a b) b where > toXy2 (CircAppr divns ang rad) = > let dAng = 2 * pi / (fromIntegral divns) in > let angles = map ((+ ang) . (* dAng) . fromIntegral) [0..divns] in > map (\a -> am2xy a rad) angles The third step is to move to associated types. At this stage you can consider them just as a different syntax of writing functional dependencies: > class XYConv3 a where > type XYT a :: * > toXy3 :: a -> [Xy (XYT a)] > > instance (Floating b, Integral a) => XYConv3 (CircAppr a b) where > type XYT (CircAppr a b) = b > toXy3 (CircAppr divns ang rad) = > let dAng = 2 * pi / (fromIntegral divns) in > let angles = map ((+ ang) . (* dAng) . fromIntegral) [0..divns] in > map (\a -> am2xy a rad) angles The step from XYConv2 to XYConv3 is mechanical. The class XYConv3 assumes that for each convertible 'a' there is one and only Xy type 'b' to which it can be converted. This was the case for (CircAppr a b). It may not be the case in general. But we can say that for each convertible 'a' there is a _class_ of Xy types 'b' to which they may be converted. This final step brings Tillmann Rendel's solution.

1 0

ghc-mod v2.0.1
by Kazu Yamamoto 21 May '13

21 May '13

Hi cafe! I have released ghc-mod v2.0.1. From this version, ghc-mod provides the ghc-mod library in addition to the ghc-mod command: http://hackage.haskell.org/package/ghc-mod http://mew.org/~kazu/proj/ghc-mod/en/ Enjoy! --Kazu

3 4

type-level integers for GHC
by Takayuki Muranushi 21 May '13

21 May '13

What is your recommendation for type-level integers? I'd like to use it to improve the unittyped, https://bitbucket.org/xnyhps/haskell-unittyped/ the library for physical dimension. Therefore, I need negative numbers, additions, but multiplications are not necessary. I've been looking forward for the type-nats extension of GHC, but I haven't been able to compile the type-nats branch. Just learned that it still takes a few month to merge the branch into the main. http://hackage.haskell.org/trac/ghc/wiki/Status/May13 Thijs, the original author of unittyped, has commited a branch that uses type-nats, but I can't try that out for the same reason. Best, -- Takayuki MURANUSHI The Hakubi Center for Advanced Research, Kyoto University http://www.hakubi.kyoto-u.ac.jp/02_mem/h22/muranushi.html

3 5

rip in the class-abstraction continuum
by Christopher Howard 21 May '13

21 May '13

Hi. I won't pretend to be an advanced Haskell programmer. However, I have a strong interest in abstraction, and I have been playing around with programming as abstractly as possible. Naturally, I find classes to be quite attractive and useful. However, something is bothering me. Lately I keep running into this situation where I have to cut across abstraction layers in order to make the code work. More specifically, I keep finding that I have to add constraints to a class definition, because eventually I find some instance of that class which needs those constraints to compile. For example, I wanted to create a class which represents all things that can be converted into X,Y coordinates. Naturally, I would like to do something like this: code: -------- class XyConv a where toXy :: a b -> [Xy b] -------- This leaves me free in the future to use any number type conceivable in the Xy coordinates - Floating or Integral types, or whatever. (Doesn't even have to be numbers, actually!) However the first instance I create, requires me to use operators in the function definition which require at least a Floating type. (The error will say Fractional, but there are other components that also require Floating.) code: -------- data CircAppr a b = CircAppr a b b -- number of points, rotation angle, radius deriving (Show) instance Integral a => XyConv (CircAppr a) where toXy (CircAppr divns ang rad) = let dAng = 2 * pi / (fromIntegral divns) in let angles = map ((+ ang) . (* dAng) . fromIntegral) [0..divns] in map (\a -> am2xy a rad) angles -------- This gives me the error code: -------- Could not deduce (Fractional b) arising from a use of `/' from the context (Integral a) bound by the instance declaration at /scratch/cmhoward/pulse-spin/pulse-spin.hs:51:10-42 Possible fix: add (Fractional b) to the context of the type signature for toXy :: CircAppr a b -> [Xy b] or the instance declaration In the expression: 2 * pi / (fromIntegral divns) In an equation for `dAng': dAng = 2 * pi / (fromIntegral divns) In the expression: let dAng = 2 * pi / (fromIntegral divns) in let angles = map ((+ ang) . (* dAng) . fromIntegral) [0 .. divns] in map (\ a -> am2xy a rad) angles -------- I can get a quick fix by adding Floating to the context of the /class/ definition: code: -------- class XyConv a where toXy :: Floating b => a b -> [Xy b] -------- But what I really want is to put Floating in the context of the /instance/ declaration. But I don't know how to do that syntactically. -- frigidcode.com

2 2

Failure deriving MonadRWS when using a type-family for the State part
by Nicolas Trangez 20 May '13

20 May '13

All, The following code results in a compilation error (I tried GHC 7.4.1 & a 7.7.20130430 build): {-# LANGUAGE TypeFamilies, GeneralizedNewtypeDeriving, StandaloneDeriving #-} module Main where import Control.Applicative import Control.Monad.RWS data C = C data E = E data S1 = S1 Int type family I a :: * type instance I S1 = Int newtype T a s m r = T { unT :: RWST C [E] (I s) m r } deriving ( Functor , Applicative , Monad , MonadReader C , MonadWriter [E] , MonadState (I s) , MonadRWS C [E] (I s) , MonadTrans ) Error: No instance for (MonadState (I s) (T a s m)) arising from the 'deriving' clause of a data type declaration Possible fix: use a standalone 'deriving instance' declaration, so you can specify the instance context yourself When deriving the instance for (MonadRWS C [E] (I s) (T a s m)) Commenting out the MonadRWS line from the derivings list (i.e. the line pointed at by the error) works as expected. I was somehow unable to get a suitable standalone-deriving clause working, so didn't test that. Is this expected? Regards, Nicolas

1 1

Stuck on design problem
by Nicolas Trangez 20 May '13

20 May '13

All, Since I'm stuck on a coding problem and can't figure out how to proceed, I decided to call for help. I'm unable to get some code to typecheck, so maybe I'm missing something obvious on the implementation side, or more likely the design is completely wrong. Here's the idea: I have some code which uses some log of "Entry a" values (for some polymorphic type 'a'), and provides actions which output "Command a" values which should be interpreted by some wrapper code, e.g. adding some new entries to the log. These actions are implemented in a custom WriterT transformer (in this demo code, the original is more complex) to output Commands, while the inner monad should give access to the log entries (this could be in-memory like in the example, or stored on disk so using IO). You can find a trimmed-down version at https://gist.github.com/NicolasT/4230251f4f87f110d197 This doesn't type-check, and I'm not sure how to proceed. Am I taking a wrong approach? Do I need a different design? Thanks, Nicolas

3 4

DSL to English and back for game rule set?
by Matthew O'Connor 20 May '13

20 May '13

Hello all, I recognize this isn't directly a Haskell-related question, but as I'd like to solve this problem in Haskell & figured it's applicable. Let me know if there's a better place to ask. I am interested in creating a DSL (or set of types) for describing rules for a computer game. I'd like the language to be able to be written out to readable and clear English. I'd also like to be able to recreate the representation by reading the English back in. The idea is that the DSL will be unambiguous in either English or its internal representation. My thinking is that this will avoid inconsistencies between the game rules and the text describing those rules to the players. I want the ruleset to be able to describe type of heroes and monsters, their abilities, the effects of their attacks, how they use resources, etc. I realize this may not be an efficient way to go about writing a game, but it seems like an interesting project. Some of my concerns are at what level the DSL should be written to allow for extensions for new heroes, monsters, etc. without having to just add very specific extensions every time a new hero or item is created. Does anyone have thoughts on how to proceed on this, previous work, and/or ways to investigate it? Thanks, Matthew

4 3

New Functional Programming Job Opportunities
by Functional Jobs 20 May '13

20 May '13

Here are some functional programming job opportunities that were posted recently: Test Engineer at Klarna http://functionaljobs.com/jobs/146-test-engineer-at-klarna Cheers, Sean Murphy FunctionalJobs.com

1 0

ANN: lambdabot-4.3
by James Cook 19 May '13

19 May '13

As discussed a couple months ago, I have assumed maintainership of Lambdabot and a a new release has been brewing for a while. It has now been Hackaged as lambdabot-4.3. There are quite a few changes in this release, mainly internal. Plugins written for older versions will require some fairly straightforward rewriting - the plugin interface is now based on a record rather than a type class, and makes use of some simple monad transformers to stabilize the API a bit in the face of future changes. There are many things I'd like to do to continue modernizing it, the most significant of which being that I'd like to overhaul the state storage system and break it down into smaller packages. Therefore, plugin-writers should consider this a bit of a stepping-stone release - in the not too distant future, another release will probably break the plugin API again. If you have open-source plugins, please let me know and I'll feed you patches to keep up with any changes coming down the pipeline. The most significant changes from the user's perspective are probably the expanded command line interface (try --help) and the changes to the eval plugin. Eval now uses Safe Haskell, and accepts a much wider array of user-supplied code - the "@let" command now accepts module imports, type declarations, class declarations, and instances, and will add clauses to existing function definitions when applicable. I apologize in advance that the documentation is still mostly in a state of non-existence. If anyone runs into issues, please report them to me. I can be reached through the following channels: - github "issues"[1] - e-mail, at this address - #haskell (I'm "mokus" there) - I'm not often present, but pretty much always connected and will see and eventually respond to PRIVMSGs. [1] https://github.com/mokus0/lambdabot/issues

1 0

More general "pattern matching"
by Tom Ellis 19 May '13

19 May '13

Suppose I have a Category C > import Prelude hiding ((.), id) > import Control.Category > > data C a b > > instance Category C where > (.) = undefined > id = undefined which has "products" in the sense that there exists a "factors" function with suitable properties > factors :: C a (b, c) -> (C a b, C a c) > factors = undefined Then I can define this interesting combinator > (~~) :: (C a b -> r) -> (C a c -> r') -> C a (b, c) -> (r, r') > (f ~~ g) h = let (l, r) = factors h in (f l, g r) which allows some form of "pattern matching", for example > a :: C z a > b :: C z b > c :: C z c > d :: C z d > e :: C z e > ((a, b), (c, (d, e))) = ((id ~~ id) ~~ (id ~~ (id ~~ id))) undefined and even > w :: C a w > x :: C a x > y :: C a y > z :: (C a z, C a z') > ((w, x), (y, z)) = ((id ~~ id) ~~ (id ~~ (id ~~ id))) undefined Does anyone have anything to say about this? I'm sure others must have come across it before. There's something very lensy going on here too. There's nothing special about 'Category's here, but it's an example where the structure is demonstrated nicely. It's a shame that the structure of the pattern must be duplicated on the left and right of the binding. Tom

1 0