February 2016 - Haskell-Cafe

Re: [Haskell-cafe] Compile times and separate compilation
by Johannes Waldmann 01 Mar '16

01 Mar '16

> I presume you are using the -j switch. Does it really help? I recently found that for travis builds, it is used by default (first surprise) but it's faster when it's turned off (second surprise). https://ghc.haskell.org/trac/ghc/ticket/10818#comment:15 - J.

4 4

Infer Nat type from Integer argument
by Jake 01 Mar '16

01 Mar '16

{-# LANGUAGE DataKinds, KindSignatures, ScopedTypeVariables, GADTs, AllowAmbiguousTypes #-} import GHC.TypeLits import Data.Proxy import Data.Type.Equality data NatString (n :: Nat) = NatString String deriving Show showNS :: KnownNat n => NatString n -> (String, Integer) showNS b@(NatString s) = (s, natVal b) In this example, we use NatString like this: > showNS (NatString "hey" :: NatString 4) -- ("hey", 4) We can then dynamically make NatStrings from Integers. For example, we can read an Integer from stdin and use it to create a NatString main :: IO () main = do i <- readLn case someNatVal i of Just (SomeNat (p :: Proxy n)) -> let ns :: NatString n ns = NatString "hello!" in print $ showNS NatString However, if I have trouble when I try to refactor out the middle part to create a function with type forall n. KnownNat n => Integer -> Bar n. I use sameNat to convince the compiler that the Nat we get from the Integer is the same type as the the type n of the output. fromN :: forall n. KnownNat n => Integer -> NatString n fromN i = case someNatVal i of Just (SomeNat p) -> case sameNat p (Proxy :: Proxy n) of Just (Refl) -> let ns :: NatString n ns = NatString "hello!" in ns This compiles, but if you try and use it the compiler complains. > showNS (fromN 3) -- No instance for (KnownNat n0) arising from a use of ‘showNS’ If we manually add the type annotation, everything is fine, but that kind of defeats the entire purpose. > showNS (fromN 3 :: NatString 3) -- ("hello!",3) Strangely enough, when the NatString is immediately consumed instead of being returned, the compiler does its job and infers the correct type. showFromN :: Integer -> (String, Integer) showFromN i = case someNatVal i of Just (SomeNat (p :: Proxy n)) -> let ns :: NatString n ns = NatString "hello!" in showNS ns > showFromN 3 -- ("hello!", 3) Clearly the intermediate value of ns inside of showFromN has a type NatString 3 because showNS is using that fact. How can I make the compiler infer that fromN 3 :: NatString 3 separately?

4 5

Functional dependencies and overloading of operation
by Kristoffer Føllesdal 01 Mar '16

01 Mar '16

I am trying to use Functional dependencies to overload a operation on Vector space and its basis (Use the Vector spaces module Math.Algebras.VectorSpace <https://hackage.haskell.org/package/HaskellForMaths-0.4.8/docs/Math-Algebra…>). I have tried to mimic the example for matrices and vectors from https://wiki.haskell.org/Functional_dependencies <https://wiki.haskell.org/Functional_dependencies>. I have tried different ways of defining classes and instances, but I do not get it to work. What I want is to have the «same» function for these cases: operation :: a -> a -> Vect k a operation :: a -> Vect k a -> Vect k a operation :: Vect k a -> a -> Vect k a operation :: Vect k a -> Vect k a -> Vect k a Her are som sample code to illustrate what I want. Do anybody have an idea to how to solve it? {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE FunctionalDependencies #-} import Math.Algebras.VectorSpace linearExtension :: (Eq k, Num k, Ord a) => (a -> a -> Vect k a) -> Vect k a -> Vect k a -> Vect k a linearExtension f xs ys = linear (\x -> linear (f x) ys) xs data Tree t = Root t [Tree t] deriving(Eq, Show, Ord) op :: (Eq k, Num k, Ord t) => Tree t -> Tree t -> Vect k (Tree t) op x y = return x <+> return y opA :: (Eq k, Num k, Ord t) => Vect k (Tree t) -> Vect k (Tree t) -> Vect k (Tree t) opA = linearExtension op class Operation a b c | a b -> c where (<.>) :: a -> b -> c instance (Ord t) => Operation (Tree t) (Tree t) (Vect k (Tree t)) where (<.>)= op instance (Ord t) => Operation (Vect k (Tree t)) (Vect k (Tree t)) (Vect k (Tree t)) where (<.>) = opA instance (Ord t) => Operation (Tree t) (Vect k (Tree t)) (Vect k (Tree t)) where (<.>) x = opA (return x) instance (Ord t) => Operation (Vect k (Tree t)) (Tree t) (Vect k (Tree t)) where (<.>) x y = opA x (return y)

4 3

Re: [Haskell-cafe] Functional dependencies and overloading of operation
by Kristoffer Føllesdal 01 Mar '16

01 Mar '16

Internally in programs I will use the specific functions for each case. But I want some «syntactic sugar» for this functions when doing direct calculations in for example ghci. It will be more user friendly for direct interaction not to have four different functions that in practice do the same thing. Kristoffer > Date: Sun, 28 Feb 2016 21:11:20 +0000 > From: Tom Ellis <tom-lists-haskell-cafe-2013(a)jaguarpaw.co.uk <mailto:tom-lists-haskell-cafe-2013@jaguarpaw.co.uk>> > To: haskell-cafe(a)haskell.org <mailto:haskell-cafe@haskell.org> > Subject: Re: [Haskell-cafe] Functional dependencies and overloading of > operation > Message-ID: <20160228211120.GB23479@weber> > Content-Type: text/plain; charset=iso-8859-1 > > On Sun, Feb 28, 2016 at 10:00:42PM +0100, Kristoffer F?llesdal wrote: >> I am trying to use Functional dependencies to overload a operation on >> Vector space and its basis > [...] >> operation :: a -> a -> Vect k a >> operation :: a -> Vect k a -> Vect k a >> operation :: Vect k a -> a -> Vect k a >> operation :: Vect k a -> Vect k a -> Vect k a > > This is unlikely to be a good idea in practice. Is there a good reason you > can't use four different names for these operations? > > Date: Sun, 28 Feb 2016 22:00:42 +0100 > From: Kristoffer F?llesdal <kfollesdal(a)gmail.com <mailto:kfollesdal@gmail.com>> > To: haskell-cafe(a)haskell.org <mailto:haskell-cafe@haskell.org> > Subject: [Haskell-cafe] Functional dependencies and overloading of > operation > Message-ID: <84F1908D-05B0-4EAE-9CB7-50847BD65344(a)gmail.com <mailto:84F1908D-05B0-4EAE-9CB7-50847BD65344@gmail.com>> > Content-Type: text/plain; charset="utf-8" > > I am trying to use Functional dependencies to overload a operation on Vector space and its basis (Use the Vector spaces module Math.Algebras.VectorSpace <https://hackage.haskell.org/package/HaskellForMaths-0.4.8/docs/Math-Algebra… <https://hackage.haskell.org/package/HaskellForMaths-0.4.8/docs/Math-Algebra…>>). I have tried to mimic the example for matrices and vectors from https://wiki.haskell.org/Functional_dependencies <https://wiki.haskell.org/Functional_dependencies> <https://wiki.haskell.org/Functional_dependencies <https://wiki.haskell.org/Functional_dependencies>>. > I have tried different ways of defining classes and instances, but I do not get it to work. > > What I want is to have the ?same? function for these cases: > > operation :: a -> a -> Vect k a > operation :: a -> Vect k a -> Vect k a > operation :: Vect k a -> a -> Vect k a > operation :: Vect k a -> Vect k a -> Vect k a > > Her are som sample code to illustrate what I want. Do anybody have an idea to how to solve it? > > {-# LANGUAGE MultiParamTypeClasses #-} > {-# LANGUAGE FlexibleInstances #-} > {-# LANGUAGE FunctionalDependencies #-} > > import Math.Algebras.VectorSpace > > linearExtension :: (Eq k, Num k, Ord a) > => (a -> a -> Vect k a) -> Vect k a -> Vect k a -> Vect k a > linearExtension f xs ys = linear (\x -> linear (f x) ys) xs > > data Tree t = Root t [Tree t] deriving(Eq, Show, Ord) > > op :: (Eq k, Num k, Ord t) => Tree t -> Tree t -> Vect k (Tree t) > op x y = return x <+> return y > > opA :: (Eq k, Num k, Ord t) => Vect k (Tree t) -> Vect k (Tree t) -> Vect k (Tree t) > opA = linearExtension op > > class Operation a b c | a b -> c where > (<.>) :: a -> b -> c > > instance (Ord t) => Operation (Tree t) (Tree t) (Vect k (Tree t)) where > (<.>)= op > > instance (Ord t) => Operation (Vect k (Tree t)) (Vect k (Tree t)) (Vect k (Tree t)) where > (<.>) = opA > > instance (Ord t) => Operation (Tree t) (Vect k (Tree t)) (Vect k (Tree t)) where > (<.>) x = opA (return x) > > instance (Ord t) => Operation (Vect k (Tree t)) (Tree t) (Vect k (Tree t)) where > (<.>) x y = opA x (return y) >

2 1

Question: Do block precedence
by Jonne Ransijn 29 Feb '16

29 Feb '16

Dear Haskell-Cafe mailing list people (?) I've been writing parenthesis around do blocks since forever now, but I don't get why they are necessary. I can't seem to come up with a program where they are necessary. Am I missing something or are parenthesis around do blocks nececairy for no reason? Since parsing 'do' blocks as if they have parenthesis around them doesn't seem to break any code, why not do so? when (doBlocksNeedParenthesis) do putStrLn "This code is invalid." when (doBlocksNeedParenthesis) $ do putStrLn "This code is valid." when (doBlocksHaveInvisibleParenthesis) do putStrLn "These are equal v" when (doBlocksHaveInvisibleParenthesis) (do putStrLn "These are equal ^")

4 5

FLTKHS - GHCi help
by aditya siram 29 Feb '16

29 Feb '16

Hi all, I am the author of FLTKHS (http://github.com/deech/fltkhs) which aims to make it easy to install, write and deploy a native GUI application in pure Haskell. It is already able to build static executables on Linux, *BSD and OSX (Yosemite & El Capitan). However a smooth GHCi experience across platforms is still lacking due to some outstanding issues that I am unable to figure it out. I have written up the issues in the documentation [1]. I could use some help specifically with running a REPL with a C++ shared library in GHC 7.10.3. It works fine in 7.8.4. This is documented in the section titiled "GHCi (Linux, *BSD & OSX Yosemite)" in the link below. There is also a mysterious GHCi error on Windows that I can't seem to figure out. It is documented in "GHCi (Windows only)" section. Any help or pointers are appreciated. Thanks! -deech [1] http://hackage.haskell.org/package/fltkhs/docs/Graphics-UI-FLTK-LowLevel-FL…

2 1

Playing with OverloadedLabels in GHC 8 RC2, how to do this?
by Daniel Díaz 29 Feb '16

29 Feb '16

Hi all, I'm playing with the OverloadedLabels extension in GHC 8 RC2. I have been able to define simple record accessors, like in this gist: https://gist.github.com/danidiaz/3b9a6865686c777f328c After realizing than with OverloadedLabels a single symbol can be used to extract two different types from the same record, I tried to define an instance that says: "if a symbol can be used to extract an string from my record, then it can also be used to extract that a Text value". Here's my attempt (using a dummy Text type): {-# LANGUAGE OverloadedLabels #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE UndecidableInstances #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE MagicHash #-} module Main where import GHC.OverloadedLabels import GHC.Prim newtype Text = Text { getText :: String } deriving Show data Person = Person { _id :: Int , _name :: String } instance IsLabel "name" (Person -> String) where fromLabel _ = _name instance IsLabel symbol (Person -> String) => IsLabel symbol (Person -> Text) where fromLabel _ = Text . fromLabel (proxy# :: (Proxy# (Person -> String))) person :: Person person = Person 123 "Horace" main :: IO () main = do print (#name person :: String) print (#name person :: Text) Bu this doesn't work. The error I get is puzzling: • Expected kind ‘Proxy# ((->) Person String)’, but ‘proxy# :: Proxy# (Person -> String)’ has kind ‘Proxy# (Person -> String)’ • In the first argument of ‘fromLabel’, namely ‘(proxy# :: Proxy# (Person -> String))’ Is this a bug? What is going on here?

3 6

[ANN] sparkle: native Apache Spark applications in Haskell
by Alp Mestanogullari 28 Feb '16

28 Feb '16

Hello -cafe! Recently at Tweag I/O we've been working on sparkle, a library for writing (distributed) Apache Spark applications directly in Haskell! We have published a blog post introducing the project (and some of its challenges) here: http://www.tweag.io/blog/haskell-meets-large-scale-distributed-analytics The corresponding repository lives at https://github.com/tweag/sparkle While this is still early stage work, we can already write non-trivial Spark applications in Haskell and have them run accross an entire cluster. We obviously do not cover the whole Spark API yet (very, very far from that) but would be glad to already get some feedback. Cheers -- Alp Mestanogullari

2 2

Haskell Symposium 2016 CFP?
by Ivan Perez 27 Feb '16

27 Feb '16

Hi Café Is there going to be a Haskell Symposium this year? I haven't been able to find the call for papers. Best regards Ivan

2 1

ANNOUNCE: Applied Functional Programming (AFP) Summerschool 4-15 July 2016, Utrecht, Netherlands
by Atze Dijkstra 27 Feb '16

27 Feb '16

=========== AFP Summerschool 2016 =========== Applied Functional Programming (AFP) Summerschool July 4-15, 2016 Utrecht University, Department of Information and Computing Sciences Utrecht, The Netherlands Summerschool & registration website: http://www.utrechtsummerschool.nl/courses/science/applied-functional-progra… AFP website : http://www.cs.uu.nl/wiki/USCS contact : Uscs-afp(a)lists.science.uu.nl *** The 2016 edition of the Applied Functional Programming (AFP) Summerschool in Utrecht, Netherlands will be held from 4-15 July 2016. The summerschool teaches Haskell on both beginners and advanced levels via lectures and lab exercises. More info can be found via the references above, included here is a summary from the summerschool info: ``Typed functional programming languages allow for the development of robust, concise programs in a short amount of time. The key advantages are higher-order functions as an abstraction mechanism, and an advanced type system for safety and re usability. This course explores Haskell, a state-of-the-art functional programming language, together with some of its theoretical background, such as typed lambda calculi, referential transparency, Damas-Milner type inference, type level programming, and functional design patterns. We will combine this with applications of functional programming, concentrating on topics such as language processing, building graphical user interfaces, networking, databases, and programming for the web. The goal of the course is not just to teach the programming language and underlying theory, but also to learn about the Haskell community and to get hands-on experience by doing lab exercises or a Haskell project of your own.'' The summerschool is organised and given by the Software Technology group (http://www.uu.nl/en/research/software-systems/software-technology) within the Department of Information and Computing Sciences (http://www.uu.nl/en/organisation/department-of-information-and- computing-sciences), a group which in the departmental research evaluation over the past years was singled out by ``...the functional programming activities are known to be world leading in their domain.'' *** regards, - Atze - Atze Dijkstra, Department of Information and Computing Sciences. /|\ Utrecht University, PO Box 80089, 3508 TB Utrecht, Netherlands. / | \ Tel.: +31-30-2534118/1454 | WWW : http://www.cs.uu.nl/~atze . /--| \ Fax : +31-30-2513971 .... | Email: atze(a)uu.nl ............... / |___\

1 0