- Haskell-Cafe - Haskell.org

Polls on Haskellers.com
by Michael Snoyman 24 Nov '11

24 Nov '11

I noticed the recent thread about mascots, and trying to get accurate polling information. Don't consider this email to say I think we need safeguards against a poll on mascots (are people *really* trying to rig the election on this???), but I thought this might be a good features for Haskellers.com. Since we already have the "verified account" issue, we could use that to break down polls. More specifically, anyone would be allowed to vote, and then you could review results for verified users only, all logged in users, or theoretically even not-logged-in users (not sure how I feel about this one). If people would use this feature, I think I can add it next week. Michael

2 1

type level strings?
by Evan Laforge 24 Nov '11

24 Nov '11

So suppose I have a simple data type: > data Thing { > thing_id :: ThingId > , thing_stuff :: Stuff > } > newtype ThingId = ThingId String Stuff is a Monoid, and Things need to be combined as well, so: > instance Monoid Thing where > mappend (Thing id1 stuff1) (Thing id2 stuff2) > | id1 /= id2 = error "..." > | otherwise = Thing id1 (stuff1 `mappend` stuff2) > mempty = Thing $ (ThingId "dummy value?") mempty So clearly both the error and the "dummy value?" are not very nice (and mappend would need a special hack to treat the dummy as compatible with everything). I'd like to be able to lift that ID up to the type level, and then I don't have to worry about incompatible IDs and the mempty can figure out the ID from the type. Now if ThingId were a natural, I gather there's a new GHC feature for type level naturals that can do this kind of thing. Of course any string could be encoded into a large natural, but the resulting type errors would be less than readable. There is probably also a way to encode type level strings in the same way as the traditional way for type level naturals, e.g. 'data A; ... data Z;' and then a type encoding for lists. But I'm guessing that would also lead to excessive compilation times and crazy type errors. In any case, I don't think this can work even if I used naturals instead of ints, because it seems to me I can't write a function '(NatI n) => ThingId -> Thing n' without a statically knowable constant value for 'n'. Otherwise, the value has magically disappeared into the type system and I can't expect to get it back after types are erased. So I need a runtime value for the ThingId, but it still seems like it should be possible to do something better than the 'error' and "dummy value?". Maybe there's a completely different way to ensure that incompatible Things can't be mappended. Any ideas?

4 5

Quickcheck research
by Macías López 24 Nov '11

24 Nov '11

Hello: I'm a Master's student in Computer Science. I have to make a project involving some research, I'm very interested in Quickcheck and I wonder if there are some areas which need work or if there is some potential research topic related to it. In particular I know that Erlang Quickcheck has been worked on a lot and has some features like state machines or C bindings which may be useful to the Haskell community. I would appreciate any directions. Cheers, Macías López.

4 5

Re: [Haskell-cafe] Quickcheck research
by Jonathan Fischoff 23 Nov '11

23 Nov '11

> which makes me think that Arbitrary isn't the right set of > abstractions for controlling coverage of the value space. I agree with you Wren. I think what is needed is a library for expressing the distribution of values for a given type. I can see several ways of specifying distributions, directly (exponential, normal, etc), qualitative constraints (a tuple where each value is less then the next), constraints on moments (MaxEnt), etc, there are many ways that are not mutually exclusive. There are other ways to improve quickcheck. Writing arbitrary instance could be made more declarative. The process of describing an indicator function that fully determines the set of values that are valid for my type, and writing the sequence of steps necessary to make the function efficient could be separated. Combinatorial species and symbolic combinatorics are too possibilities to simplify the creation of arbitrary functions. There might be way go from list of functions to an generator. Something like make_arb :: [a -> Bool] -> Gen a That is psuedo code, since you can't reify a function. But that would be the idea, although I don't think it would work in all cases. Also, the current quickcheck workflow is to run it until a example of valid input fails a test. When this happens the example should be used in a regression. Creating unit tests automatically from failed quickcheck cases would be a time saver. Additionally the right type mutation of testing would be a great addition to quickcheck. -Jonathan

1 0

"lambda.fm" How can I use this to help the Haskell community?
by Ben Wright 23 Nov '11

23 Nov '11

A while back I somehow managed to get the domain name, "lambda.fm" and I am simply creating this post to get some ideas from the community on what it could be used for to help the FP community. So tell me what you think.

4 3

Re: [Haskell-cafe] A Mascot
by John Lato 23 Nov '11

23 Nov '11

> From: Michael Orlitzky <michael(a)orlitzky.com> > > On 11/22/11 16:52, heathmatlock wrote: >> Wasn't planning on it, but I saw some emails on the topic, so I worked >> on what I presented earlier: > > Anyway, creative design-by-committee is doomed, so my advice is to > ignore this and all other advice =) +1 (The knight is my favorite, but Da for Mascot regardless)

1 0

Fwd: XML modification
by Dmitry Olshansky 23 Nov '11

23 Nov '11

