- Haskell-Cafe - Haskell.org

ANNOUNCE: Graphalyze-0.11.0.0 and SourceGraph-0.7.0.0
by Ivan Lazar Miljenovic 24 Nov '10

24 Nov '10

I am pleased to announce the 0.7.0.0 release of my graph-theoretic source code analysis tool SourceGraph [1], and the library it uses Graphalyze 0.11.0.0 [2]. [1]: http://hackage.haskell.org/package/SourceGraph [2]: http://hackage.haskell.org/package/Graphalyze Changes in SourceGraph (apart from those resulting from improvements to Graphalyze): * Edge widths are now log-based rather than being the number of function calls; this avoids having absurdly thick edges. * Source files that were not able to be parsed are now listed both to stderror and in the resulting report (thus helping you work out why you're missing some code) * Also builds with Cabal-1.10; whilst I do not currently have GHC 7 installed anywhere and thus can't test this, I know of no reason why SourceGraph cannot be built with GHC 7 (unless it uses a library that isn't buildable on GHC 7 that I have no control over). Changes in Graphalyze: * Legends can now contain text-only fields rather than just graphs; also, the title of each legend is now displayed first rather than what it describes. * To fix a bug spotted by Han Joosten, the reports currently use Posix-style path separators even on Windows (otherwise, HTML documents produced on Windows were not in a state to be uploaded elsewhere). -- Ivan Lazar Miljenovic Ivan.Miljenovic(a)gmail.com IvanMiljenovic.wordpress.com

1 0

ANNOUNCE: graphviz-2999.11.0.0
by Ivan Lazar Miljenovic 24 Nov '10

24 Nov '10

I am pleased to announce version 2999.11.0.0 of graphviz [1], my Haskell bindings to the Graphviz suite of graph visualisation tools [2]. [1]: http://hackage.haskell.org/package/graphviz [2]: http://graphviz.org/ This release is mostly backwards-compatible (unless you dealt directly with Point and LayerList values); the changes are: * Improved documentation, including examples of how to use `GraphvizParams` values (since several people indicated that they found them confusing) * Addition of the `Labellable` class (and its method `toLabel`) to make it easier to construct labels. * Backslashes (i.e. the `\` character) are now escaped/unescaped properly (bug spotted by Han Joosten). As part of this: - Dot-specific escapes such as `\N` are now also handled correctly, so the slash does not need to be escaped. - Newline (`'\n'`) characters in labels, etc. are escaped to centred-newlines in Dot code, but not unescaped. * `Point` values can now have the optional third dimension and end in a `!` to indicate that that position should be used (as input to Graphviz). * `LayerList` uses `LayerID` values, and now has a proper `shrink` implementation in the test suite. -- Ivan Lazar Miljenovic Ivan.Miljenovic(a)gmail.com IvanMiljenovic.wordpress.com

1 0

ANN: dnscache - caching DNS resolver
by Ertugrul Soeylemez 24 Nov '10

24 Nov '10

