September 2009 - Haskell-Cafe

Thank you guys
by Cristiano Paris 18 Sep '09

18 Sep '09

I wish to thank Cafè's people for their great support in understanding Haskell. Thank you all! Cristiano

1 0

Re: Where can I find a non-fee-based version of Hudak's paper, "Conception, evolution, and application of functional programming languages"?
by jean legrand 18 Sep '09

18 Sep '09

> Does anybody know where I can find a non-fee-based version of Paul > Hudak's paper, "Conception, evolution, and application of functional > programming languages" [1]? There used to be a version that did not seems you can get a djvu copy here http://lib.org.by/info/Cs_Computer science/CsPl_Programming languages/Hudak P. Conception, evolution, and application of functional programming languages (ACM comp.surveys 21, 1989)(T)(53s).djvu the site is in Russian and you wait 30s before a link to the file appears.

2 1

About the parse error (possibly incorrect indentation)
by xu zhang 18 Sep '09

18 Sep '09

Hi, I am trying to get the function showMinProp to return String, but I always get an error of parse error (possibly incorrect indentation) Who can help with this? any idea? Thank u in advance! data Prop = Var String | Negation Prop | BinOp Op Prop Prop data Op = And | Or | Implies | Equiv derived Eq showOp :: Op -> String showOp And = "&" showOp Or = "|" showOp Implies = "=>" showOp Equiv = "<=>" instance Show Op where show = showOp precList = [(And,4),(Or,3),(Implies,2),(Equiv,1)] showProp :: Prop -> String showProp (Var s) = s showProp (Negation p) = "~" ++ showProp p showProp (BinOp op p q) = paren (showProp a p ++ space (showOp op) ++ showProp a q) showMinProp :: Int -> Prop -> String showMinProp preNo (BinOp op p q) = case op of And -> let a = 4 Or -> let a = 3 Implies -> let a = 2 Equiv -> let a = 1 if (a > preNo) then (showMinProp a p ++ space (showOp op) ++ showMinProp a q) else paren (showMinProp a p ++ space (showOp op) ++ showMinProp a q)) space s = " " ++ s ++ " " paren s = "(" ++ s ++ ")" instance Show Prop where show = showProp

3 2

Where can I find a non-fee-based version of Hudak's paper, "Conception, evolution, and application of functional programming languages"?
by Benjamin L.Russell 18 Sep '09

18 Sep '09

Does anybody know where I can find a non-fee-based version of Paul Hudak's paper, "Conception, evolution, and application of functional programming languages" [1]? There used to be a version that did not require an ACM account available at http://www.cs.berkeley.edu/~jcondit/pl-prelim/hudak89functional.pdf , but when I try to download that file, the following error message appears: >The server has encountered a problem because access is restricted. > >Your request was : > http://www.cs.berkeley.edu/~jcondit/pl-prelim/hudak89functional.pdf -- Benjamin L. Russell [1] Hudak, Paul. "Conception, Evolution and Application of Functional Programming Languages." New York, NY: _ACM Computing Surveys (CSUR)_ 21(3) (September 1989): 359-411. <http://portal.acm.org/citation.cfm?id=72551.72554&coll=ACM&dl=ACM&idx=J204&…>. Also available at <http://www.cs.berkeley.edu/~jcondit/pl-prelim/hudak89functional.pdf>. -- Benjamin L. Russell / DekuDekuplex at Yahoo dot com http://dekudekuplex.wordpress.com/ Translator/Interpreter / Mobile: +011 81 80-3603-6725 "Furuike ya, kawazu tobikomu mizu no oto." -- Matsuo Basho^

2 2

How to understand the 'forall' ?
by zaxis 18 Sep '09

18 Sep '09

data Branch tok st a = forall b. Branch (PermParser tok st (b -> a)) (GenParser tok st b) please shed a light on me, thanks! -- View this message in context: http://www.nabble.com/How-to-understand-the-%27forall%27---tp25250783p25250… Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

12 23

help with FFI
by José Prous 17 Sep '09

17 Sep '09

Hello Lets say I have a library in C with a header like this: #include <stdio.h> /*really big structure*/ typedef struct { int *a; int *b; /*lots of stuff ... */ int *z; } foo; /*this function allocate memory and fill the structure, reading from a file*/ int create_foo(foo *f,FILE *file,int x,int y); /*some functions that use the structure*/ int use_foo(foo *f,int w); /*a funtion that releases the memory*/ int destroy_foo(foo *f); And I want to use it in haskell using FFI. I can create a .hsc file like this: {-# LANGUAGE CPP, ForeignFunctionInterface #-} import Foreign import Foreign.C.Types #include "foo.h" newtype Foo = Foo () foreign import ccall "static foo.h create_foo" c_create_foo :: Ptr (Foo) -> Ptr (CFile) -> CInt -> CInt -> IO CInt foreign import ccall "static foo.h use_foo" c_use_foo :: Ptr (Foo) -> CInt -> IO CInt foreign import ccall "static foo.h destroy_foo" c_destroy_foo :: Ptr (Foo) -> IO CInt It compiles but I have no idea how to call c_create_foo and get back Foo Any suggestions? thanks

