- Haskell-Cafe - Haskell.org

(no subject)
by L.Guo 24 May '07

24 May '07

Hi MailList Haskell-Cafe: Till now, which module / package / lib can i use to access binary file ? And is this easy to use in GHC ? Regards -------------- L.Guo 2007-05-24

4 7

Should "do 1" compile
by Neil Mitchell 24 May '07

24 May '07

Hi, As discussed on #haskell, the following code: ---------------- module Foo where foo = do (1 :: Int) ---------------- Compiles fine on Yhc, but doesn't on Hugs and GHC. GHC: Couldn't match expected type `t t1' against inferred type `Int' In the expression: (1 :: Int) In the expression: do (1 :: Int) In the definition of `foo': foo = do (1 :: Int) Hugs: ERROR "test.hs":4 - Type error in final generator *** Term : 1 *** Type : Int *** Does not match : a b So the question is, who is right? Where do the bugs need filing? Does this issue need clarifying for Haskell' ? Thanks Neil

11 15

Software Engineer, Functional Programmer, Team/Project lead positions
by Isaac Jones 23 May '07

23 May '07

Are you seeking an intellectually challenging position in which you'll be developing cutting edge software using functional programming technologies? Do you aspire to work with a team that shares your level of commitment and enthusiasm to develop tomorrow's high-assurance technology today? Do you want to take ideas and turn them into real-world products? If so, you might be just the person we're looking for. Galois Connections, Inc., located near Portland, Oregon, designs and develops high confidence software for critical applications using cutting edge methods and technology. Innovative and highly creative in the demanding application areas of security, information assurance, cross-domain platform development, and formal-methods engineering, Galois has earned a reputation of excellence in both private and government sectors. Galois has recently opened several positions for software engineers/ functional programmers and team leads who will participate in/lead projects from inception to product delivery. These people will work in a highly cooperative and collaborative team settings and will be responsible for ensuring the delivery of robust and fully functional products according to client expectations and potential certifying agencies. For more details about these exciting opportunities please go to: http://www.galois.com/join.php To learn more about Galois visit our website at http://www.galois.com

1 0

Re: [Haskell-cafe] Currying: The Rationale
by Chad Scherrer 23 May '07

23 May '07

Is (^2) really considered currying? As I understand it, this is syntactic sugar for a "section", and might confuse the issue a bit, since it's distinct from ((^) 2). In this case we would have something like Prelude> let pow2 = ((^) 2) Prelude> map pow2 [1..10] [2,4,8,16,32,64,128,256,512,1024] I think it's also worth pointing out that currying can make point-free programming more natural. So, foldl has type Prelude> :t foldl foldl :: (a -> b -> a) -> a -> [b] -> a That this could have been defined as foldlUncurried :: ((a -> b -> a), a, [b]) -> a but then simple point-free definitions like sum = foldl (+) 0 would have to be written as sum xs = foldlUncurried ((+), 0, xs) OTOH, sometimes an uncurried version is easier to reason about. So, in some of Richard Bird's work ("Algebra of Programming" is like this, and probably at least some of his intro book) examples are uncurried, as it shows more of the algebraic structure, and allows reasoning in a product space rather than an exponential. Umm, I guess that qualifies as jargon - sorry. Chad > (^) applied to 2, produces a new function, we can map over a list: > > Prelude> let sq = (^2) > Prelude> map sq [1..10] > [1,4,9,16,25,36,49,64,81,100] > > or more explicitly: > > Prelude> let x `to` y = x ^ y > Prelude> let sq x = x `to` 2 > Prelude> map sq [1..10] > [1,4,9,16,25,36,49,64,81,100] > > -- Don

4 4

Currying: The Rationale
by PR Stanley 23 May '07

23 May '07

Hi What is the rationale behind currying? is it for breaking subroutines into pure one-to-one mappings? If f x y = f x -> a function which takes y for argument then does that mean that the second function already has value x, as it were, built into it? The syntax in Haskell is perfectly lucid and almost intuitive; unlike the underlying theory which is a bit ... top marks for the least jargoned answer. Many thanks in advance, Paul

5 5

efficient and/or lazy partitions of a multiset
by Greg Meredith 23 May '07

23 May '07

HC-er's, Find below some simple-minded code from a naive Haskeller for generating all partitions of a multiset about which i have two questions. mSplit :: [a] -> [([a], [a])] mSplit [x] = [([x],[])] mSplit (x:xs) = (zip (map (x:) lxs) rxs) ++ (zip lxs (map (x:) rxs)) where (lxs,rxs) = unzip (mSplit xs) 1. Is there a clever way to reduce the horrid complexity of the naive approach? 2. How lazy is this code? Is there a lazier way? i ask this in the context of checking statements of the form \phi * \psi |= e_1 * ... * e_n where - [| \phi * \psi |] = { a \in U : a === b_1 * b_2, b_1 \in [| \phi |], b_2 \in [| \psi |] } - === is some congruence generated from a set of relations A nice implementation for checking such statements will iterate through the partitions, generating them as needed, checking subconditions and stopping at the first one that works (possibly saving remainder for a rainy day when the client of the check decides that wasn't the partition they meant). Best wishes, --greg -- L.G. Meredith Managing Partner Biosimilarity LLC 505 N 72nd St Seattle, WA 98103 +1 206.650.3740 http://biosimilarity.blogspot.com

