- Haskell-Cafe - Haskell.org

RE: Numeric literals
by Chris Angus 28 Aug '01

28 Aug '01

this is a bit ugly but would allow you to do if (x `isA` string) ... or (x `isA` int) ... int = int::Int string = string::String typeBind :: a -> ReadS a -> ReadS a typeBind _ x = x isA :: Read a => String -> a -> Bool isA s x = not (null (typeBind x (readsPrec 0) s)) -----Original Message----- From: Simon Marlow [mailto:simonmar@microsoft.com] Sent: 28 August 2001 15:53 To: Mark Carroll; haskell-cafe(a)haskell.org Subject: RE: Numeric literals > I also haven't yet worked out how to tell if a string is "read"able or > not, yet - if (read "45")::Integer or whatever gives an error > (e.g. if I'd > put "af" instead of "45"), it seems to be pretty uncatchable, > which is a > pain. How do I tell if an instance of reading will work, or > catch that it > didn't? In GHC, you can do this: import Exception do result <- catch (evaluate (read "foo" :: Int)) (\error -> ... ) but unfortunately read doesn't raise a useful exception (just error "Prelude.read: no parse"), so you can't filter it very easily. However I don't think that read is likely to raise any other exceptions. Cheers, Simon _______________________________________________ Haskell-Cafe mailing list Haskell-Cafe(a)haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe

1 0

Re: Easy syntax question
by Marcin 'Qrczak' Kowalczyk 27 Aug '01

27 Aug '01

