Brent Yorgey | 1 Nov 2008 21:42
Favicon
Gravatar

Haskell Weekly News: Issue 91 - November 1, 2008

---------------------------------------------------------------------------
Haskell Weekly News
http://sequence.complete.org/hwn/20081101
Issue 91 - November 01, 2008
---------------------------------------------------------------------------

   Welcome to issue 91 of HWN, a newsletter covering developments in the
   [1]Haskell community.

Announcements

   blas version 0.6. Patrick Perry [2]announced a [3]new version of the
   Haskell BLAS bindings, now with support for the ST monad!

   darcs hacking sprint #1 (report). Eric Y. Kow [4]summarized the
   [5]progress made during the darcs hacking sprint last weekend. Looks
   like exciting stuff! Much more detail and links can be found in Eric's
   original email.

   LAST CALL: Haskell Communities and Activities Report. Janis
   Voigtlaender [6]is extending the submission deadline for the 15th
   edition of the Haskell Community and Activities Report by a few days.
   If you haven't already, please [7]write an entry for your new project
   or update your old entry.

   Data.TCache 0.5.1. Alberto G. Corona [8]announced the release of
   [9]Data.TCache, which implements a transactional cache with
   configurable persistence. It tries to simulate Hibernate for Java or
   Rails for Ruby; the main difference is that transactions are done in
   memory trough STM.
(Continue reading)

Gwern Branwen | 2 Nov 2008 01:23
Picon
Gravatar

Re: Publication of InputYourData.com + Project Announcement

2008/10/26 Enzo Haussecker <ehaussecker <at> gmail.com>:
> I would like to announce the publication of InputYourData.com (beta) - the
> online resource tool for financial, mathematical and scientific
> calculations. All web applications found at http://inputyourdata.com/ are
> written solely in Haskell and based on the Network.CGI framework.
> This website began as an experiment to familiarize myself with the monadic
> features of Haskell and their use in web programming. Namely, the mapping
> and manipulation of user inputs as typed objects. Through these experiments
> I found that Haskell allows for an efficient system where a variety of
> operations can be preformed while minimizing as many resources (such as time
> and memory space) as possible.
> I am now interested in developing a similar type of website, except wiki
> style - where all web applications are created by the user. Essentially, I
> am designing a web application where users can symbolically declare the
> arguments of a function and that function's call based on arbitrary
> variables. For example, say a user would like to create a web application to
> compute the roots of a second degree polynomial. He/she would simply declare
> the arguments to her function - three complex numbers a b and c, and the
> call of that function - (-b ± sqrt (b^2 - 4*a*c))/(2*a). The product of that
> users inputs will render a web application that looks similar
> to http://inputyourdata.com/cgi-bin/quadratic.cgi (all text is to be updated
> by the user as well). As one could imagine, other, more complex functions
> invo lving vectors, matrices, stock prices, and other arguments can also be
> defined in terms of arbitrary variables and declared as an inputs to my
> wiki-style web application.

That sounds interesting, certainly. But out of curiosity, how would
you handle the security aspect? It sounds like the utility of such a
wiki lies in letting the user use the full power of Haskell for
development & configuration (which has worked out well for XMonad) -
(Continue reading)

Marc Weber | 2 Nov 2008 14:47
Picon
Picon

Need help with VXML again (fun deps and forall types)

Some time I've announced that I'm working on VXML, a validating xml
library.

The use case which makes trouble is elem+ (one or more)

<!ELEMENT root (a|b|(c,d+))*>

This example is encoded in this way:

root -> St 1

 id :1
   endable : True
   a -> St 1
   b -> St 1
   c -> St 12

 id :11
   endable : True
   (a|b|c) -> St 1
   d -> St 11

 id :12
   endable : False
   d -> St 11

to be read as:
When creating a new root element start with state 1, then expect one of
a,b,c subelemnts.

(Continue reading)

Alberto G. Corona | 2 Nov 2008 15:02
Picon

Re: [Haskell] ANNOUNCE: RefSerialize-0.2.1

