December 2013 - Haskell-Cafe

Polymorphic updating with TC/TFs?
by Hans Höglund 16 Dec '13

16 Dec '13

Hello, I am working with a set of type classes of the following form (http://lpaste.net/97110) The idea is that every such class provide an associated type Foo, and a lens to the Foo in every instance. I.e. this class is used to provide view/set/modify for all types that contain a Foo somewhere deep in its structure. For "simple lenses", i.e. functions that does not modify the associated Foo, this is straightforward. However to support polymorphic updates it seems necessary to add another associated type NoFoo, which must be used to constraint the return type of set. What bothers me is the redundancy of the two set functions. I would intuitively expect set' to be implemented in terms of set (as it seems to be a restriction of that function), but this is not possible, as the compiler can not deduce that (NoFoo a (Foo a) ~ a). Is there a way to add this constraint to the type class? Hans

1 0

Alternatives to ThreadScope?
by Justin Bailey 16 Dec '13

16 Dec '13

Are there any other GUI tools that do something similar? Maybe something web-based? Justin

3 3

SBLP 2014 - Preliminary Call for Papers
by Simon Thompson 16 Dec '13

16 Dec '13

PRELIMINARY CALL FOR PAPERS 18th Brazilian Symposium on Programming Languages (SBLP 2014) A member of CBSoft joint conference http://www.ic.ufal.br/evento/cbsoft2014/ to be held in Maceio, Brazil. CBSoft dates are September 28, 2014 to October 3, 2014 (SBLP dates are yet to be decided.) IMPORTANT DATES Paper abstract submission: May 2nd, 2014 Full paper submission: May 9th, 2014 Notification of acceptance: June 13th, 2014 Final papers due: July 4th, 2014 INTRODUCTION The 18th Brazilian Symposium on Programming Languages, SBLP 2014, will be held in Maceio, a beautiful cite in the Northeastern part of Brazil. The conference will happen between September 28th and October 3rd, 2014. SBLP provides a venue for researchers and practitioners interested in the fundamental principles and innovations in the design and implementation of programming languages and systems. SBLP 2014 invites authors to contribute with technical papers related (but not limited) to: * Program generation and transformation, including domain-specific languages and model-driven development in the context of programming languages. * Programming paradigms and styles, including functional, object-oriented, aspect-oriented, scripting languages, real-time, service-oriented, multithreaded, parallel, and distributed programming. * Formal semantics and theoretical foundations, including denotational, operational, algebraic and categorical. * Program analysis and verification, including type systems, static analysis and abstract interpretation. * Programming language design and implementation, including new programming models, programming language environments, compilation and interpretation techniques. SUBMISSIONS Contributions should be written in Portuguese or English. Papers should fall into one of two different categories: full papers, with at most 15 pages, or short papers, with at most 5 pages. Full papers submitted in English will be published in a volume of Lecture Notes in Computer Science (LNCS), by Springer. For this reason, all papers must be prepared using the LNCS template, available at http://www.springer.com/computer/lncs?SGWID=0-164-6-793341-0. We encourage the submission of short papers reporting partial results of on-going master dissertations or doctoral theses. All accepted papers will be published in the conference proceedings distributed in a digital media by the CBSOFT organizers. Submissions should be done through the SBLP 2014 page at EasyChair, which is available at http://www.easychair.org/conferences/?conf=sblp2014. As in previous editions, a journal's special issue, with selected papers from accepted contributions, is anticipated. Selected papers from the 2003 to the 2008 editions of SBLP were published in special issues of the Journal of Universal Computer Science, by Springer. The post-proceedings of SBLP from 2009 to 2012, also with selected papers from the conference, have been published as special issues of Science of Computer Programming, by Elsevier. KEYNOTE SPEAKERS Louis-Noel Pouchet, University of California Los Angeles Fabrice Rastello, INRIA PROGRAMME CHAIR Fernando Magno Quintao Pereira, UFMG PROGRAMME COMMITTEE Alberto Pardo, Universidad de la República Alex Garcia, IME Alvaro Moreira, Federal University of Rio Grande do Sul Andre Rauber Du Bois, Federal University of Pelotas Carlos Camarão, Federal University of Minas Gerais Christiano Braga, Fluminense Federal University Fabio Mascarenhas, Federal University of Rio de Janeiro Fernando Pereira, Federal University of Minas Gerais Fernando Castor, Federal University of Pernambuco Francisco Carvalho-Junior, Federal University of Ceara Hans-Wolfgang Loidl, Heriot-Watt University João Saraiva, University of Minho Joao F. Ferreira, Teesside University Louis-Noel Pouchet, University of California, Los Angeles Lucilia Figueiredo, Federal University of Ouro Preto Luis Barbosa, University of Minho Manuel A. Martins, University of Aveiro Marcello Bonsangue, Leiden University Marcelo Maia, Federal University of Uberlândia Marcelo D'Amorim, Federal University of Pernambuco Mariza Bigonha, Federal University of Minas Gerais Martin Musicante, Federal University of Rio Grande do Norte Noemi Rodriguez, PUC-Rio Peter Mosses, Swansea University Rafael Lins, Federal University of Pernambuco Renato Cerqueira, PUC-Rio Roberto Bigonha, Federal University of Minas Gerais Rodrigo Geraldo, Federal University of Ouro Preto Sandro Rigo, State University of Campinas Sérgio Medeiros, Federal University of Sergipe Simon Thompson, University of Kent Varmo Vene, University of Tartu 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

[ANN] IHaskell Update -- Call for Help/Suggestions
by Andrew Gibiansky 16 Dec '13

16 Dec '13

Hey everyone! I'm excited to announce a significant update to IHaskell. I originally announced IHaskell a few months ago, but there's been a few exciting changes: Significantly more stable and less buggy. It's been updated to use the GHC API for parsing and evaluation, so behavior should be very similar to GHCi in most places. You can now defined modules in cells instead of just interactive code. These modules are compiled to object code and loaded and provide fast runtime compared to interactive code. Most important: IHaskell can now load additional packages in order to provide rich display capabilities for specific data types. This means that it can be augmented through separate packages. If you have interest in providing a rich display mechanism for a data type, please consider writing an IHaskell extension package to do so! (If there are any data types that you think would be particularly useful but don't have time to implement yourself, let me know, too!) The extensibility is provided through an IHaskell.Display module. For instance, if you are creating an extension for a particular package foo, you should create a package called ihaskell-foo. This package should contain a module along the following lines: -- The name is important module IHaskell.Display.Foo where import Foo (DataThing) import IHaskell.Display -- Define how to display my data thing instance IHaskellDisplay DataThing where display myDataThing = [ plain "Plain Text output" , html "<b>HTML output</b>"] I would love to work with anyone who's interested in helping create these packages to make IHaskell as useful as possible. In addition, if you have any features you think would really make this more useful or bugs you've found, let me know! If you have any issues with installation, please let me know. I've had some trouble with getting a Hackage-based installation to work, so for now it's just from the Github repository, but I'd be happy to help people individually.

