- Haskell - Haskell.org

Ann: HAllInOne bug fix release
by Hal Daume III 30 Jul '03

30 Jul '03

Hi Fellow Haskellers, I normally wouldn't send out bug fix notifications, but there has been an update to HAllInOne (http://www.isi.edu/~hdaume/HAllInOne/) which fixes two major bugs: - recursive modules now work correctly - proper separation of type and value environments The reason I'm posting is because these fixes have enabled me to All-In-One-ify the NHC Haskell Compiler. This results is about 44k lines of code in a single, 1.6mb module, which can then be compiled with your favorite Haskell compiler (provided you have a lot of RAM). A few people have asked me for speed-up results from All-In-One-ifying code, so here's a good one. We take two versions of NHC. One is the original binary distribution and the other is the All-In-One-ified version, compiled by GHC. We then ask each of these compilers to compile a large program (I didn't bother making it link it -- that seemed too tangential). The large program I asked these two compilers to compile was, not surprisingly, the All-In-One NHC source code :). The timing results are: Normal NHC: real 3m14.295s user 3m9.879s sys 0m2.143s All-In-One NHC: real 1m11.380s user 0m10.102s sys 0m1.711s So there's definitely a speedup. I will make further speedup posts directly to the web page instead of the mailing list. - Hal p.s., for extra fun, google for "Haskell Modules" and look to the right :).

2 1

RE: exceptions
by Simon Marlow 30 Jul '03

30 Jul '03

> just out of curiosity, which is the proper idiom? > > trace a = r <- catch a (\e -> putStr "exceptional\n" >> throw e) > trace a = r <- catch a (\e -> putStr "exceptional\n" >> ioError e) > > I am worried that one might subtly change the semantics of an > execption > depending on how it was originally thrown... but i am uncertain how. > probably some obscure case involving bottoms. But to be on the safe > side, thought I'd ask. The second is more correct, if you're using Prelude.catch. If you're using Control.Exception.catch, then you want throwIO instead of ioError. The difference between throw and ioError is this: seq (throw e) E == throw e seq (ioError e) E == E Cheers, Simon

1 0

FW: [IcfpSC] Call for spam -- one more time-sensitive round
by Simon Peyton-Jones 30 Jul '03

30 Jul '03