I uploadad RefSerialize  to  Hackage .

Read, Show and Data.Binary do not check for repeated references to the same data address. As a result, the data is serialized multiple times when serialized. This is a waste of space in the filesystem  and  also a waste of serialization time. but the worst consequence is that, when the serialized data is read, it allocates multiple copies in memory for the same object referenced multiple times. Because multiple referenced data is very typical in a pure language such is Haskell, this means that the resulting data loose the beatiful economy of space and processing time that referential transparency permits.
                    
This package allows the serialization and deserialization of large data structures without duplication of data, with
the result of optimized performance and memory usage. It is also useful for debugging purposes.
                    
There are automatic derived instances for instances of Read/Show, lists and strings. the deserializer contains a almos complete set of Parsec.Token parsers for deserialization.
                    
 Every instance of Show/Read is also a instance of Data.RefSerialize
                    
 The serialized string has the form "expr( var1, ...varn) where  var1=value1,..valn=valueN " so that the
string can ve EVALuated.
                    
 See demo.hs and tutorial. I presumably will add a entry in haskell-web.blogspot.com
                    
                     To develop: -derived instances for Data.Binary
                                 -serialization to/from ByteStings

I wrote this module because I needed to serialize lists of verisions of the same data with slight modifications between each version.


This is a short tutorial (in tutorial.txt)



runW applies showp, the serialization parser of the instance Int for the RefSerialize class

Data.RefSerialize>let x= 5 :: Int
Data.RefSerialize>runW $ showp x
"5"

every instance of Read and Show is an instance of RefSerialize.

rshowp is derived from showp, it labels the serialized data with a variable name

Data.RefSerialize>runW $ rshowp x
" v8 where {v8= 5; }"

Data.RefSerialize>runW $ rshowp [2::Int,3::Int]
" v6 where {v6= [ v9,  v10]; v9= 2; v10= 3; }"

while showp does a normal show serialization

Data.RefSerialize>runW $ showp [x,x]
"[5, 5]"

rshowp variables are serialized memory references: no piece of data that point to the same addrees is serialized but one time

Data.RefSerialize>runW $ rshowp [x,x]
" v9 where {v6= 5; v9= [ v6, v6]; }"

This happens recursively

Data.RefSerialize>let xs= [x,x] in str = runW $ rshowp [xs,xs]
Data.RefSerialize>str
" v8 where {v8= [ v10, v10]; v9= 5; v10= [ v9, v9]; }"

the rshowp serialized data is read with rreadp. The showp serialized data is read by readp

Data.RefSerialize>let xss= runR rreadp str :: [[Int]]
Data.RefSerialize>print xss
[[5,5],[5,5]]

this is the deserialized data

the deserialized data keep the references!! pointers are restored! That is the whole point!

Data.RefSerialize>varName xss !! 0 == varName xss !! 1
True


rShow= runW rshowp
rRead= runR rreadp

Data.RefSerialize>rShow x
" v11 where {v11= 5; }"


In the definition of a referencing parser non referencing parsers can be used and viceversa. Use a referencing parser
when the piece of data is being referenced many times inside the serialized data.

by default the referencing parser is constructed by:

rshowp= insertVar showp
   rreadp= readVar readp
but this can be redefined. See for example the instance of [] in RefSerialize.hs

This is an example of a showp parser for a simple data structure.

data S= S Int Int deriving ( Show, Eq)      

instance  Serialize S  where
    showp (S x y)= do
                    xs <- rshowp x  -- rshowp parsers can be inside showp parser
                    ys <- rshowp y
                    return $ "S "++xs++" "++ys
      
      

    readp =  do
                    symbol "S"     -- I included a (almost) complete Parsec for deserialization
                    x <- rreadp   
                    y <- rreadp
                    return $ S x y

there is a mix between referencing and no referencing parser here:    
 
Data.RefSerialize>putStrLn $ runW $ showp $ S x x
S  v23 v23 where {v23= 5; }    


(I corrected some errors in this file here)


