April 2006 - Haskell - Haskell.org

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

17 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

ANNOUNCE: HAppS 0.8
by Einar Karttunen 14 Apr '06

14 Apr '06

Hello, HAppS - Haskell Application Server version 0.8 has been released and contains a complete rewrite of the ACID and HTTP functionalities. Features include: * MACID - Monadic framework for ACID transactions: Write apps as a set of simple state transformers. MACID write-ahead logging and checkpointing make it easy for you to guarantee application integrity in the face of unplanned outages. MACID even guarantees that your side effects will be executed at-least-once if they can complete within a timelimit you define. * HTTP Server: Performs better than Apache/PHP in our informal benchmarks (thanks to Data.FastPackedString), handles serving both large (video) files and lazy (javascript) streaming, supports HTTP-Auth, and more. * SMTP Server Handle incoming email in your application without worrying about .procmail or other user level inbound mail configuration hackery. Just have the HAppS.SMTP listen on port 25 or have the system mail server SMTP forward mail for your app to some internal port. * Mail delivery agent Stop worrying about making sure a separate local mail server or DNS is up and running to deliver your mail. HAppS takes care of making sure your mail is delivered as long as your application itself is running and makes sure no outbound mail is lost even with unplanned restarts. * DNS resolver in pure Haskell For resolving MX records and concurrent queries. Can use an upstream DNS server or root servers directly. * XML and XSLT Separate application logic from presentation using XML/XSLT. With HAppS, you can have your application output XML (via HTTP or SMTP) and handle style/presentation via separate XSLT files at runtime. HAppS takes care of doing server side XSLT for outbound mail and HTTP user-agents that don't support it client side. * Sessions and much more! Where to get? http://happs.org/ darcs get http://happs.org/HAppS -- Einar Karttunen

2 1

QuickCheck revival and Cabal
by Koen Claessen 13 Apr '06

13 Apr '06

Dear all, For the past couple of years, I have been quietly hacking on a brand new version of QuickCheck with lots of cool features. I have been distributing copies to some friends, but have not released any official package. Now, after lots of peer pressure, the time has come that I want to release the current version as a Cabal package. I have been agonizing however over where in the module hierarchy the new QuickCheck package should be. There is currently an old QuickCheck version in the standard hierarchy in Test.QuickCheck. As the new QuickCheck is incompatible with the old one, I do not want to override that place. Rather, I would like to create my own little space in the hierarchy where the new version can sit and develop. It feels to me that there should be a convention that people use to add their own contributions to the module hierarchy without the danger of clashing with other packages. Proposals: Contrib.Chalmers.QuickCheck External.Chalmers.QuickCheck Chalmers.QuickCheck Contrib.Test.QuickCheck Contrib.QuickCheck The first three I like -- but not the last one; I don't want to rule out anyone else (except for my own colleagues :-) making their own version of QuickCheck and releasing it somewhere in the tree. What does one think? Regards, /Koen PS1. Previously discussions about this were referred to the libraries mailing list but I feel that this is of interest to the larger crowd too. PS2. I welcome myself back to the Haskell mailing list after years of inactivity :-)

4 4

ANN: MissingH 0.14.2
by John Goerzen 13 Apr '06

13 Apr '06

Hello, I'm pleased to announce the release of version 0.14.2 of MissingH. New features since 0.14.0 include: * New module MissingH.Path.Glob. This module expands wildcards by examining the filesystem. For instance, given the pattern /*bin/*sh, you might get back ["/bin/bash", "/bin/sh", "/sbin/sash"] * New module MissingH.Path.WildMatch. This module evaluates whether a given string matches a POSIX-style wildcard. It can also convert such a wildcard into a regular expression for use with Text.Regex. * New function MissingH.List.hasAny :: Eq a => [a] -> [a] -> Bool It returns true if the given list contains any of the elements in the search list * New function MissingH.IO.HVFS.vDoesExist, which returns true if the named object exists on the filesystem, regardless of what type of object it is * New function MissingH.Str.escapeRe, which takes a string and makes a regular expression that matches the string literally. It takes care to properly escape all characters that could have special meaning in a regular expression. * ConfigParser now gives more helpful error messages when possible, including section and option in most error messages * Total number of unit tests for MissingH now stands at 716. As always, MissingH can be downloaded from http://quux.org/devel/missingh or, after a few days, from http://http.us.debian.org/debian/pool/main/m/missingh MissingH.Path.Glob and WildMatch are high-level ports of similar modules in Python. Thanks, -- John Goerzen Author, Foundations of Python Network Programming http://www.amazon.com/exec/obidos/tg/detail/-/1590593715