1 0

Data.Vector with stride
by Niklas Hambüchen 16 Dec '13

16 Dec '13

For low-level performance, especially when dealing with images, pixel buffers, camera devices etc, arrays can have a "stride" to align rows to word boundaries. http://en.wikipedia.org/wiki/Stride_of_an_array Data.Vector does not support strides (as mentioned in http://u.arboreus.com/2011/03/how-to-choose-haskell-array-library.html) but it would be nice to have them, especially for Storable vectors and interfacing with C imaging libraries. Is there a particular reason / difficulty that would go against an implementation of a Data.Vector.Storable.Stride and the corresponding generic vector instances?

3 3

Re: [Haskell-cafe] getting source
by Doug McIlroy 16 Dec '13

16 Dec '13

> > It is a shame that when you look something up in Hayoo, > > you can immediately look at the source--but you can't > > You can, but not for every package; try looking up the "map" function, you > will see a link to the source at the right of the page. > > Regards, > Henk-Jan van Tuyl Yes, I said you can look at the source, but not compile it. Hayoo's yellow "source" links get HTML generated from source-- a rendering intended for eyeballs, not compilers. What I suggested is that the HTML include a link to the underlying .hs file. Why should you have to go hassle with git or some other repository, and maybe cabal too, to get code that's right before your eyes? Doug

2 1

Real world project with Cloud Haskell
by jean-christophe mincke 16 Dec '13

16 Dec '13

Hello, Has anybody heard about (or better, made) a real world project using Cloud Haskell? Thank you Regards J-C