_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe <at> haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe
Ivan Lazar Miljenovic | 3 Nov 2008 04:35
Picon
Gravatar

ANNOUNCE: Graphalyze-0.5 and SourceGraph-0.3

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

I've just submitted my thesis this morning (w00t!!!) and as such I'm announcing
the latest versions of Graphalyze [1,2] and SourceGraph [3,4], which fix a
couple of bugs in the previous versions (these bugs were fixed whilst waiting
for my supervisor to finish reading through my draft, and as such I had to
re-write bits of my thesis that talked about the limitations of the
software :s ).

[1] http://hackage.haskell.org/cgi-bin/hackage-scripts/package/Graphalyze

[2] http://code.haskell.org/Graphalyze

[3] http://hackage.haskell.org/cgi-bin/hackage-scripts/package/SourceGraph

[4] http://code.haskell.org/SourceGraph


Briefly, SourceGraph is a utility that uses the Graphalyze library to analyse
Cabalized Haskell software.  Its input/output is rather restrictive at
the moment: it takes a single argument, which is the path to a .cabal file, and
then produces an HTML report in:
      <project directory>/SourceGraph/≤project name>.html
This report contains visualisation of the code for each module, for the imports
(similar to what graphmod [5] does) as well as the entire code base.
Furthermore, the entire code base is also visualised with functions grouped by
the modules they're defined in, as well some simple analyses (such as comparing
the export list to what functions are actually roots, similar to the output for
top-level functions returned by GHC when using -fwarn-unused-binds).

Main changes in Graphalyze since version 0.4:
* When writing my thesis, I found some obvious silly mistakes (such as copying
  the rootsOf function definition to leavesOf, but not changing the function
  definition).
* Images in the document representation are now inline elements.
* When using Pandoc [6] for document generation, the size of generated graphs
  is now customisable on a per-format basis; furthermore, for web pages graph
  visualisations link to larger versions.  Also, graph visualisations can now
  be created in a sub-directory.

Main changes in SourceGraph since version 0.2:
* Now uses Cabal 1.6
* Improve visual layout of generated HTML report (still no CSS though).
* "Smarter" analysis: don't show trivial analysis results, and when analysing
  the entire code base don't return cliques, etc. that contain functions all in
  the same module (as they would have been reported in the per-module section).

Note, however, that the parsing limitations for version 0.2 still apply: cpp is
still as-yet unsupported (as I'm not sure what I'll do about choosing cpp
flags); Template Haskell, HaRP and HXML are still ignored and functions in
class declarations/records are still ignored (the former because it's ambiguous
which actual function you want, the latter because they're boring :p ).  Also,
SourceGraph is _still_ not a refactoring tool ;-)

If anyone's interested, I'll soon be uploading the final version of my thesis
to my blog.  Also, if anyone is interested in hacking on any of this, feel
free!  I'll probably leave it for a while (I'm going to be doing Java coding
over summer, blech :s ), but I intend to come back to it later on.

- -- 
Ivan Lazar Miljenovic
Ivan.Miljenovic <at> gmail.com
IvanMiljenovic.wordpress.com
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v2.0.9 (GNU/Linux)

iEYEARECAAYFAkkOcaAACgkQfEfFJ9JhvyjhIwCeM9VXsJeSVK2CdWURJDer6zoA
A5YAoIfayHtjpw0qt/gyPZhhhypOwzSh
=x+/X
-----END PGP SIGNATURE-----
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe <at> haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe
Achim Schneider | 3 Nov 2008 09:09
Picon

Re: ANNOUNCE: Graphalyze-0.5 and SourceGraph-0.3

Ivan Lazar Miljenovic <ivan.miljenovic <at> gmail.com> wrote:

> This report contains visualisation of the code for each module, for
> the imports (similar to what graphmod [5] does) as well as the entire
> code base.
>
We cna haz screenshotz?

--

-- 
(c) this sig last receiving data processing entity. Inspect headers
for copyright history. All rights reserved. Copying, hiring, renting,
performance and/or quoting of this signature prohibited.
Simon Marlow | 3 Nov 2008 10:18
Picon

