May 2010 - Haskell-Cafe

darcs to mercurial migration
by Günther Schmidt 10 May '10

10 May '10

Hello, I'm switching from darcs to mercurial with some of my projects. I'd like to retain as much of the history as possible, what tools are there available for this? Günther

6 6

Type of (>>= f) where f :: a -> m b
by Milind Patil 10 May '10

10 May '10

For a function f :: a -> m b f = undefined I am having trouble understanding how the type of (>>= f) is (>>= f) :: m a -> m b where, by definition, type of (>>=) is (>>=) :: (Monad m) => m a -> (a -> m b) -> m b I do not see how (>>= f) even unifies. I mean if I code a function with the same type as (>>=) ie. tt :: (Monad m) => m a -> (a -> m b) -> m b tt = undefined type of (tt f) does not infer to the same type as (>>= f), from ghc ... (tt f) :: (Monad ((->) b)) => (m a -> b -> b1) -> b -> b1 There seems to something special about (>>=) apart from its type. And whats (Monad ((->) b))? I am new to Haskell and I may have gaps in my understanding of type inference in Haskell. regards, Milind Patil

4 4

FRP demos and tutorials page
by Tom Poliquin 10 May '10

10 May '10

Haskell Cafe'rs, My student and I (sometimes it's difficult to determine who is who) have struggled to understand Reactive for several months and thanks to some initial help from the Reactive list (thanks Paul C) have been able to write some demos and tutorials. Apologies for posting this to the Haskell Cafe, instead of the FRP list but we wanted to make our efforts available to a wider audience, and the experts there are the choir. We have created are a set of demos and tutorials for FRP ("Conal reactive"). It consists of four demos: the simple furnace, the human controlled furnace, the hybrid robot sim, and the FRP robot sim. The furnace demos both consist of a thermostat like application, in which a furnace heats up and cools down in attempt maintain a constant temperature. In the simple furnace, the goal temperature is a fixed constant, while in the human controlled furnace, the user can control the goal temperature. The robot sim demos both consist of a 3D simulation in which a robot follows the walls of an arena using a simple control algorithm. The hybrid robot sim consists of two programs, one with FRP that simulates the robot, and one GLUT program that reads piped date from the first program to display the 3D view. The FRP robot sim is a single program that simulates the same robot scenario as the first, but uses reactive GLUT and FRP to do the whole demo in reactive style. We attempted to but as much documentation in the programs as possible, as well as give an overview on the webpage about the functions we used. Please note that both of us are rather new to Haskell, and so, we may have used poor programming practices in these tutorials and demos. If you have any suggestions about them, please feel free to write to us. Website: http://www.formicite.com/dopage.php?frp/frp.html Thanks, Tom and Tony

3 3

Set Operations In Haskell's Type System
by John Creighton 09 May '10

09 May '10

