- Haskell - Haskell.org

lhs2TeX: lazy pattern "~" formatting
by Conal Elliott 19 Apr '06

19 Apr '06

Does anyone have a nice way to format the "~" of a lazy pattern in lhs2TeX? I use %format ~ = "{} ^\sim " but the result isn't as pretty as I'd like. For one thing, no space is inserted before the "~" after a lambda, "do", or whatever. Thanks, - Conal

2 1

Call for Contributions - HC&A Report (May 2006 edition)
by Andres Loeh 19 Apr '06

19 Apr '06

Dear Haskellers, it is nearly time for the tenth edition of the ================================================================ Haskell Communities & Activities Report http://www.haskell.org/communities/ Submission deadline: 12 May 2006 (please send your contributions to hcar at haskell.org, in plain ASCII or LaTeX format) ================================================================ This is the short story: * If you are working on any project that is in some way related to Haskell, write a short entry and submit it to the me. * If you are interested any project related to Haskell that has not previously been mentioned in the HC&A Report, please tell me, so that I can contact the project leaders and ask them to submit an entry. * Feel free to pass on this call for contributions to others that might be interested. More detailed information: The Haskell Communities & Activities Report is a bi-annual overview of the state of Haskell as well as Haskell-related projects over the last, and possibly the upcoming 6 months. If you have only recently been exposed to Haskell, it might be a good idea to browse the November 2005 edition -- you will find interesting topics described as well as several starting points and links that may provide answers to many questions. Contributions will be collected until the middle of May. They will be compiled into a coherent report which will appear sometime near the end of May. As always, this is a great opportunity to update your webpages, make new releases, announce of even start new projects, or to point at some developments you want every Haskeller to see! As the purpose of the report is to collect recent or current activities, I encourage you to update all existing summaries and reports. I will probably drop any topics that have not had any activity for the past year, i.e., since May 2005, but I would very much prefer you to present an updated description of the topic. Of course, new entries are more than welcome. Reports should generally be kept brief and informative, ranging from a few sentences to a few hundred words, to keep the whole report reasonably sized. Looking forward to your contributions, Andres (current editor) ----------------------------------- topics New suggestions for current hot topics, activities, projects, etc. are welcome - especially with names and addresses of potential contacts, but here is a non-exclusive list of likely topics (see also http://www.haskell.org/communities/topics.html ): General Haskell developments Haskell implementations Haskell extensions Standardization (Haskell', ...) Documentation Libraries Papers and Books Feedback Summaries of discussions in specialist mailing lists Conference reports Community activities Other Haskell information channels (TMR, Sequence, HWN, ...) Announcements Everything that's new or has had new releases Ongoing projects Reports on what's happening behind the scenes Confirmations that projects are still maintained Calls for contributions and contributors Tutorials Tools and Applications Released and unreleased Haskell applications Tools useful for Haskell programmers Experiences with using Haskell for a project Commercial uses of Haskell Even if your topic is not listed in this list, there's a good chance it has a place in the Report. Please get in touch with me. If you want to see an entry that hasn't been there in the past, but you are not the maintainer of the project, then please encourage the maintainers to write an entry/update, or ask permission to write the entry yourself. -------------------------- what should I write? That depends on your topic, but as a general rule, it shouldn't take you long. A simple sentence or two about your use of Haskell could go into the "Individual Haskellers" section. If you're a company, or if you're working on a project using Haskell as the implementation language, a paragraph on that could go into the "Applications" section. A typical summary report about a tool/library/project/application/... would be between 1 and 3 paragraphs of ASCII text (what's it about? major topics and results since the last report? current hot topics? major goals for the next six months?) plus pointers to material for further reading (typically to a home page, or to mailing list archives, specifications and drafts, implementations, meetings, minutes, ...). Browsing through previous editions should give you a good idea of the variety of possibilities, ranging from very brief to extensive. For those who prefer templates to fill in, the report is edited in LaTeX, and an entry template might look something like this: \begin{hcarentry}{(MYSTUFF)} \report{(MY NAME)} \status{(PROJECT STATUS IN ONE LINE)} \participants{(PARTICIPANTS OTHER THAN MYSELF)}% optional \makeheader Put the text here. What's following are suggestions for the content of an entry. (WHAT IS IT?) (WHAT IS ITS STATUS? / WHAT HAS HAPPENED SINCE LAST TIME?) (CAN OTHERS GET IT?) (WHAT ARE THE IMMEDIATE PLANS?) \FurtherReading \url{(PROJECT URL)} \end{hcarentry} This template and a style file to preview your document are available at http://haskell.org/communities/05-2006/template.tex http://haskell.org/communities/05-2006/hcar.sty