Fwd: ACL2 2009 Call for Papers

[ forwarding on behalf of Sandip Ray <sandip <at> cs.utexas.edu> ]

[ Apologies if you get several copies of this call for papers.  Please
   share it with students and colleagues who may be interested in the
   workshop. ]

===============================================================================
                          CALL FOR PAPERS
===============================================================================
                             ACL2 2009
International Workshop on the ACL2 Theorem Prover and Its Applications
                            May 11-12, 2009
                    Northeastern University, Boston, MA, USA
                      http://www.cs.utexas.edu/~sandip/acl2-09/

                         In cooperation with ACM SIGPLAN

===============================================================================
IMPORTANT DATES

Abstract Submission: January 12, 2009
Paper Submission: January 19, 2009
Acceptance Notification: February 23, 2009
Final Version: March 23, 2009

===============================================================================
SCOPE OF CONFERENCE

ACL2 2009 is a major forum for the users of the ACL2 theorem proving
system to present research related to the ACL2 theorem prover and its
application, and is the eighth in the series of workshops, occurring
at approximately 18-month intervals.  ACL2 is a state-of-the-art
automated reasoning system, the latest in the Boyer-Moore family of
theorem provers, for which its authors received the 2005 ACM Software
Systems Award. ACL2 2009 is planned as a two-day workshop to be held
in Boston, MA, USA, on May 11-12, 2009.  In addition to paper
presentations, ACL2 2009 is anticipated to include two keynote
lectures, a panel discussion, and several rump sessions discussing
ongoing research.

We invite submission of papers on any topic related to ACL2 and its
applications. We strongly encourage the participation of users of
other theorem provers and researchers and practitioners interested in
theorem proving technology. Appropriate topics include, but are not
limited to, the following:

     * Applications of ACL2 in hardware and software system verification
     * Formalization of mathematics in ACL2
     * Use of ACL2 in emerging and novel application areas
     * New libraries, tools, and interfaces for ACL2
     * Connection of ACL2 with other formal (and semi-formal) verification 
tools
     * Foundational issues related to ACL2
     * Comparison of ACL2 with other formal verification tools
     * Reports and proposals on improvement of ACL2
     * Challenge problems related to implementation and applications of ACL2
     * Classroom and pedagogical experiences in the use of ACL2

===============================================================================
PAPER SUBMISSION

