- Haskell-Cafe - Haskell.org

ByteString in patterns
by Manlio Perillo 11 Mar '09

11 Mar '09

Hi. Using normal String type I can define a pattern like: > let foo "baz" = 777 > foo "baz" 777 But if I want to use ByteString, what should I do? This seems impossible, since ByteString data constructor is not available. Thanks Manlio Perillo

5 12

View patterns and warnings about overlapping or non-exhaustive patterns
by Stephan Friedrichs 11 Mar '09

11 Mar '09

Hi, I'm working on a data structure that uses Data.Sequence a lot, so views are important and I tried to simplify my code using view patterns. The problem is, that I keep getting warnings about both overlapping and non-exhaustive pattern matches. A simple test case: ===============================T.hs=============================== {-# LANGUAGE ViewPatterns #-} import Data.Sequence test :: Seq a -> Seq b -> String test (viewl -> EmptyL) (viewl -> EmptyL) = "empty, empty" test (viewl -> EmptyL) (viewl -> _ :< _) = "empty, non-empty" test (viewl -> _ :< _) (viewl -> EmptyL) = "non-empty, empty" test _ _ = "non-empty, non-empty" ================================================================== > ghci -Wall T.hs GHCi, version 6.10.1: http://www.haskell.org/ghc/ :? for help Loading package ghc-prim ... linking ... done. Loading package integer ... linking ... done. Loading package base ... linking ... done. [1 of 1] Compiling Main ( T.hs, interpreted ) T.hs:6:0: Warning: Pattern match(es) are overlapped In the definition of `test': test ((viewl -> EmptyL)) ((viewl -> EmptyL)) = ... test ((viewl -> EmptyL)) ((viewl -> _ :< _)) = ... test ((viewl -> _ :< _)) ((viewl -> EmptyL)) = ... test _ _ = ... T.hs:6:0: Warning: Pattern match(es) are non-exhaustive In the definition of `test': Patterns not matched: Ok, modules loaded: Main. *Main> test empty (singleton 'a') "empty, non-empty" *Main> test (singleton 'b') (singleton 'a') "non-empty, non-empty" *Main> test (singleton 'b') empty "non-empty, empty" *Main> test empty empty "empty, empty" There are warnings about non-exhaustive and overlapping pattern matches, but the tests show that this isn't the case. So what's the problem? I don't want to turn off or ignore warnings. //Stephan -- Früher hieß es ja: Ich denke, also bin ich. Heute weiß man: Es geht auch so. - Dieter Nuhr

3 3

QC 2.0 missing some stuff I need
by John Goerzen 11 Mar '09

11 Mar '09

Hi, QuickCheck 1.x had this function: evaluate :: Testable a => a -> Gen Result which I used in TestPack to help wrap a QuickCheck test as a HUnit test case. QuickCheck 2.x seems to have no pure evaluate-like function at all; all of its functions are in the IO monad and also write their result to stdout, according to the docs. Am I missing something? Thanks, -- John

2 1

Using FosSyDe to translate haskell to VHDL.
by wanghanyi 11 Mar '09

11 Mar '09

Dear all, I have used ForSyDe to translate a Haskell script to VHDL for a while, and I have one problem by applying where-clause during the translation. I wrote a small function Plus2.hs which is implied as following addTwof :: ProcFun (Int32 -> Int32) addTwof = $(newProcFun [d|addTwof :: Int32 -> Int32 addTwof n = addOnef+1 where addOnef = n +1 |]) *Plus2> writeVHDL plus2SysDef *** Exception: VHDL Compilation Error: Untranslatable function: where constructs are not supported in functions: where addOnef_0 = n_1 GHC.Num.+ 1 in process function `addTwof' (created in Plus2) used by process `plus2Proc' belonging to system definition `plus2' (created in <unkown>) The compiling process was fine, but the script could not be translated into VHDL, like the error i mentioned above. Is there any way to solve this problem if a where-clause is a must. Thanks all. Hanyi _________________________________________________________________ Live Search视频搜索，快速检索视频的利器！ http://www.live.com/?scope=video

2 2

Re: [Haskell-cafe] Design Patterns by Gamma or equivalent
by Sean Leather 11 Mar '09

11 Mar '09

Hi Mark, Because Haskell is not OO, it is functional, I was wondering if there is > some kind of analogous “design pattern”/”template” type concept that > describe commonly used functions that can be “factored out” in a general > sense to provide the same kind of usefulness that Design Patterns do for > OOP. Basically I’m asking if there are any kinds of “common denominator” > function compositions that are used again and again to solve problems. If > so, what are they called? > Look at Jeremy Gibbons' publications. All of the ones that have "pattern" or "origami" in the title describe design patterns in Haskell. Some of them relate to the translation of Gang-of-Four patterns. http://www.comlab.ox.ac.uk/people/publications/date/Jeremy.Gibbons.html Regards, Sean

1 0

Re: Design Patterns by Gamma or equivalent
by Achim Schneider 11 Mar '09

11 Mar '09

"Mark Spezzano" <mark.spezzano(a)chariot.net.au> wrote: > Basically I___m asking if there are any kinds of ___common denominator___ > function compositions that are used again and again to solve > problems. If so, what are they called? > Haskellers tend to cast their design patterns into functions and libraries. What they're supposed to be called is a zealously heated discussion, there's, for example, return == pure == point and fmap == map == (.) == liftM [1] OTOH, we're said to not care at all: | Don't underrate Haskell programmers. The ones I know have the kind of | minds where if you switched the names to pig latin, they wouldn't skip | a beat. -- [2] If you're looking for a text that could be named "The N most (use|success)ful Haskell Design Patterns", I recommend having a look at the Typeclassopedia[3]. [1]well, at least there _could_ be. [2]http://www.mail-archive.com/boost@lists.boost.org/msg08898.html [3]http://byorgey.wordpress.com/2009/02/16/the-typeclassopedia-request-for-f… -- (c) this sig last receiving data processing entity. Inspect headers for copyright history. All rights reserved. Copying, hiring, renting, performance and/or quoting of this signature prohibited.

1 0

Re: [Haskell-cafe] Design Patterns by Gamma or equivalent
by Robin Green 11 Mar '09

11 Mar '09

The concept of "design pattern" tends not to be used by Haskell programmers - it brings a lot of baggage with it (like being formally documented in a particular way, being "proven" by being used in production several times, etc.) and it doesn't seem to be particularly useful for us in this heavyweight form. However, we do have a more lightweight concept of an "idiom" and "idiomatic Haskell". See http://www.haskell.org/haskellwiki/Category:Idioms (Not all of these pages should probably be in this category, but it gives you an idea.) -- Robin On Wed, 11 Mar 2009 21:28:52 +1030 "Mark Spezzano" <mark.spezzano(a)chariot.net.au> wrote: > Hi, > > > > I’m very familiar with the concept of Design Patterns for OOP in Java > and C++. They’re basically a way of fitting components of a program > so that objects/classes fit together nicely like Lego blocks and it’s > useful because it also provides a common “language” to talk about > concepts, like Abstract Factory, or an Observer to other programmers. > In this way one programmer can instantly get a feel what another > programmer is talking about even though the concepts are > fundamentally abstract. > > > > Because Haskell is not OO, it is functional, I was wondering if there > is some kind of analogous “design pattern”/”template” type concept > that describe commonly used functions that can be “factored out” in a > general sense to provide the same kind of usefulness that Design > Patterns do for OOP. Basically I’m asking if there are any kinds of > “common denominator” function compositions that are used again and > again to solve problems. If so, what are they called? > > > > Cheers, > > > > Mark Spezzano > > > > > > > No virus found in this outgoing message. > Checked by AVG. > Version: 7.5.557 / Virus Database: 270.11.9/1993 - Release Date: > 10/03/2009 7:19 AM >

1 0

Re: [Haskell-cafe] Design Patterns by Gamma or equivalent
by minh thu 11 Mar '09

11 Mar '09

2009/3/11 Mark Spezzano <mark.spezzano(a)chariot.net.au>: > Hi, > > > > I’m very familiar with the concept of Design Patterns for OOP in Java and > C++. They’re basically a way of fitting components of a program so that > objects/classes fit together nicely like Lego blocks and it’s useful because > it also provides a common “language” to talk about concepts, like Abstract > Factory, or an Observer to other programmers. In this way one programmer can > instantly get a feel what another programmer is talking about even though > the concepts are fundamentally abstract. > > > > Because Haskell is not OO, it is functional, I was wondering if there is > some kind of analogous “design pattern”/”template” type concept that > describe commonly used functions that can be “factored out” in a general > sense to provide the same kind of usefulness that Design Patterns do for > OOP. Basically I’m asking if there are any kinds of “common denominator” > function compositions that are used again and again to solve problems. If > so, what are they called? Hi, A particular instance of what can replace the idea of design pattern is given by this now famous post : http://blog.sigfpe.com/2009/01/haskell-monoids-and-their-uses.html You'll see that what 'speaks' to the haskell programmers, maybe in the same way you say design patterns speak to another oo programmer, is much more fitted to the language in haskell. At a lower scale, the reusability of some simple functions like fold or map is reflected at a higher scale by the reusability of concepts like monoids (whih 'exist' in the language, as type classes, while a pattern doesn't). Cheers, Thu

1 0

Design Patterns by Gamma or equivalent
by Mark Spezzano 11 Mar '09

11 Mar '09

Hi, I’m very familiar with the concept of Design Patterns for OOP in Java and C++. They’re basically a way of fitting components of a program so that objects/classes fit together nicely like Lego blocks and it’s useful because it also provides a common “language” to talk about concepts, like Abstract Factory, or an Observer to other programmers. In this way one programmer can instantly get a feel what another programmer is talking about even though the concepts are fundamentally abstract. Because Haskell is not OO, it is functional, I was wondering if there is some kind of analogous “design pattern”/”template” type concept that describe commonly used functions that can be “factored out” in a general sense to provide the same kind of usefulness that Design Patterns do for OOP. Basically I’m asking if there are any kinds of “common denominator” function compositions that are used again and again to solve problems. If so, what are they called? Cheers, Mark Spezzano No virus found in this outgoing message. Checked by AVG. Version: 7.5.557 / Virus Database: 270.11.9/1993 - Release Date: 10/03/2009 7:19 AM

1 0

Re: [Haskell-cafe] Generics Versus Parametric Polymorphism
by Bulat Ziganshin 11 Mar '09

11 Mar '09

Hello Mark, Wednesday, March 11, 2009, 9:11:42 AM, you wrote: > Just wondering if Generics and Parametric polymorphism are one and the same in Haskell. haskell Parametric polymorphism is the same type of thing as Java Generics :) haskell Generics provides ability to define procedures polymorphic by *any* data type with just a fixed number of definitions there are at least dozen of various tools/libraries supporting Generics in some way in haskell, so indeed we are interested to have at least one with guaranteed availability google for "scrap your boilerplate" paper for a description of one of the most popular Generics implementation -- Best regards, Bulat mailto:Bulat.Ziganshin@gmail.com

2 2