1 0

standard prelude and specifications
by Laszlo Nemeth 13 Apr '06

13 Apr '06

Hi, Chp 8 of the Haskell Report says: > In this chapter the entire Haskell Prelude is given. It constitutes a > *specification* for the Prelude. > Many of the definitions are written with clarity rather than > efficiency in mind, and it is not required > that the specification be implemented as shown here. My question is how strictly this word "specification" is to be interpreted? I can think of a strict and a loose interpretation: (1 - strict) Whatever invariant I can read out from the code which is given I am allowed to interpret it as part of the specification. e.g here is the code for filter: filter :: (a -> Bool) -> [a] -> [a] filter p [] = [] filter p (x:xs) | p x = x : filter p xs | otherwise = filter p xs Primarily this states that the resulting list have no elements for which the predicate 'p' does not hold. But I can also read out from the code that filter does not rearrange the elements in the list: for example if the list was sorted, it remains so afterwards. Under the strict interpretation this is also taken as part of specification for filter. (2 - loose) Filter is meant to drop elements for which the predicate 'p' doesn' t hold, and an implementation is free to rearrange the elements. There must have been some discussion of this earlier but google didn't find anything useful. Thanks, Laszlo

2 1

Announcing Halfs, a Haskell Filesystem
by Isaac Jones 12 Apr '06

12 Apr '06

Halfs is a filesystem implemented in the functional programming language 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. We've created a virtual machine to make using Halfs 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). For the impatient, go to the quick start: http://hackage.haskell.org/trac/halfs/wiki/QuickStart The Halfs web page is here: http://www.haskell.org/halfs/ Background: In the course of developing a web server for an embedded operating system, Galois Connections had need of a filesystem which was small enough to alter to our needs and written in a high-level language so that we could show certain high assurance properties about its behavior. Since we had already ported the Haskell runtime to this operating system, Haskell was the obvious language of choice. Halfs is a port of our filesystem to Linux, with some modifications. High assurance development is a methodology for creating software systems that meet rigorously-defined specifications with a high degree of confidence. That methodology comprises tools and practices. Its goal is to produce such systems reliably and effectively, with an ordinary degree of developer effort. Haskell is particularly well-suited to high assurance development. It is a high-level, fully-expressive, pure, functional language, with a powerful type system. One of the obligations of high assurance development is the demonstration of strong correspondence between high-level executable models and the eventual implementation. Haskell supports this directly: it can describe systems all the way from high-level executable models through to system implementations. The fact that Haskell is pure comes from its mathematical basis, and means that, by default, a function does not interfere with other functions. The type system is an automatic and scalable proof engine that can encode and enforce desirable properties. Together, these features allow the correctness of complex systems to be established, making Haskell ideal for high assurance development. The question was whether Haskell is well suited as the implementation language for a filesystem, which involves fixed sized buffers, lots of IO, and binary data structures. Though correctness is much more important to us than performance, we hoped that a Haskell filesystem would have acceptable performance, and that writing such low-level code would not be awkward or error-prone. We have developed a filesystem, Halfs, which aims to answer the above questions. One may mount a Halfs filesystem in Linux using the FUSE (Filesystem in Userspace) kernel module. We have created two new monads, FSRead and FSWrite which restrict the IO monad to reading and writing operations respectively. For performance, Halfs uses efficient mutable arrays for block IO, as well as caching for blocks and inodes.

1 0

Haskell concepts in the next Visual Basic
by Paul Johnson 11 Apr '06

11 Apr '06

In the recent discussion on "Haskell as a disruptive technology" I predicted that MS would incorporate functional programming into its languages. See here for details. http://lambda-the-ultimate.org/node/1406 Paul.

2 1