Personally I prefer xml-enumerator. You can work with xml-stream or with DOM through cursor (like XPath). I think that in your case working with stream is preferrable. You can just make an Enumeratee like >import qualified Data.Enumerator.List as EL > myEnum = EL.map f > where > f (EventBeginElement n ats) = ... -- parse attributes > f e = e 2011/11/23 Andrew Coppin <andrewcoppin(a)btinternet.com> > Hi guys. > > I've got a folder with about 80 XML files in it. I want to take each file > and make specific modifications to it. (Mostly just finding specific > attributes and changing their values to make then all consistent.) > > Now I guess it wouldn't take me /that/ long to code something from > scratch. But does anybody have a better suggestion for tools or libraries > that might be useful? > > ______________________________**_________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/**mailman/listinfo/haskell-cafe<http://www.haskell.org/mailman/listinfo/haskell-cafe> >

1 0

PEPM'12 Call for participation
by Simon Thompson 23 Nov '11

23 Nov '11

ACM SIGPLAN 2012 Workshop on Partial Evaluation and Program Manipulation http://www.program-transformation.org/PEPM12 January 23-24, 2012. Philadelphia, PA, USA (co-located with POPL'12) Call For Participation Online registration is open at https://regmaster3.com/2012conf/POPL12/register.php Early registration deadline is December 24, 2011 The PEPM Symposium/Workshop series brings together researchers and practitioners working in the broad area of program transformation, which spans from refactoring, partial evaluation, supercompilation, fusion and other metaprogramming to model-driven development, program analyses including termination, inductive programming, program generation and applications of machine learning and probabilistic search. PEPM focuses on techniques, supporting theory, tools, and applications of the analysis and manipulation of programs. In addition to the presentations of regular research papers, the PEPM program includes tool demonstrations and `short paper' presentations of exciting if not fully polished research. PEPM has established a Best Paper award. The winner will be announced at the workshop. INVITED TALKS Compiling Math to High Performance Code Markus Pueschel (ETH Zuerich, Switzerland) http://www.inf.ethz.ch/~markusp/index.html Specification and verification of meta-programs Martin Berger (University of Sussex, UK) http://www.informatics.sussex.ac.uk/users/mfb21/ ACCEPTED PAPERS Regular research papers: Naoki Kobayashi, Kazutaka Matsuda and Ayumi Shinohara. Functional Programs as Compressed Data Kazutaka Matsuda, Kazuhiro Inaba and Keisuke Nakano. Polynomial-Time Inverse Computation for Accumulative Functions with Multiple Data Traversals Dana N. Xu. Hybrid Contract Checking via Symbolic Simplification Susumu Katayama. An Analytical Inductive Functional Programming System that Avoids Unintended Programs Roberto Giacobazzi, Neil Jones and Isabella Mastroeni. Obfuscation by Partial Evaluation of Distorted Interpreters Michael Gorbovitski, Yanhong A. Liu, Scott Stoller and Tom Rothamel. Composing Transformations for Instrumentation and Optimization Elvira Albert, Jesus Correas Fernandez, German Puebla and Guillermo Roman-Diez. Incremental Resource Usage Analysis Takumi Goto and Isao Sasano. An approach to completing variable names for implicitly typed functional languages Martin Hirzel and Bugra Gedik. Streams that Compose using Macros that Oblige Vlad Ureche, Tiark Rompf, Arvind Sujeeth, Hassan Chafi and Martin Odersky. StagedSAC: A Case Study in Performance-Oriented DSL Development Markus Degen, Peter Thiemann and Stefan Wehr. The Interaction of Contracts and Laziness Surinder Kumar Jain, Chenyi Zhang and Bernhard Scholz. Translating Flowcharts to Non-Deterministic Languages Francisco Javier Lopez-Fraguas, Enrique Martin-Martin and Juan Rodriguez-Hortala. Well-typed Narrowing with Extra Variables in Functional-Logic Programming Geoff Hamilton and Neil Jones. Superlinear Speedup by Distillation: A Semantic Basis Short papers: Jacques Carette and Aaron Stump. Towards Typing for Small-Step Direct Reflection Janis Voigtlaender. Ideas for Connecting Inductive Program Synthesis and Bidirectionalization Tool demonstration papers: Edvard K. Karlsen, Einar W. Hoest and Bjarte M. Oestvold. Finding and fixing Java naming bugs with the Lancelot Eclipse plugin Adriaan Moors, Tiark Rompf, Philipp Haller and Martin Odersky. Scala-Virtualized Elvira Albert, Puri Arenas, Samir Genaim, Miguel Gomez-Zamalloa and German Puebla. COSTABS: A Cost and Termination Analyzer for ABS Simon Thompson | Professor of Logic and Computation School of Computing | University of Kent | Canterbury, CT2 7NF, UK s.j.thompson(a)kent.ac.uk | M +44 7986 085754 | W www.cs.kent.ac.uk/~sjt

1 0

Why does GHC not warn about unnamed uninitialized fields?
by Eelis van der Weegen 23 Nov '11

23 Nov '11

Today I noticed that GHC is more concerned (when using -Wall) about uninitialized fields when those fields have names: data A = A {a::Integer} data B = B Integer x :: A x = A{} -- Gives a nice warning: "Fields of `A' not initialised: a" y :: B y = B{} -- No warning! Is this on purpose? If so, what is the rationale? The context in which I encountered this boils down to the following: {-# LANGUAGE RecordWildCards #-} data C = C {c::Integer} f :: C -> C f C{..} = C{..} g :: C -> Integer g (C i) = i main :: IO () main = print (g (f (C 3))) This code worked fine (and printed "3"), until I made C's Integer nameless. This made it crash with following runtime error instead: T: T.hs:6:11-15: Missing field in record construction The crash and error are perfectly understandable, but it would have been more helpful if GHC had warned about this at compile-time! The reason it didn't, though, is because of its aforementioned cavalier attitude towards uninitialized fields that don't have names... :-) (I'm using GHC 7.0.4.) Cheers, Eelis

1 0

PEPM 2012: Call for participation
by oleg＠okmij.org 23 Nov '11

23 Nov '11

ACM SIGPLAN 2012 Workshop on Partial Evaluation and Program Manipulation http://www.program-transformation.org/PEPM12 January 23-24, 2012. Philadelphia, PA, USA (co-located with POPL'12) Call For Participation Online registration is open at https://regmaster3.com/2012conf/POPL12/register.php Early registration deadline is December 24, 2011 The PEPM Symposium/Workshop series brings together researchers and practitioners working in the broad area of program transformation, which spans from refactoring, partial evaluation, supercompilation, fusion and other metaprogramming to model-driven development, program analyses including termination, inductive programming, program generation and applications of machine learning and probabilistic search. PEPM focuses on techniques, supporting theory, tools, and applications of the analysis and manipulation of programs. In addition to the presentations of regular research papers, the PEPM program includes tool demonstrations and `short paper' presentations of exciting if not fully polished research. PEPM has established a Best Paper award. The winner will be announced at the workshop. INVITED TALKS Compiling Math to High Performance Code Markus Pueschel (ETH Zuerich, Switzerland) http://www.inf.ethz.ch/~markusp/index.html Specification and verification of meta-programs Martin Berger (University of Sussex, UK) http://www.informatics.sussex.ac.uk/users/mfb21/ ACCEPTED PAPERS Regular research papers: Naoki Kobayashi, Kazutaka Matsuda and Ayumi Shinohara. Functional Programs as Compressed Data Kazutaka Matsuda, Kazuhiro Inaba and Keisuke Nakano. Polynomial-Time Inverse Computation for Accumulative Functions with Multiple Data Traversals Dana N. Xu. Hybrid Contract Checking via Symbolic Simplification Susumu Katayama. An Analytical Inductive Functional Programming System that Avoids Unintended Programs Roberto Giacobazzi, Neil Jones and Isabella Mastroeni. Obfuscation by Partial Evaluation of Distorted Interpreters Michael Gorbovitski, Yanhong A. Liu, Scott Stoller and Tom Rothamel. Composing Transformations for Instrumentation and Optimization Elvira Albert, Jesus Correas Fernandez, German Puebla and Guillermo Roman-Diez. Incremental Resource Usage Analysis Takumi Goto and Isao Sasano. An approach to completing variable names for implicitly typed functional languages Martin Hirzel and Bugra Gedik. Streams that Compose using Macros that Oblige Vlad Ureche, Tiark Rompf, Arvind Sujeeth, Hassan Chafi and Martin Odersky. StagedSAC: A Case Study in Performance-Oriented DSL Development Markus Degen, Peter Thiemann and Stefan Wehr. The Interaction of Contracts and Laziness Surinder Kumar Jain, Chenyi Zhang and Bernhard Scholz. Translating Flowcharts to Non-Deterministic Languages Francisco Javier Lopez-Fraguas, Enrique Martin-Martin and Juan Rodriguez-Hortala. Well-typed Narrowing with Extra Variables in Functional-Logic Programming Geoff Hamilton and Neil Jones. Superlinear Speedup by Distillation: A Semantic Basis Short papers: Jacques Carette and Aaron Stump. Towards Typing for Small-Step Direct Reflection Janis Voigtlaender. Ideas for Connecting Inductive Program Synthesis and Bidirectionalization Tool demonstration papers: Edvard K. Karlsen, Einar W. Hoest and Bjarte M. Oestvold. Finding and fixing Java naming bugs with the Lancelot Eclipse plugin Adriaan Moors, Tiark Rompf, Philipp Haller and Martin Odersky. Scala-Virtualized Elvira Albert, Puri Arenas, Samir Genaim, Miguel Gomez-Zamalloa and German Puebla. COSTABS: A Cost and Termination Analyzer for ABS

1 0