This is partly a continuation from: http://groups.google.ca/group/haskell-cafe/browse_thread/thread/4ee2ca1f5eb… and http://hpaste.org/fastcgi/hpaste.fcgi/view?id=25265 Also of relevance: http://groups.google.ca/group/haskell-cafe/browse_thread/thread/9cc8858a2e5… http://www.haskell.org/haskellwiki/GHC/AdvancedOverlap http://homepages.cwi.nl/~ralf/HList/paper.pdf http://okmij.org/ftp/Haskell/typecast.html http://www.haskell.org/haskellwiki/User:ConradParker/InstantInsanity http://okmij.org/ftp/Haskell/types.html (haven't looked at this link yet) I will continue to try to solve the problem on my own but at the moment I'm able to get IsSuperSet to work but not the classes Isa, Child and IsSubSet to work. Unlike set theory IsSubSet is not the same as switching the order arguments in IsSuperSet because the searching is done in the opposite direction. In one case we are searching the parents and each child only has one parent. In the other Case we are searching the children and each parent could have multiple children). Bellow is my current code: {-# LANGUAGE EmptyDataDecls, MultiParamTypeClasses, ScopedTypeVariables, FunctionalDependencies, OverlappingInstances, FlexibleInstances, UndecidableInstances, TypeFamilies #-} {-# LANGUAGE TypeOperators #-} --10 {-# LANGUAGE FlexibleContexts #-} --{-# LANGUAGE IncoherentInstances #-} ----------------------IsSubSet ----------------------------------- data ItsNotAParrent class IsSubSet a b c | a b -> c where -- General Definition isSubSet :: a->b->c class Child a b|b->a where {} instance ( Parrent b a2, TypeEq a2 a itsAParrent, -- Child' itsAParrent a b ) => Child a b class Child' itsAParrent a b where {} instance (TypeCast b ItsNotAParrent)=>Child' F a b --No Childern instance (TypeCast b c, Parrent c b)=>Child' T a b instance (TypeCast b M)=>Child' itsAParrent a b --- Fail Case instance ( TypeEq ItsNotAParrent a itsNotAParrent, TypeEq a b iseq, IsSubSet' itsNotAParrent iseq a b c3 -- ) => IsSubSet a b c3 where -- isSubSet a b = undefined::c3 class IsSubSet' itsNotAParrent iseq a b c| itsNotAParrent iseq a b -> c where {} instance (TypeCast c T)=>IsSubSet' F T a b c where {} instance (TypeCast c F)=>IsSubSet' T iseq a b c where {} --Not sure which logic value is best for this case. instance (TypeCast c M)=>IsSubSet' itsNotAParrent iseq a b c where {} --Fail Case instance ( Child a d, IsSubSet d b c )=> IsSubSet' F F a b c where {} --bla11=isSubSet Cat Animal -----------------------Isa --------------------------------------------- class Isa' a b c|a b->c where {} --Direct Relationship class Isa a b c|a b->c where isa::a->b->c instance ( Isa' a1 b1 c1, --Direct Relationship IsSuperSet a1 a c2, --Check --20 IsSuperSet b b1 c3, -- Isa'' c1 c2 c3 a1 b1 c4 -- Decesion function -- )=>Isa a b c4 where isa a b = undefined::c4 class Isa'' c1 c2 c3 a b c4|c1 c2 c3 a b->c4 where {} -- isa :: c1->c2->c3->a->b->c4 instance Isa'' T T T a1 b1 T where {} -- isa'' c1 c2 c3 a b = T --30 instance Isa'' F c2 c3 a1 b1 F where {} -- -- isa'' c1 c2 c3 a b = F instance Isa'' c1 F c3 a1 b1 F where {} -- isa'' c1 c2 c3 a b = F instance Isa'' c1 c2 F a1 b1 F where {} -- isa'' c1 c2 c3 a b = F ---------------- Instance Isa Relations ---------------------------------- instance Isa' Animal Noun T instance (TypeCast F result) => Isa' a b result -----------------Test Relationships ----------------------------------40 --bla6 = isa Cat Noun -- --bla4 = isa Cat Verb -----------------------Basic Type Declarations --------------------------- data Noun = Noun deriving (Show) --15 data Verb = Verb deriving (Show) -- data Adjactive = Adjactive deriving (Show) data Animal=Animal deriving (Show) data Feline=Feline deriving (Show) --50 data Cat = Cat deriving (Show) data Taby_Cat=Taby_Cat deriving (Show) -----------------------Instance SubType Relations -------------------------------- data ItsAnOrphan = ItsAnOrphan instance Show ItsAnOrphan where show _ = "ItsAnOrphan" --60 class Parrent a b| a->b where -- Specific Cases parrent :: a->b -- instance Parrent Cat Feline where -- parrent a = Feline --40 instance Parrent Feline Animal where -- parrent a = Animal -- instance (TypeCast result ItsAnOrphan) => Parrent anyChild result where parrent a = undefined::result ----------------------- Generic subType Relations ------------------------------ class IsSuperSet a b c | a b -> c where -- General Definition isSuperSet :: a->b->c --instance (TypeEq b Animal T,TypeEq c F T)=>IsSuperSet a b c where --85 -- isSuperSet a b = F -- u=undefined instance ( TypeEq ItsAnOrphan b isOrphan, TypeEq a b iseq, IsSuperSet' isOrphan iseq a b c3 -- ) => IsSuperSet a b c3 where --S isSuperSet a b = undefined::c3 -- isSuperSet a b=(isSuperSet' (u::isaninmal) (u::iseq) (a::a) (b::b))::c3 class IsSuperSet' isOrphan iseq a b c| isOrphan iseq a b -> c where {} -- isSuperSet' :: isOrphan->iseq->a->b->c instance (TypeCast c T)=>IsSuperSet' F T a b c where {} -- isSuperSet' isOrphan iseq a b = T instance (TypeCast c F)=>IsSuperSet' T T a b c where {} --Not sure which logic value is best for this case. instance ( Parrent b d, IsSuperSet a d c )=> IsSuperSet' F F a b c where {} -- isSuperSet' isOrphan iseq a b = (isSuperSet a ((parrent (b::b))::d))::c instance (TypeCast c F)=>IsSuperSet' T F a b c where {} -- isSuperSet' isOrphan iseq a b = F ----------- Logical Types ------------------ data T=T -- deriving (Show) data F=F -- deriving (Show) --25 data M=M -- Fail case instance Show T where show _ = "T" instance Show F where show _ = "F" instance Show M where show _ = "M" class ToBool a where toBool :: a->Bool instance ToBool T where toBool a = True instance ToBool F where toBool a = False -----------------------Loical Type Relations ----------------------------- class TypeOr a b c|a b->c where typeOr :: a->b->c instance TypeOr T T T where typeOr a b = T --50 instance TypeOr T F T where typeOr a b = T instance TypeOr F T T where typeOr a b = T instance TypeOr F F T where typeOr a b = T ----------------------- OKMIJ ------------------------------------------ class TypeEq' () x y b => TypeEq x y b | x y -> b instance TypeEq' () x y b => TypeEq x y b class TypeEq' q x y b | q x y -> b --60 class TypeEq'' q x y b | q x y -> b instance TypeCast b T => TypeEq' () x x b instance TypeEq'' q x y b => TypeEq' q x y b instance TypeEq'' () x y F -- see http://okmij.org/ftp/Haskell/typecast.html class TypeCast a b | a -> b, b->a where typeCast :: a -> b class TypeCast' t a b | t a -> b, t b -> a where typeCast' :: t->a- >b class TypeCast'' t a b | t a -> b, t b -> a where typeCast'' :: t->a- >b --70 instance TypeCast' () a b => TypeCast a b where typeCast x = typeCast' () x instance TypeCast'' t a b => TypeCast' t a b where typeCast' = typeCast'' instance TypeCast'' () a a where typeCast'' _ x = x ----------------------- Testing Code -------------------------------- myCat=Cat bla=isSuperSet Animal Cat bla2=isSuperSet Cat Animal bla3=isSuperSet Animal Noun bla4=isSuperSet Noun Animal bla5=isSuperSet Noun Noun