Submissions must be made electronically in PDF format through the ACL2
2009 Web site.  Submissions must use ACM SIG Proceedings format with
letter-size paper (see URL
http://www.acm.org/sigs/pubs/proceed/template.html).  ACL2 2009 is
organized in cooperation with ACM SIGPLAN and the proceedings are
expected to be published in the ACM Digital Library.

Two categories of papers will be accepted: long (at most 10 pages) and
short (at most 4 pages).  Authors may assume that the audience has a
working knowledge of ACL2's syntax, basic commands, and modeling
techniques.  Papers should contain a short abstract of about 150
words, clearly stating the contribution of the submission.  Papers
should be self-contained, but we strongly encourage authors to follow
the tradition (where applicable) of providing ACL2 "books", or script
files, with instructions for their execution.  For accepted papers,
these books will be mirrored from the ACL2 Home Page and included in
the future ACL2 distributions.  At least one author of each accepted
paper will be required to register for the workshop and present the
paper.

==============================================================================
ORGANIZATION

Co-Chairmen:         Sandip Ray,  University of Texas at Austin, USA
                      David Russinoff, 	Advanced Micro Devices, Inc., USA
Local Arrangements:  Panagiotis Manolios, Northeastern University, USA
Publications:        Ruben Gamboa, University of Wyoming

Steering Committee:  John Cowles, University of Wyoming, USA
		     Ruben Gamboa, University of Wyoming, USA
		     Matt Kaufmann, University of Texas at Austin, USA
		     Panagiotis Manolios, Northeastern University, USA
		     J Strother Moore, University of Texas at Austin, USA
		     Jun Sawada, IBM Austin Research Laboratory, USA
		     Matt Wilding, Rockwell Collins, Inc., USA

==============================================================================
PROGRAM COMMITTEE

   * John Cowles, University of Wyoming, USA
   * Ruben Gamboa, University of Wyoming, USA
   * Mike Gordon, Cambridge University, UK
   * Matt Kaufmann, University of Texas at Austin, USA
   * Francisco Palomo Lozano, Universidad de Cadiz, Spain
   * Panagiotis Manolios, Northeastern University, USA
   * John Matthews, Galois, Inc., USA
   * J Strother Moore, University of Texas at Austin, USA
   * Rex Page, University of Oklahoma, USA
   * Jun Sawada, IBM Austin Research Laboratory, USA
   * Julien Schmaltz, Radboud University, Nijmegen, the Netherlands
   * Natarajan Shankar, SRI International, USA
   * Rob Sumners, Advanced Micro Devices, Inc., USA
   * Freek Wiedijk, Radboud University, Nijmegen, the Netherlands
   * Matt Wilding, Rockwell Collins, Inc., USA
David Sankel | 3 Nov 2008 19:25
Picon
Gravatar

ANNOUNCE: htags-1.0

http://hackage.haskell.org/cgi-bin/hackage-scripts/package/htags

htags is a tag file generator to enable extra functionality in editors
like vim. It expands upon hasktags by using a full Haskell 98 parser
and options for recursion.

--
David Sankel
Sankel Software
www.sankelsoftware.com
585 617 4748 (Office)
585 309 2016 (Mobile)
Nicolas Pouillard | 3 Nov 2008 19:35
Picon
Gravatar

Re: ANNOUNCE: htags-1.0

Excerpts from David Sankel's message of Mon Nov 03 19:25:23 +0100 2008:
> http://hackage.haskell.org/cgi-bin/hackage-scripts/package/htags
> 
> htags is a tag file generator to enable extra functionality in editors
> like vim. It expands upon hasktags by using a full Haskell 98 parser
> and options for recursion.

Hi,

I've just tried to install it and the build fails here (GHC 6.8.3)

$ cabal update
$ cabal install htags                                                                                                                                                                                              ──(Mon,Nov03)─┘
Resolving dependencies...
Downloading htags-1.0...
Configuring htags-1.0...
Preprocessing executables for htags-1.0...
Building htags-1.0...

src/htags.hs:8:7:
    Could not find module `GenTags':
      Use -v to see a list of the files searched for.
cabal: Error: some packages failed to install:
htags-1.0 failed during the building phase. The exception was:
exit: ExitFailure 1

Best regards,

--

-- 
Nicolas Pouillard aka Ertai
Don Stewart | 3 Nov 2008 19:50
Favicon
Gravatar

Re: ANNOUNCE: htags-1.0

nicolas.pouillard:
> Excerpts from David Sankel's message of Mon Nov 03 19:25:23 +0100 2008:
> > http://hackage.haskell.org/cgi-bin/hackage-scripts/package/htags
> > 
> > htags is a tag file generator to enable extra functionality in editors
> > like vim. It expands upon hasktags by using a full Haskell 98 parser
> > and options for recursion.
> 
> Hi,
> 
> I've just tried to install it and the build fails here (GHC 6.8.3)
> 
> $ cabal update
> $ cabal install htags                                                                                                                                                                                              ──(Mon,Nov03)─┘
> Resolving dependencies...
> Downloading htags-1.0...
> Configuring htags-1.0...
> Preprocessing executables for htags-1.0...
> Building htags-1.0...
> 
> src/htags.hs:8:7:
>     Could not find module `GenTags':
>       Use -v to see a list of the files searched for.
> cabal: Error: some packages failed to install:
> htags-1.0 failed during the building phase. The exception was:
> exit: ExitFailure 1
> 

Worked for me.

Package for Arch Linux,

    http://aur.archlinux.org/packages.php?ID=21145

Gmane