Hello everybody, (second try, since the first mail somehow didn't arrive) I've just uploaded a caching DNS resolver library, which also includes a command line utility for quick mass DNS resolution: http://hackage.haskell.org/package/dnscache Although I've tested it throroughly it's still in beta phase. Feel free to play around with it. Feedback is highly appreciated. Thank you. Greets, Ertugrul -- nightmare = unsafePerformIO (getWrongWife >>= sex) http://ertes.de/

1 0

Re: [Haskell-cafe] Derived type definition
by Miguel Mitrofanov 24 Nov '10

24 Nov '10

Well, you can resort to functional dependencies, I guess... {-# LANGUAGE FlexibleInstances, FunctionalDependencies, MultiParamTypeClasses, UndecidableInstances #-} module FunDeps where data Rec a r = Rec a r data RecNil = RecNil data Wrapper a = Wrapper a class Wrapped r w | r -> w where i :: r -> w instance Wrapped RecNil RecNil where i RecNil = RecNil instance Wrapped r w => Wrapped (Rec a r) (Rec (Wrapper a) w) where i (Rec a r) = Rec (Wrapper a) (i r) type TTest = Rec Int (Rec String RecNil) type TTestWrapped = Rec (Wrapper Int) (Rec (Wrapper String) RecNil) a :: TTest a = Rec 1 (Rec "a" RecNil) f :: TTestWrapped -> (Int, String) f (Rec (Wrapper n) (Rec (Wrapper s) RecNil)) = (n, s) r = f (i a) ...but that would be just an awkward way to do the same thing, so, my advice: don't. Type families are much nicer. On the other hand, you could do your "Rec" type polimorphic in "wrapper"; assuming your real-life Wrapper is not just an identity, this would be worth considering: {-# LANGUAGE KindSignatures #-} module PolyM where data Rec a r w = Rec (w a) (r w) data RecNil (w :: * -> *) = RecNil data Wrapper a = Wrapper a -- in reality it should be something else newtype Identity a = Identity a class Wrapped r where i :: r Identity -> r Wrapper instance Wrapped RecNil where i RecNil = RecNil instance Wrapped r => Wrapped (Rec a r) where i (Rec (Identity a) r) = Rec (Wrapper a) (i r) type TTest = Rec Int (Rec String RecNil) Identity type TTestWrapped = Rec Int (Rec String RecNil) Wrapper a :: TTest a = Rec (Identity 1) (Rec (Identity "a") RecNil) f :: TTestWrapped -> (Int, String) f (Rec (Wrapper n) (Rec (Wrapper s) RecNil)) = (n, s) r = f (i a) 24.11.2010 12:24, kg пишет: > Ok, it's exactly what i hoped. > > And I would like to know (for fun) if it's possible to do it without type family extension. > I've tried ... without success. > > Thx. > > On 11/22/2010 10:46 PM, Miguel Mitrofanov wrote: >> Sure, it's possible with TypeFamilies. The following compiles OK: >> >> {-# LANGUAGE TypeFamilies #-} >> module TypeCalc where >> data Rec a r = Rec a r >> data RecNil = RecNil >> data Wrapper a = Wrapper a >> class TypeList t where >> type Wrapped t >> i :: t -> Wrapped t >> instance TypeList RecNil where >> type Wrapped RecNil = RecNil >> i RecNil = RecNil >> instance TypeList r => TypeList (Rec a r) where >> type Wrapped (Rec a r) = Rec (Wrapper a) (Wrapped r) >> i (Rec a r) = Rec (Wrapper a) (i r) >> type TTest = Rec Int (Rec String RecNil) >> type TTestWrapped = Rec (Wrapper Int) (Rec (Wrapper String) RecNil) >> a :: TTest >> a = Rec 1 (Rec "a" RecNil) >> f :: TTestWrapped -> (Int, String) >> f (Rec (Wrapper n) (Rec (Wrapper s) RecNil)) = (n, s) >> r = f (i a) -- so, "i a" is of the type TTestWrapped. >> >> >> On 22 Nov 2010, at 23:43, kg wrote: >> >>> Hi, >>> >>> I've tried to simplify as much as possible my problem. Finally, I think I can resume it like that: >>> >>> Suppose these following data types : >>> data Rec a r = Rec a r >>> data RecNil = RecNil >>> data Wrapper a = Wrapper a >>> >>> Then, we can build the following type: >>> type TTest = Rec Int (Rec String RecNil) >>> or this type: >>> type TTestWrapped = Rec (Wrapper Int) (Rec (Wrapper String) RecNil) >>> >>> Is it possible to build TTestWrapped from TTest ? >>> >>> >>> Thx in advance, >>> Antoine. >>> >>> _______________________________________________ >>> Haskell-Cafe mailing list >>> Haskell-Cafe(a)haskell.org >>> http://www.haskell.org/mailman/listinfo/haskell-cafe >>> >> _______________________________________________ >> Haskell-Cafe mailing list >> Haskell-Cafe(a)haskell.org >> http://www.haskell.org/mailman/listinfo/haskell-cafe >

1 0

Re: [Haskell-beginners] Problem "grouping" a list
by Aai 24 Nov '10

24 Nov '10

I don't know what this tuple is representing, but if you want to group you'll have to specify on 'what': - the tuple, - the fst or - the snd Here's a possibility with grouping on the fst import Data.List import Data.Ord import Data.Function groupAtoms :: (Float -> Bool) -> [(Float,Integer)] -> ([[(Float,Integer)]],[[(Float,Integer)]]) groupAtoms p = partition (p.sum. map fst). groupBy ((==)`on`fst). sortBy (comparing fst) Use: groupAtoms (>=1.0) myList If this is what you want: proper lists are in the fst of the result. Hallo João Paulo Pizani Flor, je schreef op 23-11-10 18:23: > Hello dear Haskellers! > > I've been a user and big fan of Haskell for a while, but only now I'm writing > my first "big" project in Haskell (some thousands of lines of code perhaps). > It's an interpreter for a programming language, the source code is music! Yes, > sheet music! :D > > OK, so my specific problem goes like this: I have a list of tuples > :t myList > [ (Float, Integer) ] > > And I want to "group" this list into a nested list > groupAtoms :: [ (Float,Integer) ] -> [ [(Float,Integer)] ] > > Of course, I want that the concatenation of the groups yield me the original > list, i.e, (foldl (++) [] . groupAtoms == id), and the criterion that defines > a group is that: > "The sum of the first elements in the tuples comprising the list must be > greater than or equal to 1.0". That is, given a list of tuples, the boolean > predicate deciding whether this list is a PROPER group (True) or TOO SMALL > (False) is: > \g -> sum (map fst g) >= 1.0 > > > Although the criterion is very clear, I've tried hard until now and couldn't > come up with a function for producing the nested list based on this grouping > criterion. I am sure that the Haskell Hierarchical Libraries have something > to help me, but only now I see I'm still a big noob :P > > Could someone please help me writing this function? > > > My best regards from Brazil, > > João Paulo Pizani Flor > joaopizani(a)gmail.com <mailto:joaopizani@gmail.com> > Federal University of Santa Catarina > > > _______________________________________________ > Beginners mailing list > Beginners(a)haskell.org > http://www.haskell.org/mailman/listinfo/beginners -- Met vriendelijke groet, =@@i

1 0

ANN: dnscache - caching DNS resolver
by Ertugrul Soeylemez 24 Nov '10

24 Nov '10

Hello everybody, I've just uploaded a caching DNS resolver library, which also includes a command line utility for quick mass DNS resolution: http://hackage.haskell.org/package/dnscache Although I've tested it throroughly it's still in beta phase. Feel free to play around with it. Feedback is highly appreciated. Thank you. Greets, Ertugrul -- nightmare = unsafePerformIO (getWrongWife >>= sex) http://ertes.de/

1 0

save the dates: SF Bay Area Haskell Hackathon: Feb 11~13, 2011
by Mark Lentczner 24 Nov '10

24 Nov '10

Bryan O'Sullivan and I are hosting a SF Bay Area Haskell Hackathon at the Hacker Dojo in Mountain View, California. Details are all sketchy at this point, but we plan on two components: 1) Haskell Project Hackathon 2) Learn Haskell Workshop See: http://wiki.hackerdojo.com/w/page/Haskell-Hackathon-2011 At this stage we're trying to gauge interest, size, and volunteers to help with organizing and running it. Either add yourself to that wiki page, or e-mail me. - Mark Lentczner Mark Lentczner http://www.ozonehouse.com/mark/ IRC: mtnviewmark

1 0

Another Quasi Quotation question
by jean-christophe mincke 23 Nov '10

23 Nov '10

Hello, I am still playing with template-haskell... I wonder, is there any reason why a quasiquoter cannot create haskell statements and declarations in addition to expressions and patterns? Or more generally create any legal Haskell syntax tree. I.e Suppose I would like to create a quasiquoter for the C language (please, imagine that it could be useful). I could write sth such as : [$c| int a = 6; int b = 7; int c = a +b; struct S { int x; int y} |] It could be nice to generate the appropriate haskell code: a = 6 b= 7 c= a + b data S = S { x::Int; y:Int} etc That would allow to really embed any kind of language in a more or less easy way into haskell, provided that code can be translated into legal haskell. Is there anything that prevent these features. Thank you Regards J-C

1 0

Musings on type systems
by Andrew Coppin 23 Nov '10

23 Nov '10

OK, so how do types actually work? Musing on this for a moment, it seems that declaring a variable to have a certain type constrains the possible values that the variable can have. You could say that a type is some sort of "set", and that by issuing a type declaration, the compiler statically guarantees that the variable's value will always be an element of this set. Now here's an interesting thought. Haskell has "algebraic data types". "Algebraic" because they are sum types of product types (or, equivilently, product types of sum types). Now I don't actually know what those terms mean, but proceeding by logical inferrence, it seems that Either X Y defines a set that could be described as the union or "sum" of the types X and Y. So is Either what is meant by a "sum type"? Similarly, (X, Y) is a set that could be considered the Cartesian product of the sets X and Y. It even has "product" in the name. So is this a "product type"? So not only do we have "types" which denote "sets of possible values", but we have operators for constructing new sets from existing ones. (Mostly just applying type constructors to arguments.) Notionally (->) is just another type constructor, so functions aren't fundamentally different to any other types - at least, as far as the type system goes. Now, what about type variables? What do they do? Well now, that seems to be slightly interesting, since a type variable holds an entire type (whereas normal program variables just hold a single value), and each occurrance of the same variable is statically guaranteed to hold the same thing at all times. It's sort of like how every instance of a normal program variable holds the same value, except that you don't explicitly say what that value is; the compiler infers it. So what about classes? Well, restricting ourselves to single-parameter classes, it seems to me that a class is like a *set of types*. Now, interestingly, an enumeration type is a set of values where you explicitly list all possible values. But once defined, it is impossible to add new values to the set. You could say this is a "closed" set. A type, on the other hand, is an "open" set of types; you can add new types at any time. I honestly can't think of a useful intuition for MPTCs right now. Now what happens if you add associated types? For example, the canonical class Container c where type Element c :: * We already have type constructor functions such as Maybe with takes a type and constructs a new type. But here we seem to have a general function, Element, which takes some type and returns a new, arbitrary, type. And we define it by a series of equations: instance Container [x] where Element [x] = x instance Container ByteString where Element ByteString = Word8 instance (Ord x) => Container (Set x) where Element (Set x) = x instance Container IntSet where Element IntSet = Int ... Further, the inputs to this function are statically guaranteed to be types from the set (class) "Container". So it's /almost/ like a regular value-level function, just with weird definition syntax. Where *the hell* do GADTs fit in here? Well, they're usually used with phantom types, so I guess we need to figure out where phantom types fit in. To the type checker, Foo Int and Foo Bool are two totally seperate types. In the phantom type case, the set of possible values for both types are actually identical. So really we just have two names for the same set. The same thing goes for a type alias (the "type" keyword). It's not quite the same as a "newtype", since then the value expressions do actually change. So it seems that a GADT is an ADT where the elements of the set are assigned to sets of different names, or the elements are partitioned into disjoint sets with different names. Hmm, interesting. At the same type, values have types, and types have "kinds". As best as I can tell, kinds exist only to distinguish between /types/ and /type functions/. For type constructors, this is the whole story. But for associated types, it's more complicated. For example, Element :: * -> *, however the type argument is statically guaranteed to belong to the Container set (class). In other news... my head hurts! >_< So what would happen if some crazy person decided to make the kind system more like the type system? Or make the type system more like the value system? Do we end up with another layer to our cake? Is it possible to generalise it to an infinite number of layers? Or to a circular hierachy? Is any of this /useful/ in any way? Have aliens contacted Earth in living member? OK, I should probably stop typing now. [So you see what I did there?] Also, I have a sinking feeling that if anybody actually replies to this email, I'm not going to comprehend a single word of what they're talking about...

12 16

About "Fun with type functions" example
by Arnaud Bailly 23 Nov '10

23 Nov '10

Hello, I am trying to understand and use the Nat n type defined in the aforementioned article. Unfortunately, the given code does not compile properly: Here is the code: module Naturals where data Zero data Succ a class Nat n where toInt :: n -> Int instance Nat Zero where toInt _ = 0 instance (Nat n) => Nat (Succ n) where toInt _ = 1 + toInt (undefined :: n) type One = Succ Zero type Two = Succ One And here is the error: D:\projets\sequencer>ghc Naturals.hs Naturals.hs:16:18: Ambiguous type variable `n' in the constraint: `Nat n' arising from a use of `toInt' at Naturals.hs:16:18-39 Probable fix: add a type signature that fixes these type variable(s) I use 6.12.3 on Windows XP. I am most probably missing an option but does not know which one. Thanks in advance for any advice, Arnaud

11 20