Mon, 27 Aug 2001 15:02:24 -0400 (EDT), Mark Carroll <mark(a)chaos.x-philes.com> pisze: > Generally, this is a question about where multiple cases lead to the same > thing, maybe even in the middle of a function. (Like C's "case 1: case 2: > case 3: foo; break;".) Apart from what others said, if the common expression is big, the common solution is to bind it outside using 'let' or 'where'. -- __("< Marcin Kowalczyk * qrczak(a)knm.org.pl http://qrczak.ids.net.pl/ \__/ ^^ SYGNATURA ZASTÊPCZA QRCZAK

1 0

Numeric literals
by Mark Carroll 27 Aug '01

27 Aug '01

Today's other question has to do with numeric literals. How do I write literals for interesting IEEE values, e.g. Prelude> x Infinity Prelude> :type x Double Prelude> (read "Infinity") :: Double *** Exception: Ratio.%: zero denominator Prelude> ...? If I'm just missing something obvious in the standard documentation, please feel free to just give me a citation. I've already tried sections 2.5 and 6.4.1 of the Haskell Report, etc. though. Thanks. -- Mark

1 0

Easy syntax question
by Mark Carroll 27 Aug '01

27 Aug '01

I can write a function x :: Integer -> Integer that returns 5 if I give it 2, 5 or 9, or 7 otherwise. Say, x 2 = 5 x 5 = 5 x 9 = 5 x _ = 7 Generally, this is a question about where multiple cases lead to the same thing, maybe even in the middle of a function. (Like C's "case 1: case 2: case 3: foo; break;".) Does it get any better than this, though? I can't convince 'case' to do something like, case n of 2,5,9 -> 5 otherwise -> 7 Am I missing some syntax somewhere? I'm lost in the grammar in the Haskell report. -- Mark

2 1

Re: GHC Mandrake problem
by Pixel 24 Aug '01

24 Aug '01

Hampus Ram <d00ram(a)dtek.chalmers.se> writes: > > Loading package std ... ghc-5.00.2: can't find .o or .so/.DLL for: m (lib.so: cannot open shared object file: No such file or directory) > > > > Can anyone tell me what's missing, or how to fix this?? > > A _very_ ugly "fix" for this problem is to make a symbolic link to > libm.so and call it lib.so. Maybe a nicer fix:

1 0

GHC Mandrake problem
by phaywood＠mail.iprimus.com.au 24 Aug '01

24 Aug '01

Hello, I tried to install version ghc 5.00.2 & prof from mandrake (vers 8.0 with current updates). It installed fine, but i get this message when i try to run ghci: Loading package std ... ghc-5.00.2: can't find .o or .so/.DLL for: m (lib.so: cannot open shared object file: No such file or directory) Can anyone tell me what's missing, or how to fix this?? TIA -------------------------------------------------------------------- Mail2Web - Check your email from the web at http://www.mail2web.com/ .

2 1

Re: 2 points on language
by D. Tweed 24 Aug '01

24 Aug '01

On Fri, 24 Aug 2001, S.D.Mechveliani wrote: > D. Tweed <tweed(a)compsci.bristol.ac.uk> writes > > On a purely pragmatic note ( :-) ) these optimisations can't necessarily > > be safely used in three of the four most common cases, namely Int, Float > > and Double because of the restricted range of intermediates. > Int, Float, Double > are not supposed to be provided with the CommutativeRing instance. > And most common cases are, to my mind, different: > Integer, Rational, (Integer, Rational), Polynomial Integer ... Ah, I must admit I'd rather missed the point that you were only intending them to apply to things that were of the algebraic class `Commutative Ring'. I was thinking that it'd be something where a particular funciton over a (possibly polymorphic) type could be declared associative, commutative, etc and then those more elementary classes came together in the particular example of the CommutativeRing. For example, the operator ++ on lists is associative, there are useful computational savings to be made utilising this (IIRC Lennart Augustsson had this specal cased in the hbc compiler), but it's difficult to see how you gain anything by trying to pin down any of the other properties of lists that would figure in the mathematically standard classes (there's no inverse as far as I can see so we don't even make it as far as a group). I think from the point of view of lobbying compiler implementors to put in the spade work to make this happen you're more likely to get support if the elegant algebraic classes come as a neat combination of more low-level, `unstructured' features. Don't get me wrong, I like the idea of extending the power of the Haskell compilers, I was just pointing out that the obvious thought that associative- and commutative-rewrite based optimisation `will also be very helpful for programs that are doing "everyday arithmetic" operations (say running a Kalman filter over a sequence of data represented using Doubles)' isn't necessarily true, and it certainly wasn't obvious to me: it was only happening upon the reference in the MetaFont book that made me realise it. ___cheers,_dave________________________________________________________ www.cs.bris.ac.uk/~tweed/pi.htm |tweed's law: however many computers email: tweed(a)cs.bris.ac.uk | you have, half your time is spent work tel: (0117) 954-5250 | waiting for compilations to finish.

1 0

Braces vs. Whitespace
by Ashley Yakeley 22 Aug '01

22 Aug '01

At 2001-08-21 20:31, Dean Herington wrote (on the Haskell list): >Now realizing that the "where" keyword is optional when there are no >accompanying declarations, I think it would be preferable to omit the >"where" keyword to indicate that the absence of declarations is >intentional. Personally I prefer the explicit braces/semicolons syntax rather than worrying about whitespace: module DeepSeq where { class DeepSeq a where { deepSeq :: a -> b -> b; deepSeq = seq; -- default, for simple cases }; ... instance DeepSeq Ordering; instance DeepSeq Integer; instance DeepSeq Int; instance DeepSeq Float; instance DeepSeq Double; } ...or if you prefer... module DeepSeq where { class DeepSeq a where { deepSeq :: a -> b -> b; deepSeq = seq; -- default, for simple cases }; ... instance DeepSeq Ordering; instance DeepSeq Integer; instance DeepSeq Int; instance DeepSeq Float; instance DeepSeq Double; } etc. Basically you put a braced block after every 'do', 'in' and 'where', and semicolons after every declaration. When I was first learning Haskell, I got massively confused by the whitespace rules, especially with mixed tabs/spaces etc. I reckon the braces style is more readable to anyone used to C/C++/Java etc. -- Ashley Yakeley, Seattle WA

1 0

Re: Subtyping
by Fritz K Ruehr 21 Aug '01

21 Aug '01

[sorry about that, let's try again...] Ross Paterson wrote (in regards variations on factorial): > Another version: > > fac = foldr (*) 1 . unfoldr (\n -> guard (n > 0) >> return (n, n-1)) Thanks for forwarding this; may I quote it on the web site? (with full attribution, of course) If so, you are welcome to give it a name and a pithy little "slogan" (also for the one below). > Also, the combinatory programmer would regard defining y by recursion > as cheating, and would probably prefer one of these versions: > > newtype SelfApp a = SA (SelfApp a -> a) > > selfApply :: SelfApp a -> a > selfApply (SA f) = f (SA f) > > yCurry :: (a -> a) -> a > yCurry f = selfApply (SA (\x -> f (selfApply x))) > > yTuring :: (a -> a) -> a > yTuring = selfApply (SA (\x f -> f (selfApply x f))) Yes, this is definitely the right way to go here. I comment on the site about the fact that we should really *define* Y (and I felt a bit guilty about it :) ), but I didn't try hard enough to get around the typing issue. You have done so quite elegantly. Of course, there is also a trade-off at some point between the impact of the various examples and their sheer number (I added an environment-model based interpreter yesterday that started to push this boundary). Still, more monads (arrows, even?) are needed. -- Fritz Ruehr PS: for those who missed it, the site is at: <http://www.willamette.edu/~fruehr/haskell/evolution.html>

1 0

Re: Subtyping
by Fritz K Ruehr 21 Aug '01

21 Aug '01

Ross Paterson wrote (in regards variations on factorial):

1 0

Re: GHC Mandrake problem
by Pixel 21 Aug '01

21 Aug '01

"phaywood(a)mail.iprimus.com.au" <phaywood(a)pop.iprimus.com.au> writes: > Hello, I tried to install version ghc 5.00.2 & prof from mandrake (vers 8.0 > with current updates). It installed fine, but i get this message when i try to > run ghci: > > > Loading package std ... ghc-5.00.2: can't find .o or .so/.DLL for: m (lib.so: > cannot open shared object file: No such file or directory) booh :'-( it tries to find m.o then tries lib.so > > Can anyone tell me what's missing, or how to fix this?? i don't know either. It used to work. I'm currently trying a rebuild...

1 0

Re: Subtyping
by Fritz K Ruehr 21 Aug '01

21 Aug '01

Frank Atanassow wrote: > This is a situation where the explicit fixpoint datatype comes in handy: > > data Fix f = In (f (Fix f)) > > ... > > BTW, this is not a beginner, or even intermediate, Haskell programmer's > technique. For those who are interested in what exactly is or isn't a beginner or intermediate Haskell programmer's technique, I humbly offer the following <http://www.willamette.edu/~fruehr/haskell/evolution.html> which includes examples of the afore-mentioned approach, along with many others, from accumulating parameters to comonads. Fair warning: tongue held firmly in cheek ... -- Fritz Ruehr fruehr(a)willamette.edu

2 1

Modular arithmetic
by Dylan Thurston 21 Aug '01

21 Aug '01

They said it couldn't be done! They said Haskell didn't have dependent types! Here's a way to mimic dependent types using existential types, illustrated by an implementation of modular arithmetic. To try it out, load modulus.hs and try something like Modulus> inModulus (mkModulus (1234567890123::Integer)) (^98765432198765) 2 1160454313058 to compute 2 to the 98765432198765'th power modulo 1234567890123. The key is the definitions at the top of TypeVal.hs: > class TypeVal a t | t -> a where > -- typeToVal should ignore its argument. > typeToVal :: t -> a > > data Wrapper a = forall t . (TypeVal a t) => Wrapper t > > class ValToType a where > valToType :: a -> Wrapper a `valToType' takes a value `x' and returns a (wrapped version of a) fake value in a new type; from the new type, `x' can be recovered by applying typeToVal. This code works under ghc. It uses existentially quantified data constructors, scoped type variables, and explicit universal quantification. Enjoy, Dylan Thurston

1 1

Singular Type Constructor
by Ashley Yakeley 21 Aug '01

21 Aug '01

Consider: -- data T a = T -- Is there anything in the Prelude or a standard library that looks like this? Should there be? What should it be called? 'Singleton'? 'Reified'? 'T'? I looked but couldn't find anything. Such a simple type constructor is in fact very useful when you need to pass types around to disambiguate class instances. For instance: -- class HasTypeName t where getTypeName :: T t -> String instance HasTypeName Int where getTypeName T = "Int" instance HasTypeName () where getTypeName T = "()" intName = getTypeName (T :: T Int) -- -- Ashley Yakeley, Seattle WA

3 2

deriving
by Mark Carroll 20 Aug '01

20 Aug '01

Does anyone know of any Haskell texts that introduce 'deriving' fairly comprehensively? All I've been able to find out from what I have is that your type can derive Eq, Ord, Show etc. and then they'll magically work as if you'd written the instance declarations yourself. I've no idea how you can make your own type classes that types can 'derive' from, etc. IYSWIM, or really what's going on at all. -- Mark

2 2

Re: Subtyping
by Mansour Al-Mutairi 20 Aug '01

20 Aug '01

Hi, I am a newbie but I think that what you are proposing can be simulated in haskell. It is like subclassing in OOP. You can create a new type that is an extension of the older one. Unlike OOP overloading, you will need to create a new function that can work on the new type. >data SomeObject = SomeInt Int | SomeString String | _ will become: data SomeObject = SomeInt Int | SomeString String >...later... > >data SomeObject |= SomeReal Double will become: data SomeObject2 = SO SomeObject | SomeReal Double >same :: SomeObject -> SomeObject -> Bool >same (SomeInt a) (SomeInt b) = a == b >same (SomeString a) (SomeString b) = a == b >same _ _ = False > >...later... > >same (SomeReal a) (SomeReal b) = a == b will become: same :: SomeObject -> SomeObject -> Bool same (SomeInt a) (SomeInt b) = a == b same (SomeString a) (SomeString b) = a == b ...later... same2 :: SomeObject2 -> SomeObject2 -> Bool same2 (SomeReal a) (SomeReal b) = a == b same2 x y = same x y tell me if I am wrong. thanks. Mansour Al-Mutairi :) _________________________________________________________________ Get your FREE download of MSN Explorer at http://explorer.msn.com/intl.asp

2 1

Re: trying to run programs
by Patrik Jansson 20 Aug '01

20 Aug '01

[I move this thread to haskell-cafe.] On Mon, 20 Aug 2001, Johansson Mikael wrote: > I'm starting up using a GHC-compiler and have successfully compiled a simple > "Hello World" program. Thanks for the responses. > Now I'm trying to use some simple programs from haskell.org/hugs but there are > problems. > > AnsiDemo.hs:10: Variable not in scope: `writeStr' > > It seems some object are missing. I have tried to find them > in ghc/lib/imports and others but haven't succeded. > Is there some libraries I need to run these hugs-files on > my ghc-compiler? AnsiDemo.hs imports some hugs-specific files (AnsiInteract.hs, ...) which are also available in the hugs distribution but (somewhat confusing for your use) not in the demos directory. [Maybe the hugs example suite could be transformed into a stand-alone Haskell example suite? Any takers?] If you have hugs installed, then the necessary files are in ../lib/hugs (seen from the demos directory). I think the files for AnsiDemo are propoer Haskell 98 and not using any hugs-extensions so it should work. (Using ghci-5.0 it "compiles" OK, but on my Solaris xterm the printing is delayed - that might work better under Window$.) For use with ghc the required files could either be copied/moved into the demos directory, or you could start ghc with -i../lib/hugs added to the command line (so that it searches theat directory as well). I attach a tarball with the directory tree including lib and demos from my installation of hugs. Good luck, Patrik Jansson

1 0

Need help to get GTK bindings working
by mgross＠dorsai.org 19 Aug '01

19 Aug '01

I've got ghc5 running, have downloaded all the documented bits and pieces for the GTK bindings, done the compiles, modifed the package.conf file (probably incorrectly, since I haven't been able to find complete documentation on the contents of that file), and am having a variety of difficulties--like reported missing exports (which aren't missing from the .hi file), etc. Would some kind soul out there be willing to do a bit of hand holding off list to get this thing working? After the job is done, we can post the results as instructions for others to follow. Thanks in advance. Murray Gross mgross(a)dorsai.org

2 1

Re: Subtyping
by Ashley Yakeley 19 Aug '01

19 Aug '01

At 2001-08-18 17:29, Mansour Al-Mutairi wrote: >data SomeObject2 = SO SomeObject | SomeReal Double ... >same2 :: SomeObject2 -> SomeObject2 -> Bool >same2 (SomeReal a) (SomeReal b) = a == b >same2 x y = same x y This won't help you if you already have modules that use 'SomeObject' and 'same'. In OOP you can extend a 'Base' class in module M1 with a 'Derived' class in module M2. M1 knows nothing about 'Derived', and yet code in M1 that manipulates 'Base' objects will be able to handle 'Derived' objects, since every 'Derived' object is also a 'Base' (upcasting). Furthermore it is possible for M2 to determine whether a 'Base' object from a function or structure in M1 is also a 'Derived' object and use it appropriately (downcasting). You can't do this in Haskell (or O'Haskell for that matter), though you could with extensible data-types: module M1 where data Base = _ foo :: Base -> Integer foo _ = 0 module M2 where data Derived = MyDerived Int Char data Base |= DerivedBase Derived foo (DerivedBase (MyDerived i _)) = i upcast :: Derived -> Base upcast = DerivedBase downcast :: Base -> Maybe Derived downcast (DerivedBase d) = Just d downcast _ = Nothing -- Ashley Yakeley, Seattle WA

1 0

Re: Subtyping
by Ashley Yakeley 19 Aug '01

19 Aug '01

At 2001-08-18 06:15, Marcin 'Qrczak' Kowalczyk wrote: >Later additions to the function would have to be restricted to match >at least one constructor defined in the current module, to make the >combined definition independent of the order of additions - modules >are by nature unordered. Agreed. >And something more - this is not enough for >unambiguous definition: > -- Base definition > foo :: SomeObject -> SomeObject -> Int > foo _ _ = 0 > -- Module 1 > foo (SomeInt a) _ = 1 > -- Module 2 > foo _ (SomeString a) = 2 > -- Which argument is evaluated as the first? > -- What is called for foo (SomeInt 0) (SomeString "")? The first argument would take priority. So Haskell would assemble these cases in this order: foo (SomeInt a) _ = 1 foo _ (SomeString a) = 2 foo _ _ = 0 If Module 2 included Module 1, it could do this: -- Module 2 foo _ (SomeString a) = 2 foo (SomeInt a) (SomeString a) = 2 In which case, the cases would be assembled in this order: foo (SomeInt a) (SomeString a) = 2 foo (SomeInt a) _ = 1 foo _ (SomeString a) = 2 foo _ _ = 0 -- Ashley Yakeley, Seattle WA

1 0

Re: Subtyping
by Marcin 'Qrczak' Kowalczyk 18 Aug '01

18 Aug '01

Sat, 18 Aug 2001 01:05:17 -0700, Ashley Yakeley <ashley(a)semantic.org> pisze: > One possible solution would be to extend Haskell with "open" > algebraic data types. > This seems to me straightforward, but perhaps not very useful unless > there's a way of declaring "generic" functions on these types that > can be extended somehow later: Indeed. Later additions to the function would have to be restricted to match at least one constructor defined in the current module, to make the combined definition independent of the order of additions - modules are by nature unordered. And something more - this is not enough for unambiguous definition: -- Base definition foo :: SomeObject -> SomeObject -> Int foo _ _ = 0 -- Module 1 foo (SomeInt a) _ = 1 -- Module 2 foo _ (SomeString a) = 2 -- Which argument is evaluated as the first? -- What is called for foo (SomeInt 0) (SomeString "")? > But would this sort of thing solve your problem? Yes, although now I think that this use would be equivalent to using Dynamic, only with a prettier syntax. There is a particular case which could make use of extensible functions and can't be simulated with Dynamic, but I would use a different solution anyway (the same as I would use now with Dynamic) - for speed. The situation is as follows: The interpreted language (BTW, designed and implemented purely for fun, no serious external reason) introduces the concept of type in the standard library. A type is represented as a symbol (term without arguments). Unique symbols are born by calling a builtin function, and obtaining bindings is generally associated with executing some code (like value bindings in ML). How a type is determined: - Function is called with a distinguished argument (Type) and is supposed to return its type. - Terms have types depending on their symbol, looked up in a dictionary. - Integers and strings have types Integer_t, String_t. Type are used to look up definitions of generic functions in dictionaries, usually depending on the first argument. There is also a dictionary of supertypes, so e.g. equality on Bool_t uses the implementation of equality on Term_t if not defined directly. Suppose that arbitrary foreign Haskell objects would be included in values, wrapped as Dynamic. How to determine the type of such an object? It's trivial to return a generic Haskell_t, but there is no way to make further classification otherwise than invoking foreign functions checking for particular Haskell types in sequence (the functions would have to be registered somehow). With open algebraic types it can be done. Just define a generic function for returning the type, and populate its definition in modules providing particular foreign object types. Fortunately it can be done better than both solutions and it's compatible with Dynamic. Just include a representation of type in the value, along with Dynamic holding the actual object. Since most actions on such object would begin with determining its type, it's good to have it ready instead of looking it up in a dictionary. It requires foresight that checking types of foreign objects will be needed, but well, I indeed know now that it's needed. And it's enough. Since type is used for classification to the granularity equivalent to Haskell types sitting inside the Dynamic, further dispatching can be done in the language proper, looking up the type in dictionaries, as for all its generic functions, and they will usually assume a concrete Haskell type inside the Dynamic. It happens that the language uses open algebraic types itself, only without static typechecking. All algebraic types are open: one can always register more symbols for a particular type, or produce functions which return such type for a Type request (it can be considered lying about their types). But expect that registering something non-standard as a Bool_t and passing it to functions expecting a Bool_t will usually surprise these functions and many of them will refuse to work. There is a continuum between making new types and using open algebraic types. Constructors for exceptions are born as other terms with unique symbols. You can either register them under a generic Exception_t type or give them new types; it doesn't matter for how they are caught if all these types use the same generic pattern matching implementation for Term_t. Either way you can implement patterns which perform matching in any fancy way (e.g. look up in a hierarchy of exception symbols they maintain). -- __("< Marcin Kowalczyk * qrczak(a)knm.org.pl http://qrczak.ids.net.pl/ \__/ ^^ SYGNATURA ZASTÊPCZA QRCZAK

1 0

Subtyping
by Ashley Yakeley 18 Aug '01

18 Aug '01

At 2001-08-14 03:46, Marcin 'Qrczak' Kowalczyk wrote (on the Libraries list): >> I've noticed that the more I use Haskell, the less I miss >> subtyping... classes and "data" unions are almost always sufficient. > >They are sometimes a better match than subtyping (e.g. parametrizing >a gcd algorithm by a type) and sometimes they are not capable at all >(e.g. heterogeneous collections when the set of possible types is >open). I'm a big fan of Haskell's typing and I'm not a fan of OOP, >but Haskell is sometimes not as expressible as the OO way. One possible solution would be to extend Haskell with "open" algebraic data types. For instance: data SomeObject = SomeInt Int | SomeString String | _ ...later... data SomeObject |= SomeReal Double The "_" would mark a data type as 'open', and the "|=" syntax would be used to extend it in another module. This seems to me straightforward, but perhaps not very useful unless there's a way of declaring "generic" functions on these types that can be extended somehow later: same :: SomeObject -> SomeObject -> Bool same (SomeInt a) (SomeInt b) = a == b same (SomeString a) (SomeString b) = a == b same _ _ = False ...later... same (SomeReal a) (SomeReal b) = a == b -- this case needs to be "inserted" somehow But would this sort of thing solve your problem? -- Ashley Yakeley, Seattle WA

1 0

Emacs
by Mark Carroll 17 Aug '01

17 Aug '01

Is it just me, or does haskell-indent-mode sometimes have some surprising ideas about how much to indent? That Haskell modes exist at all is wonderful. (-: -- Mark

1 0

Re: Deep confusion about monads
by Mark Carroll 17 Aug '01

17 Aug '01

Gosh, thank you everybody! Let me try to summarise where I am, given all the help. haskell-cafe is an okay place to ask this stuff. (-: I should also check out the wiki too; it looked a bit scary to use last time I looked, but it seems to have relevant stuff. It's a pity that the mailing list archives aren't more easily searched; maybe applying google to them would work. Part of my confusion was due to a usual problem with teaching. People come in to a lesson with preconceived ideas X, the teacher tells them stuff Y, and instead of coming out of the lesson thinking Y, they come out thinking f(X,Y), because the teacher didn't tell them not-X. It's instructional to ask children where they think trees' mass comes from as they grow, after a lesson on the subject. I originally thought that "IO a" meant "an a whose value may depend on some IO that was done", as if that data were tainted by other data it touched which stemmed from IO actions. Instead, "IO a" it appears to mean "some IO action you can do that will give an a", and you can only do stuff with the "a" within an "IO-aware" context. A Haskell program is an IO action. I got the idea of tainted data from Perl, which is a security aid to help you ensure that any data drawn from outside your program has to be approved by you before your program can use it to affect other things outside your program. Try to keep most code functional, even if this means that your monadic code uses very complex referentially-transparent helper functions. I hadn't bumped into Theo Norvell's monad tutorial yet. I'm guessing that it's the one at http://www.engr.mun.ca/~theo/Misc/haskell_and_monads.htm ? I'll take a look. There is a concept of being in the IO monad. My current concept of "A >>= B" is that it helps let B into the monad that A's in. This is how 'head' is let in by readFile "/etc/hosts" >>= (return . head) I find fmap deeply strange, though, because I don't really understand functors. People pointed me towards fmap, and I figured from IO's instance of Functor that fmap head $ readFile "/etc/hosts" also works, so I plan to learn a little category theory to help find out why this makes sense. (Someone also taught me how to use $. (-:) >>= actually has the type (Monad m) => m a -> (a -> m b) -> m b That makes some sense. I get >> and the syntactic sugar of 'do' looks fairly simple so I'll probably start using that more once I'm happy with the translation between that and >>= All the best, Mark

1 0

RE: Namespace clashes
by brk＠jenkon.com 17 Aug '01

17 Aug '01

> -----Original Message----- > From: Mark Carroll [SMTP:mark@chaos.x-philes.com] > Sent: Wednesday, August 15, 2001 10:11 PM > To: haskell-cafe(a)haskell.org > Subject: Namespace clashes > > When I use Haskell, I'm still tripping over reserved words; lately I tried > to use 'type' as a data field name, for example, and was somewhat > irritated to note that I can't. (Can I?) What gives me the willies is that > [Bryn Keller] Personally, I don't mind this sort of thing and I find the import capabilities in Haskell sufficient for most purposes. However, I'm new enough to Haskell that I sometimes have a hard time figuring out what I've done wrong from the error messages. Here's one such: func x = do data <- readFile x return data Where the problem is that I've mistakenly used the reserved word 'data' for a name binding. Here's the error message I get for that: scratch.hs:3: Empty 'do' construct But I'm learning. :-)

2 1

Deep confusion about monads
by Mark Carroll 17 Aug '01

17 Aug '01

Let me know if I'm bugging you guys too much. It'd be great if I had someone close at hand who knew more about Haskell than I do, but unfortunately I don't. Are there any fora that are especially for people to help novices, or is haskell-cafe the best fit? I decided I ought to learn more about monads, so I've been trying to do simple IO. However, I'm running into really basic problems that I haven't managed to solve with the three monad tutorials I've read so far! First, given an IO String, I don't seem to be able to take the head of it to get an IO Char. I'm guessing that the IO monad is quite unlike the simple 'tainting' I first imagined; I reall do seem to have to treat it as an abstract polymorphic type. Worse, I can't work out how to write a IO String -> IO Char version of head; I can't make my (x:xs) match an IO String! Better would be if I could somehow write an IO String -> IO Char wrapper for head. I'm also confused as to why I can write: readFile "/tmp/foo" >>= putStr to print out the contents of a file but, in ghci, let x = readFile "/tmp/foo" putStr x ...doesn't work. Then again, I'm also confused by the way that Simon Thompson's book says that, (>>=) :: IO a -> (a -> IO a) -> IO a which I think might be a misprint for, (>>=) :: IO a -> (a -> IO b) -> IO b ...? I'm not sure if I've explained enough of my confusion that a succinct, helpful response not mentioned in what I've read so far can be easily given. I guess that my problem is that I had initially imagined that the prefix 'IO' appears as a magical tainting of any data that could depend on the result of some IO action. However, I'm coming to the conclusion that I'm quite wrong in this. I'd like to be able to manipulate IO Strings as if they were just strings that I can't forget came from IO, but I'm guessing now that things aren't that simple - they really are quite different to strings, yet I want to avoid resorting to unsafePerformIO. The really annoying thing is that all the monad examples I've read so far have made perfect sense to me. (-: What I'm really hoping is that a simple answer as to how best to arrange my IO String -> IO Char (or IO [a] -> IO a) version of head will somehow resolve a lot of my confusion. For instance, maybe I have to somehow write an 'action' version of head that I apply with the help of >>= ? -- Mark

4 6

Re: Deep confusion about monads
by Ashley Yakeley 17 Aug '01

17 Aug '01

At 2001-08-16 16:30, I wrote: >>(>>=) :: IO a -> (a -> IO b) -> IO b > >This one is correct. Whoops! No it's not. It should be: (>>=) :: (Monad m) => m a -> (a -> m b) -> m b The other two are however special cases of this type. -- Ashley Yakeley, Seattle WA

1 0

Re: Deep confusion about monads
by Ashley Yakeley 17 Aug '01

17 Aug '01

At 2001-08-16 13:30, Mark Carroll wrote: >in ghci, > >let x = readFile "/tmp/foo" x here has type "IO String" >putStr x putStr wants x to be type "String". You want this: do { x <- readFile "/tmp/foo"; putStr x; } ...which is translated to... readFile "/tmp/foo" >>= (\x -> putStr x) >(>>=) :: IO a -> (a -> IO b) -> IO b This one is correct. -- Ashley Yakeley, Seattle WA

1 0

Qualified imports
by Mark Carroll 16 Aug '01

16 Aug '01

In writing a large program, do people tend to just name all their functions differently, or do they make much use of qualified imports? I'm currently facing this design decision in starting my first significant Haskell project and I'd prefer to do whatever's conventional in the Haskell community. Personally, I'd probably veer towards all the qualified stuff, given that I'm the sort of person who never uses 'import' in Java, but then I have the question of how to name types that would otherwise be of the form Foo.Foo and look silly. (In Modula-3, Foo.T would be the traditional choice.) -- Mark

2 1

Namespace clashes
by Mark Carroll 16 Aug '01

16 Aug '01

When I used to use Modula-3, I never had to worry about mildly-surprising namespace clashes. This was for two reasons: (a) Functions imported from other modules could only be referred to by prefixing their name with their module's name. (b) All system-provided keywords were upper case, and one named variables and functions using mixed case or lower case. When I use Haskell, I'm still tripping over reserved words; lately I tried to use 'type' as a data field name, for example, and was somewhat irritated to note that I can't. (Can I?) What gives me the willies is that a later Haskell might introduce a new keyword or a new Prelude function that clashes with something I define myself (not that it's that unstable, I know). Of course, I haven't tried this, but maybe if I always did an "import qualified Prelude"-type thing, that might mean I was always definitely safe from at least Prelude extensions though not language changes, but maybe at the price of my code looking real nasty! I'm not exactly complaining here; I suppose Lisp had the same problem. I'm just noting the thought. (-: Overall, I'm quite enjoying playing with Haskell. -- Mark

1 0

RE: newbie conceptual question [from haskell list]
by Frank Atanassow 16 Aug '01

16 Aug '01

[redirected from haskell(a)haskell.org to haskell-cafe(a)haskell.org] David Hughes wrote: > > It seems to me that I can still use functional > > programming paradigm with an imperative language. How can I benefit more > > from a functional programming language (i.e.Haskell)? > Point One: functional languages are powerful. [..] > Point Two: functional languages are beautiful. [..] > Point Three: functional languages are robust; [..] These things are nice, but the more I learn about functional languages, the more I feel that they are only icing on the cake. The most important thing about functional languages is that we know _what they are_, and that they can be characterized in a regular fashion which is amenable to analysis; in other words, we know how to reason about them, and what sorts of properties functional programs satisfy. Saying that a language "satisfies nice properties" sounds abstract and useless to some people who just want to get things done, but I really believe that it helps not only researchers who know know how to read and use formal semantics, but also everyday programmers, because they absorb some of these reasoning methods and then start using them intuitively and unconsciously. For example, every Haskell programmer has some grasp of referential transparency, and uses it implicitly every time he thinks about how to structure or rearrange his programs. Of course, this argument holds for any "simple" language, not just functional ones, where by "simple" I mean "easy to reason about". For example, there are concurrent calculi of processes, object calculi and first-order algebraic languages which also share this property, and I prefer any of them to warty conventional languages. (And this is why I also like SML: even though it's not referentially transparent like Haskell, I know what sorts of properties it satisfies.) > Point Four: functional languages are difficult are learn. [..] I would say "there is more in functional languages to learn about than there is in conventional languages". I get the feeling that programmers who come into FP from more conventional languages expect that FP will be just like C, only with a few new features and the syntax mixed up a bit, because if you look at the world of conventional languages---C, C++, Pascal, Java, Python, Perl, Ruby, FORTRAN---it is almost invariably true: there is hardly any difference between these languages, except surface syntax, and the fact that in some of them you have to macro-define what is a built-in in another. So they are all about the same level of difficulty, because they are really no genuinely new concepts, or at least they are not encapsulated in the language. Also, they are mostly implementation-defined: if you roughly know the von Neumann architecture, then you know what to expect. Haskell (and ML) really is different. First, it's not implementation-defined. Second, they satisfy some genuinely new properties. Some of these languages have closures, for example, but they don't obey the same properties as Haskell's higher-order functions because you don't have referential transparency. So you have to start thinking, "OK, is this one of those situations where I _can't_ use this property?", and pretty soon that's all you're thinking about---the exceptions to the rule. (At least, this is what happens to me in, for example, Emacs LISP, where closures can only be passed downwards.) In Haskell, you never have to think about that, because though the context may affect the efficiency of a program, it cannot affect its meaning. > Point Five: there's a dearth of libraries. [..] > Philip Wadler, "What The Hell Are Monads?" The second one is by Noel Winstanley, not Wadler. --- Frank Atanassow, Information & Computing Sciences, Utrecht University Padualaan 14, PO Box 80.089, 3508TB Utrecht, The Netherlands Tel +31 (0)30 253-3261 Fax +31 (0)30 251-3791

6 20

Spotting unnecessary parentheses
by Mark Carroll 13 Aug '01

13 Aug '01

While I'm hesitantly trying to write Haskell, I'm over-using brackets so as to eliminate precedence problems from the list of things I did wrong this time. Is there any easy way of finding out which brackets are unnecessary? Nobody's written a redundancy-remover or anything? (-: I was just wondering how to painlessly come by some intuition on this score... -- Mark

1 0

Re: Singular Type Constructor
by Ashley Yakeley 13 Aug '01

13 Aug '01

At 2001-08-12 11:26, Levent Erkok wrote: >How about using overlapping instances? Add: > > instance Eq a where > _ == _ = True > >to your program: if there isn't a ``better'' instance, it'll use this one. >Such an instance declaration is inherently dangerous to have around, but >might help your particular situation. How do Hugs and GHC calculate "better" instances in this case? I make a distinction between "appears to overlap" and "actually overlaps": the first is what the compilers detect: I only switch off this checking if I have instances that "appear to" overlap but don't "actually" overlap e.g.: -- instance MyClass Bool instance (Num a) => MyClass a -- ...which don't "actually" overlap provided I don't have "instance Num Bool" anywhere. Patching GHC so that it detects instances that "actually" overlap instead of "appear to" overlap is left as an exercise for the reader... -- Ashley Yakeley, Seattle WA

1 0

Re: Singular Type Constructor
by Ashley Yakeley 13 Aug '01

13 Aug '01

At 2001-08-12 16:55, Hal Daume III wrote: >but supposing you wanted a sort of relaxed equality >wherein, if you chould check for equality on the second element, you >would, otherwise you would just check the first element. i would want >to say something like: > >instance (Eq a, Not (Eq b)) => Eq (MyPair a b) where > (MyPair a _) == (MyPair a' _) = a == a' > >But from what you're telling me there's no way to have both of these >instances, correct? There's no 'Not', so you can't have the second one. If you had a 'Not', it would allow some ugliness: -- data PQ = P | Q equalPQ = (MyPair 'a' P) == (MyPair 'a' Q) -- Note that equalPQ is True. But if someone else introduces an "instance Eq PQ" in another module, equalPQ could become False. I think this sort of thing is supposed to be prohibited: code that is correct cannot change its meaning due to modules it does not depend on. -- Ashley Yakeley, Seattle WA

1 0

Re: Singular Type Constructor
by Ashley Yakeley 12 Aug '01

12 Aug '01

At 2001-08-08 23:00, Hal Daume III wrote: >however, if you try something like: > >instance TypeName a where > typeName T = "??" > >it will complain because there must be one non-type variable in the >instance head. Try using "-fglasgow-exts -fallow-undecidable-instances". >moreover, even if this restriction is removed (anyone know what it's >there for?), there will be the problem of overlapping instances with, >say TypeName Char and TypeName a. Correct. And the instances really would overlap, it wouldn't just be GHC complaining that they _might_ overlap but not being able to figure out that they don't. >so i'm wondering if there is a way to specify something like: > >instance Not (TypeName a) => TypeName a where ... No. >that is, this type variable a matches with all a such that a is not an >instance of TypeName... If there were such a thing, it would be incoherent to say: "if a is not TypeName, then a is TypeName with this typeName". >there are other places where i would find such a thing >useful/interesting beyond this TypeName foo, but this seemed like a >good, simple way to explain it... Can you think of a use for it that isn't semantically incoherent? -- Ashley Yakeley, Seattle WA

3 2

Re: from micro-rant to macro-feature
by Malcolm Wallace 10 Aug '01

10 Aug '01

Gary Memovich writes: > Now if we only expanded the flexibility of 'newtype' declarations so > that we could include a conversion function to the underlying type, > and expand the type checking system to automatically add calls to such > a function when needed, and change the syntax so that the constructor > for 'newtype' wasn't limited to identifiers, and change the syntax > some more so that new 'prefix' declarations were available to adjust > the precedence levels of these new constructors, it would be a piece > of cake :-) As a point of interest, nhc98 extends very slightly the Haskell syntax for declaring infix and precedence to permit user-defined prefix operators. For instance: infixl 7 * infixl 6 + prefix negate 6 - The extended syntax is gendecl -> vars '::' [context '=>'] type | fixity [digit] ops | 'prefix' varid [digit] op | and the obvious semantics is that the unary operator is treated as if it were really the varid. Do feel free to play with it. (Note however that this kind of declaration does not change the pattern-matching language for constants - negative integer patterns are just fiddled by the compiler.) Regards, Malcolm

1 0

Re: micro-rant
by Florian Hars 10 Aug '01

10 Aug '01

On Thu, Aug 09, 2001 at 04:55:54PM +0000, Marcin 'Qrczak' Kowalczyk wrote: > Thu, 9 Aug 2001 09:27:40 +0200, Florian Hars <florian(a)hars.de> pisze: > > Yes, getting a sytax error if I write (x-1)*(-x-1) is a real stumbling block. > It's not a syntax error. Yes, I know. It had been suggested to turn it into one, to make the language more regular and easier to learn. Yours, Florian. (Moving the thread to a more appropriate list)

1 0

Re: free variable
by Jon Fairbairn 09 Aug '01

09 Aug '01

> Hi, Hi. This sort of question belongs on haskell-café. I've copied this reply there. > I still have confusing regarding the following case: > > elemNum2 :: Int -> [Int] -> Int > elemNum2 elem list = sum [ 1 | findElem <- list, elem == findElem ] > > the function I wrote finds the number of occurences of an element in a list. > If I change it to the following: > > elemNum2 elem list = sum [ 1 | elem <- list ] > > Now it simply gives the length of the list. OK I understand that "elem" in > the list comprehension defines a new variable on the fly. What I do not > understand is in the first case: > > "findElem <- list" findElem is a new variable, but "list" is not. > "elem==findElem" here for some reason "elem" is not a new variable. > > Why does the rule only apply for "<-" operation, but not "==" for example? > > Thanks <- and let ... = ... aren't operations, they're definitions. == is the usual comparison operator. A list comprehension includes both definitions and predicates -- expressions of type Bool, or if you prefer, "operations returning" Bool. Definitions are either "let <var> = <expr>", as in [a | let a = 1], which evaluates to [1], or <var> <- <expr> where expr:: [t] for some t. You can read <- as "drawn from" [a | a <- [1,2,3]] evaluates to [1,2,3], and if we add a predicate: [a | a <- [1,2,3], odd a] evaluates to [1,3] and [a | a <- [1,2,3], a == 1] evaluates to [1] Hope that helps Jón -- Jón Fairbairn Jon.Fairbairn(a)cl.cam.ac.uk 31 Chalmers Road jf(a)cl.cam.ac.uk Cambridge CB1 3SZ +44 1223 570179 (after 14:00 only, please!)

1 0

Re: Currying - Curry function
by Ashley Yakeley 08 Aug '01

08 Aug '01

At 2001-08-07 14:20, Mark Carroll wrote: >> Is there an exemple of such a function in the Haskell language ? > >Most certainly. For instance, we can define: > > f :: Integer -> Integer -> Integer > f x y = x + y > > g = f 1 That's not really currying, is it? This is currying: f :: (Integer,Integer) -> Integer f (x,y) = x + y g :: Integer -> Integer g y = f (1,y) -- g is f with the first argument curried with 1. h :: Integer -> Integer h x = f (x,1) -- h is f with the second argument curried with 1. And these are the functions for the first of two arguments: curry :: ((a,b) -> c) -> (a -> b -> c) curry f a b = f (a,b) uncurry :: (a -> b -> c) -> ((a,b) -> c) uncurry f (a,b) = f a b ... so that we can define g = curry f 1 -- Ashley Yakeley, Seattle WA

2 1

Currying - Curry function
by Normand Leclerc 08 Aug '01

08 Aug '01

Hi haskell-cafe, >From a non programmer : Does someone know the exact source, book, page no etc. where Haskell Curry intoduced and developed its concept of a curry function. Is there an exemple of such a function in the Haskell language ? Thanks, Normand mailto:leclercn@globetrotter.net

3 2

RE: Currying - Curry function
by Konst Sushenko 08 Aug '01

08 Aug '01

to check whether I myself understand currying correctly: currying is not partial application (as the example below seems to suggest), it is conversion of a function in to a form where partial application is possible. so we can say that g = curry f is a curried function. right? konst : -----Original Message----- : From: Ashley Yakeley [mailto:ashley@semantic.org] : Sent: Tuesday, August 07, 2001 3:46 PM : To: Mark Carroll; Haskell Cafe List : Subject: Re: Currying - Curry function : : : At 2001-08-07 14:20, Mark Carroll wrote: : : >> Is there an exemple of such a function in the Haskell language ? : > : >Most certainly. For instance, we can define: : > : > f :: Integer -> Integer -> Integer : > f x y = x + y : > : > g = f 1 : : That's not really currying, is it? This is currying: : : f :: (Integer,Integer) -> Integer : f (x,y) = x + y : : g :: Integer -> Integer : g y = f (1,y) : : -- g is f with the first argument curried with 1. : : h :: Integer -> Integer : h x = f (x,1) : : -- h is f with the second argument curried with 1. : : And these are the functions for the first of two arguments: : : curry :: ((a,b) -> c) -> (a -> b -> c) : curry f a b = f (a,b) : : uncurry :: (a -> b -> c) -> ((a,b) -> c) : uncurry f (a,b) = f a b : : ... so that we can define : g = curry f 1 : : : -- : Ashley Yakeley, Seattle WA : : : _______________________________________________ : Haskell-Cafe mailing list : Haskell-Cafe(a)haskell.org : http://www.haskell.org/mailman/listinfo/haskell-cafe :

1 0

Missing functions in GHC's RTS?
by Ashley Yakeley 03 Aug '01

03 Aug '01

At 2001-08-03 00:41, I wrote (on the Haskell Cafe list): >When I make a function generator with "foreign export dynamic", GHC spits >out stub files which it apparently then needs for the link. What are >these for? OK, so I don't know what they are, but the link needs the _stub.o file. Unfortunately, the stub file includes these symbols: rts_getWord8 rts_getWord16 rts_getInt16 rts_getInt64 ...which do not appear to be in any library and indeed are not declared in RtsAPI.h, although corresponding rts_mk* functions are. This looks like a bug in GHC. $ ghc -v Glasgow Haskell Compiler, Version 5.00, for Haskell 98, compiled by GHC version 5.00 Using package config file: /usr/lib/ghc-5.00/package.conf Hsc static flags: -static -fignore-interface-pragmas -fomit-interface-pragmas -fdo-lambda-eta-expansion -flet-no-escape $ uname -a Linux server 2.2.19pre17 #1 Tue Mar 13 22:37:59 EST 2001 i686 unknown -- Ashley Yakeley, Seattle WA

2 1

"foreign export dynamic" in GHC
by Ashley Yakeley 03 Aug '01

03 Aug '01

When I make a function generator with "foreign export dynamic", GHC spits out stub files which it apparently then needs for the link. What are these for? For instance: -- foreign export dynamic mkCallback :: (Int -> IO Int) -> IO Addr foreign import registerCallback :: Addr -> IO () exportCallback :: (Int -> IO Int) -> IO () exportCallback f = do fx <- mkCallback f registerCallback fx -- And then I expect the C side of things to look like this: -- typedef HsInt (*mkCallback_FunPtr) (HsInt arg1); void registerCallback (HsAddr f) { mkCallback_FunPtr callBack = reinterpret_cast<mkCallback_FunPtr>(f); ... // actually call the callback HsInt arg = 3; HsInt result = (*callBack)(arg); ... } -- Is this correct? When I compile the Haskell Test.hs I get these strange stub files, "Test_stub.h", "Test_stub.c" and "Test_stub.o". The _stub.h one looks like this: -- #include "HsFFI.h" extern HsInt Test_dvD(HsStablePtr a0, HsAddr a_, HsInt a1); -- ...while the _stub.c looks like this: -- #include "Stg.h" #include "HsStd.h" #include "HsLang.h" #include "RtsAPI.h" extern HaskellObj Test_zdfmkCallback_closure; HsInt Test_dvD(HsStablePtr a0, HsAddr a_, HsInt a1) { SchedulerStatus rc; HaskellObj ret; rc=rts_evalIO(rts_apply(rts_apply((StgClosure*)&Test_zdfmkCallback_closure, rts_mkStablePtr(a0)),rts_mkInt(a1)),&ret); rts_checkSchedStatus("Test_dvD",rc); return(rts_getInt(ret)); } -- What are the stubs for? The GHC manual, sec. 8.4.1 says this: # An FFI implementation is encouraged to generate the C # typedef corresponding to a foreign export dynamic # declaration, but isn't required to do so. It doesn't say anything about funny little stub functions. And curiously, it doesn't say exactly how GHC's FFI implementation responds to that non-requirement encouragement. There were no typedefs in the stub files. -- Ashley Yakeley, Seattle WA

1 0

Another query (-:
by Mark Carroll 02 Aug '01

02 Aug '01

I've made a bizarre little program that I don't understand the behaviour of. It's: data BoolList = End | Node Bool BoolList instance Show BoolList where show (Node False rest) = "F " ++ show rest show (Node True rest) = "T " ++ show rest show End = "<>" grow list = (Node False rest) where (Node _ rest) = add list add End = (Node True End) add (Node truth rest) = (Node truth (add rest)) The show is fine; it's the add that's confusing me. Where we have, grow list = (Node False rest) where (Node _ rest) = add list I don't really understand what's going on with this binding and matching using "where", so I'm not seeing how the True and False values are managing to propagate up to being results of grow as they do, e.g.: > grow End F <> > grow (grow End) F T <> I have Hudak, Peterson, Fasel's gentle introduction to Haskell 98, and Thompson's "Craft of Functional Programming" book - maybe I just missed something in them? Is it easy to explain what's going on with this "where" behaviour so that I could figure out what "grow"'s results are without evaluating examples? -- Mark

2 2

Re: Novice Haskell query
by Ashley Yakeley 01 Aug '01

01 Aug '01

At 2001-07-31 14:17, Mark Carroll wrote: >Now, "show x" will work, and "show y" won't. How can I write things so >that I can show both x and y? I don't seem to be able to write, say, > > instance Show a => Show (Tree a) where > show (Branch datum left right) = > show left ++ " <- " ++ show datum ++ " -> " ++ show right > > instance Show (Tree a) where > show Leaf = "*" These two instances overlap. You want one instance, with both Branch and Leaf alternatives in the 'show' function. >or, perhaps, > > instance Show (Tree a) where > Show a => show (Branch datum left right) = > show left ++ " <- " ++ show datum ++ " -> " ++ show right > show Leaf = "*" Close, but you're making a promise (that 'Tree a' is Show for _any_ 'a') that you can't fulfill. Attempting to restrict the type of 'a' while defining the function is bogus, the 'a' symbol simply isn't in scope at that point. Clearly the type 'Tree a' is only Show if 'a' is. It's irrelevant that the 'Leaf' part of the definition doesn't need 'a' to be Show: the 'Branch' part does, so the type has to be restricted to 'Show a => Tree a' if it is going to be Show. So you want this: instance Show a => Show (Tree a) where ... -- Ashley Yakeley, Seattle WA

2 1

Re: newbie conceptual question [from haskell list]
by Steinitz, Dominic J 01 Aug '01

01 Aug '01

Alex, The code isn't ready to go public but you can try out a web interface at http://r341-02.king.ac.uk/cgi-bin/ldap.cgi. If you use the search filter objectClass=top you will get the whole tree on our test server. You shouldn't be able to add, modify or delete (let me know if you can!). The web code isn't very resilient. If you specifiy a non-existent attribute or use the wild card character (*), you will get an uninformative error message. Or you can try searching any public ldap server. Dominic. alex(a)shop.com on 01/08/2001 13:30:00 To: Dominic Steinitz cc: hdaume franka haskell-cafe bcc: Subject: Re: newbie conceptual question [from haskell list] Is the LDAP client available somewhere? -Alex- On 1 Aug 2001, Steinitz, Dominic J wrote: > I don't know about functional dependencies but using an existential type turned out to be very useful in writing an LDAP protocol handler. The protocol is specified at an abstract level using ASN.1 and could, in theory, be encoded using any set of encoding rules. It happens to use the Basic Encoding Rules. We used an existential type to "encode" the protocol at an abstract level and the encoding rules take this type and produce a concrete representation ready to send over a transport mechanism. Thus we get a good separation between the abstract protocol and the concrete encoding. So the next time we implement a protocol handler we can re-use the encoding code or we could encode LDAP with a different set of encoding rules without having to touch the LDAP code itself. > > We are presenting a paper which includes this at the Scottish Functional Programming workshop. > > Dominic. > > > > > hdaume(a)ISI.EDU on 31/07/2001 22:29:00 > To: franka > cc: haskell-cafe > bcc: Dominic Steinitz > Subject: Re: newbie conceptual question [from haskell list] > > Hi, > > Frank Atanassow wrote: > > D. Tweed wrote: > > > I've never written a Haskell program using functional dependencies, or > > > existential classes, ... > > > > I find them indispensible, and I know for a fact that I am not the only one > > around our office who feels that way. Though, the people around here > > (Utrecht's software technology group) are not exactly typical programmers... > > :) > > I've been recently experimenting quite a bit with existential classes > and somewhat less with functional dependencies, primarily to help my > understanding of the concepts. However, I've yet to be able to think of > an appropriate place to use them in the "real world". That is, in > something more than a toy thought-experiment. Could you give some > examples of what you are using them for? > > -- > Hal Daume III > > "Computer science is no more about computers | hdaume(a)isi.edu > than astronomy is about telescopes." -Dijkstra | www.isi.edu/~hdaume > > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe > > > > > ------------------------------------------------------------------------------- ------------------ > 21st century air travel http://www.britishairways.com > > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe > ___________________________________________________________________ S. Alexander Jacobson Shop.Com 1-646-638-2300 voice The Easiest Way To Shop (sm) ------------------------------------------------------------------------------------------------- 21st century air travel http://www.britishairways.com

1 0

Re: newbie conceptual question [from haskell list]
by S. Alexander Jacobson 01 Aug '01

01 Aug '01

Is the LDAP client available somewhere? -Alex- On 1 Aug 2001, Steinitz, Dominic J wrote: > I don't know about functional dependencies but using an existential type turned out to be very useful in writing an LDAP protocol handler. The protocol is specified at an abstract level using ASN.1 and could, in theory, be encoded using any set of encoding rules. It happens to use the Basic Encoding Rules. We used an existential type to "encode" the protocol at an abstract level and the encoding rules take this type and produce a concrete representation ready to send over a transport mechanism. Thus we get a good separation between the abstract protocol and the concrete encoding. So the next time we implement a protocol handler we can re-use the encoding code or we could encode LDAP with a different set of encoding rules without having to touch the LDAP code itself. > > We are presenting a paper which includes this at the Scottish Functional Programming workshop. > > Dominic. > > > > > hdaume(a)ISI.EDU on 31/07/2001 22:29:00 > To: franka > cc: haskell-cafe > bcc: Dominic Steinitz > Subject: Re: newbie conceptual question [from haskell list] > > Hi, > > Frank Atanassow wrote: > > D. Tweed wrote: > > > I've never written a Haskell program using functional dependencies, or > > > existential classes, ... > > > > I find them indispensible, and I know for a fact that I am not the only one > > around our office who feels that way. Though, the people around here > > (Utrecht's software technology group) are not exactly typical programmers... > > :) > > I've been recently experimenting quite a bit with existential classes > and somewhat less with functional dependencies, primarily to help my > understanding of the concepts. However, I've yet to be able to think of > an appropriate place to use them in the "real world". That is, in > something more than a toy thought-experiment. Could you give some > examples of what you are using them for? > > -- > Hal Daume III > > "Computer science is no more about computers | hdaume(a)isi.edu > than astronomy is about telescopes." -Dijkstra | www.isi.edu/~hdaume > > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe > > > > > ------------------------------------------------------------------------------------------------- > 21st century air travel http://www.britishairways.com > > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe > ___________________________________________________________________ S. Alexander Jacobson Shop.Com 1-646-638-2300 voice The Easiest Way To Shop (sm)

1 0

Re: newbie conceptual question [from haskell list]
by Steinitz, Dominic J 01 Aug '01

01 Aug '01

I don't know about functional dependencies but using an existential type turned out to be very useful in writing an LDAP protocol handler. The protocol is specified at an abstract level using ASN.1 and could, in theory, be encoded using any set of encoding rules. It happens to use the Basic Encoding Rules. We used an existential type to "encode" the protocol at an abstract level and the encoding rules take this type and produce a concrete representation ready to send over a transport mechanism. Thus we get a good separation between the abstract protocol and the concrete encoding. So the next time we implement a protocol handler we can re-use the encoding code or we could encode LDAP with a different set of encoding rules without having to touch the LDAP code itself. We are presenting a paper which includes this at the Scottish Functional Programming workshop. Dominic. hdaume(a)ISI.EDU on 31/07/2001 22:29:00 To: franka cc: haskell-cafe bcc: Dominic Steinitz Subject: Re: newbie conceptual question [from haskell list] Hi, Frank Atanassow wrote: > D. Tweed wrote: > > I've never written a Haskell program using functional dependencies, or > > existential classes, ... > > I find them indispensible, and I know for a fact that I am not the only one > around our office who feels that way. Though, the people around here > (Utrecht's software technology group) are not exactly typical programmers... > :) I've been recently experimenting quite a bit with existential classes and somewhat less with functional dependencies, primarily to help my understanding of the concepts. However, I've yet to be able to think of an appropriate place to use them in the "real world". That is, in something more than a toy thought-experiment. Could you give some examples of what you are using them for? -- Hal Daume III "Computer science is no more about computers | hdaume(a)isi.edu than astronomy is about telescopes." -Dijkstra | www.isi.edu/~hdaume _______________________________________________ Haskell-Cafe mailing list Haskell-Cafe(a)haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe ------------------------------------------------------------------------------------------------- 21st century air travel http://www.britishairways.com

1 0

Re: Singular Type Constructor
by Ashley Yakeley 01 Aug '01

01 Aug '01

At 2001-07-30 19:08, I wrote: >Consider: > >-- >data T a = T >-- > >Is there anything in the Prelude or a standard library that looks like >this? Should there be? What should it be called? 'Singleton'? 'Reified'? >'T'? In the end I called it 'Type'. Perhaps something like it should be in the Prelude... See <http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/jvm-bridge/source/Haskell/T ype.hs?rev=HEAD&content-type=text/vnd.viewcvs-markup>. -- Ashley Yakeley, Seattle WA

1 0

Novice Haskell query
by Mark Carroll 01 Aug '01

01 Aug '01

Let's say I have: data Tree a = Branch a (Tree a) (Tree a) | Leaf instance Show a => Show (Tree a) where show (Branch datum left right) = show left ++ " <- " ++ show datum ++ " -> " ++ show right show Leaf = "*" y = Leaf x = (Branch 3 Leaf Leaf) Now, "show x" will work, and "show y" won't. How can I write things so that I can show both x and y? I don't seem to be able to write, say, instance Show a => Show (Tree a) where show (Branch datum left right) = show left ++ " <- " ++ show datum ++ " -> " ++ show right instance Show (Tree a) where show Leaf = "*" or, perhaps, instance Show (Tree a) where Show a => show (Branch datum left right) = show left ++ " <- " ++ show datum ++ " -> " ++ show right show Leaf = "*" ...or whatever other things come to mind. -- Mark

2 1