March 2016 - Haskell-Cafe

HGamer3D has a new dependency installer
by Peter Althainz 26 Mar '16

26 Mar '16

Dear All, it took a long while, but now a new solution has been found for dependency setup for HGamer3D. What do you think? Check here: http://www.hgamer3d.org/Install.html . regards uotbw

1 0

[ANN] Csound-expression-5 is out (framework for computer music)
by Anton Kholomiov 26 Mar '16

26 Mar '16

I'd like to announce a new version of Csound-expression library. It's a framework for computer music production. It compiles Haskell code to Csound. What's new? **The 5.0 is out! New features:** csound-expression * **Microtonal tunings**. We can use custom temperaments with insturments, patches, soundfonts and MIDI-instruments. Check out the guide on tuning and microtonal music (see also module `Csound.Tuning`). There are many predefined tunings (including ancient ones). Now we can play the authentic Bach music with Haskell! See [Custom temperament. Microtonal music]( https://github.com/anton-k/csound-expression/blob/master/tutorial/chapters/… ) for details. * **Functions for Csound API**. We can interface with generated code through many other languages. We can generate the code with Haskell and the use it in other environments. we can build UI with Python or Clojure, we can create an Android synthesizer. See the guide section on Csound API. See [Csound API. Using generated code with another languages]( https://github.com/anton-k/csound-expression/blob/master/tutorial/chapters/… ) for details. * **Padsynth algorithm** (need Csound 6.05). There are functions that makes it easy to use wonderful PADsynth algorithm, This algorithm is designed to make "alive" instruments, natural pads. There are not only function that explore the algorithm but also new PAtches in the package csound-catalog that are based on it! See the section in the guide on the PADsynth. Lot's of padsynth instruments are mode with morphing support. We can crossfade between 2 or even 4 timbres. See [Padsynth algorithm]( https://github.com/anton-k/csound-expression/blob/master/tutorial/chapters/… ) for details. * **Argument modifiers** make it very convinient to modulate the rguments (apply vibrato to frequency or add some randomness to the parameter). See [Arguments modulation]( https://github.com/anton-k/csound-expression/blob/master/tutorial/chapters/… ) for details. * The **hard clipping** was substituted with **limiter**. There should be no distortion when amplitude goes higher than `0dbfs` value. * Adds **Ping-pong delay** implementation. See function `pingPong` at the module `Csound.Air.Fx`. * Adds Rory Walsh's brand **new analog filters** (need Csound 6.07). See functions `alp1`, `alp2` and `alp3` at the module `Csound.Air.Filter`. * Bugfixes for `mixAt` function. Now it doesn't duplicates the effectful-code. Now `mixAt` is not a function that is based on class `At`. It becomes a method in it's own class called `MixAt`. That fixes the code duplication problem. csound-catalog * **new instruments** that are based on **PADsynth algorithm**. Check out `Csound.Patch` at the section on PADsynth Sharc instruments. There are new deep spiritual vedic pads (vibhu, rishi, agni, prakriti, rajas, avatara, bhumi). See [Padsynth algorithm]( https://github.com/anton-k/csound-expression/blob/master/tutorial/chapters/… ) for details. Link to the library: http://hackage.haskell.org/package/csound-expression Github repo: https://github.com/spell-music/csound-expression You can listen to some PADsynth instruments at the link: https://www.dropbox.com/s/pqn4dkvoo01dome/ce-5.zip?dl=0 Cheers, Anton

1 0

Lightweight Unicode normalization library
by Harendra Kumar 25 Mar '16

25 Mar '16

I looked around and found only one package, text-icu which provides unicode normalization operations and a lot more. But text-icu depends on the icu library being installed on the system. We would prefer to avoid dependency on the icu library. Is there a lightweight alternative which does not depend on icu? It could be a pure Haskell package or bindings to a lightweight C library where the library is small and shipped with the package itself. I wonder if there is a need for unicode normalization operations in GHC code itself? If so how does it handle that? I found a lightweight C library (https://github.com/JuliaLang/utf8proc) for normalization and case folding used by the Julia lang project. If there is no other option I am considering creating bindings to this library. Any pointers, thoughts? Thanks, Harendra

2 3

Docs pending for a long time, on Hackage
by Henk-Jan van Tuyl 24 Mar '16

24 Mar '16

L.S., There is no documentation for the most recent version of package wx[0], even though it is on Hackage since December last year. It's Hackage page says: Status Docs pending Build status unknown [no reports yet] Why is this and how can I get the build started? Regards, Henk-Jan van Tuyl [0] https://hackage.haskell.org/package/wx-0.92.2.0 -- Folding@home What if you could share your unused computer power to help find a cure? In just 5 minutes you can join the world's biggest networked computer and get us closer sooner. Watch the video. http://folding.stanford.edu/ http://Van.Tuyl.eu/ http://members.chello.nl/hjgtuyl/tourdemonad.html Haskell programming --

1 0

[ANN] task-distribution: simple distribution of new code in a cluster computing setup
by Axel Mannhardt 24 Mar '16

24 Mar '16

Hello cafe, I am happy to announce task-distribution, a framework written in order to distribute and execute tasks as fast as possible on a large data set. Its accentuation is that it supports distributing new logic to other nodes from within the program itself, thus avoiding both restarting slave node processes and a separated plugin-management infrastructure. An example use case is running continuously changing analytics logic on a given data set stored in HDFS. Avalailable on hackage and github: https://github.com/michaxm/task-distribution Cheers, Axel

1 0

Three Haskell dev roles at Standard Chartered
by Don Stewart 23 Mar '16

23 Mar '16

Hi all I'm hiring another 3 devs to join Strats at Standard Chartered in London or Singapore. This is a good chance to join a growing, experienced team using Haskell for a wide set of projects in finance. More details in https://donsbot.wordpress.com/2016/03/23/haskell-developer-roles-at-standar… -- Don

1 0

Haskell-related PhD Studentship at Kent
by Meng Wang 22 Mar '16

22 Mar '16

Dear Haskellers, I am seeking a PhD student on a Haskell-related project: http://www.cs.kent.ac.uk/research/studyingforaphd/phd-wang.html This would be a good opportunity for someone who is interested in applying Haskell ideas to real problems. The funding covers maintenance, EU student fees and research related expenses. But non-EU students are welcome to apply too. For Sep 2015 starting, the application deadline is 17 April 2015. If you are interested, please contact me at m.w.wang(a)kent.ac.uk<mailto:m.w.wang@kent.ac.uk>. Best wishes, Meng — Dr Meng Wang School of Computing University of Kent http://www.cs.kent.ac.uk/people/staff/mw516/

1 1

[TFPIE 2016] 2nd call for papers
by Peter Achten 22 Mar '16

22 Mar '16

Trends in Functional Programming in Education (TFPIE 2016) 2nd Call for papers https://wiki.science.ru.nl/tfpie/TFPIE2016 The 5th International Workshop on Trends in Functional Programming in Education, TFPIE 2016, will be held on June 7, 2016 at the University of Maryland College Park in the USA. It is co-located with the Symposium on Trends in Functional Programming (TFP 2016) which takes place from June 8 - 10. *** Goal *** The goal of TFPIE is to gather researchers, teachers and professionals that use, or are interested in the use of, functional programming in education. TFPIE aims to be a venue where novel ideas, classroom-tested ideas and work-in-progress on the use of functional programming in education are discussed. The one-day workshop will foster a spirit of open discussion by having a review process for publication after the workshop. The program chair of TFPIE 2016 will screen submissions to ensure that all presentations are within scope and are of interest to participants. Potential presenters are invited to submit an extended abstract (4-6 pages) or a draft paper (up to 16 pages) in EPTCS style. The authors of accepted presentations will have their preprints and their slides made available on the workshop's website/wiki. Visitors to the TFPIE 2016 website/wiki will be able to add comments. This includes presenters who may respond to comments and questions as well as provide pointers to improvements and follow-up work. After the workshop, presenters will be invited to submit (a revised version of) their article for review. The PC will select the best articles for publication in the journal Electronic Proceedings in Theoretical Computer Science (EPTCS). Articles rejected for presentation and extended abstracts will not be formally reviewed by the PC. TFPIE workshops have previously been held in St Andrews, Scotland (2012), Provo Utah, USA (2013), Soesterberg, The Netherlands (2014), and Sophia-Antipolis, France (2015). *** Program Committee *** Stephen Chang at Northeastern University in Massachusetts, USA Marc Feeley at Université de Montréal in Québec, Canada Patricia Johann at Appalachian State University in North Carolina, USA Jay McCarthy at University of Massachusetts Lowell in Massachusetts, USA (Chair) Prabhakar Ragde at University of Waterloo in Ontario, Canada Brent Yorgey at Hendrix College in Arkansas, USA *** Submission Guidelines *** TFPIE 2016 welcomes submissions describing techniques used in the classroom, tools used in and/or developed for the classroom and any creative use of functional programming (FP) to aid education in or outside Computer Science. Topics of interest include, but are not limited to: - FP and beginning CS students - FP and Computational Thinking - FP and Artificial Intelligence - FP in Robotics - FP and Music - Advanced FP for undergraduates - Tools supporting learning FP - FP in graduate education - Engaging students in research using FP - FP in Programming Languages - FP in the high school curriculum - FP as a stepping stone to other CS topics - FP and Philosophy *** Best Lectures *** In addition to papers, we request "best lecture" presentations. What is your best lecture topic in an FP related course? Do you have a fun way to present FP concepts to novices or perhaps an especially interesting presentation of a difficult topic? In either case, please consider sharing it. Best lecture topics will be selected for presentation based on a short abstract describing the lecture and its interest to TFPIE attendees. *** Submission *** Papers and abstracts can be submitted via EasyChair at the following link: https://easychair.org/conferences/?conf=tfpie2016 It is expected at at least one author for each submitted paper will attend the workshop. *** Registration & Local Information *** Please see the TFP site for registration and local information: http://tfp2016.org/ *** Important Dates *** April 27, 2016: Submission deadline for draft TFPIE papers and abstracts May 3, 2016: Notification of acceptance for presentation May 13, 2016: Registration for TFP/TFPIE closes June 7, 2016: Presentations in Maryland, USA July 7, 2016: Full papers for EPTCS proceedings due. September 1, 2016: Notification of acceptance for proceedings September 22, 2016: Camera ready copy due for EPTCS Submission of an abstract implies no obligation to submit a full version; abstracts with no corresponding full versions by the full paper deadline will be considered as withdrawn.

1 0

Stuck on a type family problem where kind inference fails
by Oliver Charles 21 Mar '16

21 Mar '16

Hi all, This is a little tricky to explain, so bear with me. I'm working on some code that roughly models a PostgreSQL schema. Users begin by defining their tables as Haskell records, parametrized over some f :: k -> *, and use a special Col type family that applies some normalisation: data Table f = Table { tableId :: Col f ('NotNullable 'DBInt) , tableX :: Col f ('Nullable 'DBString) } is one such example. The idea behind Col is that sometimes we don't need information about the "full type" when we know more about f. One such choice of f is Expr, which corresponds to expressions inside a query. In this case, I would desire tableId :: Col Expr ('NotNullable 'DBInt) = tableId :: Expr 'DBInt tableX :: Col Expr ('Nullable 'DBString) = tableX :: Expr ('Nullable 'DBString) Notice here that if you use 'NotNullable, then this information is erased - but it's important if the column is 'Nullable. However, I'm struggling to work out any way to actually pull this off in the general case. Here's what I've been attempting: {-# LANGUAGE FunctionalDependencies #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE TypeOperators #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE KindSignatures #-} {-# LANGUAGE PolyKinds #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE UndecidableInstances #-} {-# LANGUAGE ScopedTypeVariables #-} module ExprTest where import Data.Singletons import Data.Singletons.Prelude hiding (Null) import Data.Singletons.TH data Expr (a :: k) data MyExprSym :: TyFun k * -> * type instance Apply MyExprSym (x :: k) = Expr x $(singletons [d| data Null a = Nullable a | NotNullable a |]) $(promote [d| notNullableType k (NotNullable a) = baseType k a nullableType k (Nullable a) = baseType (k . Nullable) a baseType k a = k a |]) So far, this seems to work well. If I ask GHCI: *ExprTest> :kind! Apply (Apply NullableTypeSym0 MyExprSym) ('Nullable 'DBString) Apply (Apply NullableTypeSym0 MyExprSym) ('Nullable 'DBString) :: * = Expr ('Nullable 'DBString) *ExprTest> :kind! Apply (Apply NotNullableTypeSym0 MyExprSym) ('NotNullable 'DBInt) Apply (Apply NotNullableTypeSym0 MyExprSym) ('NotNullable 'DBInt) :: * = Expr 'DBInt This is exactly what I want, but note that I had to choose the necessary symbols NullableTypeSym0 and NotNullableTypeSym0. I would like to calculate those symbols from the column type itself. Looking at the kinds of these symbols though, they are both different: *ExprTest> :kind! NotNullableTypeSym0 NotNullableTypeSym0 :: TyFun (TyFun k1 k -> *) (TyFun (Null k1) k -> *) -> * = NotNullableTypeSym0 *ExprTest> :kind! NullableTypeSym0 NullableTypeSym0 :: TyFun (TyFun (Null k1) k -> *) (TyFun (Null k1) k -> *) -> * = NullableTypeSym0 So I can't see a way to write a single type family that returns them. To summarise, I'd like a way to write this following instance for Col: type instance Col Expr x = Apply (Apply ?? MyExprSym) x such that Col Expr ('Nullable a) = Expr ('Nullable a') and Col Expr ('NotNullable a) = Expr a but I cannot work out how to write the placeholder ?? above. One attempt is type family ExprTyfun (col :: colK) :: TyFun (TyFun k * -> *) (TyFun j * -> *) -> * type instance ExprTyfun ('NotNullable a) = NotNullableTypeSym0 type instance ExprTyfun ('Nullable a) = NullableTypeSym0 But neither of these instances actually normalise as I'd like, presumably because of k and j being forall'd in the return type: *ExprTest> :set -fprint-explicit-kinds *ExprTest> :kind! ExprTyfun ('Nullable 'DBInt) ExprTyfun ('Nullable 'DBInt) :: TyFun (TyFun k * -> *) (TyFun k1 * -> *) -> * = ExprTyfun k k1 (Null DBType) ('Nullable DBType 'DBInt) *ExprTest> :kind! ExprTyfun ('NotNullable 'DBInt) ExprTyfun ('NotNullable 'DBInt) :: TyFun (TyFun k * -> *) (TyFun k1 * -> *) -> * = ExprTyfun k k1 (Null DBType) ('NotNullable DBType 'DBInt) *ExprTest> :i ExprTyfun type family ExprTyfun (k :: BOX) (j :: BOX) (colK :: BOX) (col :: colK) :: TyFun (TyFun k * -> *) (TyFun j * -> *) -> * -- Defined at src/Opaleye/TF/ExprTest.hs:39:1 type instance ExprTyfun (Null k) (Null k) (Null k1) ('Nullable k1 a) = NullableTypeSym0 * k -- Defined at src/Opaleye/TF/ExprTest.hs:41:1 type instance ExprTyfun k (Null k) (Null k1) ('NotNullable k1 a) = NotNullableTypeSym0 * k -- Defined at src/Opaleye/TF/ExprTest.hs:40:1 I'd also like to point out that in my full code the types to Col can be a lot bigger, and I'd like to not assume any ordering. For example, here's a possible type: userId :: Col f ('Column "id" ('NotNullable ('HasDefault 'DBInt))) In this case Col Expr ('Column "id" ('NotNullable ('HasDefault 'DBInt))) = Expr 'DBInt I hope this question is understandable! Please let me know if there's anything I can do to provide more clarity. - Ollie

2 10

Using rebox2 (emacs) with Haskell
by Henry Laxen 20 Mar '16

20 Mar '16

If any of you have tried using rebox2 with haskell, you've discovered that it does not have a built in Haskell comment mode. I was looking for something like this: ------------------------------------- -- You can put a nice comment here -- -- and surround with a pretty box -- ------------------------------------- Actually, it is easy to set this up with a few lines in your .emacs file. Here is what you need: (require 'rebox2) (add-to-list 'rebox-language-character-alist '(7 . "-")) (setq rebox-style-loop '(725)) (rebox-register-all-templates) (add-hook 'haskell-mode-hook 'rebox-mode) Then just type Meta-q if you want to refill the comment, and Meta-Q if you don't want to refill. I hope this is helpful. Best wishes, Henry Laxen

1 0