1 0

ANNOUNCE: GHC vesrion 6.4.2
by Simon Marlow 19 Apr '06

19 Apr '06

============================================================= The (Interactive) Glasgow Haskell Compiler -- version 6.4.2 ============================================================= The GHC Team is pleased to announce a new patchlevel release of GHC. This release contains a significant number of bugfixes relative to 6.4.1, so we recommend upgrading. Highlights in this release: - Cabal has been upgraded to version 1.1.4. While strictly speaking this breaks our rules about not changing any library APIs in a patchlevel release, it was felt that the Cabal shipped in 6.4.1 was lacking in various ways, and it was more important to provide a Cabal that works with more existing packages. Some distributions of GHC were already supplying an upgraded Cabal by default. With the exception of Cabal, and OpenAL which was also upgraded, all library APIs are identical to 6.4.1. Release notes are here: http://haskell.org/ghc/docs/6.4.2/html/users_guide/release-6-4-2.html How to get it ~~~~~~~~~~~~~ The easy way is to go to the web page, which should be self-explanatory: http://www.haskell.org/ghc/ We supply binary builds in the native package format for many platforms, and the source distribution is available from the same place. Packages will appear as they are built - if the package for your system isn't available yet, please try again later. Background ~~~~~~~~~~ Haskell is a standard lazy functional programming language; the current language version is Haskell 98, agreed in December 1998 and revised December 2002. GHC is a state-of-the-art programming suite for Haskell. Included is an optimising compiler generating good code for a variety of platforms, together with an interactive system for convenient, quick development. The distribution includes space and time profiling facilities, a large collection of libraries, and support for various language extensions, including concurrency, exceptions, and foreign language interfaces (C, whatever). GHC is distributed under a BSD-style open source license. A wide variety of Haskell related resources (tutorials, libraries, specifications, documentation, compilers, interpreters, references, contact information, links to research groups) are available from the Haskell home page (see below). On-line GHC-related resources ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Relevant URLs on the World-Wide Web: GHC home page http://www.haskell.org/ghc/ GHC developers' home page http://hackage.haskell.org/trac/ghc/ Haskell home page http://www.haskell.org/ Supported Platforms ~~~~~~~~~~~~~~~~~~~ The list of platforms we support, and the people responsible for them, is here: http://hackage.haskell.org/trac/ghc/wiki/Contributors Ports to other platforms are possible with varying degrees of difficulty. The Building Guide describes how to go about porting to a new platform: http://www.haskell.org/ghc/docs/latest/html/building/building-guide.html Developers ~~~~~~~~~~ We welcome new contributors. Instructions on accessing our source code repository, and getting started with hacking on GHC, are available from the GHC's developer's site run by Trac: http://hackage.haskell.org/trac/ghc/ Mailing lists ~~~~~~~~~~~~~ We run mailing lists for GHC users and bug reports; to subscribe, use the web interfaces at http://www.haskell.org/mailman/listinfo/glasgow-haskell-users http://www.haskell.org/mailman/listinfo/glasgow-haskell-bugs There are several other haskell and ghc-related mailing lists on www.haskell.org; for the full list, see http://www.haskell.org/mailman/listinfo/ GHC developers occasionally hang out on #haskell on IRC, too: http://www.haskell.org/haskellwiki/IRC_channel Please report bugs using our bug tracking system. Instructions on reporting bugs can be found here: http://www.haskell.org/ghc/reportabug

1 0

Haskell Reflection
by Oleg Mürk 18 Apr '06