Gentle Haskellfolk ICFP is nearly upon us. Early registration ends today! So this would be a good moment to click. Simon ------------------------------------------------------------------------------- Call for Participation ICFP 2003: ACM International Conference on Functional Programming August 25-29, 2003 Uppsala, Sweden * About ICFP ------------ The goal of ICFP is to - stimulate and promote international research on functional programming, and - act as focal point to bring together the functional-programming community for intellectual cross-pollination and collaboration. The scope of the conference includes all languages that encourage programming with functions, including both purely applicative and imperative languages, as well as languages that support objects and concurrency. The topics covered range from principles to practice, from foundations to features, and from abstractions to applications. The conference is affiliated with PLI, a confederation of international meetings sponsored by ACM SIGPLAN, which this year will also include - PPDP (International Conference on Principles and Practice of Declarative Programming) - LOPSTR (International Symposium on Logic-based Program Synthesis and Transformation) - Haskell Workshop - Erlang Workshop - MERLIN (Mechanised Reasoning About Languages with Variable Binding) - DPCOOL (Declarative Programming in the Context of Object-oriented Languages) * Useful URLs ------------- - Main web page for the entire PLI meeting; contains information on accepted papers, registration, accomodation, and social events: http://www.it.uu.se/pli03/ - Main web page for ICFP: http://www-users.cs.york.ac.uk/~colin/icfp2003.html - ICFP programme: http://www.cc.gatech.edu/~shivers/icfp03/schedule.html * Registration now open ----------------------- Registration is now open and the early registration deadline is July 30th. NOTE: The cut-off date for guaranteed hotel reservations varies with the hotel and is typically *before* July 30th. It is advisable to make your hotel reservations soon. ------------------------------------------------------------------------------- * Conference programme ---------------------- Monday 25 August 2003 Invited talk: 9:00-10:00 ------------------------ Conservation of information: Applications in functional, reversible, and quantum computing Thomas Knight, Jr. (MIT Artificial Intelligence Laboratory) Session I: 10:30-12:30 ---------------------- Scripting the type-inference process Bastiaan Heeren, Jurriaan Hage, Doaitse Swierstra (Universiteit Utrecht) Discriminative sum types locate the source of type errors Matthias Neubauer, Peter Thiemann (Universität Freiburg) MLF: Raising ML to the power of system F Didier Le Botlan, Didier Remy (INRIA Rocquencourt) An extension of HM(X) with bounded existential and universal data-types Vincent Simonet (INRIA Rocquencourt) Session II: 2:15-3:45 --------------------- CDuce: an XML-centric general-purpose language Véronique Benzaken (LRI, Université Paris Sud, Orsay), Giuseppe Castagna (CNRS, LIENS, École Normale Supérieure), Alain Frisch (LIENS, École Normale Supérieure, Paris) Compiling regular patterns Michael Levin (University of Pennsylvania) Software is discrete mathematics Rex Page (University of Oklahoma) Session III: 4:15-6:00 ---------------------- Global abstraction-safe marshalling with hash types James Leifer (INRIA Rocquencourt), Gilles Peskine(INRIA Rocquencourt), Peter Sewell (University of Cambridge), Keith Wansbrough (University of Cambridge) Dynamic rebinding for marshalling and update, with destruct-time lambda Gavin Bierman (University of Cambridge), Michael Hicks (University of Maryland, College Park), Peter Sewell (University of Cambridge), Gareth Stoyle (University of Cambridge), Keith Wansbrough (University of Cambridge) Iterative-free program analysis Mizuhito Ogawa (Japan Advanced Institute of Science and Technology), Zhenjiang Hu (University of Tokyo), Isao Sasano (Japan Advanced Institute of Technology and Science) Report on ICFP 2003 & 2004 Olin Shivers & Kathleen Fisher =============================================================================== Tuesday 26 August 2003 Invited talk: 9:00-10:00 ------------------------ From Hilbert space to Dilbert space: Context semantics as a language for games and flow analysis Harry Mairson (Brandeis University) Session IV: 10:30-12:30 ----------------------- A theory of aspects David Walker (Princeton University), Steve Zdancewic (University of Pennsylvania), Jay Ligatti (Princeton University) Dependency-style Generic Haskell Andres Löh, Dave Clarke, Johan Jeuring (Universiteit Utrecht) Functional automatic differentiation with Dirac impulses Henrik Nilsson (Yale University) A user-centred approach to functions in Excel Simon Peyton Jones (Microsoft Research), Alan Blackwell (University of Cambridge), Margaret Burnett (Oregon State University) Session V: 2:15-3:45 -------------------- A sound and complete axiomatization of delimited continuations Yukiyoshi Kameyama (University of Tsukuba), Masahito Hasegawa (Kyoto University) Call-by-value is dual to call-by-name Philip Wadler (Avaya Labs) Disjunctive normal forms and local exceptions Emmanuel Beffara, Vincent Danos (Université Paris 7) Session VI: 4:15-6:00 --------------------- An effective theory of type refinements Yitzhak Mandelbaum (Princeton University), David Walker (Princeton University), Robert Harper (Carnegie Mellon University) A static type system for JVM access control Tomoyuki Higuchi, Atsushi Ohori (Japan Advanced Institute of Science and Technology) Parsing polish, step by step (functional pearl) John Hughes (Chalmers University), Doaitse Swierstra (Universiteit Utrecht) Programming contest awards presentation John Hughes et al. (Chalmers University of Technology) =============================================================================== Wednesday 27 August 2003 Session VII: 9:00-10:30 ----------------------- Boxes go bananas: Encoding higher-order abstract syntax with parametric polymorphism Geoffrey Washburn, Stephanie Weirich (University of Pennsylvania) FreshML: Programming with binders made simple Mark Shinwell, Andrew Pitts, Murdoch Gabbay (University of Cambridge) Meta-programming through typeful code representation Chiyan Chen, Hongwei Xi (Boston University) Session VIII: 11:00-11:30 ------------------------- Optimistic evaluation: An adaptive evaluation strategy for non-strict programs Robert Ennals (University of Cambridge), Simon Peyton Jones (Microsoft Research) Invited talk (joint with PPDP'03): 11:30-12:30 ---------------------------------------------- Understanding aspects Mitchell Wand (Northeastern University) _______________________________________________ IcfpSC mailing list IcfpSC(a)mailman.cs.luc.edu http://mailman.cs.luc.edu/mailman/listinfo/icfpsc