3 2

getting source
by Doug McIlroy 16 Dec '13

16 Dec '13

It is a shame that when you look something up in Hayoo, you can immediately look at the source--but you can't

2 1

10 PhD studentships in Nottingham
by Graham Hutton 16 Dec '13

16 Dec '13

Dear all, The School of Computer Science in Nottingham is advertising 10 fully-funded PhD studentships. Applicants in the area of the Functional Programming lab (fp.cs.nott.ac.uk) are encouraged! If you are interested in applying, please contact a potential supervisor in the FP lab prior to submitting your application: Thorsten Altenkirch - constructive logic, proof assistants, type theory, category theory, lambda calculus, quantum computing. Venanzio Capretta - type theory, mathematical logic, corecursive structures, proof assistants, dependently-typed programming. Graham Hutton - program construction and verification, category theory, recursion operators, coinductive types. Henrik Nilsson - functional reactive programming, modelling and simulation languages, domain-specific languages. Best wishes, Graham +-----------------------------------------------------------+ 10 Fully-Funded PhD Studentships School of Computer Science University of Nottingham, UK Applications are invited for up to ten fully-funded PhD studentships in the School of Computer Science at the University of Nottingham, starting on 1st October 2014. The topics for the studentships are open, but should relate to the interests of one of the School’s research groups: Agents Lab; Automated Scheduling, Optimisation and Planning; Computer Vision Lab; Functional Programming Lab; Intelligent Modelling and Analysis; Mixed Reality Lab; Networked Systems. The studentships are for three years and include a stipend of £13,726 per year and tuition fees, and are available to students of any nationality. Applicants are normally expected to have a first-class Undergraduate or Masters degree in Computer Science or a related discipline, and should discuss their interest and obtain the support of a potential supervisor in the School before applying. To apply, please submit the following items by email to <Christine.Fletcher(a)nottingham.ac.uk>: (1) a brief covering letter that describes your reasons for wishing to pursue a PhD, any ideas you have regarding possible areas or topics, and the name of a potential supervisor; (2) a copy of your CV, including your actual or expected degree class(es), and results of all University examinations; (3) an example of your technical writing, such as a project report or dissertation; (4) contact details for two academic referees. Closing date for applications: 10th January 2014 +-----------------------------------------------------------+ -- Prof Graham Hutton Functional Programming Lab School of Computer Science University of Nottingham, UK http://www.cs.nott.ac.uk/~gmh This message and any attachment are intended solely for the addressee and may contain confidential information. If you have received this message in error, please send it back to me, and immediately delete it. Please do not use, copy or disclose the information contained in this message or in any attachment. Any views or opinions expressed by the author of this email do not necessarily reflect the views of the University of Nottingham. This message has been checked for viruses but the contents of an attachment may still contain software viruses which could damage your computer system, you are advised to perform your own checks. Email communications with the University of Nottingham may be monitored as permitted by UK legislation.

1 0

RFC: Top level mutable state in terms of pure-function initialization?
by EatsKittens 15 Dec '13

15 Dec '13

A pure function (enumToIORef :: (Enum a, Defaultable b) => a -> IORef b). This function returns referentially transparently an IORef as a function of its "seed" with the guarantee that the IORef returned is identical if and only if the seed is. This function can be used to implement top level mutable state in a module. The module can specifically create an enumerated type for this and not export it, thereby removing any possibility of another module passing the seed type and conflicting. The Defaultable class is added in this case to implement only a single method (defaultValue :: Defaultable a => a -> a). This is conceptionally the 'simplest' value of the type, such as the empty list, the number 0, False, the null character &c. The IORef returned by enumToIORef would be initialized before being written to to this specific default value of its type. This approach is chosen because it is impossible to initialize it to user specified value because enumToIORef can be called twice with the same seed but a different initial value. In the alternative it is also possible to do without the default value and say the IORef returned is the same if and only if the seed and the initial value given are the same. Allowing the function to remain referentially transparent as well. This would probably require for good semantics the underlying type of the IORef to be a member of EQ...? All this would of course require that newIORef and enumToIORef never produce the same IORef. Aside its limitations of the type IORef's initialized with this method can carry, I do believe they cover the vast majority of use cases of top level mutable state? Caveats?

3 5