2 1

ANN: Unification in a Commutative Monoid (cmu 1.1) and a new release of Abelian group unification and matching (agum 2.2)
by John D. Ramsdell 17 Sep '09

17 Sep '09

Package cmu 1.1 provides unification in a commutative monoid, also know as ACU-unification. The core computation finds the minimal non-zero solutions to homogeneous linear Diaphantine equations. The linear equation solver has been place in a separate module so it can be used for other applications Package agum 2.2 provides unification and matching in an Abelian group, also know as AG-unification and matching. The core computation finds the integer solutions to inhomogeneous linear equations. The linear equation solver has been place in a separate module so it can be used for other applications John

1 0

matching types in Haskell
by pat browne 17 Sep '09

17 Sep '09

Hi, I wish to align or match some Haskell types in order to represent a set of ontologies and their embedded concpts [1]. I am not sure wheather modules or classes could be used. I have done this task in a language called Maude[2]. The code is below. I appreciate that Maude is not very popular so there is a brief description below. This diagram below represents the semantics of what I am trying to achive. I want to construct MERGEDONTOLOGY from ONTOLOGY1 and ONTOLOGY2 both of which are based on COMMON. MERGEDONTOLOGY { Woman, RiverBank, FinancialBank, HumanBeing} /\ /\ / \ / \ / \ / \ / \ / \ ONTOLOGY1 ONTOLOGY2 {Woman, Bank, Person} {Woman, Bank, Human} /\ /\ \ / \ / \ / \ / \ / \ / \ / {Woman , Person} COMMMON Each Maude module represents (below) a distinct ontology, each sort (or type in Haskell) represents a concept. This example includes both synonyms and homonyms. I want to align ONTOLOGY1 and ONTOLOGY2 w.r.t COMMON to produce MERGEDONTOLOGY. The details of the concepts are as follows. The Woman concept should be the same in all ontologies, there is only one Woman concept and it is named as such in each ontology. Hence there should be only one Woman.MERGEDONTOLOGY There is only one concept HumanBeing.MERGEDONTOLOGY, but there are 3 synonyms Human.ONTOLOGY2, Person.ONTOLOGY1, and Person.COMMON It would seem that Person.COMMON should be mapped (or renamed?) to Human.ONTOLOGY2 which in turn is renamed (or mapped) to HumanBeing.MERGEDONTOLOGY. The homonyms are Bank.ONTOLOGY1 and Bank.ONTOLOGY2 which should become distinct entities in RiverBank.MERGEDONTOLOGY and FinancialBank.MERGEDONTOLOGY My question is how should this be done in Haskell. Is there a classes only solution? Is ther a module only solution? Or do I need both? Regards, Pat ============================================= Brief description of Maude code In the Maude Language the module is the basic conceptual unit. Sorts are declared in modules Every line ends with a space dot. In this case each module is bracketed by fth .. endfth There are various types of mappings between modules. In this case I used renamings where the syntax is *( name_in_source_module to name_in_target_module....) The keyword protecting is a type of inport. The + symbol between the modules forms a new module that includes all the information in each of its arguments ============================== fth COMMON is sorts Woman Person . endfth fth ONTOLOGY1 is protecting COMMON . sorts Bank . endfth fth ONTOLOGY2 is protecting COMMON *( sort Person to Human) . sorts Bank . endfth fth MERGEDONTOLOGY is including (ONTOLOGY1 * (sort Bank to RiverBank,sort Person to HumanBeing)) + (ONTOLOGY2 * (sort Human to HumanBeing, sort Bank to FinancialBank)) . endfth with the command show all MERGEDONTOLOGY the system will produce the following module fth MERGEDONTOLOGY0 is sorts Woman HumanBeing FinancialBank RiverBank . endfth ================================ Reference [1]Shapes of Alignments Construction, Combination, and Computation by Oliver Kutz, Till Mossakowsk, and Mihai Codescu http://www.informatik.uni-bremen.de/~okutz/shapes.pdf [2] Informa tiom on Maude at: http://maude.cs.uiuc.edu/

3 3

algebra/grammar/language for expressing time intervals
by Jeremy Shaw 17 Sep '09

17 Sep '09

