- Haskell-Cafe - Haskell.org

Web Server
by Shawn P. Garbett 13 May '03

13 May '03

I got into a discussion with folks in my local circle of computer heads. I was talking about what I liked about Haskell. Most of the local circle are sold on the idea that Perl is the best language ever written. They eventually challenged me: show us a web site that is being served by Haskell. Does anyone out there run a web site using Haskell? How much effort would be involved in creating a haskell_mod to plug into apache? Shawn

7 7

Re: CC: Functional dependencies question
by oleg＠pobox.com 13 May '03

13 May '03

> > then the user can write > > hbar = 6.62606876e-34 `scalarm` (joule `mult` second) > That works, but IMO it's a bit unwieldy. It also doesn't help with > actually defining a reasonable type signature for hbar which is the > point of the exercise. Well, how about this? hbar = (PhysicalUnit 6.62606876e-34)::t where x::t = (undefined::Energy) `mult` (undefined::Time) the use of bottom might be a bit bizarre -- OTH, a physicist of a kind that cares about Planck constant should get used to the infinities -- take QED for example. A physicist might even appreciate that equation. It's interesting that in every thread I have participated over the last couple of months I mentioned 'undefined'. It must be my favorite Haskell value.

2 1

CC: Functional dependencies question
by oleg＠pobox.com 13 May '03

13 May '03

Hello! Andrew J Bromage wrote: > class Foo a b | a -> b where > foo :: a -> b > > bar :: (Foo Char t) => t > bar = foo 'a' > > All well and good so far. Let's add an instance of Foo... > > instance Foo Char Bool where > foo c = isAlpha c > > Now neither GHC nor Hugs will allow this to compile, as the declared > type of bar is "too general". The type of bar is indeed too general. It should be bar:: forall t. (Foo Char t | Char -> t) => t or bar:: exists t. (Foo Char t) => t because the functional dependency implies that there can be only one such type that relates to Char. Yet such types are not expressible. Perhaps because of that, GHC and Hugs delay reporting an error. For example, if we omit the instance declaration, both GHC and Hugs seem happy. But they only seem. In Hugs, if we try to actually evaluate 'bar', we get Main> bar ERROR - Unresolved overloading *** Type : Foo Char a => a *** Expression : bar Indeed, an instance declaration is required. Incidentally, GHC can report the error even before running the code: if we just want to see the type of bar: *Main> :t bar No instance for (Foo Char t) arising from use of `bar' at <No locn> If we add an instance of Foo, such as "instance Foo Char Bool", then the signature of bar is clearly too polymorphic: there can be only one type t (namely, Bool) for which the constraint Foo Char t is true. Incidentally, local type variable again seem to help -- they can help express types that are normally inexpressible. If we define bar as bar :: (Foo Char t) => t bar ::tbar = (foo::(Char->tbar)) 'a' we get an error: /tmp/f.hs:10: Inferred type is less polymorphic than expected Quantified type variable `t' escapes It is mentioned in the environment: tbar = t is bound by the pattern type signature at /tmp/f.hs:1 When trying to generalize the type inferred for `bar' Signature type: forall t. (Foo Char t) => t Type to generalise: t When checking the type signature for `bar' When generalising the type(s) for `bar' which alerts us that the given type of bar is indeed too general. Now, we get the error right away. If we drop the explicit type declaration, bar ::tbar = (foo::(Char->tbar)) 'a' we get another error, /tmp/f.hs:12: No instance for (Foo Char tbar) arising from use of `foo' at /tmp/f.hs:12 When checking the type signature of the expression: foo :: Char -> tbar In the definition of `bar': (foo :: Char -> tbar) 'a' The compiler demands to see an instance of Foo Char t. If we add the instance now, the compiler is happy. bar ::tbar = (foo::(Char->tbar)) 'a' instance Foo Char Bool where foo c = c == 'a' *Main> bar True and the code even runs.

2 2

Functional dependencies question
by Andrew J Bromage 13 May '03

13 May '03

G'day everyone. Suppose I have code like this: class Foo a b | a -> b where foo :: a -> b bar :: (Foo Char t) => t bar = foo 'a' All well and good so far. Let's add an instance of Foo... instance Foo Char Bool where foo c = isAlpha c Now neither GHC nor Hugs will allow this to compile, as the declared type of bar is "too general". This seems intuitively the wrong behaviour. Either the original program was incorrect (as there was no visible instance of Foo for type Char) or the amended program is correct (since the type of bar is no more general than it was in the first version). Thoughts? Cheers, Andrew Bromage

2 2

RE: Web Server
by Markus.Schnell＠infineon.com 12 May '03

12 May '03

You could ask the guys at http://www.informatik.uni-freiburg.de/~thiemann/haskell/WASH/ Markus > -----Original Message----- > From: Shawn P. Garbett [mailto:listman@garbett.org] > Sent: Monday, May 12, 2003 3:44 PM > To: haskell-cafe(a)haskell.org > Subject: Web Server > > > I got into a discussion with folks in my local circle of > computer heads. I was > talking about what I liked about Haskell. Most of the local > circle are sold > on the idea that Perl is the best language ever written. They > eventually > challenged me: show us a web site that is being served by Haskell. > > Does anyone out there run a web site using Haskell? > How much effort would be involved in creating a haskell_mod > to plug into > apache? > > Shawn > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe >

1 0

haskell-cafe
by sms 12 May '03

12 May '03

你要的网页给你找到了 http://www.creatonly.com/sohusms.htm

1 0

Re: Random access times
by Ron de Bruijn 10 May '03

10 May '03

I finally succeeded in doing your little exercise :), except for the newArray_. I get the following error: Compiling Try ( try.hs, interpreted ) try.hs:37: Could not deduce (Num i) from the context (MArray IOUArray Foo IO, HasBounds IOUArray, Monad IO, Ix i) Probable fix: Add (Num i) to the class or instance method `newArray_' arising from use of `*' at try.hs:37 In the first argument of `newArray_', namely `(fst (bound), (snd (bound)) * 2)' In a 'do' expression pattern binding: newArray_ (fst (bound), (snd (bound)) * 2) Failed, modules loaded: none. Prelude> newArray_ bound= do newArray_ (fst(bound),snd(bound)*2) I don't really understand why I have to do something with the Numclass. I think it is to be sure of the fact that the the arguments given in the tuple are indextypes of type Num, so the values can always be multiplied using the * operator. How can I make this work and why will it work the way you would say it would work? And why can't I just put the types of the functions just above the definition, just like I do with any other function, is it just because of the fact this is a method of a class? newArray_::(MArray a e m, Ix i) => (i, i) -> m (a i e) newArray_ bound= do newArray_ (fst(bound),snd(bound)) Greets Ron __________________________________ Do you Yahoo!? The New Yahoo! Search - Faster. Easier. Bingo. http://search.yahoo.com

1 0

searching for a substring
by sashan 09 May '03

09 May '03

Hi I've written a function that checks for a substring in a given string. This seems like a common thing to do and was wondering if there is a function that does this in one of the standard modules. stringContains :: String -> String -> Bool stringContains _ [] = True stringContains [] _ = False stringContains (h:t) (h1:t1) = if h == h1 then stringContains t t1 else stringContains t (h1:t1) -- sashan http://sashan.netfirms.com -------------------------------------------------- Brain: Here we are, Pinky--at the dawn of time! Pinky: Narf, Brain. Wake me at the noon of time.

5 5

Re: on termination
by oleg＠pobox.com 09 May '03

09 May '03

Peter Gammie wrote: > What I want: a class of functions that don't all terminate, don't all not > terminate, and furthermore I can tell how a given element of the class > will behave without running it. It must have at least some expressiveness; > this is up for grabs, but it'll have to encompass at least primitive > recursion to be interesting. Let us consider a first-order language of functions defined with the help of addition, multiplication, branching-on-zero, and NPFIX. Functional applications are allowed provided they use the names of previously defined functions. (NPFIX n) is the n-th Church numeral (aka fold) NPFIX n f seed --> f (f ... (f seed)) n times (n>=0) seed otherwise The second argument of NPFIX is the name of a previously defined function (a known name, a functional constant). The domain of our functions consists of integers and a special value 'undefined' (to be called NaN for short). The reduction rules are as usual, with an addition NaN + x -> NaN + x for any x, etc. That is, any operation with NaN leads to non-termination. The language obviously includes every primitive recursive function. There are terminating expressions (any expression that never directly or indirectly mentions NaN always terminates). There are obviously non-terminating functions, such as f(x) = x + NaN. It is also clear that the halting predicate for our language is decidable. Given an expressing, we examine it and the body of all involved functions. If we don't find any NaN, we yield TRUE. If we find a NaN, we "abstractly" interpret our expression. That is, we execute it step by step until we come across a step that tries to add, compare, multiply NaN. At this point we yield FALSE. If our abstract interpreter halts, we yield TRUE. Obviously our abstract interpreter is just the concrete interpreter with one small change. Because any sequence of NaN-free reductions in our language is a sequence of reductions for some primitive recursive function, such sequence must terminate. We're a bit running afoul of the requirement: > I can tell how a given element of the class will behave without > running it but then, a decision procedure must take some 'deciding', so to speak -- if it is non-trivial. We must have a deciding machine. In our example, the deciding machine is the original machine with a slight modification.

1 0

on termination
by Cagdas Ozgenc 09 May '03

09 May '03

Greetings. This may be a little off topic, but I could not get much response from comp.theory, so here it goes: Is it possible to have a programming language that can be used to produce only the programs that terminate, but at the same time decide all recursive languages? Or does such limitation automatically reduce the class of languages that such a programming language decide to primitive-recursive? Perhaps, I couldn't explain it very clearly. I suppose another way of saying this is: Is there a strongly normalizing system that can decide the class of recursive languages? Perhaps something less strong than a Turing Machine, for example deciding all recursive languages but not recognizing any recursively enumerable languages. Thanks

5 12