18 Apr '06

Hello, I want to do the following wierd things with arbitrary Haskell program: * Have an IO callback each time a closure is forced * Dynamically load small Haskell expressions that will be executed in the callback * Have access to the syntactic scope of closure being forced in the dynamically loaded expressions * Navigate data graph a'la Java reflection * Test if given closure has been forced I see two ways of doing this: 1) Some Haskell implementation having super-reflective capabilities 2) Doing Haskell program transformation before running it (1) seems doubtful, but I would be more than happy if someone proved me wrong :) As for (2), I would kindly ask the readers of this list for suggestions: * Which program tranformation tool to use. I need to compute syntactic scope of the closures. And I need to know exact line and row numbers of syntactic constructions. Knowing types of expressions of the program being transformed doesn't hurt either. * Most of the features described above are straightforward to implement, but if some of these have been implemented before I would be more than happy to reuse them. In any case I would still need to load dynamically small Haskell expressions. What is the best way to do it? Disclaimer: I am not planning to do application programming using these techniques :) With kind regards, Oleg Mürk

1 0

lhs2TeX-friendly emacs mode?
by Conal Elliott 18 Apr '06

18 Apr '06

Is there a Haskell emacs mode that works well with lhs2TeX? Specifically (a) treating \begin{spec} ... \end{spec} like \begin{code}... \end{code}, and (b) coloring inline code ("|<expr>|)" and maybe inline verbatim ("@<expr>@") as Haskell rather than LaTeX code. - Conal

4 6

6.2.1 for glibc-2.4
by Paul A. Steckler 17 Apr '06

17 Apr '06

[Apologies for the cross-post from Haskell Cafe, but I got no responses there.] I need a Linux ghc 6.2.1 built with glibc-2.4. The existing 6.2.1 RPM, built with glibc-2.3, works mostly OK, but with some programs, the generated executables barf and die on startup. Any suggestions on how to create such a beast? I've tried using ghc 6.4.1, for which there's a Fedora 5 RPM, to build 6.2.1 from source, but all sorts of compile errors occur. On a Linux with glibc-2.3 installed, is there a way to have the ghc build use a different glibc? -- Paul -- Paul Steckler, PhD Tel: +1 503.626.6616 x156 Galois Connections, Inc. Fax: +1 503.350.0833 12725 SW Millikan Way, Beaverton, OR 97005 Email: steck at galois.com

1 0

Haskell Weekly News: April 17, 2006
by dons＠cse.unsw.edu.au 16 Apr '06

16 Apr '06

Haskell Weekly News: April 17, 2006 Greetings, and thanks for reading issue 33 of HWN, a weekly newsletter covering developments in the Haskell community. Each Monday, new editions are posted to [1]the Haskell mailing list and to [2]The Haskell Sequence. [3]RSS is also available. Headlines also go to [4]haskell.org. 1. http://www.haskell.org/mailman/listinfo/haskell 2. http://sequence.complete.org/ 3. http://sequence.complete.org/node/feed 4. http://haskell.org/ Announcements * Halfs, a Haskell filesystem. Isaac Jones [5]announced the first release of Halfs, a filesystem written in Haskell. Halfs can be mounted and used like any other Linux filesystem, or used as a library. Halfs is a fork (and a port) of the filesystem developed by Galois Connections. In addition, Halfs comes with a virtual machine to make using it extremely easy. You don't need an extra partition or a thumb drive, or even Linux (Windows and Mac OS can emulate the virtual machine). See more at [6]the Halfs site. 5. http://article.gmane.org/gmane.comp.lang.haskell.general/13550 6. http://www.haskell.org/halfs/ * DrIFT-2.2.0. John Meacham [7]released DrIFT-2.2.0, the type sensitive preprocessor for Haskell. It extracts type declarations and directives from modules. The directives cause rules to be fired on the parsed type declarations, generating new code which is then appended to the bottom of the input file. Read more [8]here. 7. http://article.gmane.org/gmane.comp.lang.haskell.general/13541 8. http://repetae.net/john/computer/haskell/DrIFT/ * MissingH 0.14.2. John Goerzen [9]announced version 0.14.2 of MissingH, the library of "missing" Haskell code. Now including support for shell globs, POSIX-style wildcards and more. Check [10]here for more details. 9. http://article.gmane.org/gmane.comp.lang.haskell.general/13555 10. http://quux.org/devel/missingh * HAppS - Haskell Application Server 0.8 Einar Karttunen [11]announced HAppS 0.8. The Haskell Application Server version 0.8 contains a complete rewrite of the ACID and HTTP functionalities. Features include: + MACID - Monadic framework for ACID transactions. + An HTTP Server (outperforms Apache/PHP in informal benchmarks). + An SMTP Server. + Mail delivery agent. + DNS resolver in pure Haskell + XML and XSLT. Separate application logic from presentation using XML/XSLT. + And more.. More information on the [12]the HAppS page. 11. http://article.gmane.org/gmane.comp.lang.haskell.general/13557 12. http://happs.org/ * Index-aware linear algebra. Frederik Eaton [13]announced an index-aware linear algebra library written in Haskell. The library exposes index types and ranges so that static guarantees can be made about the library operations (e.g. an attempt to add two incompatibly sized matrices is a static error). Frederik's motivation is that a good linear algebra library which embeds knowledge of the mathematical structures in the type system, such that misuse is a static error, could mean Haskell makes valuable contribution in the area of technical computing, currently dominated by interpreted, weakly typed languages. 13. http://article.gmane.org/gmane.comp.lang.haskell.general/13561 * Crypto-3.0.3. Dominic Steinitz [14]announced Crypto-3.0.3, a new version of the Haskell Cryptography Library. Version 3.0.3 supports: DES, Blowfish, AES, Cipher Block Chaining (CBC), PKCS#5 and nulls padding, SHA-1, MD5 , RSA, OAEP-based encryption (Bellare-Rogaway), PKCS#1v1.5 signature scheme, ASN.1, PKCS#8, X.509 Identity Certificates, X.509 Attribute Certificates. See [15]here for more. 14. http://article.gmane.org/gmane.comp.lang.haskell.general/13564 15. http://www.haskell.org/crypto Haskell' This section covers activity on [16]Haskell' standardisation process. * [17]Concurrency and FFI status * [18]On Unicode * [19]The goals of the concurrency standard * [20]Preemptive versus cooperative scheduling * [21]Postponing deepSeq and exceptions discussion * [22]Defaults for superclass methods * [23]Collecting requirements for FDs * [24]FDs and confluence * [25]Network IO 16. http://hackage.haskell.org/trac/haskell-prime 17. http://thread.gmane.org/gmane.comp.lang.haskell.prime/1409/focus=1409 18. http://thread.gmane.org/gmane.comp.lang.haskell.prime/1404/focus=1404 19. http://thread.gmane.org/gmane.comp.lang.haskell.prime/1361/focus=1361 20. http://thread.gmane.org/gmane.comp.lang.haskell.prime/1354/focus=1354 21. http://thread.gmane.org/gmane.comp.lang.haskell.prime/1352/focus=1352 22. http://thread.gmane.org/gmane.comp.lang.haskell.prime/1328/focus=1328 23. http://thread.gmane.org/gmane.comp.lang.haskell.prime/1318/focus=1318 24. http://thread.gmane.org/gmane.comp.lang.haskell.prime/1296/focus=1296 25. http://thread.gmane.org/gmane.comp.lang.haskell.prime/1432/focus=1432 Discussion * QuickCheck. Koen Claessen [26]hinted that a "brand new" version of QuickCheck with lots of cool features is soon to be released. 26. http://article.gmane.org/gmane.comp.lang.haskell.general/13543 * Accurate event scheduling. Henning Thielemann [27]asked about how to improve the accuracy of event scheduling, while working on Haskore, the Haskell music system. John Meacham suggested a binding to the Linux real time clock interface, while Tomasz Zielonka pointed to a library he has been developing using software transactional memory actions for accurate timeouts. He also mentioned the new registerDelay function in the GHC head. Measurements indicated that the average error from the expected waiting time dropped from 0.010140108245s to 0.00080999391s. Quite good results. 27. http://thread.gmane.org/gmane.comp.lang.haskell.cafe/12350/focus=12350 * Good fusion. [28]A casual remark about an alternative version of the inits function lead to a huge discussion about using fusion to improve code quality. 28. http://thread.gmane.org/gmane.comp.lang.haskell.libraries/4520/focus=4520 Code watch * Sun Apr 2 14:59:11 PDT 2006 simonpj Improve newtype deriving Ross Paterson pointed out a useful generalisation of GHC's newtype-deriving mechanism. This implements it. The idea is to allow newtype Wrap m a = Wrap (m a) deriving (Monad, Eq) where the representation type doesn't start with a type constructor. * Tue Apr 11 05:04:41 PDT 2006 simonpj Allow IO to be wrapped in a newtype in foreign import/export Up to now, the silent unwrapping of newtypes in foreign import/export has been limited to data values. But it's useful for the IO monad itself: newtype MyIO a = MIO (IO a) foreign import foo :: Int -> MyIO Int This patch allows the IO monad to be wrapped too. Contributing to HWN You can help us create new editions of this newsletter. Please see the [29]contributing information, send stories to dons -at- cse.unsw.edu.au. The darcs repository is available at darcs get http://www.cse.unsw.edu.au/~dons/code/hwn 29. http://haskell.org/haskellwiki/HWN

1 0

ANNOUNCE: Crypto-3.0.3
by Dominic Steinitz 15 Apr '06

15 Apr '06

I should like to announce a new version of the Haskell Cryptography Library. Version 3.0.3 supports: • DES • Blowfish • AES • Cipher Block Chaining (CBC) • PKCS#5 and nulls padding • SHA-1 • MD5 • RSA • OAEP-based encryption (Bellare-Rogaway) • PKCS#1v1.5 signature scheme • ASN.1 • PKCS#8 • X.509 Identity Certificates • X.509 Attribute Certificates It also includes Base64, a hexdump function, support for Word128, Word192, Word256 (key sizes for AES) and beyond. The ASN.1 handling has been re-written. Details on how to use it are contained in the user guide http://www.haskell.org/crypto/ReadMe.pdf. Haddock documentation is available at http://www.haskell.org/crypto/doc/html. See the home page (http://www.haskell.org/crypto) for downloading. Dominic.

1 0

Platform-dependent behaviour with functions on NaN
by Geisler, Tim (EXT) 14 Apr '06

14 Apr '06

In Haskell, the behaviour of functions on floating-point values which are NaN can be platform dependent. On "SunOS sun 5.9 Generic_118558-09 sun4u sparc SUNW,Sun-Blade-1500": Prelude> ceiling (0/0) 359538626972463141629054847463408713596141135051689993197834953606314521 560057077521179117265533756343080917907028764928468642653778928365536935 093407075033972099821153102564152490980180778657888151737016910267884609 166473806445896331617118664246696549595652408289446337476354361838599762 500808052368249716736 On Windows: Prelude> ceiling (0/0) -26965397022934738615939577861835371004269654684134598591014512173659901 370825144469906271598361130403168017081980709003648818465322162493373927 114595921118656665184013729822791445332940186914117917962442812750865325 722602351369432221086966581124085574502576602687944735992086890771957445 7253034494436336205824 Both machines use the binary distributions of GHC 6.4.1. In our production code, this error (which is actually an error in our program) occured inside a quite complex expression which can be simplified to max 0 (ceiling (0/0)). On Windows, we did not recognize the error in the program, because the complex expression just returned 0. On Solaris, the complex expression returned this large number (which represents in the application "the number of CPUs needed in a certain device" ;-) We develop Haskell programs on Windows and run them in production on Sparc with Solaris. It seems that we have to run special regression tests testing for differences between Sparc Solaris and Windows. The Haskell 98 report http://www.haskell.org/onlinereport/basic.html#sect6.4 states: "The results of exceptional conditions (such as overflow or underflow) on the fixed-precision numeric types are undefined; an implementation may choose error (_|_, semantically), a truncated value, or a special value such as infinity, indefinite, etc." There has been some discussion six years ago and nearly two years ago: http://blog.gmane.org/gmane.comp.lang.haskell.glasgow.user/month=2004080 1 Is there a chance to - properly define the behaviour of functions depending on the function properFraction for values like NaN, Infinity, ...? - get an implementation of this in GHC which computes the same results for all platforms? Perhaps the function properFraction could raise an exception in case of isNaN and isInfinity? Other languages are more portable. E.g., for Java, these cases are defined. http://java.sun.com/docs/books/jls/second_edition/html/typesValues.doc.h tml#9249 states: "All numeric operations with NaN as an operand produce NaN as a result." Tim

5 4

ANNOUNCE: An index-aware linear algebra library in Haskell
by Frederik Eaton 14 Apr '06

14 Apr '06

An index-aware linear algebra library in Haskell I've been exploring the implementation of a library for linear algebra, i.e. manipulating vectors and matrices and so forth, which has as a fundamental design goal the exposure of index types and ranges to the type system so that operand conformability can be statically guaranteed (e.g. an attempt to add two matrices of incompatible sizes, or multiply an NxK matrix by an MxL matrix where K /= M, is flagged statically by the compiler). A significant contribution of this work is a mechanism for supporting interactive use. This is challenging because it requires instantiating values with user-specified index types directly, rather than via CPS rank-2 polymorphic "with" functions as in Kiselyov and Shan's "Implicit Configurations". The solution is based on Template Haskell. MOTIVATION: Haskell has never been a serious language choice for numerics, partly because of efficiency problems. However, a large portion of the demand for number-processing in science is met by other interpreted languages such as Octave and Matlab. These languages are just as slow, or slower, than Haskell when it comes to executing a large number of operations in succession. Their advantage is in making available to the user a collection of highly-optimized linear algebra routines. Since many numerical tasks consist of simple, repetitive operations on large amounts of data, and because these operations can often be reformulated in terms of operations on vectors and matrices, such matrix languages can give good performance on appropriately written code, and have become standard, viable workbenches for numerical analysis. However, matrix languages are often good for little more than matrix manipulations - their support for more complicated data structures is poor. Furthermore, they are generally dynamically typed, which means that type errors only become evident at runtime. In particular, operand conformability errors, caused for instance by multiplying matrices A*B instead of B*A or A'*B' (in Matlab notation), are runtime errors, and such errors can be masked when dimensions happen to be equal, for instance when A and B are square matrices as in the above example. I believe that with a good linear algebra library which solves this problem via static typing, Haskell could make a valuable contribution in the area of technical computing. DESIGN: - The fundamental type is a "vector", which includes an element type and an index type. Matrices are vectors indexed by pairs. Vectors are members of the Vector class. The element type is a class parameter, to allow vectors over specialized types: class Vector v e | v -> e (note, the index type is not a class parameter) http://ofb.net/~frederik/futility/src/Vector/Base.hs - The building-block index type wraps a type-level integer N, and accepts a range of possible values 0..(N-1). I use a modified version of Oleg Kiselyov and Chung-chieh Shan's "Implicit Configurations" paper for the type-level integers. Index types must implement the Dom ("domain") class. Superclasses are Bounded, Enum, Ix, Eq, and Show. Instances are defined so that index types may be combined with (,) and Either. Additionally, there is a generics-style method domCastPair which allows us to detect when a vector is also a matrix. The primary intent of this is to make it possible for libraries such as Alberto Ruiz's GSL library to implement our interface, using different data types for matrices and vectors "under the hood". I also use domCastPair to display vectors and matrices differently. http://ofb.net/~frederik/futility/src/Domain.hs http://ofb.net/~frederik/futility/src/Prepose.hs - I have provided an example implementation of most of the operations using the Array type. This is very slow for numerical operations (about 200x slower than Octave), but it allows arbitrary (boxed) element types, which faster implementations are unlikely to do. http://ofb.net/~frederik/futility/src/Vector/Array.hs Thus in the current state the library is a working prototype. For it to be practically useful, it still needs a Vector instance which wraps some fast linear algebra library such as the GSL (at the expense of only supporting a restricted set of element types). A faster Haskell-only implementation would also be possible using unboxed arrays, but I think it is unlikely that this would be able to come close to the performance of an external C or Fortran library such as GSL. - Due to the need to specify index types at some point, input of vectors is difficult. I have provided two functions in Fu.Vector.Base which should cover most of the cases: listVec :: Vector v e => [e] -> (forall n . (ReflectNum n) => v (L n) -> w) -> w listMat :: Vector v e => [[e]] -> (forall n m . (ReflectNum n, ReflectNum m) => v (L m, L n) -> w) -> w However, these aren't useful in interactive situations. So I have also provided some template-haskell routines http://ofb.net/~frederik/futility/src/Vector/Template.hs which can be used to instantiate vectors directly. For example: -- 'ident' is an identity matrix with polymorphic dimensions -- $(cm 3 3) specifies a 3x3 matrix -- aV specifies use of the Array implementation > let x = aV $ $(cm 3 3) ident > x <# 1, 0, 0; 0, 1, 0; 0, 0, 1 #> > let v = x + ones > v <# 2, 1, 1; 1, 2, 1; 1, 1, 2 #> See also http://ofb.net/~frederik/futility/src/Vector/examples.hs I haven't finalized the names in Vector/Template.hs. While it seems desirable that they be short ('cm', 'aV'), I imagine the names I have chosen, and the interface in general, could be improved upon. PROBLEMS stemming from shortcomings in the language / GHC: - Any code using template haskell cannot be profiled. - When vector index types are known explicitly, for instance with interactive use, errors can be difficult to parse: > ($(cv 5) ones) + ($(cv 4) ones) <interactive>:1:18: Couldn't match `Succ (Twice (Twice (Succ Zero)))' against `Twice (Twice (Succ Zero))' Expected type: v (L (Succ (Twice (Twice (Succ Zero))))) Inferred type: v (L (Twice (Twice (Succ Zero)))) In the application `$[splice](cv 4) ones' In the second argument of `(+)', namely `($[splice](cv 4) ones)' A base-10 implementation of the type-level integers might help, but even better would be language support for dependent types. - Class annotations are repetitive and tiresome. The code starts to look like Prolog. vzipWith_ :: (Dom a, Vector v k, Vector u l, Vector w m) => (k -> l -> m) -> v a -> u a -> w a A "functional" syntax would be cleaner: vzipWith_ :: (k -> l -> m) -> V k a -> V l a -> V m a where "v = V k a" implies a constraint (Vector v k, Dom a). Oleg suggests this might be accomplished with better support for type aliases: type V k a = (Vector v k, Dom a) => v a "Partial signatures", i.e. being able to specify types without class constraints, would also be nice. PROBLEMS stemming from shortcomings in the approach: - In Octave, it is easy to create a new vector from a subset of the indices of an existing vector, by specifying a boolean relation on those indices: > a=[1,0,1,1]; > b=[1,2,3,4]; > b(a==1) ans = 1 3 4 Doing this sort of thing in an environment where vector indices are strongly-typed seems difficult. Probably the best option in this particular case would be returning a list of values. - Lazy evaluation is likely to be a source of performance headaches, although I haven't actually investigated this. - Many expressions can be better optimized if one has access to the structure of the whole expression. For instance, given matrices A, B, and C, a specialized routine might calculate A*B+C in one step, and it may be that A*(B*C) is more efficient to calculate than (A*B)*C. A special-purpose language such as Matlab can perform these kinds of optimizations easily. It is more difficult to do them in a library, although it is not impossible. FUTURE work: The set of standard Vector operations needs to be fleshed out. A wrapper for Alberto's GSL library, or another fast matrix library, should be written. ACKNOWLEDGMENTS: Thanks to Oleg Kiselyov for many useful discussions, and to Ralf Lammel for help understanding generics. -- http://ofb.net/~frederik/

1 0