Hello, I need some cron-like functionality for long running daemon written in Haskell. I want to be able to schedule an event to be run: 1. once, at a specific time 2. some regularly scheduled time I don't see an existing library to do this, so I am starting work on my own. The first issue I am looking at is how to specify time intervals. The primary example I have looked at is cron. Cron is pretty good, but I don't see a way to do something like, run a job every other Wednesday. I also want to be able to display the interval schedule to the user, allow them to modify it, and also save the schedule to disk and reload it. So this essentially means that the type for describing the intervals can not contain any functions. Does anyone know of a good language for describing intervals? I want to be able to express things like: - run every other wednesday - run at 15 minutes past the hour - run at 15 minutes past the hour every wednesday - run at 15 and 25 minutes past the hour between the hours of 2 and 6 AM. - run every weekday at 8AM unless it is a holiday (the list of holidays would be supplied). Basically, everything you can express with cron, and a bit more. Is there any existing languages/grammars/algebras for this that I should look at? thanks! - jeremy

3 2

Composition, delegation and interfaces -- a 20K ft critique of Noop
by Greg Meredith 17 Sep '09

17 Sep '09

Dear Programmers, Someone just asked me to give my opinion on Noop's composition proposal<http://code.google.com/p/noop/wiki/ProposalForComposition>. It reminds me a little bit of Self<http://en.wikipedia.org/wiki/Self_%28programming_language%29>which found its way into JavaScript. It also reminds me a little of Haskell's type classes <http://en.wikipedia.org/wiki/Type_class>. In general, movement away from inheritance is good. The proposal, however, feels a bit like looking for the lost quarter where the light is good, rather than where you lost it. Before considering delegation machinery, let's consider the *value*of an interface. How many interfaces are there? One way to see that is just to consider all the sub interfaces of a single interface with n methods on it. Hmmm... that's 2^n interfaces. That's a lot. Does that give us any confidence that any one way of carving up functionality via interfaces is going to be sane? Further, in practice, do we see random distribution through this very large space? What we see over and over again in practice is that the answer to these questions is 'no!'. That means that there is *something* that binds a collection of methods together. What might that something be? One place to look is mathematics. Which maths should we look at? The maths of category has been very fruitful both in explaining existing functional programming techniques and -- perhaps more importantly -- suggesting ways to improve them as well as wholly new techniques. What we find in category theory is that it is natural to collect maps (read functions) together. A good example of such a beast is a monad. A monad -- viewed categorically -- is - a map, T, taking types to new types and functions on those types to new functions. Let's call the universe of types and functions expressible in our model of computation (as proscribed by our programming language), C. Then T : C -> C. - a higher order map, unit. Just like T takes C to C, we can understand a "noop" like map that takes C to C, call it Id. Then unit : Id -> T. We intuitively think about it as putting basic types inside the container T, but it's really a higher order map. - another higher order map, mult : T^2 -> T. We talk about it as a kind of flattening (and in Scala it's called flatMap), but it's a higher order map. Now, one is not finished spelling out a monad when giving this collection of maps. One must also show that they satisfy certain constraints. - T is functorial, meaning T g f = T(g) T(f) - unit and mult are natural transformations, look up the meaning because unpacking it here would take to long - mult( mult T ) = mult( T mult ) - mult( unit T ) = mult( T unit ) This set of constraints must go with the monad. This example provides a little more detail in terms of what binds a group of maps together, and hence of what *might* replace the notion of interface and *explain* what we see in practice. Good programmers invariably pick out just a few factorizations of possible interfaces -- from the giant sea of factorizations (read different ways to carve up the functionality). The reason -- i submit -- is because in their minds there are some constraints they know or at least intuit must hold -- but they have no good way at the language level to express those constraints. A really practical language should help the programmer by providing a way express and check the constraints that hold amongst the maps in an interface. i submit that this idea is not the same as "design by contract". i am not proposing an Eiffel-like mechanism. Again, taking a functional approach to computation via category theory leads one towards modeling interfaces as categorical "situations" like monads, comonads, distribution laws, etc. This means that a large number of the constraints come down to - functoriality - naturality - coherence Language support for this approach might include *keywords for these kinds of assertions*. It is a gnarly beast to offer automatic and/or compiler support for checking general constraints. Even this limited family of constraints that i'm proposing can generate some very difficult computations, with very bad complexity. However, for those situations where a general purpose solution to check assertions of functoriality, naturality and coherence are infeasible, one can use these hints to generate tests to probe for possible failures. This idea follows the in the same spirit of replacing proof with proof-checking. Of course, this is not the only way to go. i've yet to be convinced that category theory offers a good account of concurrency. Specifically, categorical composition does not line up well with concurrent composition. So, interfaces organized around types for concurrency is also something to consider. In this case, one might find a natural beginning in interfaces in which -- roughly speaking -- the methods constitute the tokens of a formal language the constructors of which are given by the types for concurrency paradigm. Best wishes, --greg On Thu, Sep 17, 2009 at 11:14 AM, Charles F. Munat <charles(a)munat.com>wrote: > http://code.google.com/p/noop/wiki/ProposalForComposition > -- L.G. Meredith Managing Partner Biosimilarity LLC 1219 NW 83rd St Seattle, WA 98117 +1 206.650.3740 http://biosimilarity.blogspot.com

1 0