3 6

Re: [Haskell-cafe] Haskell and the Software design process
by John Lato 09 May '10

09 May '10

> From: Rafael Cunha de Almeida <assinante(a)kontesti.me> > > Ivan Miljenovic <ivan.miljenovic(a)gmail.com> disse: >> On 3 May 2010 14:17, aditya siram <aditya.siram(a)gmail.com> wrote: >>> I'm a little confused about this too. I've seen many functions defined like: >>> f x = (\s -> ...) >>> which is a partial function because it returns a function and is the same as: >>> f x s = ... >> >> No, that's a partially applied function. >> >> A partial function is one such as: >> >> secondElement (_:x:_) = x >> >> Note that it is only defined for lists with at least two elements, for >> any other list (i.e. singleton or empty) it will throw an error; >> -fwarn-incomplete-patterns (which is included in -Wall) tells you >> about these. >> >> You can also argue that functions such as head are partial, as they >> explicitly throw an error if the input data isn't correct. >> >> Partial functions are bad because if you accidentally use one the >> wrong way, your entire program crashes in a flaming wreck. It's much >> better to do something like this: >> >> safeSecondElement (_:x:_) = Just x >> safeSecondElement _ = Nothing >> >> This will work with all possible input types. > > I don't think that safeSecondElement is worse than secondElement. I think it's > better for the program to crash right away when you try to do something that > doesn't make sense. > > Getting the secondElement of a list with one or less elements doesn't make > sense, so you are definetely doing something wrong if you expected the list to > have two elements, but it doesn't. It's best that the program crashes there, > than propagate the error and crash somewhere else or, worse, not crash at all > and give a wrong answer. Stepping in on the tail end of this discussion, however... The reason people argue for safeSecondElement over secondElement is exactly the reason you argue against it. Calling safeSecondElement on a list with < 2 elements forces the programmer to handle the result immediately by returning a Maybe, which requires the programmer to handle the Nothing case, corresponding to invalid input for this function. This is better than the program crashing because the programmer has to fix it before it's even released. This is exactly how to use the type system to your advantage; the error condition is indicated by the return type of the function. "Crashing at the point of the error" isn't necessarily useful in Haskell due to lazy evaluation. The code will crash when the result of the partial function is evaluated, which may be quite far away (in terms of function calls) from where the programmer would expect. John