2 4

Editor
by Michael T. Richter 23 May '07

23 May '07

I have a dream. It's not a little dream. It's a big dream. I have a dream that someday I can find a UNIX/Linux text editor for Haskell hacking (and possibly two or three hundred other programming languages, although that's optional) that can give me all of the following: 1. A real GUI environment that takes into account some of the HID advances made in the past 30 years. (Emacs and Vim don't count, in other words.) 2. Good quality syntax highlighting for Haskell that includes all of the usual syntax highlighting goodies, plus: * the ability to seamlessly handle raw Haskell and both common forms of Literate Haskell; * the ability to properly highlight Haddock comments; * the ability to highlight functions and types from libraries (user-expandable) differently from local functions and types. 3. Line folding to hide and show blocks of code. 4. Code completion (user-expandable, ideally) for common library functions, type declarations, etc. 5. Easy, quick access to online documentation for said functions and declarations. 6. Good (ideally scriptable) access to external utilities for compilation, debugging, profiling, type inference, project management, etc. 7. A good plug-in system (ideally written in Haskell?) for expansion. Is there such a beast available out there somewhere? If not, is such a beast lurking in the background ready to pounce in the near future? -- Michael T. Richter <ttmrichter(a)gmail.com> (GoogleTalk: ttmrichter(a)gmail.com) I have to wonder why people think that when they can't manage local personnel within easy strangling and shooting distance, then they can manage personnel thousands of miles away that have different languages, cultures, and business rules. (Joe Celko)

26 39

Re: [Haskell-cafe] New book: Real-World Haskell!
by Alfonso Acosta 23 May '07

23 May '07

On 5/23/07, Donald Bruce Stewart <dons(a)cse.unsw.edu.au> wrote: > > Bryan O'Sullivan, Don Stewart and John Goerzen are pleased, and frankly, > very excited to announce that were developing a new book for O'Reilly, on > practical Haskell programming. The working title is Real-World Haskell. That is simply great! I've been looking forward to read a book like that for so long. > 28. Advanced Haskell: MPTCs, TH, strong typing, GADTs Existential types are a must in this chapter! even more important that TH and GADTs.

1 0

type class question
by Tim Docker 22 May '07

22 May '07

I think this must almost be a FAQ, or at least a PAQ (Previously AQ)... If I have a type class for conversion to a type X: class XType a where toX :: a -> X I can define instances for instance XType Int where toX = ... instance XType Double where toX = ... instance XType Tuple where toX = ... but not for Strings, given that they are a synonym for [Char]. Hence: instance XType String where toX = ... results in: Illegal instance declaration for `XType String' (The instance type must be of form (T a b c) where T is not a synonym, and a,b,c are distinct type variables) In the instance declaration for `XType String' Is there some type class cleverness that can make this work in haskell 98? I can create a new wrapper type for strings: newtype StringWrap = StringWrap String and write an instance for that, but then I'll have to litter my code with calls to this constructor. I'm aware of the approach taken by class Show in the prelude, which adds a extra method to the class: class XType a where toX :: a -> X listToX :: [a] -> X but I believe this says that whenever we can convert a to an X we can also convert [a] to an X, whereas I only want [Char] to be acceptable. Thanks for any pointers. Tim

4 5

Re: [Haskell] boilerplate boilerplate
by Jacques Carette 22 May '07

22 May '07

Personally I would like {-# OPTIONS -fglasgow-exts -fgenerics -} module Blog.Types where family Usual = (Eq, Ord, Read, Show, Typeable) data BlogEntry = Entry EpochSeconds Name Email Title Body deriving Usual newtype Name = Name String deriving Usual newtype Title = Title String deriving Usual newtype Body = Body String deriving Usual Of course, if you're doing that, you might as well change those last 3 lines with newtype-schema NamedString = NamedString String deriving Usual instantiate NamedString with Name, Title, Body To me, that is very clear. Syntax-wise, I am sure things can be improved (but I rather like 'family', 'foo-schema' and 'instantiate', but not really the 'with'). Jacques Alex Jacobson wrote: > Consider this module for a blog entry that I will want to put in > various generic collections that require Ord > > {-# OPTIONS -fglasgow-exts #-} > module Blog.Types where > import Data.Typeable > import Data.Generics > > data BlogEntry = Entry EpochSeconds Name Email Title Body > deriving (Eq,Ord,Read,Show,Typeable) > > newtype Name = Name String deriving (Eq,Ord,Read,Show,Typeable) > newtype Title = Title String deriving (Eq,Ord,Read,Show,Typeable) > newtype Body = Body String deriving (Eq,Ord,Read,Show,Typeable) > > > It seems really unnecessarily verbose. Having to add the OPTION > header AND import Data.Typeable and Data.Generics just to derive > Typeable is a beat-down. It is even more of a beat-down to have to > add a deriving clause for every newtype to make this all work nicely. > Is there a way to make all types automatically derive everything > unless there is an explicit instance declaration otherwise? > > {-# OPTIONS -fglasgow-exts -fgenerics -fderiving#-} > module Blog.Types where > > data BlogEntry = Entry EpochSeconds Name Email Title Body > newtype Name = Name String newtype Title = Title String newtype > Body = Body String > Isn't that much nicer? > > -Alex- > > > _______________________________________________ > Haskell mailing list > Haskell(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell

1 0