1 0

exceptions
by John Meacham 29 Jul '03

29 Jul '03

just out of curiosity, which is the proper idiom? trace a = r <- catch a (\e -> putStr "exceptional\n" >> throw e) trace a = r <- catch a (\e -> putStr "exceptional\n" >> ioError e) I am worried that one might subtly change the semantics of an execption depending on how it was originally thrown... but i am uncertain how. probably some obscure case involving bottoms. But to be on the safe side, thought I'd ask. John -- --------------------------------------------------------------------------- John Meacham - California Institute of Technology, Alum. - john(a)foo.net ---------------------------------------------------------------------------

1 0

Proposal for a new I/O library design
by Ben Rudiak-Gould 29 Jul '03

29 Jul '03

The other day I was reading the Haskell i18n debate in the list archives, and started thinking about possible replacements for the existing Haskell file I/O model. It occurred to me that the Haskell community has really dropped the ball on this one. Haskell's design has always emphasized doing the right thing, not merely doing the thing that everyone else happens to be doing. It's that philosophy that led to the invention of the monadic I/O model, among other things. And yet, what do we choose for our I/O primitives? The same old crocks that everyone else was using. We open and close files (whatever that's supposed to mean); we expose file handles to the user; we even maintain a current position in the file, which is an unnecessary global state variable if I've ever seen one. The proposal below is the result of a few hours spent thinking about how the file system would be accessed if it were actually implemented in Haskell, instead of behind a weird C API. I'm very interested in hearing comments and criticism. In particular, I want to know if there's enough interest in this model that I should actually try to implement it. The most important idea in this design as far as i18n is concerned is the separation of random-access files from input and output streams. Most of the ugliness of the usual file I/O interface comes from conflating these three concepts, which are almost totally unrelated. In particular, there's no need in this model to worry about the meaning of reading or seeking in a "text file." Text encoding and decoding apply to streams, not files. To read text from a file you layer an input stream on it, apply a text parser to that, and read characters. If you need to "seek" to a new location, you create a new stream which starts at that location in the underlying file. > module System.ProposedNewIOModel (...) where I assume that all I/O occurs in terms of octets. I think that this holds true of every platform on which Haskell is implemented or is likely to be implemented. > type Octet = Word8 File offsets are 64 bits on all platforms. This model never uses negative offsets, so there's no need for a signed type. (But perhaps it would be better to use one anyway?) BlockLength should be something appropriate to the architecture's address space. > type FilePos = Word64 > type BlockLength = Int A value of type File represents a file, which is essentially a resizable strict array of octets. Two values of type File compare equal if they are the same file -- that is, if they have the same contents and changes to one also appear in the other. ("File" is a bad name for this. For one thing, NTFS and HFS can associate more than one chunk of data with each directory entry, and "file" usually refers to all the chunks together. "Fork" would be more accurate, but it doesn't sound much like what it's supposed to represent.) (Should files be buffered at the application level? I'm not convinced it's necessary. Streams will be buffered, of course.) > data File -- abstract A value of type InputStream or OutputStream represents an input or output stream: that is, an octet source or sink. Two InputStreams or OutputStreams compare equal iff reading/writing one also reads/writes the other. (Should I call these "ports" instead of "streams"? How about "OctetSource" and "OctetSink"?) > data InputStream -- abstract > data OutputStream -- abstract Fundamental operations on files. XXX represents some sort of memory buffer (an IOUArray or a Ptr?). All reads and writes supply absolute offsets. (Note that there's no such thing as reading fewer bytes than requested -- the read either succeeds or it throws an exception. This may be problematic because the file size could decrease between a call to fGetSize and a later call to fRead. One solution is to make fRead treat bytes beyond EOF as zeroes, which is consistent with the usual behavior for sparse files. fWrite should probably expand the file automatically if asked to write beyond its bounds, for similar reasons.) (A serious unaddressed problem here is locking. There should be a way to e.g. prevent someone else from writing to a file while I'm appending to it, to avoid race conditions. But for whatever reason, the usual OS interface only allows this kind of lock to be acquired when opening the file -- and I can't generally reopen the file because its name might have changed. Meanwhile, another kind of lock, the kind I don't want, can be acquired and released on an already-opened file. I don't know why it's done this way, or how to work around it.) (And what about asynchronous I/O?) > fGetSize :: File -> IO FilePos > fSetSize :: File -> FilePos -> IO () > fRead :: File -> FilePos -> BlockLength -> XXX -> IO () > fWrite :: File -> FilePos -> BlockLength -> XXX -> IO () > fCheckRead :: File -> FilePos -> BlockLength -> IO Bool > fCheckWrite :: File -> FilePos -> BlockLength -> IO Bool Fundamental operations on streams. "Maybe Octet" is supposed to represent "Octet or EOS," though I'm not sure this is enough for proper EOS handling. isPeek might be useful for text parsers. isUnGet is another possibility -- it's more versatile but harder to implement efficiently. Or this may be a moot point because text parsers will probably want to use isGetBlock anyway for efficiency. > isGet :: InputStream -> IO (Maybe Octet) > isPeek :: InputStream -> IO (Maybe Octet) > isGetBlock :: InputStream -> BlockLength -> XXX -> IO BlockLength > -- efficiency hack > > osPut :: OutputStream -> Octet -> IO () > osPuts :: OutputStream -> [Octet] -> IO () > osPutBlock :: OutputStream -> BlockLength -> XXX -> IO () > osFlush :: OutputStream -> IO () Standard streams. (How to deal with line buffering?) > stdin :: InputStream > stdout, stderr :: OutputStream Streams can be layered on top of files. Each stream keeps track of its own independent position within the file. The effects of overlapped stream reading and writing on the same part of a file are unspecified, since streams will be buffered in practice. > fileToInputStreamFrom :: File -> FilePos -> (IO?) InputStream > fileToOutputStreamFrom :: File -> FilePos -> (IO?) OutputStream > > fileToInputStream f = fileToInputStreamFrom f 0 > fileToOutputStreamAppend f = > fGetSize f >>= fileToOutputStreamFrom f InputStreams can be read as lazy lists. You're not allowed to use the InputStream again after you call this. > isGetContents :: InputStream -> IO [Octet] A value of type Directory represents a directory, which is essentially a mutable associative array from names (Unicode strings) to File/Directory/Stream values plus some metadata. This is supposed to represent a directory *independently of its name*, so it's robust against changes at higher levels of the filesystem hierarchy. I don't know if this can be implemented on Posix or Win32. (The old Mac OS and the NT API do support it.) > data Directory -- abstract Operations on directories. I suggest dGetContentsWithMetadata rather than dLookupMetadata because using the latter to scan a directory on a FAT32 filesystem takes O(n^2) time. > dGetContents :: Directory -> IO [String] > dGetContentsWithMetadata :: Directory -> IO [(String,???)] > dLookup :: Directory -> String -> IO (Either File Directory) > -- Also should handle named pipes here > dCreateFile :: Directory -> String -> (metadata?) -> IO File > -- etc... Pathnames don't fit well with this model, but they're not going to go away, so I provide these functions. If the pathname argument names a directory, that directory and Nothing are returned. Otherwise, a directory and string are returned such that a subsequent call to dLookup or dCreateFile with these values will refer to the same thing as the original pathname. lookupPathname is dLookupPathname from the current directory. > dLookupPathname :: Directory -> String -> IO (Directory, Maybe String) > lookupPathname :: String -> IO (Directory, Maybe String) > getCurrentDirectory :: IO Directory -- no corresponding set! Convenient shortcuts for common cases. > lookupFileByPathname :: String -> IO File > lookupInputStreamByPathname :: String -> IO InputStream > -- at least as likely to succeed as lookupFileByPathname -- Ben

5 5

ICFP 2003 / PLI 2003 -- early registration ends tomorrow (July 30)!
by shivers＠ai.mit.edu 29 Jul '03

29 Jul '03

ICFP, the International Conference on Functional Programming, is coming up soon -- August 25-29, in Uppsala, Sweden. The following "Call for Participation" has the important bits, but here is the key thing you need to know if you are thinking of attending this year: ** Early registration ends tomorrow, July 30. ** Most hotels will close out their guaranteed reservations by tomorrow, as well. I also append the complete program of talks. See you in Sweden... -Olin Shivers program chairman ------------------------------------------------------------------------------- Call for Participation ICFP 2003: ACM International Conference on Functional Programming August 25-29, 2003 Uppsala, Sweden * About ICFP ------------ The goal of ICFP is to - stimulate and promote international research on functional programming, and - act as focal point to bring together the functional-programming community for intellectual cross-pollination and collaboration. The scope of the conference includes all languages that encourage programming with functions, including both purely applicative and imperative languages, as well as languages that support objects and concurrency. The topics covered range from principles to practice, from foundations to features, and from abstractions to applications. The conference is affiliated with PLI, a confederation of international meetings sponsored by ACM SIGPLAN, which this year will also include - PPDP (International Conference on Principles and Practice of Declarative Programming) - LOPSTR (International Symposium on Logic-based Program Synthesis and Transformation) - Haskell Workshop - Erlang Workshop - MERLIN (Mechanised Reasoning About Languages with Variable Binding) - DPCOOL (Declarative Programming in the Context of Object-oriented Languages) * Useful URLs ------------- - Main web page for the entire PLI meeting; contains information on accepted papers, registration, accomodation, and social events: http://www.it.uu.se/pli03/ - Main web page for ICFP: http://www-users.cs.york.ac.uk/~colin/icfp2003.html - ICFP programme: http://www.cc.gatech.edu/~shivers/icfp03/schedule.html * Registration now open ----------------------- Registration is now open and the early registration deadline is July 30th. NOTE: The cut-off date for guaranteed hotel reservations varies with the hotel and is typically *before* July 30th. It is advisable to make your hotel reservations soon. ------------------------------------------------------------------------------- * Conference programme ---------------------- Monday 25 August 2003 Invited talk: 9:00-10:00 ------------------------ Conservation of information: Applications in functional, reversible, and quantum computing Thomas Knight, Jr. (MIT Artificial Intelligence Laboratory) Session I: 10:30-12:30 ---------------------- Scripting the type-inference process Bastiaan Heeren, Jurriaan Hage, Doaitse Swierstra (Universiteit Utrecht) Discriminative sum types locate the source of type errors Matthias Neubauer, Peter Thiemann (Universität Freiburg) MLF: Raising ML to the power of system F Didier Le Botlan, Didier Remy (INRIA Rocquencourt) An extension of HM(X) with bounded existential and universal data-types Vincent Simonet (INRIA Rocquencourt) Session II: 2:15-3:45 --------------------- CDuce: an XML-centric general-purpose language Véronique Benzaken (LRI, Université Paris Sud, Orsay), Giuseppe Castagna (CNRS, LIENS, École Normale Supérieure), Alain Frisch (LIENS, École Normale Supérieure, Paris) Compiling regular patterns Michael Levin (University of Pennsylvania) Software is discrete mathematics Rex Page (University of Oklahoma) Session III: 4:15-6:00 ---------------------- Global abstraction-safe marshalling with hash types James Leifer (INRIA Rocquencourt), Gilles Peskine(INRIA Rocquencourt), Peter Sewell (University of Cambridge), Keith Wansbrough (University of Cambridge) Dynamic rebinding for marshalling and update, with destruct-time lambda Gavin Bierman (University of Cambridge), Michael Hicks (University of Maryland, College Park), Peter Sewell (University of Cambridge), Gareth Stoyle (University of Cambridge), Keith Wansbrough (University of Cambridge) Iterative-free program analysis Mizuhito Ogawa (Japan Advanced Institute of Science and Technology), Zhenjiang Hu (University of Tokyo), Isao Sasano (Japan Advanced Institute of Technology and Science) Report on ICFP 2003 & 2004 Olin Shivers & Kathleen Fisher =============================================================================== Tuesday 26 August 2003 Invited talk: 9:00-10:00 ------------------------ From Hilbert space to Dilbert space: Context semantics as a language for games and flow analysis Harry Mairson (Brandeis University) Session IV: 10:30-12:30 ----------------------- A theory of aspects David Walker (Princeton University), Steve Zdancewic (University of Pennsylvania), Jay Ligatti (Princeton University) Dependency-style Generic Haskell Andres Löh, Dave Clarke, Johan Jeuring (Universiteit Utrecht) Functional automatic differentiation with Dirac impulses Henrik Nilsson (Yale University) A user-centred approach to functions in Excel Simon Peyton Jones (Microsoft Research), Alan Blackwell (University of Cambridge), Margaret Burnett (Oregon State University) Session V: 2:15-3:45 -------------------- A sound and complete axiomatization of delimited continuations Yukiyoshi Kameyama (University of Tsukuba), Masahito Hasegawa (Kyoto University) Call-by-value is dual to call-by-name Philip Wadler (Avaya Labs) Disjunctive normal forms and local exceptions Emmanuel Beffara, Vincent Danos (Université Paris 7) Session VI: 4:15-6:00 --------------------- An effective theory of type refinements Yitzhak Mandelbaum (Princeton University), David Walker (Princeton University), Robert Harper (Carnegie Mellon University) A static type system for JVM access control Tomoyuki Higuchi, Atsushi Ohori (Japan Advanced Institute of Science and Technology) Parsing polish, step by step (functional pearl) John Hughes (Chalmers University), Doaitse Swierstra (Universiteit Utrecht) Programming contest awards presentation John Hughes et al. (Chalmers University of Technology) =============================================================================== Wednesday 27 August 2003 Session VII: 9:00-10:30 ----------------------- Boxes go bananas: Encoding higher-order abstract syntax with parametric polymorphism Geoffrey Washburn, Stephanie Weirich (University of Pennsylvania) FreshML: Programming with binders made simple Mark Shinwell, Andrew Pitts, Murdoch Gabbay (University of Cambridge) Meta-programming through typeful code representation Chiyan Chen, Hongwei Xi (Boston University) Session VIII: 11:00-11:30 ------------------------- Optimistic evaluation: An adaptive evaluation strategy for non-strict programs Robert Ennals (University of Cambridge), Simon Peyton Jones (Microsoft Research) Invited talk (joint with PPDP'03): 11:30-12:30 ---------------------------------------------- Understanding aspects Mitchell Wand (Northeastern University)

1 0

LOPSTR 2003 (Call for registration + program)
by Wim Vanhoof 29 Jul '03

29 Jul '03

Call for Participation LOPSTR (International Symposium on Logic-based Program Synthesis and Transformation) August 25-27, in Uppsala, Sweden. Early registration deadline is July 30 More info (also the other events of PLI'03) at http://www.it.uu.se/pli03/index.shtml The program: Monday August 25 9h00-10h00 ICFP invited talk 10h30-12h30 Specification and Synthesis Predicate synthesis from inductive proof attempt of faulty conjectures. Moussa Demba, Khaled Bsa\"{\i}es and Francis Alexandre. Specification and Synthesis of Hybrid Automata for Physics-Based Animation. Thomas Ellman. Adding Concrete Syntax to a Prolog-Based Program Synthesis System. Bernd Fischer and Eelco Visser. Specifying Object-Oriented Systems in Computational Logic. Kung-Kiu Lau and Mario Ornaghi. 14h15-15h45 Verification Building Satisfiability Procedures for Verification: The Case Study of Sorting Algorithmsm. Abdessamad Imine and Silvio Ranise. Formal Development and Verification of Approximation Algorithms using Auxiliary Variables. Rudolf Berghammer and Markus M\"uller-Olm. Formal Reasoning About Efficient Data Structures: A Case Study in ACL2. José-Luis Ruiz-Reina, José-Antonio Alonso, María-José Hidalgo and Francisco-Jesús Martín Mateos. 16h15-17h45 Analysis A Program Transformation for Backwards Analysis of Logic Programs. John P. Gallagher. An Efficient Staging Algorithm for Binding-Time Analysis. Takuma Murakami, Zhenjiang Hu, Kazuhiko Kakehi and Masato Takeichi. Proving termination with adornments. Alexander Serebrenik and Danny De Schreye. Tuesday August 26 9h00-10h00 ICFP Invited Talk 10h30-12h30 Transformation Constructively Characterizing Fold and Unfold Tjark Weber and James Caldwell. Deterministic Second-order Patterns Tetsuo Yokoyama, Zhenjiang Hu, and Masato Takeichi. From Interpreter to Logic Engine: A Functional Derivation. Dariusz Biernacki and Olivier Danvy. Linearization by Program Transformation. Sandra Alves and Mário Florido. 14h15-15h15 Invited Talk Inductive Theorem Proving by Program Specialisation: Generating proofs for Isabelle using Ecce Michael Leuschel (work with Helko Lehmann) 15h15-15h45 Specialisation Provably Correct Code Generation for High Assurance Systems via Partial Evaluation: A Case Study. Qian Wang and Gopal Gupta. Wednesday August 27 9h00-10h30 Constraints Simplification of database integrity constraints revisited: A transformational approach. Henning Christiansen and Davide Martinenghi. Integration and Optimization of Rule-based Constraint Solvers. Slim Abdennadher and Thom Fr\"uhwirth. Introducing ESRA, a Relational Language for Modelling Combinatorial Problems. Pierre Flener, Justin Pearson, and Magnus {\AA}gren. 11h30-12h30 PLI Invited Talk Understanding aspects Mitchell Wand

1 0

System.Directory (was RE: Proposal for a new I/O library design)
by Hal Daume 29 Jul '03

29 Jul '03

Hi guys, I'm not replying to anything in the message, but... > Is the idea > to abstract away from the syntax of pathnames on the platform (eg. > directory separator characters)? If so, I'm not sure it's worthwhile. > There are lots of differences between pathname conventions: case > sensitivity, arbitrary limits on the lengh of filenames, filename > extensions, and so on. Would there be any way to get some of these differences into the System.Directory structure? At least the following would be nice: > pathSeparator :: Char > '\\' on Windows, '/' on unices, ':' (I believe) on macs, etc... > directorySeparator :: Char > ';' on Windows, ':' on unices, i have no idea on macs > isCaseSensitive :: Bool > False on Windows, True on (all?) unices, i have no idea on macs given just these, i think we'd all be a lot happier. I also don't particularly care whether these are IO operations or just values (so long as they are constant, they might as well be values with unsafePerformIO wrapped around them if necessary). My current approach to figuring this out is to create a directory, change to that directory, get the current path name and try to parse it. This is bad for so many reasons I won't enumerate them here. ...unless this stuff is hiding somewhere else, please let me know (but System.Directory would probably be a good place for it to end up)... - Hal

2 1

RE: Existentials...
by Hal Daume 28 Jul '03

28 Jul '03

Sure it's possible :)...using the GMap library...heres an implementation: > module PushF where > > import GMap.Adhoc > import GMap.GenericLib > import GMap.Term > import Data.Dynamic > > data F a b = forall c. (Typeable c, Term c) => PushF (a -> c) (F c b) > | Bottom (a -> b) > > _tc_F = mkTyCon "F" > instance (Typeable a, Typeable b) => Typeable (F a b) where > typeOf (_ :: F a b) = mkAppTy _tc_F [typeOf (undefined::a), typeOf (undefined::b)] > > instance (Term a, Term b) => Term (F a b) where > gmapT f (Bottom x) = Bottom x > gmapT f (PushF g h) = PushF g (f h) > gfoldl f z (Bottom x) = z (Bottom x) > gfoldl f z (PushF g h) = z (PushF g) `f` h > > getInner :: (Typeable a, Typeable b, Typeable c, Term (F a b)) => F a b -> c -> Maybe (F c b) > getInner (x :: F a b) (c :: c) = something (isCToB (undefined::c) (undefined::b)) x > > isCToB :: (Typeable t, Typeable c, Typeable b) => c -> b -> t -> Maybe (F c b) > isCToB (c::c) (b::b) t = cast t if we define this as you have: > f1 :: Char -> Bool > f1 'a' = True > f1 _ = False > > f2 :: Bool -> String > f2 = show > > f3 :: String -> Int > f3 = length > > fs :: F Char Int > fs = f1 `PushF` (f2 `PushF` (f3 `PushF` (Bottom id))) then we can do the following: *PushF> Maybe.isJust (getInner fs 'a') True *PushF> Maybe.isJust (getInner fs "hello") True *PushF> Maybe.isJust (getInner fs True) True *PushF> Maybe.isJust (getInner fs (1::Int)) True *PushF> Maybe.isJust (getInner fs (1::Float)) False *PushF> Maybe.isJust (getInner fs ()) False hope this helps. - hal -- Hal Daume III | hdaume(a)isi.edu "Arrest this man, he talks in maths." | www.isi.edu/~hdaume > -----Original Message----- > From: haskell-admin(a)haskell.org > [mailto:haskell-admin@haskell.org] On Behalf Of Amr A Sabry > Sent: Monday, July 28, 2003 2:22 PM > To: haskell(a)haskell.org > Cc: sabry(a)cs.indiana.edu > Subject: Existentials... > > > Hi, > > I believe this can be done with enough type hacking but I am not sure > how... > > Consider the use existentials to implement a list of composable > functions using something like: > > data F a b = > forall c. PushF (a -> c) (F c b) > | Bottom (a -> b) > > For example: > > f1 :: Char -> Bool > f1 'a' = True > f1 _ = False > > f2 :: Bool -> String > f2 True = "true" > f2 False = "false" > > f3 :: String -> Int > f3 = length > > fs :: F Char Int > fs = PushF f1 (PushF f2 (PushF f3 (Bottom id))) > > Is it possible to write a function > f :: F a b -> T c -> F c b > where (T c) is some type for values of type 'c' or values representing > the type 'c' or whatever is appropriate. Thus if given the > representation of Bool, the function should return: > PushF f2 (PushF f3 (Bottom id)) > and if given the representation of String the function should return > PushF f3 (Bottom id) > and so on. > > I hope the question makes sense. Thanks. --Amr > _______________________________________________ > Haskell mailing list > Haskell(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell >

1 0

Re: System.Directory (was RE: Proposal for a new I/O library design)
by Wolfgang Thaller 28 Jul '03

28 Jul '03

>> pathSeparator :: Char >> '\\' on Windows, '/' on unices, ':' (I believe) on macs, etc... Used to be ':' in Classic MacOS, and there are still some old routines in Apple's Carbon library that take ':'-separated paths. However, Apple always insisted that Pathnames should only be used for display purposes, mostly because a pathname did not always uniquely identify a file (!). Mac OS X uses "normal" unix-style paths for everything that concerns us. Also, the "Classic" Mac-style paths had different semantics (no "." or "..", etc.), so treating them would have been more difficult than just using a different separator. Fortunately, they're a thing of the past. >> directorySeparator :: Char >> ';' on Windows, ':' on unices, i have no idea on macs As there was no command line, no PATH, and no textual config files on classic Mac OS, there is no mac-specific directory separator, so it's ':'. (although I think that stealing yet another character from > >> isCaseSensitive :: Bool >> False on Windows, True on (all?) unices, i have no idea on macs It's not that easy. Case sensitivity is a property of a file system, not of the operating system. So if you mount a Windows or Mac OS volume on a Linux system, the filenames on that volume will still be case-insensitive (but case-preserving). On Mac OS X, the default file system type is HFS+ (a.k.a. Mac OS Extended), which is case insensitive, but you can also choose UFS (case sensitive). You could also have both, on two partitions. Of course, "False" for Windows and MacOS, "True" for everything else is a reasonable guess, but you can't rely on it. Right now I have no idea how to implement something like isCaseSensitive :: FilePath -> IO Bool which would determine whether a specific path would be case sensitive. Maybe it's worth the effort to think about it. > given just these, i think we'd all be a lot happier. I agree. If the last one can be implemented properly, that is. Cheers, Wolfgang

3 2