10 14

Chicago Haskell Users Group Meeting Tuesday, May 11, 7PM
by Jeremy Shaw 09 May '10

09 May '10

Hello Chicago People! The Chicago Haskell Users Group will be meeting this Tuesday, May 11, at 7PM at The Grafton. Say goodbye to Tom Tobin (our founder), and hello to Haskell world domination! The Grafton is in Lincoln Square next to the Old Town School of Folk Music, close to the Western stop on the Brown line. We will be wishing Tom Tobin goodbye as he prepares to head back to New York. Leon Smith is possibly doing a presentation on concurrency and/or circular programming. And we will have open discussion on Haskell and non-Haskell related topics. Ideally we will be sitting in the back on the couches near the fireplace, subject to availability (alas, we can't reserve them). The Grafton has free wi-fi, and great Irish food, beer, and drinks. Stay until 9PM and hear a variety of musicians playing rare and original folk music songs. http://www.thegrafton.com/ Also, be sure to join our brand new facebook group, http://www.facebook.com/group.php?gid=119966508024820 And google discussion group: http://groups.google.com/group/haskell-chicago Thanks! - jeremy

1 0

IO (Either a Error) question
by Eugeny N Dzhurinsky 09 May '10

09 May '10

Hello! I have some sort of strange question: assume that there are 2 functions func1 :: Int -> IO (Either Error String) func2 :: String -> IO (Either Error [String]) in case if there will be no IO involved, I could use Control.Monad.Either and write something like runCalc :: Int -> IO (Either Error [String]) runCalc param = func1 param >>= func2 but with that IO stuff I can't simply do in this way. Can somebody please suggest, how to combine IO and Either monads, if that's even possible? Thank you in advance! -- Eugene Dzhurinsky

17 35

mixing map and mapM ?
by briand＠aracnet.com 09 May '10

09 May '10

I was doing the following: do status <- mapM PF.getFileStatus filenames let times = map PF.modificationTime status let sorted = sortBy (\(_, t1) (_,t2) -> compare t1 t2) (zip filenames times) and I thought, surely I can combine the status and times definitions into one line, only I can't. Hint ? Thanks, Brian

10 14

nun.haskell.org http services down?
by Jens Petersen 09 May '10

09 May '10

http://{code,community,projects}.haskell..org/ seem to be inaccessible. Could someone please look into it? Thanks, Jens

11 11

Re: [Haskell-cafe] Would it be evil to add "deriving Typeable" to newtype Q?
by Ivan Miljenovic 09 May '10

09 May '10

Re-CC'ing -cafe: On 6 May 2010 12:54, Leonel Fonseca <leonelfl(a)gmail.com> wrote: > I wasn't aware of GeneralizedNewtypeDeriving. > I just edited the source file Language.Haskell.TH.Syntax > and left: > > newtype Q a = Q { unQ :: forall m. Quasi m => m a } > deriving Typeable Hang on, is Q something actually in the template-haskell library? In that case, you can't just do "deriving (Typeable)" . However, you might be able to generate the Typeable instance using DrIFT (see http://hackage.haskell.org/package/DrIFT-cabalized for a cabal-install-able package). -- Ivan Lazar Miljenovic Ivan.Miljenovic(a)gmail.com IvanMiljenovic.wordpress.com

7 6