From haskell-cafe at maartenfaddegon.nl  Sat Feb  1 12:11:13 2014
From: haskell-cafe at maartenfaddegon.nl (Maarten Faddegon)
Date: Sat, 01 Feb 2014 12:11:13 +0000
Subject: [Haskell-cafe] Mixing own and derived instances with Generic
	Deriving Mechanism
Message-ID: <52ECE461.8080303@maartenfaddegon.nl>

Dear Pedro, Cafe,

Thanks again for helping me out last December. I have been
playing a bit more with deriving show and now ran into an
interesting problem mixing my own instances with derived
instances. Hope you can enlighten me there!

 > {-# LANGUAGE DeriveGeneric #-}
 > module Test where
 > import GHC.Generics
 > import Generics.Deriving.Show

The Generic Deriving Mechanism adds the keyword 'default' to
class definitions.  With this keyword we can define a
type-generic definition of that method when not given. For
example, if we define our own MyData type, we can derive the
GShow methods:

 > data MyData = MyData MyFancyType deriving Generic
 > instance GShow MyData

We can also still give our own definition, for example if we want
values of the MyFancyType to always be shown as the same string:

 > data MyFancyType = MyFancy1 | MyFancy2 deriving Generic
 > instance GShow MyFancyType where
 >       gshow _ = "Fancy!"

There is something strange here though: when we use gshow
directly on a MyFancyType value our own instance definition is
used, evaluating as expected to "Fancy!".

 > ex1 = gshow MyFancy1

But as soon as we are inside a derived method, we will continue
using derived instances even though we defined our own. The
example below evaluates to "MyData MyFancy1", rather than "MyData
Fancy!":

 > ex2 = gshow (MyData MyFancy1)

The default methods of GShow are defined in terms of methods from
GShow' which operate on the type-representation. From this
representation I do not see a way to recover the information
that a type has a GShow instance.  Am I correct (I hope not :) or
is there a way out?

Cheers,

Maarten Faddegon

From alfredo.dinapoli at gmail.com  Sat Feb  1 12:11:09 2014
From: alfredo.dinapoli at gmail.com (Alfredo Di Napoli)
Date: Sat, 1 Feb 2014 12:11:09 +0000
Subject: [Haskell-cafe] What game libraries should I use?
In-Reply-To: <lcgrcc$q6t$1@ger.gmane.org>
References: <52EB94CA.9060604@plaimi.net>
	<lcgrcc$q6t$1@ger.gmane.org>
Message-ID: <CAFqA6+WEFHCJb4YoqNuAZu3KheWqcKUOSD9Q3cBgjEpYeTsjcw@mail.gmail.com>

The Haskell bindings to SFML might be of your interest:

https://github.com/SFML-haskell/SFML

A.


On 31 January 2014 18:52, Simon Michael <simon at joyful.com> wrote:

> FunGEn (http://joyful.com/fungen) is (amazingly) still the most
> mature/complete Haskell games library as far as I know. I'm curious to know
> if you agree, or if I'm wrong.
>
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140201/fb927fdf/attachment.html>

From corentin.dupont at gmail.com  Sat Feb  1 15:55:09 2014
From: corentin.dupont at gmail.com (Corentin Dupont)
Date: Sat, 1 Feb 2014 16:55:09 +0100
Subject: [Haskell-cafe] DSLs and heterogeous lists
Message-ID: <CAEyhvmrWRxqBOQbLanHTBt2ETca3b1v4R2c9dKUofV+FCwhqKQ@mail.gmail.com>

Hi again,
I have a game in which the user can create/write/read variables, using a
small DSL. The type of the variable created can be whatever chooses the
user, so I'm using existential types to store those variables in a
heterogeneous list.
This works fine, but the problem is that the "Typeable" class tag leaks
into the DSL... The question is, how to get rid of it?

> This is literate Haskell
> {-# LANGUAGE GADTs, ScopedTypeVariables  #-}
> module DSLClass where
> import Control.Monad
> import Control.Monad.State
> import Data.Typeable
>

This is the (simplified) DSL. With it you can read a variable stored in the
game state (creation/writing is not shown).
How can we get rid of the "Typeable a" in the ReadFirstVar constructor?

> -- first type parameter is used to track effects
> data Exp a where
>   ReadFirstVar :: (Typeable a) => Exp a           <----- Ugly
>   Return       :: a -> Exp a
>   Bind         :: Exp a -> (a -> Exp b) -> Exp b

This is the definition of a variable. The type is unknow, so I use
existantial types.

> data Var = forall a . (Typeable a) => Var { v :: a}

This game state. It holds the heterogenous list.

> data Game = Game { variables :: [Var]}

The evaluation of "Exp" can be:

> eval :: Exp a -> State Game a
> eval ReadFirstVar  = do
>   (Game ((Var v):vs)) <- get
>   case cast v of
>      Just val -> return val
>      Nothing -> error "no cast"
> eval (Bind exp f) = do
>   a <- eval exp
>   eval (f a)


As you can see, I'm obliged to cast the variable type to match it with the
expression's type. Is that the right place to do it?

Thanks!!
Corentin
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140201/4aa4c00e/attachment.html>

From blamario at acanac.net  Sat Feb  1 17:08:31 2014
From: blamario at acanac.net (=?UTF-8?B?TWFyaW8gQmxhxb5ldmnEhw==?=)
Date: Sat, 01 Feb 2014 12:08:31 -0500
Subject: [Haskell-cafe] Generalized null / zero
In-Reply-To: <CAF3sfDpKE64Eg5myQqi2m-MKrUqN8iTMRMRZY8OboqW3PRoEfQ@mail.gmail.com>
References: <CAF3sfDpKE64Eg5myQqi2m-MKrUqN8iTMRMRZY8OboqW3PRoEfQ@mail.gmail.com>
Message-ID: <52ED2A0F.9030305@acanac.net>

On 01/28/14 21:25, Alvaro J. Genial wrote:
> 1. Is there a more general version of `null`? (e.g. for a Monad, 
> Functor, Applicative, Traversable or the like.)

There is the MonoidNull class from my monoid-subclasses library. It 
comes with plenty of standard instances.

http://hackage.haskell.org/package/monoid-subclasses-0.3.5/docs/Data-Monoid-Null.html


From eir at cis.upenn.edu  Sat Feb  1 18:02:16 2014
From: eir at cis.upenn.edu (Richard Eisenberg)
Date: Sat, 1 Feb 2014 13:02:16 -0500
Subject: [Haskell-cafe] DSLs and heterogeous lists
In-Reply-To: <CAEyhvmrWRxqBOQbLanHTBt2ETca3b1v4R2c9dKUofV+FCwhqKQ@mail.gmail.com>
References: <CAEyhvmrWRxqBOQbLanHTBt2ETca3b1v4R2c9dKUofV+FCwhqKQ@mail.gmail.com>
Message-ID: <930C302F-8637-4A64-8D44-87E568D6DB8F@cis.upenn.edu>

This seems reasonable to me. What's ugly about it? As I see it, casting really is necessary, because there's no way to know whether the type of the head variable in the list is correct without it.

Richard

On Feb 1, 2014, at 10:55 AM, Corentin Dupont <corentin.dupont at gmail.com> wrote:

> Hi again,
> I have a game in which the user can create/write/read variables, using a small DSL. The type of the variable created can be whatever chooses the user, so I'm using existential types to store those variables in a heterogeneous list. 
> This works fine, but the problem is that the "Typeable" class tag leaks into the DSL... The question is, how to get rid of it?
> 
> > This is literate Haskell
> > {-# LANGUAGE GADTs, ScopedTypeVariables  #-}
> > module DSLClass where
> > import Control.Monad
> > import Control.Monad.State
> > import Data.Typeable
> >
> 
> This is the (simplified) DSL. With it you can read a variable stored in the game state (creation/writing is not shown).
> How can we get rid of the "Typeable a" in the ReadFirstVar constructor?
> 
> > -- first type parameter is used to track effects
> > data Exp a where
> >   ReadFirstVar :: (Typeable a) => Exp a           <----- Ugly
> >   Return       :: a -> Exp a
> >   Bind         :: Exp a -> (a -> Exp b) -> Exp b
> 
> This is the definition of a variable. The type is unknow, so I use existantial types.
> 
> > data Var = forall a . (Typeable a) => Var { v :: a}
> 
> This game state. It holds the heterogenous list.
> 
> > data Game = Game { variables :: [Var]}
> 
> The evaluation of "Exp" can be:
> 
> > eval :: Exp a -> State Game a
> > eval ReadFirstVar  = do
> >   (Game ((Var v):vs)) <- get
> >   case cast v of
> >      Just val -> return val
> >      Nothing -> error "no cast"
> > eval (Bind exp f) = do
> >   a <- eval exp
> >   eval (f a)
> 
> 
> As you can see, I'm obliged to cast the variable type to match it with the expression's type. Is that the right place to do it?
> 
> Thanks!!
> Corentin
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140201/2e631f8a/attachment.html>

From eir at cis.upenn.edu  Sat Feb  1 18:21:12 2014
From: eir at cis.upenn.edu (Richard Eisenberg)
Date: Sat, 1 Feb 2014 13:21:12 -0500
Subject: [Haskell-cafe] Dispatch a type-function on the existence (or
	not) of instances?
In-Reply-To: <31962063-6BA2-4C33-89C3-0641D1082FE4@hanshoglund.se>
References: <31962063-6BA2-4C33-89C3-0641D1082FE4@hanshoglund.se>
Message-ID: <67C7D749-C92D-405F-8A0F-A701AF600EB5@cis.upenn.edu>

I am sure that "2) The possibility of "converting" a constraint into a type-level bool." is *not* possible. And, it really shouldn't be possible.

The problem has to do with modules. Suppose we have:

> module A where
> data Foo
> type Magic           -- invented syntax:
>   | Show Foo  = Int
>   | otherwise = Bool

> module B where
> import A
> instance Show Foo
> bar :: Magic
> bar = 3

> module C where
> import A
> quux :: Magic -- no (Show Foo) here!
> quux = False

> module D where
> import B
> import C
> hasSameType :: a -> a -> ()
> hasSameType _ _ = ()
> unit :: ()
> unit = hasSameType bar quux

Does that last line of D type-check? `bar` and `quux` are both declared to have the same type. But, of course, they don't have the same type! Yuck. Thus, `Magic` cannot exist.

In my own work, I've often wanted something like Magic, but I've learned that whenever I start wanting Magic, what I really want is a very different design.

If you really, really want Magic and just can't live without it though, you might consider using Template Haskell. TH code can query the database of available instances and branch on the existence of an instance. See `reifyInstances`. TH can't cause the problem I described above, because the equivalent using TH would give `bar` and `quux` different types at compile time, because the TH code is fully evaluated, unlike something like `Magic` which might not be.

I hope this helps!
Richard

On Jan 31, 2014, at 12:56 PM, Hans H?glund <hans at hanshoglund.se> wrote:

> Dear all,
> 
> I have been curious about the ability to detect the presence of a certain instance (ClassFoo TypeBar) in the type system.
> Specifically, is it possible to "dispatch" a type on the existence (or not) of such an instance. For example given two functions:
> 
> withInstance :: (ClassFoo TypeBar) => TypeIfInstanceExists
> withoutInstance :: TypeIfInstanceDoesNotExists
> 
> I would be able to consolidate them into something like this:
> 
> withOrWithoutInstance :: 
>    (r ~ InstanceExists ClassFoo TypeBar, 
>     a ~ If r TypeIfInstanceExists TypeIfInstanceDoesNotExists) => a
> 
> I guess what I need is:
> 
> 1) A type-level "if".
> 2) The possibility of "converting" a constraint into a type-level bool.
> 
> I am sure (1) is possible but have no idea about (2). Anyone?
> 
> Best regards,
> Hans
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe


From corentin.dupont at gmail.com  Sat Feb  1 18:51:42 2014
From: corentin.dupont at gmail.com (Corentin Dupont)
Date: Sat, 1 Feb 2014 19:51:42 +0100
Subject: [Haskell-cafe] DSLs and heterogeous lists
In-Reply-To: <930C302F-8637-4A64-8D44-87E568D6DB8F@cis.upenn.edu>
References: <CAEyhvmrWRxqBOQbLanHTBt2ETca3b1v4R2c9dKUofV+FCwhqKQ@mail.gmail.com>
 <930C302F-8637-4A64-8D44-87E568D6DB8F@cis.upenn.edu>
Message-ID: <CAEyhvmraLqGm0XtuOG5dErwRZhNmosM3nQrQ0zfur2SaLZv47w@mail.gmail.com>

Ugly, maybe not, but I read somewhere that the class restriction should be
on the functions definitions than in the datatype definition... That is,
the datatype is usually defined without class restriction, instead the
necessary class restriction is added latter on in the functions signatures
that work on that datatype.


On Sat, Feb 1, 2014 at 7:02 PM, Richard Eisenberg <eir at cis.upenn.edu> wrote:

> This seems reasonable to me. What's ugly about it? As I see it, casting
> really is necessary, because there's no way to know whether the type of the
> head variable in the list is correct without it.
>
> Richard
>
> On Feb 1, 2014, at 10:55 AM, Corentin Dupont <corentin.dupont at gmail.com>
> wrote:
>
> Hi again,
> I have a game in which the user can create/write/read variables, using a
> small DSL. The type of the variable created can be whatever chooses the
> user, so I'm using existential types to store those variables in a
> heterogeneous list.
> This works fine, but the problem is that the "Typeable" class tag leaks
> into the DSL... The question is, how to get rid of it?
>
> > This is literate Haskell
> > {-# LANGUAGE GADTs, ScopedTypeVariables  #-}
> > module DSLClass where
> > import Control.Monad
> > import Control.Monad.State
> > import Data.Typeable
> >
>
> This is the (simplified) DSL. With it you can read a variable stored in
> the game state (creation/writing is not shown).
> How can we get rid of the "Typeable a" in the ReadFirstVar constructor?
>
> > -- first type parameter is used to track effects
> > data Exp a where
> >   ReadFirstVar :: (Typeable a) => Exp a           <----- Ugly
> >   Return       :: a -> Exp a
> >   Bind         :: Exp a -> (a -> Exp b) -> Exp b
>
> This is the definition of a variable. The type is unknow, so I use
> existantial types.
>
> > data Var = forall a . (Typeable a) => Var { v :: a}
>
> This game state. It holds the heterogenous list.
>
> > data Game = Game { variables :: [Var]}
>
> The evaluation of "Exp" can be:
>
> > eval :: Exp a -> State Game a
> > eval ReadFirstVar  = do
> >   (Game ((Var v):vs)) <- get
> >   case cast v of
> >      Just val -> return val
> >      Nothing -> error "no cast"
> > eval (Bind exp f) = do
> >   a <- eval exp
> >   eval (f a)
>
>
> As you can see, I'm obliged to cast the variable type to match it with the
> expression's type. Is that the right place to do it?
>
> Thanks!!
> Corentin
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140201/fbebb306/attachment.html>

From eir at cis.upenn.edu  Sat Feb  1 19:09:57 2014
From: eir at cis.upenn.edu (Richard Eisenberg)
Date: Sat, 1 Feb 2014 14:09:57 -0500
Subject: [Haskell-cafe] DSLs and heterogeous lists
In-Reply-To: <CAEyhvmraLqGm0XtuOG5dErwRZhNmosM3nQrQ0zfur2SaLZv47w@mail.gmail.com>
References: <CAEyhvmrWRxqBOQbLanHTBt2ETca3b1v4R2c9dKUofV+FCwhqKQ@mail.gmail.com>
 <930C302F-8637-4A64-8D44-87E568D6DB8F@cis.upenn.edu>
 <CAEyhvmraLqGm0XtuOG5dErwRZhNmosM3nQrQ0zfur2SaLZv47w@mail.gmail.com>
Message-ID: <CBFD27BB-2B1D-4F8A-9185-13E7887C6401@cis.upenn.edu>

There are three (relevant) places a constraint could go:

data Typeable a => Exp a = ...  -- (1)

data Exp a where
  ReadFirstVar :: Typeable a => Exp a        -- (2)

eval :: Typeable a => Exp a -> ... -- (3)

You're currently doing (2). When people talk about not putting constraints on datatypes, I imagine they're talking about (1), which is indeed a bad idea. Using (1) essentially buys you nothing -- you would still still a constraint like (3) to work with the type declared in (1). So, the real choice is between (2) and (3). Each of these has its advantages. (2) essentially says that the data stored by the ReadFirstVar constructor is the type of the expression. (3) essentially says that any caller of `eval` also has to pass in the desired type for the expression. Without seeing more code, it's hard to know what's better in your scenario.

But, my bottom line is that the advice you've read probably pertains to (1), not (2) -- it's not saying that what you've done is bad.

Richard

On Feb 1, 2014, at 1:51 PM, Corentin Dupont <corentin.dupont at gmail.com> wrote:

> Ugly, maybe not, but I read somewhere that the class restriction should be on the functions definitions than in the datatype definition... That is, the datatype is usually defined without class restriction, instead the necessary class restriction is added latter on in the functions signatures that work on that datatype.
> 
> 
> On Sat, Feb 1, 2014 at 7:02 PM, Richard Eisenberg <eir at cis.upenn.edu> wrote:
> This seems reasonable to me. What's ugly about it? As I see it, casting really is necessary, because there's no way to know whether the type of the head variable in the list is correct without it.
> 
> Richard
> 
> On Feb 1, 2014, at 10:55 AM, Corentin Dupont <corentin.dupont at gmail.com> wrote:
> 
>> Hi again,
>> I have a game in which the user can create/write/read variables, using a small DSL. The type of the variable created can be whatever chooses the user, so I'm using existential types to store those variables in a heterogeneous list. 
>> This works fine, but the problem is that the "Typeable" class tag leaks into the DSL... The question is, how to get rid of it?
>> 
>> > This is literate Haskell
>> > {-# LANGUAGE GADTs, ScopedTypeVariables  #-}
>> > module DSLClass where
>> > import Control.Monad
>> > import Control.Monad.State
>> > import Data.Typeable
>> >
>> 
>> This is the (simplified) DSL. With it you can read a variable stored in the game state (creation/writing is not shown).
>> How can we get rid of the "Typeable a" in the ReadFirstVar constructor?
>> 
>> > -- first type parameter is used to track effects
>> > data Exp a where
>> >   ReadFirstVar :: (Typeable a) => Exp a           <----- Ugly
>> >   Return       :: a -> Exp a
>> >   Bind         :: Exp a -> (a -> Exp b) -> Exp b
>> 
>> This is the definition of a variable. The type is unknow, so I use existantial types.
>> 
>> > data Var = forall a . (Typeable a) => Var { v :: a}
>> 
>> This game state. It holds the heterogenous list.
>> 
>> > data Game = Game { variables :: [Var]}
>> 
>> The evaluation of "Exp" can be:
>> 
>> > eval :: Exp a -> State Game a
>> > eval ReadFirstVar  = do
>> >   (Game ((Var v):vs)) <- get
>> >   case cast v of
>> >      Just val -> return val
>> >      Nothing -> error "no cast"
>> > eval (Bind exp f) = do
>> >   a <- eval exp
>> >   eval (f a)
>> 
>> 
>> As you can see, I'm obliged to cast the variable type to match it with the expression's type. Is that the right place to do it?
>> 
>> Thanks!!
>> Corentin
>> _______________________________________________
>> Haskell-Cafe mailing list
>> Haskell-Cafe at haskell.org
>> http://www.haskell.org/mailman/listinfo/haskell-cafe
> 
> 

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140201/5d51f880/attachment.html>

From hjgtuyl at chello.nl  Sat Feb  1 20:54:59 2014
From: hjgtuyl at chello.nl (Henk-Jan van Tuyl)
Date: Sat, 01 Feb 2014 21:54:59 +0100
Subject: [Haskell-cafe] Castle: Permission denied
Message-ID: <op.xame1xxdpz0j5l@zen5.arnhem.chello.nl>


L.S.,

I am trying to install castle, but I get the following messages:
   Downloading castle-0.1.0.0...
   Configuring castle-0.1.0.0...
   realgcc.exe: ./specs: Permission denied
What can I do about this?

I am running Windows XP, Haskell Platform 2013.2.0.0

Regards,
Henk-Jan van Tuyl


-- 
Folding at 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
--

From allbery.b at gmail.com  Sat Feb  1 21:15:56 2014
From: allbery.b at gmail.com (Brandon Allbery)
Date: Sat, 1 Feb 2014 16:15:56 -0500
Subject: [Haskell-cafe] Castle: Permission denied
In-Reply-To: <op.xame1xxdpz0j5l@zen5.arnhem.chello.nl>
References: <op.xame1xxdpz0j5l@zen5.arnhem.chello.nl>
Message-ID: <CAKFCL4VK6qyXJgjFVP64ExsUG=jyC9rdk-VwnRTO2nuAnuHvWg@mail.gmail.com>

On Sat, Feb 1, 2014 at 3:54 PM, Henk-Jan van Tuyl <hjgtuyl at chello.nl> wrote:

> I am trying to install castle, but I get the following messages:
>   Downloading castle-0.1.0.0...
>   Configuring castle-0.1.0.0...
>   realgcc.exe: ./specs: Permission denied
> What can I do about this?
>

That sounds like something is wrong with the permissions on your gcc
installation.

-- 
brandon s allbery kf8nh                               sine nomine associates
allbery.b at gmail.com                                  ballbery at sinenomine.net
unix, openafs, kerberos, infrastructure, xmonad        http://sinenomine.net
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140201/be2eabd2/attachment.html>

From erochest at gmail.com  Sun Feb  2 02:44:06 2014
From: erochest at gmail.com (Eric Rochester)
Date: Sat, 1 Feb 2014 21:44:06 -0500
Subject: [Haskell-cafe] Castle: Permission denied
In-Reply-To: <op.xame1xxdpz0j5l@zen5.arnhem.chello.nl>
References: <op.xame1xxdpz0j5l@zen5.arnhem.chello.nl>
Message-ID: <CAD-mb2DAvKf0UHv9W48xgiVe54kO7eR2G68duNSXc18scOOApQ@mail.gmail.com>

Thanks for opening the issue for this. I'll try to take a look on Monday
when I will have access to a Windows box, but in the meantime, I agree that
it sounds as if there are permissions problems with GCC.

Eric
 On Feb 1, 2014 3:55 PM, "Henk-Jan van Tuyl" <hjgtuyl at chello.nl> wrote:

>
> L.S.,
>
> I am trying to install castle, but I get the following messages:
>   Downloading castle-0.1.0.0...
>   Configuring castle-0.1.0.0...
>   realgcc.exe: ./specs: Permission denied
> What can I do about this?
>
> I am running Windows XP, Haskell Platform 2013.2.0.0
>
> Regards,
> Henk-Jan van Tuyl
>
>
> --
> Folding at 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
> --
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140201/66f8a7d6/attachment.html>

From jpm at cs.uu.nl  Sun Feb  2 16:02:31 2014
From: jpm at cs.uu.nl (=?ISO-8859-1?Q?Jos=E9_Pedro_Magalh=E3es?=)
Date: Sun, 2 Feb 2014 16:02:31 +0000
Subject: [Haskell-cafe] Mixing own and derived instances with Generic
	Deriving Mechanism
In-Reply-To: <52ECE461.8080303@maartenfaddegon.nl>
References: <52ECE461.8080303@maartenfaddegon.nl>
Message-ID: <CA+ZFbn815RrArk5WX=_UfY5bB9YHU-LqFMRJav4_zB-pFugu9A@mail.gmail.com>

Hi Maarten,

The problem here is that your instance of GShow MyFancyType defines gshow,
but the
function that is defined generically is actually gshowsPrec, with the
others being given
defaults. For this to work as you'd expect it to, you have to define
gshowsPrec in the
instance GShow MyFancyType. This is a bit unfortunate, but because
gshowsPrec has
a generic default, it cannot have the usual default (like showsPrec does).


Cheers,
Pedro



On Sat, Feb 1, 2014 at 12:11 PM, Maarten Faddegon <
haskell-cafe at maartenfaddegon.nl> wrote:

> Dear Pedro, Cafe,
>
> Thanks again for helping me out last December. I have been
> playing a bit more with deriving show and now ran into an
> interesting problem mixing my own instances with derived
> instances. Hope you can enlighten me there!
>
> > {-# LANGUAGE DeriveGeneric #-}
> > module Test where
> > import GHC.Generics
> > import Generics.Deriving.Show
>
> The Generic Deriving Mechanism adds the keyword 'default' to
> class definitions.  With this keyword we can define a
> type-generic definition of that method when not given. For
> example, if we define our own MyData type, we can derive the
> GShow methods:
>
> > data MyData = MyData MyFancyType deriving Generic
> > instance GShow MyData
>
> We can also still give our own definition, for example if we want
> values of the MyFancyType to always be shown as the same string:
>
> > data MyFancyType = MyFancy1 | MyFancy2 deriving Generic
> > instance GShow MyFancyType where
> >       gshow _ = "Fancy!"
>
> There is something strange here though: when we use gshow
> directly on a MyFancyType value our own instance definition is
> used, evaluating as expected to "Fancy!".
>
> > ex1 = gshow MyFancy1
>
> But as soon as we are inside a derived method, we will continue
> using derived instances even though we defined our own. The
> example below evaluates to "MyData MyFancy1", rather than "MyData
> Fancy!":
>
> > ex2 = gshow (MyData MyFancy1)
>
> The default methods of GShow are defined in terms of methods from
> GShow' which operate on the type-representation. From this
> representation I do not see a way to recover the information
> that a type has a GShow instance.  Am I correct (I hope not :) or
> is there a way out?
>
> Cheers,
>
> Maarten Faddegon
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140202/2a24173b/attachment.html>

From trupill at gmail.com  Sun Feb  2 16:49:14 2014
From: trupill at gmail.com (Alejandro Serrano Mena)
Date: Sun, 2 Feb 2014 17:49:14 +0100
Subject: [Haskell-cafe] New book: "Beginning Haskell"
Message-ID: <CAHnFXOtSFkE_LKeWnKzaLDXOQcyMSp4RebFMr19SMgVuJJW94w@mail.gmail.com>

[Disclaimer: I'm the author of the book]

Dear Haskell-cafe,

I would like to introduce a new book discussing our favourite language from
beginner into upper intermediate level: "Beginning Haskell". The book
starts assuming zero knowledge about functional programming and builds step
by step to get into the realm of web applications, type-level programming,
domain specific languages, distributed computing, unit testing and much
more! You can look at the Table of Contents in Amazon [
http://www.amazon.com/Beginning-Haskell-A-Project-Based-Approach/dp/1430262508/
].

The book revolves around the idea of a Time Machine Store: in each part
some functionality is developed. The first part serves as an introduction
and how to model the data with Haskell data types and functions; part 2
discusses many concepts around monads while developing two data-mining
algorithms; in the third part storing and interfacing with clients serves
as an excuse to introduce input/output, database access and web
applications; part 4 is devoted to discussing domain specific libraries for
describing offers; and the last part discusses testing and other
engineering issues.

All the "classical" topics in Haskell are discussed: higher-order
functions, type classes -- functors, applicatives, monads --, laziness. The
focus also lies on libraries use in modern Haskell daily programming, such
as lenses, streaming data libraries, functional dependencies and type
families, Software Transactional Memory and Cloud Haskell. One topic that
is cross-cutting through the book is how to manage projects with Cabal or
EclipseFP: initializing a new package, declaring dependencies, building and
integrating tests. The book tries thus to offer a comprehensive view of the
Haskell ecosystem, not only of the Haskell programming language.

The book is published by Apress [http://www.apress.com/9781430262503] and
available as paperback and electronic format. If somebody would like to
make a review for some FP or programming-related magazine (such as The
Monad Reader) or assess its possibilities for use in classroom, please drop
me a line.

Hope you like it! :)
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140202/227938d9/attachment.html>

From corentin.dupont at gmail.com  Sun Feb  2 19:42:03 2014
From: corentin.dupont at gmail.com (Corentin Dupont)
Date: Sun, 2 Feb 2014 20:42:03 +0100
Subject: [Haskell-cafe] manage effects in a DSL
In-Reply-To: <CAEyhvmrti3-4B0KvtdQKZPTh8foX=yg__W3AATjunRLAvaF6CA@mail.gmail.com>
References: <20140129033404.76144.qmail@www1.g3.pair.com>
 <CAEyhvmqiJCc8vs-LHpT=CW20yGjhr5G3LMB86c+w38v+e5BELw@mail.gmail.com>
 <CAEyhvmrti3-4B0KvtdQKZPTh8foX=yg__W3AATjunRLAvaF6CA@mail.gmail.com>
Message-ID: <CAEyhvmow1XbdLJv00iDVA4uBWEXmMGeLsVg1g6jpUCt2=d8CPQ@mail.gmail.com>

Building up on the exemple below, I have a problem with mixing
effectful/effectless computations. For example, this would not compile:

> noEff :: Exp NoEffect ()
> noEff = return ()

> hasEffect :: Exp Effect ()
> hasEffect = do
>   noEff                    <--- won't compile
>   return ()

But it should: you should be able to run an effectless monad in an
effectful one.
How to encode this semantic?
I know you can replace the type signature of noEff by:

> noEff :: Exp r ()

But I don't find it so elegant...

I suppose you have to encode the semantic in the Bind of the Monad instance:

> data Exp :: Eff -> * -> * where
>   ...
>   Bind1        :: Exp NoEffect a -> (a -> Exp r b) -> Exp r b
>   Bind2        :: Exp Effect a -> (a -> Exp r b) -> Exp Effect b

> instance Monad (Exp r) where
>    return = Const
>    (a :: Exp NoEffect a) >>= f = a `Bind1` f
>    (a :: Exp Effect a)   >>= f = a `Bind2` f

But this doesn't work:
Couldn't match type `r' with 'NoEffect
      `r' is a rigid type variable

Thanks a lot for the help :) all this thread helped me a lot!!

Corentin


On Thu, Jan 30, 2014 at 8:53 PM, Corentin Dupont
<corentin.dupont at gmail.com>wrote:

>
>
> Oleg: Very interresting, thanks. I have some questions:
> - What do you mean by "The type Cont Int a describes an impure
> computation, which may abort with an Int value, for example".
> Aborting with an Int value is akin to exceptions?
> - for me it's not clear when to choose an "applicative" or a "monadic"
> DSL? Betsides, what's the rational behind the name "let_" (never seen it
> before)?
>
>
> Linsey, Jacques: Thanks for the pointer! I learned about data kinds.
> I tried to apply your suggestions to add a phantom type parameter to Exp.
> I came up to (I dropped the Free monad idea, which seems unrelated to the
> problem):
>
>
>

> > data Eff = Effect | NoEffect
>
> > -- first type parameter is used to track effects
> > data Exp :: Eff -> * -> * where
> >   ReadAccount  :: Exp r Int  --ReadAccount can be used in whatever monad
> (with or without effect)
> >   WriteAccount :: Exp NoEffect Int -> Exp Effect ()  --WriteAccount
> takes an effect-less expression, and returns an effectfull expression
> >   SetVictory   :: Exp NoEffect Bool -> Exp Effect ()  -- same for
> SetVictory
> >   OnTimer      :: Exp Effect () -> Exp Effect () --OnTime can program
> whatever expression to be triggered every minutes, in particular effectful
> ones
> >   Return       :: a -> Exp r a
> >   Bind         :: Exp r a -> (a -> Exp r b) -> Exp r b
>
> This is the (simplified) game state:
>
>
> > data Game = Game { bankAccount :: Int,
> >                    victory     :: Exp NoEffect Bool,
> >                    timerEvent  :: Exp Effect ()}
>
> > -- victory when account > 100
> > victoryRule' :: Exp Effect ()
>
> > victoryRule' = SetVictory $ do
> >   m <- readAccount
> >   --WriteAccount (return $ m + 1) --won't compile (good)
>
> >   return (m > 100)
>
> > --increase my bank account by 1 every minute
> > myTimer :: Exp Effect ()
> > myTimer = OnTimer $ do
> >   m <- readAccount
>
> >   writeAccount (return $ m + 1)
>
>
> Do you have a better name suggestion for Eff? Other pointers where this
> idiom is realised??
> Thanks!!
> Corentin
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140202/3a2b91bf/attachment.html>

From lindsey at composition.al  Sun Feb  2 19:55:17 2014
From: lindsey at composition.al (Lindsey Kuper)
Date: Sun, 2 Feb 2014 14:55:17 -0500
Subject: [Haskell-cafe] manage effects in a DSL
In-Reply-To: <CAEyhvmow1XbdLJv00iDVA4uBWEXmMGeLsVg1g6jpUCt2=d8CPQ@mail.gmail.com>
References: <20140129033404.76144.qmail@www1.g3.pair.com>
 <CAEyhvmqiJCc8vs-LHpT=CW20yGjhr5G3LMB86c+w38v+e5BELw@mail.gmail.com>
 <CAEyhvmrti3-4B0KvtdQKZPTh8foX=yg__W3AATjunRLAvaF6CA@mail.gmail.com>
 <CAEyhvmow1XbdLJv00iDVA4uBWEXmMGeLsVg1g6jpUCt2=d8CPQ@mail.gmail.com>
Message-ID: <CALnXJiqhPoKEpJKszGf4EskbSVU1xh+MX=R2dBU4cGv4o+fxoQ@mail.gmail.com>

On Sun, Feb 2, 2014 at 2:42 PM, Corentin Dupont
<corentin.dupont at gmail.com> wrote:
> you should be able to run an effectless monad in an effectful one.
> How to encode this semantic?

In LVish we just have a `liftQD` operation that will let you lift a
deterministic computation to a quasi-deterministic one (recall that
deterministic computations can perform fewer effects):

  liftQD :: Par Det s a -> Par QuasiDet s a

So, analogously, you could have a `liftEff` and then write `liftEff
noEff`.  This is also a little bit ugly, but you may find you don't
have to do it very often (we rarely use `liftQD`).

Lindsey

From cobbe at ccs.neu.edu  Sun Feb  2 21:32:19 2014
From: cobbe at ccs.neu.edu (Richard Cobbe)
Date: Sun, 2 Feb 2014 16:32:19 -0500
Subject: [Haskell-cafe] problem with happy and type identity
Message-ID: <20140202213219.GA238@ridcully.local>

I'm working on a small project that involves an Alex scanner and a Happy
parser, and I'm getting an error from the type-checker that I do not
understand.  Can anyone help shed some light on what's going on?

I'm running Haskell Platform 2013.2.0.0, on MacOS 10.8.5 with XCode 4.6.3.

I've reduced the problem to a very small example, which I've attached as a
tar file.  It's a cabal package, and it contains a library with some test
cases.

If I run "cabal configure && cabal build" then the library builds with no
problems whatsoever.

But if I run

    cabal clean && cabal configure --enable-tests && cabal build

then I get the following error message:

    RunTests.hs:16:27:
        Couldn't match expected type `sample-0.4:Ast.Entry'
                    with actual type `Entry'
        In the return type of a call of `Entry'
        In the second argument of `(~?=)', namely `Entry "mumble"'
        In the expression: parse "entry" ~?= Entry "mumble"

And this doesn't make any sense to me, because the two types are supposed
to be the same.

If I take Happy and Alex out of the picture by replacing the Parser module
with a hand-written parser, the error goes away.  This is hardly feasible
in the actual project, of course :-) so I'm hoping someone can shed some
light on what I'm doing wrong here.

Thanks!

Richard

(I apologize for the attachment, by the way, but since filesystem layout is
potentially important here, and since it's only slightly larger than 1K, I
figured it was the best way.  If there's a better way to do this in the
future (which doesn't assume I can throw it on the web somewhere), then I'd
love to hear about it.)
-------------- next part --------------
A non-text attachment was scrubbed...
Name: sample.tgz
Type: application/x-tar-gz
Size: 1106 bytes
Desc: not available
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140202/1d10fcae/attachment.bin>

From blancomau at gmail.com  Sun Feb  2 23:55:35 2014
From: blancomau at gmail.com (Mauro Blanco)
Date: Sun, 2 Feb 2014 21:55:35 -0200
Subject: [Haskell-cafe] ANNOUNCE: fpnla - A library for NLA operations
Message-ID: <CAMzYd-=mfddOXeWyhEWHCYnptajySN0pd4paToa8n_42H_fMrg@mail.gmail.com>

Hi.

Today we are releasing fpnla <http://hackage.haskell.org/package/fpnla>,
which defines a framework for linear algebra operations of BLAS and LAPACK.
As its main features it allows:
- Definition of multiple representations of vectors and matrices.
- Arbitrary combination of strategies and structure representations.
- Type-safe manipulation of context information associated to each strategy.
- Definition of specialized strategies for a given representation.

And also fpnla-examples <http://hackage.haskell.org/package/fpnla-examples>,
which contains many example implementations of the operations defined in
fpnla using various data structures and algorithms.

Regards.

-- 
Mauro Blanco
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140202/3d7860ad/attachment.html>

From fumiexcel at gmail.com  Mon Feb  3 00:59:28 2014
From: fumiexcel at gmail.com (Fumiaki Kinoshita)
Date: Sun, 2 Feb 2014 16:59:28 -0800 (PST)
Subject: [Haskell-cafe] What game libraries should I use?
In-Reply-To: <52EB94CA.9060604@plaimi.net>
References: <52EB94CA.9060604@plaimi.net>
Message-ID: <d16d4f2d-7218-46aa-8c2c-5abb1d6be9be@googlegroups.com>

My free-game package has Gloss-like but far more generalized APIs[0].

When you define some series of instructions to draw something, you can move 
then, turn them, or compose them without touching the insides!

[0] http://hackage.haskell.org/package/free-game-1.0.1/docs/FreeGame.html#t:Picture2D

2014?1?31???? 21?19?22? UTC+9 Alexander Berntsen:
>
> -----BEGIN PGP SIGNED MESSAGE----- 
> Hash: SHA256 
>
> I need: 
> - -2D graphics (preferably with simple shapes available) 
> - -menus (I can make menus myself with shapes though) 
> - -simple audio 
> - -fonts (better than Gloss at least) 
> - -keyboard input 
> - -networking (simple direct connections between two computers) 
>
> I need to be able to express my game system as declaratively as 
> possible[0]. 
>
> If the library is based on SDL/OpenGL, that would be nice[1]. This is, 
> however, not necessary. 
>
> What game libraries are the most mature and adequate for this? The 
> only library I have used previously with Haskell is Gloss. I am not 
> experienced in FRP, though I have read about and somewhat groked the 
> point. I am willing to learn an FRP library. 
>
>
> [0]  I am writing it as part of a thesis in which I will look at the 
> modularity and expressiveness of purely functional programming 
> compared to object-oriented programming. Writing code that is 
> technically purely functional, but in practice looks like imperative 
> code, is sub-optimal. 
> [1]  For the thesis I am writing, I am implementing a C++ version of 
> the same game. This will probably use SDL 2.0 and OpenGL bindings. If 
> the Haskell version could use libraries based on that, this would make 
> it easier for me to write my thesis. I.e., I would not have to spend 
> time justifying that the modularity and expressiveness I am 
> investigating is due to the chosen languages and programming 
> paradigms, and not the libraries I use. 
> - -- 
> Alexander 
> alex... at plaimi.net <javascript:> 
> http://plaimi.net/~alexander 
> -----BEGIN PGP SIGNATURE----- 
> Version: GnuPG v2.0.22 (GNU/Linux) 
> Comment: Using GnuPG with Thunderbird - http://www.enigmail.net/ 
>
> iF4EAREIAAYFAlLrlMoACgkQRtClrXBQc7VkiAEAnEbfjiSLovcXttmjpdD5OSFI 
> uEMBVBJdWonY9ZMPIc8BAIAQn+YMRvGILgb8WmuB9oTWJDVZfqDMyB47qzjyfimO 
> =YGLW 
> -----END PGP SIGNATURE----- 
> _______________________________________________ 
> Haskell-Cafe mailing list 
> Haskel... at haskell.org <javascript:> 
> http://www.haskell.org/mailman/listinfo/haskell-cafe 
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140202/e0a0ef8f/attachment.html>

From michael at snoyman.com  Mon Feb  3 08:57:28 2014
From: michael at snoyman.com (Michael Snoyman)
Date: Mon, 3 Feb 2014 10:57:28 +0200
Subject: [Haskell-cafe] A new yaml module
Message-ID: <CAKA2JgJOV-jZhOL7FN0W21JVyumSfByWX2D2C+z7=syayx2u+g@mail.gmail.com>

The yaml package[1] currently provides two modules. Text.Libyaml is a lower
level, streaming API which is essentially a raw exposure of the underlying
libyaml C library. Data.Yaml uses the aeson Value data type and
ToJSON/FromJSON type classes for higher level serialization. For many
cases, this approach works well, though there are problems:

* There are problems with roundtripping, since YAML allows for ambiguity
about the data type of values[2]. For example, in the yaml snippet `foo:
1234`, is 1234 intended to be numeric or a string? Either is valid.
* YAML is intended to be human-readable output. But Data.Yaml provides no
control over the encoded representation, e.g. should we use single or
double quotes for a string (or no quotes at all), or the order of values in
a mapping[3].

For other examples, just look at the issue tracker for yaml[4].

I don't want to drop the current aeson-based functionality, since I think
it's still valid and useful in many cases. But I do think it's worthwhile
to add in an alternative API which handles YAML-specific constructs better.
My idea is:

* Create a new Data.Yaml.Aeson module, and have it mirror Data.Yaml.
* Deprecate Data.Yaml.
* Create a new Data.Yaml.? module to contain this YAML-specific API.

I'm asking for feedback on that last point. I have some basic ideas on what
such an API would look like, but given that there are many people using
YAML in ways different than how I'm using it, I don't think an API designed
entirely by me will suit all use cases.

I've opened up a new issue[5] to track this work. If you're interested in
participating in this design, please contact me. I'm happy to have the
discussion on this mailing list, but if (as I suspect) there are just a
handful of people who are interested in pushing this forward, it likely
makes sense to take the discussion offlist.

Michael

[1] http://hackage.haskell.org/package/yaml
[2] https://github.com/snoyberg/yaml/issues/22
[3] https://github.com/snoyberg/yaml/issues/37
[4] https://github.com/snoyberg/yaml/issues
[5] https://github.com/snoyberg/yaml/issues/38
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140203/a62e1890/attachment.html>

From hans at hanshoglund.se  Mon Feb  3 09:13:03 2014
From: hans at hanshoglund.se (=?iso-8859-1?Q?Hans_H=F6glund?=)
Date: Mon, 3 Feb 2014 10:13:03 +0100
Subject: [Haskell-cafe] Dispatch a type-function on the existence (or
	not) of instances?
In-Reply-To: <67C7D749-C92D-405F-8A0F-A701AF600EB5@cis.upenn.edu>
References: <31962063-6BA2-4C33-89C3-0641D1082FE4@hanshoglund.se>
 <67C7D749-C92D-405F-8A0F-A701AF600EB5@cis.upenn.edu>
Message-ID: <8B95BF87-5F9C-4B47-AFF1-880EEA80FB58@hanshoglund.se>

This makes sense, thank you for clearing it up.

My problem arises from the following situation, where I want to overload t depending whether a getter is available or not.

class HasTGetter a
class HasTSetter a

t :: HasTSetter a -> Setter a T
t :: (HasTGetter a, HasTSetter a) -> Lens a T

I could probably resolve the ambiguity by using a separate type function.

instance HasTSetter Foo
type instance LensType Foo T = Setter Foo T

instance HasTGetter Bar
instance HasTSetter Bar
type instance LensType Bar T = Lens Bar T

t :: (HasGetter a, HasSetter a) -> LensType a T

Regards,
Hans


On 1 feb 2014, at 19:21, Richard Eisenberg wrote:

> I am sure that "2) The possibility of "converting" a constraint into a type-level bool." is *not* possible. And, it really shouldn't be possible.
> 
> The problem has to do with modules. Suppose we have:
> 
>> module A where
>> data Foo
>> type Magic           -- invented syntax:
>>  | Show Foo  = Int
>>  | otherwise = Bool
> 
>> module B where
>> import A
>> instance Show Foo
>> bar :: Magic
>> bar = 3
> 
>> module C where
>> import A
>> quux :: Magic -- no (Show Foo) here!
>> quux = False
> 
>> module D where
>> import B
>> import C
>> hasSameType :: a -> a -> ()
>> hasSameType _ _ = ()
>> unit :: ()
>> unit = hasSameType bar quux
> 
> Does that last line of D type-check? `bar` and `quux` are both declared to have the same type. But, of course, they don't have the same type! Yuck. Thus, `Magic` cannot exist.
> 
> In my own work, I've often wanted something like Magic, but I've learned that whenever I start wanting Magic, what I really want is a very different design.
> 
> If you really, really want Magic and just can't live without it though, you might consider using Template Haskell. TH code can query the database of available instances and branch on the existence of an instance. See `reifyInstances`. TH can't cause the problem I described above, because the equivalent using TH would give `bar` and `quux` different types at compile time, because the TH code is fully evaluated, unlike something like `Magic` which might not be.
> 
> I hope this helps!
> Richard
> 
> On Jan 31, 2014, at 12:56 PM, Hans H?glund <hans at hanshoglund.se> wrote:
> 
>> Dear all,
>> 
>> I have been curious about the ability to detect the presence of a certain instance (ClassFoo TypeBar) in the type system.
>> Specifically, is it possible to "dispatch" a type on the existence (or not) of such an instance. For example given two functions:
>> 
>> withInstance :: (ClassFoo TypeBar) => TypeIfInstanceExists
>> withoutInstance :: TypeIfInstanceDoesNotExists
>> 
>> I would be able to consolidate them into something like this:
>> 
>> withOrWithoutInstance :: 
>>   (r ~ InstanceExists ClassFoo TypeBar, 
>>    a ~ If r TypeIfInstanceExists TypeIfInstanceDoesNotExists) => a
>> 
>> I guess what I need is:
>> 
>> 1) A type-level "if".
>> 2) The possibility of "converting" a constraint into a type-level bool.
>> 
>> I am sure (1) is possible but have no idea about (2). Anyone?
>> 
>> Best regards,
>> Hans
>> _______________________________________________
>> Haskell-Cafe mailing list
>> Haskell-Cafe at haskell.org
>> http://www.haskell.org/mailman/listinfo/haskell-cafe
> 


From rob at mars.org  Mon Feb  3 10:50:39 2014
From: rob at mars.org (Rob Leslie)
Date: Mon, 3 Feb 2014 02:50:39 -0800
Subject: [Haskell-cafe] STM and unsafePerformIO/bracket
Message-ID: <C7C695A2-437A-4B95-82FB-2A3C2AA10437@mars.org>

I?ve run into a difficulty I?d appreciate some advice to solve.

I am trying to make a call to C (through the FFI) within an STM transaction to compute what is effectively a pure result. By itself this doesn?t seem to be a problem, except that the C function depends on some global state in a way that compromises thread safety, and so I would like to serialize the process of setting up that state and calling the FFI.

I have tried wrapping my call up with:

>  unsafePerformIO $ bracket (takeMVar lock) (putMVar lock) $ \_ -> do
>    setupFFIGlobalState
>    callFFI

This seems to work as intended, with one significant exception. If the surrounding STM transaction is aborted (i.e. because of a TVar conflict detected by another thread) while inside the bracket, then apparently the second argument to ?bracket? may never be evaluated, leaving my ?lock? mutex forever empty, and eventually causing deadlock.

Here is a working example of the problem:

  http://lpaste.net/99399

When I run that, I get:

  taking lock...
  lock acquired
  taking lock...
  stm-test: thread blocked indefinitely in an MVar operation

Is this expected behavior? I realize performing any IO within an STM transaction is inherently unsafe, but I am a little surprised that ?bracket? fails here.

Is there a better way to do what I?m trying to accomplish? How can I provide a pure interface to my foreign function that will work within an STM transaction?

Thanks,

-- 
Rob Leslie
rob at mars.org



From johnw at fpcomplete.com  Mon Feb  3 11:17:04 2014
From: johnw at fpcomplete.com (John Wiegley)
Date: Mon, 03 Feb 2014 05:17:04 -0600
Subject: [Haskell-cafe] STM and unsafePerformIO/bracket
In-Reply-To: <C7C695A2-437A-4B95-82FB-2A3C2AA10437@mars.org> (Rob Leslie's
 message of "Mon, 3 Feb 2014 02:50:39 -0800")
References: <C7C695A2-437A-4B95-82FB-2A3C2AA10437@mars.org>
Message-ID: <m2ioswbg3z.fsf@newartisans.com>

>>>>> Rob Leslie <rob at mars.org> writes:

> Is this expected behavior? I realize performing any IO within an STM
> transaction is inherently unsafe, but I am a little surprised that ?bracket?
> fails here.
> 
> Is there a better way to do what I?m trying to accomplish? How can I provide
> a pure interface to my foreign function that will work within an STM
> transaction?

If your foreign function "depends on some global state in a way that
compromises thread safety", I would hestitate to simply tell the FFI that it
is pure.

Instead, you can break up your STM transaction into two pieces: A first part
that sets up the transaction and sets a guard variable so other transactions
cannot proceed until the second part is completed, then perform the FFI call,
then the second part of the transaction.  For example:

    atomically $ do
        m <- readTVar mutex
        check (not m)
        writeTVar m True
        ... do whatever STM setup work is needed here ...
    ffiCall
    atomically $ do
        ... do whatever STM cleanup work is needed here ...
        writeTVar m False

This way your ffiCall is conceptually within a larger transactional block.

John

From corentin.dupont at gmail.com  Mon Feb  3 11:44:04 2014
From: corentin.dupont at gmail.com (Corentin Dupont)
Date: Mon, 3 Feb 2014 12:44:04 +0100
Subject: [Haskell-cafe] manage effects in a DSL
In-Reply-To: <CALnXJiqhPoKEpJKszGf4EskbSVU1xh+MX=R2dBU4cGv4o+fxoQ@mail.gmail.com>
References: <20140129033404.76144.qmail@www1.g3.pair.com>
 <CAEyhvmqiJCc8vs-LHpT=CW20yGjhr5G3LMB86c+w38v+e5BELw@mail.gmail.com>
 <CAEyhvmrti3-4B0KvtdQKZPTh8foX=yg__W3AATjunRLAvaF6CA@mail.gmail.com>
 <CAEyhvmow1XbdLJv00iDVA4uBWEXmMGeLsVg1g6jpUCt2=d8CPQ@mail.gmail.com>
 <CALnXJiqhPoKEpJKszGf4EskbSVU1xh+MX=R2dBU4cGv4o+fxoQ@mail.gmail.com>
Message-ID: <CAEyhvmr=s7xTk7DS3RgKzcJgCZf4u7OEiw7eCKsQ3AuDrYUwUw@mail.gmail.com>

I saw that to write liftQD you decontruct (unwrap) the type and reconstruct
it.
I don't know if I can do that for my Exp (which is a full DSL)...

Anyway, there should be a way to encode the Effect/NoEffect semantic at
type level...
Using Oleg's parametrized monad idea (
http://hackage.haskell.org/package/monad-param-0.0.2/docs/Control-Monad-Parameterized.html),
I tried:

> {-# LANGUAGE KindSignatures, DataKinds, ScopedTypeVariables, GADTs
>   MultiParamTypeClasses, FunctionalDependencies, FlexibleInstances,
UndecidableInstances #-}

> module DSLEffects where
> import Prelude hiding (return, (>>), (>>=))
> import Control.Monad.Parameterized

This data type will be promoted to kind level (thanks to DataKinds):

> data Eff = Effect | NoEffect

This class allows to specify the semantic on Effects (Effect + NoEffect =
Effect):

> class Effects (m :: Eff) (n::Eff) (r::Eff) | m n -> r
> instance Effects Effect n Effect
> instance Effects NoEffect n n

This is the DSL:

> data Exp :: Eff -> * -> * where
>   ReadAccount  :: Exp NoEffect Int      --ReadAccount has no effect
>   WriteAccount :: Int -> Exp Effect ()  --WriteAccount has effect
>   Const        :: a -> Exp r a
>   Bind         :: Effects m n r => Exp m a -> (a -> Exp n b) -> Exp r b
--Bind comes with a semantic on effects
>   Fmap         :: (a -> b) -> Exp m a -> Exp m b

> instance Functor (Exp r) where
>   fmap = Fmap

> instance Return (Exp r) where
>    returnM = Const

> instance (Effects m n r) => Bind (Exp m) (Exp n) (Exp r) where
>    (>>=) = Bind

> noEff :: Exp NoEffect ()
> noEff = returnM ()

> hasEffect :: Exp Effect ()
> hasEffect = ReadAccount >> (returnM () :: Exp Effect ())

This is working more or less, however I am obliged to put the type
signature on the returnM (last line): why?
Furthermore, I cannot write directly:

> hasEffect :: Exp Effect ()
> hasEffect = ReadAccount


Do you have a better idea?



On Sun, Feb 2, 2014 at 8:55 PM, Lindsey Kuper <lindsey at composition.al>wrote:

> On Sun, Feb 2, 2014 at 2:42 PM, Corentin Dupont
> <corentin.dupont at gmail.com> wrote:
> > you should be able to run an effectless monad in an effectful one.
> > How to encode this semantic?
>
> In LVish we just have a `liftQD` operation that will let you lift a
> deterministic computation to a quasi-deterministic one (recall that
> deterministic computations can perform fewer effects):
>
>   liftQD :: Par Det s a -> Par QuasiDet s a
>
> So, analogously, you could have a `liftEff` and then write `liftEff
> noEff`.  This is also a little bit ugly, but you may find you don't
> have to do it very often (we rarely use `liftQD`).
>
> Lindsey
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140203/13ec7534/attachment.html>

From fryguybob at gmail.com  Mon Feb  3 14:59:58 2014
From: fryguybob at gmail.com (Ryan Yates)
Date: Mon, 3 Feb 2014 09:59:58 -0500
Subject: [Haskell-cafe] STM and unsafePerformIO/bracket
In-Reply-To: <m2ioswbg3z.fsf@newartisans.com>
References: <C7C695A2-437A-4B95-82FB-2A3C2AA10437@mars.org>
 <m2ioswbg3z.fsf@newartisans.com>
Message-ID: <CAO27hRpNa+D3xH1ctxrvYemGL9gZEDPhzH+xC6Lb54qvG99Aiw@mail.gmail.com>

John's approach is the right one, but note that the "STM setup work" will
be visible to other transactions.  Any work done there must be considered
consistent as it will be committed.  For instance if we have the following:

    atomically $ do
        m <- readTVar mutex
        check (not m)
        writeTVar m True
        writeTVar a True
    ffiCall
    atomically $ do
        writeTVar b True
        writeTVar m False

If it should be the case that `a` is true only if `b` is true then we could
run into problems with some other transaction that is not concerned with
the `ffiCall` but is concerned about `a` and `b`.

Another approach that might be viable is to just fix your foreign call's
interface by putting a lock in the foreign code.  If it really is a pure
call, then there is no danger of deadlocking there.  This will then be as
safe as any foreign call inside STM.  There are dangers here of course.
 One particular danger is if your call takes multiple arguments that need
to be consistent, you can see inconsistency inside a failed transaction
before the runtime system has determined that it is a failed transaction.
 For instance:

    atomically $ do
        x <- readTVar a
        y <- readTVar b
        return $ unsafePerformIO $ ffiCall x y

Say `x` is an array and `y` is an index into that array.  Even if your
transactions keep these consistent, you could send inconsistent data to the
foreign call.  You can fix this by checking (at the value level)
the integrity of the data or changing the granularity of the data and
putting values `x` and `y` into the same `TVar`.

Beyond this problem I don't know what other issues foreign calls inside STM
face, but I would love to hear what others know.

Ryan



On Mon, Feb 3, 2014 at 6:17 AM, John Wiegley <johnw at fpcomplete.com> wrote:

> >>>>> Rob Leslie <rob at mars.org> writes:
>
> > Is this expected behavior? I realize performing any IO within an STM
> > transaction is inherently unsafe, but I am a little surprised that
> 'bracket'
> > fails here.
> >
> > Is there a better way to do what I'm trying to accomplish? How can I
> provide
> > a pure interface to my foreign function that will work within an STM
> > transaction?
>
> If your foreign function "depends on some global state in a way that
> compromises thread safety", I would hestitate to simply tell the FFI that
> it
> is pure.
>
> Instead, you can break up your STM transaction into two pieces: A first
> part
> that sets up the transaction and sets a guard variable so other
> transactions
> cannot proceed until the second part is completed, then perform the FFI
> call,
> then the second part of the transaction.  For example:
>
>     atomically $ do
>         m <- readTVar mutex
>         check (not m)
>         writeTVar m True
>         ... do whatever STM setup work is needed here ...
>     ffiCall
>     atomically $ do
>         ... do whatever STM cleanup work is needed here ...
>         writeTVar m False
>
> This way your ffiCall is conceptually within a larger transactional block.
>
> John
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140203/a49fbcf7/attachment.html>

From allbery.b at gmail.com  Mon Feb  3 15:15:56 2014
From: allbery.b at gmail.com (Brandon Allbery)
Date: Mon, 3 Feb 2014 10:15:56 -0500
Subject: [Haskell-cafe] STM and unsafePerformIO/bracket
In-Reply-To: <C7C695A2-437A-4B95-82FB-2A3C2AA10437@mars.org>
References: <C7C695A2-437A-4B95-82FB-2A3C2AA10437@mars.org>
Message-ID: <CAKFCL4Xw5kQdhRf0p830E1D-jbrAkOoDWcJ5q8oEWET-tcGt7w@mail.gmail.com>

On Mon, Feb 3, 2014 at 5:50 AM, Rob Leslie <rob at mars.org> wrote:

> I?ve run into a difficulty I?d appreciate some advice to solve.
>
> I am trying to make a call to C (through the FFI) within an STM
> transaction to compute what is effectively a pure result. By itself this
> doesn?t seem to be a problem, except that the C function depends on some
> global state in a way that compromises thread safety, and so I would like
> to


This does not sound particularly pure to me, from a Haskell standpoint.

>  unsafePerformIO $ bracket (takeMVar lock) (putMVar lock) $ \_ -> do
>

And this looks to me like completely undefined behavior. I suspect bracket
*can't* work in unsafePerformIO.

-- 
brandon s allbery kf8nh                               sine nomine associates
allbery.b at gmail.com                                  ballbery at sinenomine.net
unix, openafs, kerberos, infrastructure, xmonad        http://sinenomine.net
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140203/71f404db/attachment.html>

From allbery.b at gmail.com  Mon Feb  3 15:23:56 2014
From: allbery.b at gmail.com (Brandon Allbery)
Date: Mon, 3 Feb 2014 10:23:56 -0500
Subject: [Haskell-cafe] A new yaml module
In-Reply-To: <CAKA2JgJOV-jZhOL7FN0W21JVyumSfByWX2D2C+z7=syayx2u+g@mail.gmail.com>
References: <CAKA2JgJOV-jZhOL7FN0W21JVyumSfByWX2D2C+z7=syayx2u+g@mail.gmail.com>
Message-ID: <CAKFCL4WgAOoeFqJkU74hdKgJhrpnU5Qb7uUXVxrfWpFzC0JmzA@mail.gmail.com>

On Mon, Feb 3, 2014 at 3:57 AM, Michael Snoyman <michael at snoyman.com> wrote:

> * There are problems with roundtripping, since YAML allows for ambiguity
> about the data type of values[2]. For example, in the yaml snippet `foo:
> 1234`, is 1234 intended to be numeric or a string? Either is valid.
>

YAML is a pretty accurate representation of Perl values, so this is
inevitable. I'm left wondering if YAML is even appropriate for Haskell....

-- 
brandon s allbery kf8nh                               sine nomine associates
allbery.b at gmail.com                                  ballbery at sinenomine.net
unix, openafs, kerberos, infrastructure, xmonad        http://sinenomine.net
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140203/76c7d81d/attachment.html>

From mail at joachim-breitner.de  Mon Feb  3 15:40:06 2014
From: mail at joachim-breitner.de (Joachim Breitner)
Date: Mon, 03 Feb 2014 15:40:06 +0000
Subject: [Haskell-cafe] A new yaml module
In-Reply-To: <CAKFCL4WgAOoeFqJkU74hdKgJhrpnU5Qb7uUXVxrfWpFzC0JmzA@mail.gmail.com>
References: <CAKA2JgJOV-jZhOL7FN0W21JVyumSfByWX2D2C+z7=syayx2u+g@mail.gmail.com>
 <CAKFCL4WgAOoeFqJkU74hdKgJhrpnU5Qb7uUXVxrfWpFzC0JmzA@mail.gmail.com>
Message-ID: <1391442006.3196.15.camel@kirk>

Hi,

Am Montag, den 03.02.2014, 10:23 -0500 schrieb Brandon Allbery:
> On Mon, Feb 3, 2014 at 3:57 AM, Michael Snoyman <michael at snoyman.com>
> wrote:
>         * There are problems with roundtripping, since YAML allows for
>         ambiguity about the data type of values[2]. For example, in
>         the yaml snippet `foo: 1234`, is 1234 intended to be numeric
>         or a string? Either is valid.
>         
> 
> 
> YAML is a pretty accurate representation of Perl values, so this is
> inevitable. I'm left wondering if YAML is even appropriate for
> Haskell....

I?m left wondering if ?is ... even appropriate for Haskell? is even
appropriate. If the task to be solved is ?Generate data in this
particular format?, and picking the format is not part of the task, then
we still want the language of our choice to be appropriate, don?t we?

YAML may be an inappropriate choice of serialisation format if we are
free to chose and there is only Haskell code involved.

Greetings,
Joachim


-- 
Joachim ?nomeata? Breitner
  mail at joachim-breitner.de ? http://www.joachim-breitner.de/
  Jabber: nomeata at joachim-breitner.de  ? GPG-Key: 0x4743206C
  Debian Developer: nomeata at debian.org
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 181 bytes
Desc: This is a digitally signed message part
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140203/84ec0b06/attachment.sig>

From vogt.adam at gmail.com  Mon Feb  3 17:47:53 2014
From: vogt.adam at gmail.com (adam vogt)
Date: Mon, 3 Feb 2014 12:47:53 -0500
Subject: [Haskell-cafe] manage effects in a DSL
In-Reply-To: <CAEyhvmr=s7xTk7DS3RgKzcJgCZf4u7OEiw7eCKsQ3AuDrYUwUw@mail.gmail.com>
References: <20140129033404.76144.qmail@www1.g3.pair.com>
 <CAEyhvmqiJCc8vs-LHpT=CW20yGjhr5G3LMB86c+w38v+e5BELw@mail.gmail.com>
 <CAEyhvmrti3-4B0KvtdQKZPTh8foX=yg__W3AATjunRLAvaF6CA@mail.gmail.com>
 <CAEyhvmow1XbdLJv00iDVA4uBWEXmMGeLsVg1g6jpUCt2=d8CPQ@mail.gmail.com>
 <CALnXJiqhPoKEpJKszGf4EskbSVU1xh+MX=R2dBU4cGv4o+fxoQ@mail.gmail.com>
 <CAEyhvmr=s7xTk7DS3RgKzcJgCZf4u7OEiw7eCKsQ3AuDrYUwUw@mail.gmail.com>
Message-ID: <CAHfjoWmj6Y=gqP4A81HLSb_Wf-tX85__N+TDo-NeVt91Rr=7VQ@mail.gmail.com>

Hi Corentin,

Oleg's January 31 message has: `ReadAccount  :: Exp r Int'. If you use that
version you can define that last `hasEffect :: Exp Effect ()'. Then bind
can just be:

Bind :: Exp m a -> (a -> Exp m b) -> Exp m b

And the `m' from a non-effectful thing (ReadAccount) will be set to Effect
when you bind it with an effectful computation. You can still have
operations that take arguments like `Exp NoEffect a', which will give you a
type error when you pass in a an argument tagged with Effect.

Adam


On Mon, Feb 3, 2014 at 6:44 AM, Corentin Dupont
<corentin.dupont at gmail.com>wrote:

> I saw that to write liftQD you decontruct (unwrap) the type and
> reconstruct it.
> I don't know if I can do that for my Exp (which is a full DSL)...
>
> Anyway, there should be a way to encode the Effect/NoEffect semantic at
> type level...
> Using Oleg's parametrized monad idea (
> http://hackage.haskell.org/package/monad-param-0.0.2/docs/Control-Monad-Parameterized.html),
> I tried:
>
> > {-# LANGUAGE KindSignatures, DataKinds, ScopedTypeVariables, GADTs
> >   MultiParamTypeClasses, FunctionalDependencies, FlexibleInstances,
> UndecidableInstances #-}
>
> > module DSLEffects where
> > import Prelude hiding (return, (>>), (>>=))
> > import Control.Monad.Parameterized
>
> This data type will be promoted to kind level (thanks to DataKinds):
>
>
> > data Eff = Effect | NoEffect
>
> This class allows to specify the semantic on Effects (Effect + NoEffect =
> Effect):
>
> > class Effects (m :: Eff) (n::Eff) (r::Eff) | m n -> r
> > instance Effects Effect n Effect
> > instance Effects NoEffect n n
>
> This is the DSL:
>
> > data Exp :: Eff -> * -> * where
> >   ReadAccount  :: Exp NoEffect Int      --ReadAccount has no effect
> >   WriteAccount :: Int -> Exp Effect ()  --WriteAccount has effect
> >   Const        :: a -> Exp r a
> >   Bind         :: Effects m n r => Exp m a -> (a -> Exp n b) -> Exp r b
> --Bind comes with a semantic on effects
> >   Fmap         :: (a -> b) -> Exp m a -> Exp m b
>
> > instance Functor (Exp r) where
> >   fmap = Fmap
>
> > instance Return (Exp r) where
> >    returnM = Const
>
> > instance (Effects m n r) => Bind (Exp m) (Exp n) (Exp r) where
> >    (>>=) = Bind
>
> > noEff :: Exp NoEffect ()
> > noEff = returnM ()
>
> > hasEffect :: Exp Effect ()
> > hasEffect = ReadAccount >> (returnM () :: Exp Effect ())
>
> This is working more or less, however I am obliged to put the type
> signature on the returnM (last line): why?
> Furthermore, I cannot write directly:
>
> > hasEffect :: Exp Effect ()
> > hasEffect = ReadAccount
>
>
> Do you have a better idea?
>
>
>
> On Sun, Feb 2, 2014 at 8:55 PM, Lindsey Kuper <lindsey at composition.al>wrote:
>
>> On Sun, Feb 2, 2014 at 2:42 PM, Corentin Dupont
>> <corentin.dupont at gmail.com> wrote:
>> > you should be able to run an effectless monad in an effectful one.
>> > How to encode this semantic?
>>
>> In LVish we just have a `liftQD` operation that will let you lift a
>> deterministic computation to a quasi-deterministic one (recall that
>> deterministic computations can perform fewer effects):
>>
>>   liftQD :: Par Det s a -> Par QuasiDet s a
>>
>> So, analogously, you could have a `liftEff` and then write `liftEff
>> noEff`.  This is also a little bit ugly, but you may find you don't
>> have to do it very often (we rarely use `liftQD`).
>>
>> Lindsey
>>
>
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140203/2697d720/attachment.html>

From corentin.dupont at gmail.com  Mon Feb  3 18:08:25 2014
From: corentin.dupont at gmail.com (Corentin Dupont)
Date: Mon, 3 Feb 2014 19:08:25 +0100
Subject: [Haskell-cafe] manage effects in a DSL
In-Reply-To: <CAHfjoWmj6Y=gqP4A81HLSb_Wf-tX85__N+TDo-NeVt91Rr=7VQ@mail.gmail.com>
References: <20140129033404.76144.qmail@www1.g3.pair.com>
 <CAEyhvmqiJCc8vs-LHpT=CW20yGjhr5G3LMB86c+w38v+e5BELw@mail.gmail.com>
 <CAEyhvmrti3-4B0KvtdQKZPTh8foX=yg__W3AATjunRLAvaF6CA@mail.gmail.com>
 <CAEyhvmow1XbdLJv00iDVA4uBWEXmMGeLsVg1g6jpUCt2=d8CPQ@mail.gmail.com>
 <CALnXJiqhPoKEpJKszGf4EskbSVU1xh+MX=R2dBU4cGv4o+fxoQ@mail.gmail.com>
 <CAEyhvmr=s7xTk7DS3RgKzcJgCZf4u7OEiw7eCKsQ3AuDrYUwUw@mail.gmail.com>
 <CAHfjoWmj6Y=gqP4A81HLSb_Wf-tX85__N+TDo-NeVt91Rr=7VQ@mail.gmail.com>
Message-ID: <CAEyhvmq-09bZrU6e+2vVUEPE9oVxEqR2gEWM=fupGxm=Au7Yjw@mail.gmail.com>

Hi Adam,
yes, on second thought, that's really the simpler.
I was just disappointed that the type signature of "ReadAccount", an
operation with no effect, would not be "Exp NoEffect ()".
:)


On Mon, Feb 3, 2014 at 6:47 PM, adam vogt <vogt.adam at gmail.com> wrote:

> Hi Corentin,
>
> Oleg's January 31 message has: `ReadAccount  :: Exp r Int'. If you use
> that version you can define that last `hasEffect :: Exp Effect ()'. Then
> bind can just be:
>
> Bind :: Exp m a -> (a -> Exp m b) -> Exp m b
>
> And the `m' from a non-effectful thing (ReadAccount) will be set to Effect
> when you bind it with an effectful computation. You can still have
> operations that take arguments like `Exp NoEffect a', which will give you a
> type error when you pass in a an argument tagged with Effect.
>
> Adam
>
>
> On Mon, Feb 3, 2014 at 6:44 AM, Corentin Dupont <corentin.dupont at gmail.com
> > wrote:
>
>> I saw that to write liftQD you decontruct (unwrap) the type and
>> reconstruct it.
>> I don't know if I can do that for my Exp (which is a full DSL)...
>>
>> Anyway, there should be a way to encode the Effect/NoEffect semantic at
>> type level...
>> Using Oleg's parametrized monad idea (
>> http://hackage.haskell.org/package/monad-param-0.0.2/docs/Control-Monad-Parameterized.html),
>> I tried:
>>
>> > {-# LANGUAGE KindSignatures, DataKinds, ScopedTypeVariables, GADTs
>> >   MultiParamTypeClasses, FunctionalDependencies, FlexibleInstances,
>> UndecidableInstances #-}
>>
>> > module DSLEffects where
>> > import Prelude hiding (return, (>>), (>>=))
>> > import Control.Monad.Parameterized
>>
>> This data type will be promoted to kind level (thanks to DataKinds):
>>
>>
>> > data Eff = Effect | NoEffect
>>
>> This class allows to specify the semantic on Effects (Effect + NoEffect =
>> Effect):
>>
>> > class Effects (m :: Eff) (n::Eff) (r::Eff) | m n -> r
>> > instance Effects Effect n Effect
>> > instance Effects NoEffect n n
>>
>> This is the DSL:
>>
>> > data Exp :: Eff -> * -> * where
>> >   ReadAccount  :: Exp NoEffect Int      --ReadAccount has no effect
>> >   WriteAccount :: Int -> Exp Effect ()  --WriteAccount has effect
>> >   Const        :: a -> Exp r a
>> >   Bind         :: Effects m n r => Exp m a -> (a -> Exp n b) -> Exp r b
>> --Bind comes with a semantic on effects
>> >   Fmap         :: (a -> b) -> Exp m a -> Exp m b
>>
>> > instance Functor (Exp r) where
>> >   fmap = Fmap
>>
>> > instance Return (Exp r) where
>> >    returnM = Const
>>
>> > instance (Effects m n r) => Bind (Exp m) (Exp n) (Exp r) where
>> >    (>>=) = Bind
>>
>> > noEff :: Exp NoEffect ()
>> > noEff = returnM ()
>>
>> > hasEffect :: Exp Effect ()
>> > hasEffect = ReadAccount >> (returnM () :: Exp Effect ())
>>
>> This is working more or less, however I am obliged to put the type
>> signature on the returnM (last line): why?
>> Furthermore, I cannot write directly:
>>
>> > hasEffect :: Exp Effect ()
>> > hasEffect = ReadAccount
>>
>>
>> Do you have a better idea?
>>
>>
>>
>> On Sun, Feb 2, 2014 at 8:55 PM, Lindsey Kuper <lindsey at composition.al>wrote:
>>
>>> On Sun, Feb 2, 2014 at 2:42 PM, Corentin Dupont
>>> <corentin.dupont at gmail.com> wrote:
>>> > you should be able to run an effectless monad in an effectful one.
>>> > How to encode this semantic?
>>>
>>> In LVish we just have a `liftQD` operation that will let you lift a
>>> deterministic computation to a quasi-deterministic one (recall that
>>> deterministic computations can perform fewer effects):
>>>
>>>   liftQD :: Par Det s a -> Par QuasiDet s a
>>>
>>> So, analogously, you could have a `liftEff` and then write `liftEff
>>> noEff`.  This is also a little bit ugly, but you may find you don't
>>> have to do it very often (we rarely use `liftQD`).
>>>
>>> Lindsey
>>>
>>
>>
>> _______________________________________________
>> Haskell-Cafe mailing list
>> Haskell-Cafe at haskell.org
>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>
>>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140203/7546f146/attachment.html>

From chrisyco+haskell-cafe at gmail.com  Mon Feb  3 20:07:07 2014
From: chrisyco+haskell-cafe at gmail.com (Chris Wong)
Date: Tue, 4 Feb 2014 09:07:07 +1300
Subject: [Haskell-cafe] A new yaml module
In-Reply-To: <1391442006.3196.15.camel@kirk>
References: <CAKA2JgJOV-jZhOL7FN0W21JVyumSfByWX2D2C+z7=syayx2u+g@mail.gmail.com>
 <CAKFCL4WgAOoeFqJkU74hdKgJhrpnU5Qb7uUXVxrfWpFzC0JmzA@mail.gmail.com>
 <1391442006.3196.15.camel@kirk>
Message-ID: <CA+qNEzKCTadKKtbUMCnEGUEWDUYPReCyhT3AP1P18YCnBXCZvg@mail.gmail.com>

On Tue, Feb 4, 2014 at 4:40 AM, Joachim Breitner
<mail at joachim-breitner.de> wrote:
> Hi,
>
> Am Montag, den 03.02.2014, 10:23 -0500 schrieb Brandon Allbery:
>> On Mon, Feb 3, 2014 at 3:57 AM, Michael Snoyman <michael at snoyman.com>
>> wrote:
>>         * There are problems with roundtripping, since YAML allows for
>>         ambiguity about the data type of values[2]. For example, in
>>         the yaml snippet `foo: 1234`, is 1234 intended to be numeric
>>         or a string? Either is valid.
>>
>>
>>
>> YAML is a pretty accurate representation of Perl values, so this is
>> inevitable. I'm left wondering if YAML is even appropriate for
>> Haskell....
>
> I?m left wondering if ?is ... even appropriate for Haskell? is even
> appropriate. If the task to be solved is ?Generate data in this
> particular format?, and picking the format is not part of the task, then
> we still want the language of our choice to be appropriate, don?t we?
>
> YAML may be an inappropriate choice of serialisation format if we are
> free to chose and there is only Haskell code involved.

AFAIK, Yesod uses YAML mainly for configuration files. For that use
case, I've found configurator[1] much easier to use.

[1] http://hackage.haskell.org/package/configurator

> Greetings,
> Joachim
>
>
> --
> Joachim ?nomeata? Breitner
>   mail at joachim-breitner.de ? http://www.joachim-breitner.de/
>   Jabber: nomeata at joachim-breitner.de  ? GPG-Key: 0x4743206C
>   Debian Developer: nomeata at debian.org
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>



-- 
Chris Wong, fixpoint conjurer
  e: lambda.fairy at gmail.com
  w: http://lfairy.github.io

From petr.mvd at gmail.com  Mon Feb  3 20:21:49 2014
From: petr.mvd at gmail.com (=?ISO-8859-1?Q?Petr_Pudl=E1k?=)
Date: Mon, 3 Feb 2014 21:21:49 +0100
Subject: [Haskell-cafe] Fwd: incorrect MonadPlus law "v >> mzero = mzero"?
In-Reply-To: <CABSda-eZyG5ZfJT7NmRpn8XB26N9tdaHWuCcy10hhWgHWQURGw@mail.gmail.com>
References: <CABSda-eZyG5ZfJT7NmRpn8XB26N9tdaHWuCcy10hhWgHWQURGw@mail.gmail.com>
Message-ID: <CABSda-dGrBgjaHb6fhGpLwnD_V=WXnPQ=unAn+dRiiDUFvGKOw@mail.gmail.com>

Since nobody replied so far, I'm also forwarding to cafe.
Petr

---------- Forwarded message ----------
From: Petr Pudl?k <petr.mvd at gmail.com>
Date: 2014-01-29
Subject: incorrect MonadPlus law "v >> mzero = mzero"?
To: "libraries at haskell.org" <libraries at haskell.org>


Hi,

this law apparently fails for a MonadPlus instance that has more than one
possible failure value. Consider:

   runIdentity . runErrorT $
    ((ErrorT . Identity $ Left "failure") >> mzero :: ErrorT String
Identity ())

evaluates to `Left "failure"`, which isn't equal to ErrorT's mzero `Left
""`.

This isn't just the case of ErrorT, it fails for any MonadPlus with
multiple failure values. For example

  lift (tell "foo") >> mzero :: MaybeT (Writer String) ()

is again distinct from mzero.

Actually, no monad transformer with a MonadPlus instance can satisfy the
law, because the first part in front of `>> mzero` can introduce side
effects in the underlying monad.

I'm not sure what should be the proper solution. Perhaps to change the laws
to:

  return x >> mzero  =  mzero
  (v >> mzero) >>= f  =  (v >> mzero)`

That is, if an expression ends with `mzero`, it behaves like `mzero`.

  Petr
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140203/dd4847bd/attachment.html>

From Charles at CharlesWeitzer.com  Mon Feb  3 21:19:12 2014
From: Charles at CharlesWeitzer.com (Charles Weitzer)
Date: Mon, 3 Feb 2014 13:19:12 -0800
Subject: [Haskell-cafe] CTO Opportunity
Message-ID: <006901cf2125$96181160$c2483420$@CharlesWeitzer.com>

My name is Charles Weitzer.  I do recruiting for major quantitative hedge
funds worldwide. I have a client, a startup quantitative hedge fund located
in Northern California, that would like to hire a Chief Technology Officer
as soon as possible. Their job description can be found below. 

* Chief Technology Officer

Fast-growing science and technology driven company seeks a Chief Technology
Officer.  We apply statistical machine learning to develop automated trading
systems. We are a growing group of exceptional software and infrastructure
professionals and seek an experienced candidate to lead and grow the team.
The CTO will manage the implementation of our next generation
infrastructure, including production trading systems, software
infrastructure for our research department, and our compute and storage
hardware systems.  The CTO will work directly with the Head of Research and
the CEO to set the technical direction of the company.  A strong candidate
will be well-versed in state-of-the-art technology (particularly distributed
systems and cluster computing), and will have a track record of building and
leading elite technical teams and successfully delivering complex projects
(especially in a startup environment).  A background in finance is not
required.

We are a science-driven systematic trading firm, built on the principle that
statistical machine learning provides the best solutions to the scientific
problems we must solve. Our CEO is a CS PhD and founded a successful
Internet startup, and our Head of Research/Chief Investment Officer is a
Berkeley statistics professor; both have a background in finance.  Our
trading is entirely automated and based on cutting-edge machine learning
techniques. We have a collegial, academic working environment, rely on open
source software, and have built our own software stack.  We have a track
record of strong performance and have been raising money and growing fast.
Willingness to take initiative, and a gritty determination to productize,
are essential.  

Benefits and compensation are highly competitive.


I look forward to speaking with you and anyone you might highly recommend
about this opportunity.  

Thank you,

Charles Weitzer

CEO/Senior Recruiter
Charles Weitzer and Associates, Inc.
Global Financial Recruiting Services
Charles at CharlesWeitzer.com
Voice: USA (510) 558-9182


From danburton.email at gmail.com  Mon Feb  3 22:51:04 2014
From: danburton.email at gmail.com (Dan Burton)
Date: Mon, 3 Feb 2014 14:51:04 -0800
Subject: [Haskell-cafe] Fwd: incorrect MonadPlus law "v >> mzero =
	mzero"?
In-Reply-To: <CABSda-dGrBgjaHb6fhGpLwnD_V=WXnPQ=unAn+dRiiDUFvGKOw@mail.gmail.com>
References: <CABSda-eZyG5ZfJT7NmRpn8XB26N9tdaHWuCcy10hhWgHWQURGw@mail.gmail.com>
 <CABSda-dGrBgjaHb6fhGpLwnD_V=WXnPQ=unAn+dRiiDUFvGKOw@mail.gmail.com>
Message-ID: <CALSygwcZodCR7ht1QPFZNGBt8YXq1C07v2bO29qZkCHEsWQSWA@mail.gmail.com>

Indeed this issue is not limited merely to multiple failure values.

    >>> runMaybeT $ lift (putStrLn "effect") >> mzero
    effect
    >>> runMaybeT mzero


So you're right. This law is being violated

-- Dan Burton


On Mon, Feb 3, 2014 at 12:21 PM, Petr Pudl?k <petr.mvd at gmail.com> wrote:

> Since nobody replied so far, I'm also forwarding to cafe.
> Petr
>
>
> ---------- Forwarded message ----------
> From: Petr Pudl?k <petr.mvd at gmail.com>
> Date: 2014-01-29
> Subject: incorrect MonadPlus law "v >> mzero = mzero"?
> To: "libraries at haskell.org" <libraries at haskell.org>
>
>
> Hi,
>
> this law apparently fails for a MonadPlus instance that has more than one
> possible failure value. Consider:
>
>    runIdentity . runErrorT $
>     ((ErrorT . Identity $ Left "failure") >> mzero :: ErrorT String
> Identity ())
>
> evaluates to `Left "failure"`, which isn't equal to ErrorT's mzero `Left
> ""`.
>
> This isn't just the case of ErrorT, it fails for any MonadPlus with
> multiple failure values. For example
>
>   lift (tell "foo") >> mzero :: MaybeT (Writer String) ()
>
> is again distinct from mzero.
>
> Actually, no monad transformer with a MonadPlus instance can satisfy the
> law, because the first part in front of `>> mzero` can introduce side
> effects in the underlying monad.
>
> I'm not sure what should be the proper solution. Perhaps to change the
> laws to:
>
>   return x >> mzero  =  mzero
>   (v >> mzero) >>= f  =  (v >> mzero)`
>
> That is, if an expression ends with `mzero`, it behaves like `mzero`.
>
>   Petr
>
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140203/8f43a742/attachment.html>

From allbery.b at gmail.com  Mon Feb  3 23:00:36 2014
From: allbery.b at gmail.com (Brandon Allbery)
Date: Mon, 3 Feb 2014 18:00:36 -0500
Subject: [Haskell-cafe] Fwd: incorrect MonadPlus law "v >> mzero =
	mzero"?
In-Reply-To: <CALSygwcZodCR7ht1QPFZNGBt8YXq1C07v2bO29qZkCHEsWQSWA@mail.gmail.com>
References: <CABSda-eZyG5ZfJT7NmRpn8XB26N9tdaHWuCcy10hhWgHWQURGw@mail.gmail.com>
 <CABSda-dGrBgjaHb6fhGpLwnD_V=WXnPQ=unAn+dRiiDUFvGKOw@mail.gmail.com>
 <CALSygwcZodCR7ht1QPFZNGBt8YXq1C07v2bO29qZkCHEsWQSWA@mail.gmail.com>
Message-ID: <CAKFCL4VcV=oMHOZMKsPTOkMEiYkWGVxQmLL44Yf9V8Kp3GkEcA@mail.gmail.com>

On Mon, Feb 3, 2014 at 5:51 PM, Dan Burton <danburton.email at gmail.com>wrote:

> Indeed this issue is not limited merely to multiple failure values.
>
>     >>> runMaybeT $ lift (putStrLn "effect") >> mzero
>     effect
>     >>> runMaybeT mzero
>
> So you're right. This law is being violated
>

I thought it was fairly well known that IO violates one of the monad laws,
in a way that would lead to this?

-- 
brandon s allbery kf8nh                               sine nomine associates
allbery.b at gmail.com                                  ballbery at sinenomine.net
unix, openafs, kerberos, infrastructure, xmonad        http://sinenomine.net
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140203/d52b2209/attachment.html>

From danburton.email at gmail.com  Mon Feb  3 23:04:06 2014
From: danburton.email at gmail.com (Dan Burton)
Date: Mon, 3 Feb 2014 15:04:06 -0800
Subject: [Haskell-cafe] Fwd: incorrect MonadPlus law "v >> mzero =
	mzero"?
In-Reply-To: <CALSygwcZodCR7ht1QPFZNGBt8YXq1C07v2bO29qZkCHEsWQSWA@mail.gmail.com>
References: <CABSda-eZyG5ZfJT7NmRpn8XB26N9tdaHWuCcy10hhWgHWQURGw@mail.gmail.com>
 <CABSda-dGrBgjaHb6fhGpLwnD_V=WXnPQ=unAn+dRiiDUFvGKOw@mail.gmail.com>
 <CALSygwcZodCR7ht1QPFZNGBt8YXq1C07v2bO29qZkCHEsWQSWA@mail.gmail.com>
Message-ID: <CALSygwcOmgBq7oKur1SYrXR6Gaiupwr_n0ZZzpg6wbDRxySfLg@mail.gmail.com>

>
> I'm not sure what should be the proper solution. Perhaps to change the
> laws to:
>   return x >> mzero  =  mzero
>   (v >> mzero) >>= f  =  (v >> mzero)`
> That is, if an expression ends with `mzero`, it behaves like `mzero`.


These laws are redundant with existing laws. The first:

    return x >> z = z

Is true forall x and z, and can be proven by just the monad laws. The
second:

    (v >> mzero) >>= f  =  (v >> mzero)

Can be proven by the associativity of monadic operations:

    (v >> mzero) >>= f  =  v >> (mzero >>= f)

And the other MonadPlus law already states that (mzero >>= f) = mzero. So I
don't think any new laws are needed. I just think the (v >> mzero = mzero)
law should be removed, or else a *lot* of instances of MonadPlus need to
come with a disclaimer that they are not law-abiding.

-- Dan Burton
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140203/d0dfdc87/attachment.html>

From jwlato at gmail.com  Mon Feb  3 23:10:47 2014
From: jwlato at gmail.com (John Lato)
Date: Mon, 3 Feb 2014 15:10:47 -0800
Subject: [Haskell-cafe] Fwd: incorrect MonadPlus law "v >> mzero =
	mzero"?
In-Reply-To: <CAKFCL4VcV=oMHOZMKsPTOkMEiYkWGVxQmLL44Yf9V8Kp3GkEcA@mail.gmail.com>
References: <CABSda-eZyG5ZfJT7NmRpn8XB26N9tdaHWuCcy10hhWgHWQURGw@mail.gmail.com>
 <CABSda-dGrBgjaHb6fhGpLwnD_V=WXnPQ=unAn+dRiiDUFvGKOw@mail.gmail.com>
 <CALSygwcZodCR7ht1QPFZNGBt8YXq1C07v2bO29qZkCHEsWQSWA@mail.gmail.com>
 <CAKFCL4VcV=oMHOZMKsPTOkMEiYkWGVxQmLL44Yf9V8Kp3GkEcA@mail.gmail.com>
Message-ID: <CAJ727GgrmfJft2U8Yio9ipEUo9haZkF8YdRucYiS9y3zEhk_ag@mail.gmail.com>

On Mon, Feb 3, 2014 at 3:00 PM, Brandon Allbery <allbery.b at gmail.com> wrote:

> On Mon, Feb 3, 2014 at 5:51 PM, Dan Burton <danburton.email at gmail.com>wrote:
>
>> Indeed this issue is not limited merely to multiple failure values.
>>
>>     >>> runMaybeT $ lift (putStrLn "effect") >> mzero
>>     effect
>>     >>> runMaybeT mzero
>>
>> So you're right. This law is being violated
>>
>
> I thought it was fairly well known that IO violates one of the monad laws,
> in a way that would lead to this?
>

The choice of IO for the underlying monad is irrelevant.  The issue is that
a later mzero in the transformer cannot undo an earlier action in a lower
monad.  For example:

>>> Prelude Control.Monad.Maybe Control.Monad.State> runStateT (runMaybeT $ (lift $ put "bar") >> mzero) "foo"
(Nothing,"bar")
>>> Prelude Control.Monad.Maybe Control.Monad.State> runStateT (runMaybeT mzero) "foo"
(Nothing,"foo")
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140203/58127aec/attachment.html>

From danburton.email at gmail.com  Mon Feb  3 23:21:41 2014
From: danburton.email at gmail.com (Dan Burton)
Date: Mon, 3 Feb 2014 15:21:41 -0800
Subject: [Haskell-cafe] Fwd: incorrect MonadPlus law "v >> mzero =
	mzero"?
In-Reply-To: <CAJ727GgrmfJft2U8Yio9ipEUo9haZkF8YdRucYiS9y3zEhk_ag@mail.gmail.com>
References: <CABSda-eZyG5ZfJT7NmRpn8XB26N9tdaHWuCcy10hhWgHWQURGw@mail.gmail.com>
 <CABSda-dGrBgjaHb6fhGpLwnD_V=WXnPQ=unAn+dRiiDUFvGKOw@mail.gmail.com>
 <CALSygwcZodCR7ht1QPFZNGBt8YXq1C07v2bO29qZkCHEsWQSWA@mail.gmail.com>
 <CAKFCL4VcV=oMHOZMKsPTOkMEiYkWGVxQmLL44Yf9V8Kp3GkEcA@mail.gmail.com>
 <CAJ727GgrmfJft2U8Yio9ipEUo9haZkF8YdRucYiS9y3zEhk_ag@mail.gmail.com>
Message-ID: <CALSygwdUA51WFEmpVKRvnB3=Z29fN2sgUvwoX+-FvP6Da4MAdw@mail.gmail.com>

>
> The issue is that a later mzero in the transformer cannot undo an earlier
> action in a lower monad.


Precisely. Another example, for fun:

>>> print (runMaybeT $ lift [1,2,3] >> mzero :: [Maybe Int])
[Nothing, Nothing, Nothing]

>>> print (runMaybeT mzero :: [Maybe Int])
[Nothing]

Actually, I'd say the problem *isn't *that a transformer "cannot undo
earlier action in a lower monad." I'd just say that most transformers *happen
to be implemented *in this "forgetful" manner. It's conceivable that we
could implement some of them differently, in a way that would obey the
MonadPlus laws. Whether or not obedience to this particular law is
worthwhile... well, that's debatable.

-- Dan Burton
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140203/61cecec9/attachment.html>

From petr.mvd at gmail.com  Tue Feb  4 08:21:25 2014
From: petr.mvd at gmail.com (=?ISO-8859-1?Q?Petr_Pudl=E1k?=)
Date: Tue, 4 Feb 2014 09:21:25 +0100
Subject: [Haskell-cafe] Fwd: incorrect MonadPlus law "v >> mzero =
	mzero"?
In-Reply-To: <CALSygwcOmgBq7oKur1SYrXR6Gaiupwr_n0ZZzpg6wbDRxySfLg@mail.gmail.com>
References: <CABSda-eZyG5ZfJT7NmRpn8XB26N9tdaHWuCcy10hhWgHWQURGw@mail.gmail.com>
 <CABSda-dGrBgjaHb6fhGpLwnD_V=WXnPQ=unAn+dRiiDUFvGKOw@mail.gmail.com>
 <CALSygwcZodCR7ht1QPFZNGBt8YXq1C07v2bO29qZkCHEsWQSWA@mail.gmail.com>
 <CALSygwcOmgBq7oKur1SYrXR6Gaiupwr_n0ZZzpg6wbDRxySfLg@mail.gmail.com>
Message-ID: <CABSda-coY1h42NRfjPwVbfHytB6rmZp5iEErCy9+aSticuS_Ww@mail.gmail.com>

My intention wasn't to add these laws, but to replace the existing
MonadPlus ones. (Adding new laws wouldn't help with the original ones being
invalid.) But you're right, the laws I proposed follow from Monad laws and
from

    mzero >>= f  =  mzero

This single law is enough to ensure that any chain of operations containing
`mzero` "ends" at this point.

So the best solution seems to just remove the problematic

    v >> mzero   =  mzero


2014-02-04 Dan Burton <danburton.email at gmail.com>:

> I'm not sure what should be the proper solution. Perhaps to change the
>> laws to:
>>   return x >> mzero  =  mzero
>>   (v >> mzero) >>= f  =  (v >> mzero)`
>> That is, if an expression ends with `mzero`, it behaves like `mzero`.
>
>
> These laws are redundant with existing laws. The first:
>
>     return x >> z = z
>
> Is true forall x and z, and can be proven by just the monad laws. The
> second:
>
>     (v >> mzero) >>= f  =  (v >> mzero)
>
> Can be proven by the associativity of monadic operations:
>
>     (v >> mzero) >>= f  =  v >> (mzero >>= f)
>
> And the other MonadPlus law already states that (mzero >>= f) = mzero. So
> I don't think any new laws are needed. I just think the (v >> mzero =
> mzero) law should be removed, or else a *lot* of instances of MonadPlus
> need to come with a disclaimer that they are not law-abiding.
>
> -- Dan Burton
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140204/f899b281/attachment-0001.html>

From petr.mvd at gmail.com  Tue Feb  4 08:32:19 2014
From: petr.mvd at gmail.com (=?ISO-8859-1?Q?Petr_Pudl=E1k?=)
Date: Tue, 4 Feb 2014 09:32:19 +0100
Subject: [Haskell-cafe] Fwd: incorrect MonadPlus law "v >> mzero =
	mzero"?
In-Reply-To: <CALSygwdUA51WFEmpVKRvnB3=Z29fN2sgUvwoX+-FvP6Da4MAdw@mail.gmail.com>
References: <CABSda-eZyG5ZfJT7NmRpn8XB26N9tdaHWuCcy10hhWgHWQURGw@mail.gmail.com>
 <CABSda-dGrBgjaHb6fhGpLwnD_V=WXnPQ=unAn+dRiiDUFvGKOw@mail.gmail.com>
 <CALSygwcZodCR7ht1QPFZNGBt8YXq1C07v2bO29qZkCHEsWQSWA@mail.gmail.com>
 <CAKFCL4VcV=oMHOZMKsPTOkMEiYkWGVxQmLL44Yf9V8Kp3GkEcA@mail.gmail.com>
 <CAJ727GgrmfJft2U8Yio9ipEUo9haZkF8YdRucYiS9y3zEhk_ag@mail.gmail.com>
 <CALSygwdUA51WFEmpVKRvnB3=Z29fN2sgUvwoX+-FvP6Da4MAdw@mail.gmail.com>
Message-ID: <CABSda-fCBJ6XNUR61hPJX2=m6c_o_kBChCv9jvUXvD8dMG2Tug@mail.gmail.com>

I would argue that a monad transformer "cannot undo earlier action in a
lower monad." For example, in the case of MaybeT: In order to determine of
an action succeeded or failed, it needs to evaluate in the underlying
monad. But what if the underlying monad doesn't provide any means to
restore its state to some previous point? So I believe having 'v >> mzero =
mzero' for a transformer with MonadPlus would be only possible if the
underlying monad provided some kind of check-pointing.


2014-02-04 Dan Burton <danburton.email at gmail.com>:

> The issue is that a later mzero in the transformer cannot undo an earlier
>> action in a lower monad.
>
>
> Precisely. Another example, for fun:
>
> >>> print (runMaybeT $ lift [1,2,3] >> mzero :: [Maybe Int])
> [Nothing, Nothing, Nothing]
>
> >>> print (runMaybeT mzero :: [Maybe Int])
> [Nothing]
>
> Actually, I'd say the problem *isn't *that a transformer "cannot undo
> earlier action in a lower monad." I'd just say that most transformers *happen
> to be implemented *in this "forgetful" manner. It's conceivable that we
> could implement some of them differently, in a way that would obey the
> MonadPlus laws. Whether or not obedience to this particular law is
> worthwhile... well, that's debatable.
>
> -- Dan Burton
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140204/30fde7b1/attachment.html>

From jan.stolarek at p.lodz.pl  Tue Feb  4 12:21:10 2014
From: jan.stolarek at p.lodz.pl (Jan Stolarek)
Date: Tue, 4 Feb 2014 13:21:10 +0100
Subject: [Haskell-cafe] [ANNOUNCE] tasty-hunit-adapter and tasty-program
Message-ID: <201402041321.10691.jan.stolarek@p.lodz.pl>

Dear Haskellers,

I recently released two small packages that extend functionality of Roman Cheplyaka's tasty 
testing framework:

1. tasty-hunit-adapter allows to import existing HUnit tests into tasty.

Hackage: http://hackage.haskell.org/package/tasty-hunit-adapter
GitHub: https://github.com/jstolarek/tasty-hunit-adapter

2. tasty-program allows to run external program and test whether it terminates successfully.

Hackage: http://hackage.haskell.org/package/tasty-program
GitHub: https://github.com/jstolarek/tasty-program

These packages are inspired by similar packages for test-framework. tasty-program has very basic 
functionality at the moment, most notably it completely ignores stdout and stderr of a program. 
If you want this functionality please say so here: 
https://github.com/jstolarek/tasty-program/issues/1

Jan Stolarek

From haskell-cafe at maartenfaddegon.nl  Tue Feb  4 12:53:55 2014
From: haskell-cafe at maartenfaddegon.nl (Maarten Faddegon)
Date: Tue, 04 Feb 2014 12:53:55 +0000
Subject: [Haskell-cafe] Mixing own and derived instances with Generic
	Deriving Mechanism
In-Reply-To: <CA+ZFbn815RrArk5WX=_UfY5bB9YHU-LqFMRJav4_zB-pFugu9A@mail.gmail.com>
References: <52ECE461.8080303@maartenfaddegon.nl>
 <CA+ZFbn815RrArk5WX=_UfY5bB9YHU-LqFMRJav4_zB-pFugu9A@mail.gmail.com>
Message-ID: <52F0E2E3.2050905@maartenfaddegon.nl>

Thanks! I rewrote my example from gshow into gshowPrec and now it works 
as expected :)

Would it be correct to say that the 'from'-function does a shallow 
convert of my value into the type representation (up to the constant 
representations), and from there we either use an ad-hoc instance of 
gshowPrec, or we do another shallow convert one layer deeper via the 
default gShowPrec?

Cheers,

Maarten

On 02/02/14 16:02, Jos? Pedro Magalh?es wrote:
> Hi Maarten,
>
> The problem here is that your instance of GShow MyFancyType defines 
> gshow, but the
> function that is defined generically is actually gshowsPrec, with the 
> others being given
> defaults. For this to work as you'd expect it to, you have to define 
> gshowsPrec in the
> instance GShow MyFancyType. This is a bit unfortunate, but because 
> gshowsPrec has
> a generic default, it cannot have the usual default (like showsPrec does).
>
>
> Cheers,
> Pedro
>
>
>
> On Sat, Feb 1, 2014 at 12:11 PM, Maarten Faddegon 
> <haskell-cafe at maartenfaddegon.nl 
> <mailto:haskell-cafe at maartenfaddegon.nl>> wrote:
>
>     Dear Pedro, Cafe,
>
>     Thanks again for helping me out last December. I have been
>     playing a bit more with deriving show and now ran into an
>     interesting problem mixing my own instances with derived
>     instances. Hope you can enlighten me there!
>
>     > {-# LANGUAGE DeriveGeneric #-}
>     > module Test where
>     > import GHC.Generics
>     > import Generics.Deriving.Show
>
>     The Generic Deriving Mechanism adds the keyword 'default' to
>     class definitions.  With this keyword we can define a
>     type-generic definition of that method when not given. For
>     example, if we define our own MyData type, we can derive the
>     GShow methods:
>
>     > data MyData = MyData MyFancyType deriving Generic
>     > instance GShow MyData
>
>     We can also still give our own definition, for example if we want
>     values of the MyFancyType to always be shown as the same string:
>
>     > data MyFancyType = MyFancy1 | MyFancy2 deriving Generic
>     > instance GShow MyFancyType where
>     >       gshow _ = "Fancy!"
>
>     There is something strange here though: when we use gshow
>     directly on a MyFancyType value our own instance definition is
>     used, evaluating as expected to "Fancy!".
>
>     > ex1 = gshow MyFancy1
>
>     But as soon as we are inside a derived method, we will continue
>     using derived instances even though we defined our own. The
>     example below evaluates to "MyData MyFancy1", rather than "MyData
>     Fancy!":
>
>     > ex2 = gshow (MyData MyFancy1)
>
>     The default methods of GShow are defined in terms of methods from
>     GShow' which operate on the type-representation. From this
>     representation I do not see a way to recover the information
>     that a type has a GShow instance.  Am I correct (I hope not :) or
>     is there a way out?
>
>     Cheers,
>
>     Maarten Faddegon
>
>

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140204/5b933571/attachment.html>

From benjamin.foppa at gmail.com  Tue Feb  4 13:55:47 2014
From: benjamin.foppa at gmail.com (Ben Foppa)
Date: Tue, 4 Feb 2014 08:55:47 -0500
Subject: [Haskell-cafe] fromString and toString
Message-ID: <CADu1bNR8r1hZ9goukjoi+rjn=eQ6wLNedp1gFhQjPgAo=mbEiQ@mail.gmail.com>

I know we have

class IsString a where
    fromString :: String -> a

But do we have an inverse generic function toString defined anywhere?
IsString implies that the type `a` is a subset of String; if all we have is
fromString, then IsString defines *supersets* of String. To me, the most
logical thing would be that IsString defines bijections to String (i.e.
things that are subsets *and* supersets).

The reason this came up is that I'm getting pretty sick of type-juggling
different string types from different libraries (String, Text, various
ByteStrings), especially since I have to tweak all the functions I use if a
type changes; discovering fromString was fantastic, but without toString, I
can't define something like

reString :: (IsString a, IsString b) => a -> b

which is great to have if your putStrLn only accepts one kind of string,
and you have several distinct ones floating around.

Thanks,
Ben
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140204/6dc00795/attachment.html>

From dima at dzhus.org  Tue Feb  4 14:03:39 2014
From: dima at dzhus.org (Dmitry Dzhus)
Date: Tue, 04 Feb 2014 18:03:39 +0400
Subject: [Haskell-cafe] fromString and toString
In-Reply-To: <CADu1bNR8r1hZ9goukjoi+rjn=eQ6wLNedp1gFhQjPgAo=mbEiQ@mail.gmail.com>
References: <CADu1bNR8r1hZ9goukjoi+rjn=eQ6wLNedp1gFhQjPgAo=mbEiQ@mail.gmail.com>
Message-ID: <62511391522619@web23h.yandex.ru>

04.02.2014, 17:55, "Ben Foppa" <benjamin.foppa at gmail.com>:
> I know we have
>
> class IsString a where
>
> ??? fromString :: String -> a
>
> But do we have an inverse generic function toString defined anywhere? IsString implies that the type `a` is a subset of String; if all we have is fromString, then IsString defines supersets of String. To me, the most logical thing would be that IsString defines bijections to String (i.e. things that are subsets and supersets).

There's more than one way to interpret a ByteString as a String/Text
and vice versa. If reString exists, what would you expect it to do
when called with a ~ ByteString and b ~ Text?

From bertram.felgenhauer at googlemail.com  Tue Feb  4 14:06:11 2014
From: bertram.felgenhauer at googlemail.com (Bertram Felgenhauer)
Date: Tue, 4 Feb 2014 15:06:11 +0100
Subject: [Haskell-cafe] STM and unsafePerformIO/bracket
In-Reply-To: <C7C695A2-437A-4B95-82FB-2A3C2AA10437@mars.org>
References: <C7C695A2-437A-4B95-82FB-2A3C2AA10437@mars.org>
Message-ID: <20140204140611.GA3202@24f89f8c-e6a1-4e75-85ee-bb8a3743bb9f>

Rob Leslie wrote:
> I?ve run into a difficulty I?d appreciate some advice to solve.
[unsafePerformIO and bracket, within an STM transaction]

There's a long-standing bug report for this issue,

  https://ghc.haskell.org/trac/ghc/ticket/2401

So the current situation is that bracket within unsafePerformIO
(and unsafeIOToSTM) and STM transactions don't mix. I'm a bit
surprised that this doesn't bite more people.

Cheers,

Bertram

From marco-oweber at gmx.de  Tue Feb  4 14:11:10 2014
From: marco-oweber at gmx.de (Marc Weber)
Date: Tue, 04 Feb 2014 15:11:10 +0100
Subject: [Haskell-cafe] Big Data & Haskell
Message-ID: <1391522838-sup-5331@nixos>

Is Haskell ready?
Are there library which can

- distribute data on multiple machines (similar to cassandra)

- implement multi index things, such as
  having fields
    - name (eg of stores)
    - geo location (x/y) keys so that you can find items nearby a
      location fast
    - additional data to be searched as needed

Maybe have server which gets "code" sent by a master to be compiled
defining the data to host or such?

I know that this could be done - just wondering whether it has been done
already.

Marc Weber

From waldmann at imn.htwk-leipzig.de  Tue Feb  4 14:13:13 2014
From: waldmann at imn.htwk-leipzig.de (Johannes Waldmann)
Date: Tue, 4 Feb 2014 14:13:13 +0000 (UTC)
Subject: [Haskell-cafe] fromString and toString
References: <CADu1bNR8r1hZ9goukjoi+rjn=eQ6wLNedp1gFhQjPgAo=mbEiQ@mail.gmail.com>
Message-ID: <loom.20140204T150905-533@post.gmane.org>

Ben Foppa <benjamin.foppa <at> gmail.com> writes:

> But do we have an inverse generic function toString defined anywhere? 

well, we have:  class Show a where show :: a -> String

> likereString :: (IsString a, IsString b) => a -> b

well you probably don't want to actually convert from a to String
(= List of Char) then from there to b, 
so it would need to be accompanied by some RULES 
(for specific instances of a, b) for efficiency.

This still does not answer the concern whether it is 
(semantically) wise to have String as the "base" concept here.

- J.W.



From vlatko.basic at gmail.com  Tue Feb  4 14:38:15 2014
From: vlatko.basic at gmail.com (Vlatko Basic)
Date: Tue, 04 Feb 2014 15:38:15 +0100
Subject: [Haskell-cafe] Big Data & Haskell
In-Reply-To: <1391522838-sup-5331@nixos>
References: <1391522838-sup-5331@nixos>
Message-ID: <52F0FB57.7000509@gmail.com>

Hi Marc,

Maybe you can have a look at Riak DB. It is a key/value storage written in 
Erlang with many features. All peers, no master/slave and replication.

Haskell package is at http://hackage.haskell.org/package/riak, but haven't tried 
it yet.


Best regards,

vlatko

-------- Original Message  --------
Subject: [Haskell-cafe] Big Data & Haskell
From: Marc Weber <marco-oweber at gmx.de>
To: haskell-cafe <haskell-cafe at haskell.org>
Date: 04.02.2014 15:11

> Is Haskell ready?
> Are there library which can
>
> - distribute data on multiple machines (similar to cassandra)
>
> - implement multi index things, such as
>    having fields
>      - name (eg of stores)
>      - geo location (x/y) keys so that you can find items nearby a
>        location fast
>      - additional data to be searched as needed
>
> Maybe have server which gets "code" sent by a master to be compiled
> defining the data to host or such?
>
> I know that this could be done - just wondering whether it has been done
> already.
>
> Marc Weber
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>

From jpmoresmau at gmail.com  Tue Feb  4 16:11:04 2014
From: jpmoresmau at gmail.com (JP Moresmau)
Date: Tue, 4 Feb 2014 17:11:04 +0100
Subject: [Haskell-cafe] Big Data & Haskell
In-Reply-To: <52F0FB57.7000509@gmail.com>
References: <1391522838-sup-5331@nixos>
	<52F0FB57.7000509@gmail.com>
Message-ID: <CAAambFSTamrOXm75sorKy_Jcp=ycVgvF-MReODfwowr6-nLXeg@mail.gmail.com>

Have you looked at Cloud Haskell (
http://www.haskell.org/haskellwiki/Cloud_Haskell)?

JP


On Tue, Feb 4, 2014 at 3:38 PM, Vlatko Basic <vlatko.basic at gmail.com> wrote:

> Hi Marc,
>
> Maybe you can have a look at Riak DB. It is a key/value storage written in
> Erlang with many features. All peers, no master/slave and replication.
>
> Haskell package is at http://hackage.haskell.org/package/riak, but
> haven't tried it yet.
>
>
> Best regards,
>
> vlatko
>
>
> -------- Original Message  --------
> Subject: [Haskell-cafe] Big Data & Haskell
> From: Marc Weber <marco-oweber at gmx.de>
> To: haskell-cafe <haskell-cafe at haskell.org>
> Date: 04.02.2014 15:11
>
>  Is Haskell ready?
>> Are there library which can
>>
>> - distribute data on multiple machines (similar to cassandra)
>>
>> - implement multi index things, such as
>>    having fields
>>      - name (eg of stores)
>>      - geo location (x/y) keys so that you can find items nearby a
>>        location fast
>>      - additional data to be searched as needed
>>
>> Maybe have server which gets "code" sent by a master to be compiled
>> defining the data to host or such?
>>
>> I know that this could be done - just wondering whether it has been done
>> already.
>>
>> Marc Weber
>> _______________________________________________
>> Haskell-Cafe mailing list
>> Haskell-Cafe at haskell.org
>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>
>>  _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>



-- 
JP Moresmau
http://jpmoresmau.blogspot.com/
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140204/e7808815/attachment.html>

From jpm at cs.uu.nl  Tue Feb  4 16:32:22 2014
From: jpm at cs.uu.nl (=?ISO-8859-1?Q?Jos=E9_Pedro_Magalh=E3es?=)
Date: Tue, 4 Feb 2014 16:32:22 +0000
Subject: [Haskell-cafe] Mixing own and derived instances with Generic
	Deriving Mechanism
In-Reply-To: <52F0E2E3.2050905@maartenfaddegon.nl>
References: <52ECE461.8080303@maartenfaddegon.nl>
 <CA+ZFbn815RrArk5WX=_UfY5bB9YHU-LqFMRJav4_zB-pFugu9A@mail.gmail.com>
 <52F0E2E3.2050905@maartenfaddegon.nl>
Message-ID: <CA+ZFbn_WRixo8jf0xdJp5yCPWoiL=UqiK8iD8WEy-YoAjU1NgQ@mail.gmail.com>

Hi Maarten,

On Tue, Feb 4, 2014 at 12:53 PM, Maarten Faddegon <
haskell-cafe at maartenfaddegon.nl> wrote:

>  Thanks! I rewrote my example from gshow into gshowPrec and now it works
> as expected :)
>
> Would it be correct to say that the 'from'-function does a shallow convert
> of my value into the type representation (up to the constant
> representations),
>

This is true, yes.


> and from there we either use an ad-hoc instance of gshowPrec, or we do
> another shallow convert one layer deeper via the default gShowPrec?
>

The shallow vs. deep representation isn't really at play here. The
outermost type (|MyData|)
is not the same as the innermost type (|MyFancyType|). The issue is that
you defined an
adhoc |gshow|, but in fact the function that was being used is
|gshowsPrec|, which was
using the generic default. That and the fact that the generic |gshow| is
defined in terms of
|gshowsPrec|.


Cheers,
Pedro



>
> Cheers,
>
> Maarten
>
>
> On 02/02/14 16:02, Jos? Pedro Magalh?es wrote:
>
> Hi Maarten,
>
>  The problem here is that your instance of GShow MyFancyType defines
> gshow, but the
> function that is defined generically is actually gshowsPrec, with the
> others being given
> defaults. For this to work as you'd expect it to, you have to define
> gshowsPrec in the
> instance GShow MyFancyType. This is a bit unfortunate, but because
> gshowsPrec has
>  a generic default, it cannot have the usual default (like showsPrec
> does).
>
>
>  Cheers,
> Pedro
>
>
>
> On Sat, Feb 1, 2014 at 12:11 PM, Maarten Faddegon <
> haskell-cafe at maartenfaddegon.nl> wrote:
>
>> Dear Pedro, Cafe,
>>
>> Thanks again for helping me out last December. I have been
>> playing a bit more with deriving show and now ran into an
>> interesting problem mixing my own instances with derived
>> instances. Hope you can enlighten me there!
>>
>> > {-# LANGUAGE DeriveGeneric #-}
>> > module Test where
>> > import GHC.Generics
>> > import Generics.Deriving.Show
>>
>> The Generic Deriving Mechanism adds the keyword 'default' to
>> class definitions.  With this keyword we can define a
>> type-generic definition of that method when not given. For
>> example, if we define our own MyData type, we can derive the
>> GShow methods:
>>
>> > data MyData = MyData MyFancyType deriving Generic
>> > instance GShow MyData
>>
>> We can also still give our own definition, for example if we want
>> values of the MyFancyType to always be shown as the same string:
>>
>> > data MyFancyType = MyFancy1 | MyFancy2 deriving Generic
>> > instance GShow MyFancyType where
>> >       gshow _ = "Fancy!"
>>
>> There is something strange here though: when we use gshow
>> directly on a MyFancyType value our own instance definition is
>> used, evaluating as expected to "Fancy!".
>>
>> > ex1 = gshow MyFancy1
>>
>> But as soon as we are inside a derived method, we will continue
>> using derived instances even though we defined our own. The
>> example below evaluates to "MyData MyFancy1", rather than "MyData
>> Fancy!":
>>
>> > ex2 = gshow (MyData MyFancy1)
>>
>> The default methods of GShow are defined in terms of methods from
>> GShow' which operate on the type-representation. From this
>> representation I do not see a way to recover the information
>> that a type has a GShow instance.  Am I correct (I hope not :) or
>> is there a way out?
>>
>> Cheers,
>>
>> Maarten Faddegon
>>
>
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140204/661f1af8/attachment.html>

From k-bx at k-bx.com  Tue Feb  4 20:53:03 2014
From: k-bx at k-bx.com (Konstantine Rybnikov)
Date: Tue, 4 Feb 2014 21:53:03 +0100
Subject: [Haskell-cafe] hyperloglog build error
Message-ID: <CAAbahfRczgrE-_30RygRNuHkdwOo=61J1zgX_au=6xXEijppBQ@mail.gmail.com>

Hi!

I wanted to use hyperloglog [0] package, but got these errors:

https://gist.github.com/k-bx/70654962d4d98ee52e22

I am now trying to "match by hands" why that instance doesn't exist for me,
but maybe some of your could help, since I'm far away from all near-lens
libraries (but I promise to learn those!).

Thank you!

[0]: https://github.com/ekmett/hyperloglog/
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140204/6af3db7c/attachment.html>

From atzeus at gmail.com  Wed Feb  5 08:13:44 2014
From: atzeus at gmail.com (Atze van der Ploeg)
Date: Wed, 5 Feb 2014 09:13:44 +0100
Subject: [Haskell-cafe] fromString and toString
In-Reply-To: <loom.20140204T150905-533@post.gmane.org>
References: <CADu1bNR8r1hZ9goukjoi+rjn=eQ6wLNedp1gFhQjPgAo=mbEiQ@mail.gmail.com>
 <loom.20140204T150905-533@post.gmane.org>
Message-ID: <CAGigdocAVqXYa9R1t2oHKPQ1QawOZRLXhu8b6o2DYhf+2GbHTg@mail.gmail.com>

Isn't toString just show?
On Feb 4, 2014 3:20 PM, "Johannes Waldmann" <waldmann at imn.htwk-leipzig.de>
wrote:

> Ben Foppa <benjamin.foppa <at> gmail.com> writes:
>
> > But do we have an inverse generic function toString defined anywhere?
>
> well, we have:  class Show a where show :: a -> String
>
> > likereString :: (IsString a, IsString b) => a -> b
>
> well you probably don't want to actually convert from a to String
> (= List of Char) then from there to b,
> so it would need to be accompanied by some RULES
> (for specific instances of a, b) for efficiency.
>
> This still does not answer the concern whether it is
> (semantically) wise to have String as the "base" concept here.
>
> - J.W.
>
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140205/06fecf70/attachment.html>

From hesselink at gmail.com  Wed Feb  5 09:35:26 2014
From: hesselink at gmail.com (Erik Hesselink)
Date: Wed, 5 Feb 2014 10:35:26 +0100
Subject: [Haskell-cafe] fromString and toString
In-Reply-To: <CAGigdocAVqXYa9R1t2oHKPQ1QawOZRLXhu8b6o2DYhf+2GbHTg@mail.gmail.com>
References: <CADu1bNR8r1hZ9goukjoi+rjn=eQ6wLNedp1gFhQjPgAo=mbEiQ@mail.gmail.com>
 <loom.20140204T150905-533@post.gmane.org>
 <CAGigdocAVqXYa9R1t2oHKPQ1QawOZRLXhu8b6o2DYhf+2GbHTg@mail.gmail.com>
Message-ID: <CAPeieQGmjEUe1enEcmixnz0ZM+Y1fxZvguCrYGVH_7sOzwnCKg@mail.gmail.com>

Show is usually valid Haskell (at least derived instances are), and
has instances for most types. This class would only be a conversion
from types that *are* strings in some sense (like Text) to String.

We have a (very small) package for this called 'isstring' that we use
internally. It has instances for String, Text (x2) and ByteString (x2)
assuming UTF8 encoding. I'd be happy to open source it if people are
interested.

Regards,

Erik

On Wed, Feb 5, 2014 at 9:13 AM, Atze van der Ploeg <atzeus at gmail.com> wrote:
> Isn't toString just show?
>
> On Feb 4, 2014 3:20 PM, "Johannes Waldmann" <waldmann at imn.htwk-leipzig.de>
> wrote:
>>
>> Ben Foppa <benjamin.foppa <at> gmail.com> writes:
>>
>> > But do we have an inverse generic function toString defined anywhere?
>>
>> well, we have:  class Show a where show :: a -> String
>>
>> > likereString :: (IsString a, IsString b) => a -> b
>>
>> well you probably don't want to actually convert from a to String
>> (= List of Char) then from there to b,
>> so it would need to be accompanied by some RULES
>> (for specific instances of a, b) for efficiency.
>>
>> This still does not answer the concern whether it is
>> (semantically) wise to have String as the "base" concept here.
>>
>> - J.W.
>>
>>
>> _______________________________________________
>> Haskell-Cafe mailing list
>> Haskell-Cafe at haskell.org
>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>

From bjarkigeirbenediktsson at gmail.com  Wed Feb  5 10:00:07 2014
From: bjarkigeirbenediktsson at gmail.com (Bjarki Geir Benediktsson)
Date: Wed, 5 Feb 2014 10:00:07 +0000
Subject: [Haskell-cafe] Google Summer of Code 2014 project suggestion
Message-ID: <CAGNhWDyjMwKP9S49Z98dwxFMjDk=Ho0YA0qvTm6j5HaC+p5qPQ@mail.gmail.com>

Hi
I  have a suggestion for a project for Google Summer of Code 2014


Currently Cabal-Install is not a fully featured package manager and can be
improved considerably by adding package management features to it.

Features that could  be implemented include:
      Interaction with ghc-pkg to be able to modify (upgrade/downgrade) or
remove packages
      Support for having multiple versions of the same package installed
      Automatic installation of build tools when needed (Alex, Happy)

this is not an exhaustive list of what could be added  to make
Cabal-Install behave more like a package manager and it could be extended
to interact with system package manager where available

Do you agree this would be a good project for GSoC 2014 ? Do you think some
important features have been overlooked ? Do you think it would be better
to write a replacement for Cabal-Install from scratch rather than extending
it?
I would appreciate feedback.

Regards

Bjarki Geir Benediktsson
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140205/edc7ac6f/attachment.html>

From roma at ro-che.info  Wed Feb  5 11:23:38 2014
From: roma at ro-che.info (Roman Cheplyaka)
Date: Wed, 5 Feb 2014 13:23:38 +0200
Subject: [Haskell-cafe] ANN: asynchronous-exceptions
Message-ID: <20140205112338.GA5055@sniper>

It is often useful to distinguish between synchronous and asynchronous
exceptions. The common idiom is to run a user-supplied computation
catching any synchronous exceptions but allowing asynchronous exceptions
(such as user interrupt) pass through.

base 4.7 (shipped with GHC 7.8) will have SomeAsyncException type that
solves this problem.

asynchronous-exceptions is a new package that serves two purposes:
* provide compatibility with older `base` versions that lack the
  `SomeAsyncException` type
* define convenient functions for catching only synchronous exceptions

Roman
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140205/b4f17191/attachment.sig>

From roma at ro-che.info  Wed Feb  5 11:28:01 2014
From: roma at ro-che.info (Roman Cheplyaka)
Date: Wed, 5 Feb 2014 13:28:01 +0200
Subject: [Haskell-cafe] ANN: asynchronous-exceptions
In-Reply-To: <20140205112338.GA5055@sniper>
References: <20140205112338.GA5055@sniper>
Message-ID: <20140205112801.GA5306@sniper>

The links are:

http://hackage.haskell.org/package/asynchronous-exceptions
https://github.com/feuerbach/asynchronous-exceptions

* Roman Cheplyaka <roma at ro-che.info> [2014-02-05 13:23:38+0200]
> It is often useful to distinguish between synchronous and asynchronous
> exceptions. The common idiom is to run a user-supplied computation
> catching any synchronous exceptions but allowing asynchronous exceptions
> (such as user interrupt) pass through.
> 
> base 4.7 (shipped with GHC 7.8) will have SomeAsyncException type that
> solves this problem.
> 
> asynchronous-exceptions is a new package that serves two purposes:
> * provide compatibility with older `base` versions that lack the
>   `SomeAsyncException` type
> * define convenient functions for catching only synchronous exceptions
> 
> Roman
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140205/1d515fe7/attachment.sig>

From mail at nh2.me  Wed Feb  5 12:19:24 2014
From: mail at nh2.me (=?ISO-8859-1?Q?Niklas_Hamb=FCchen?=)
Date: Wed, 05 Feb 2014 12:19:24 +0000
Subject: [Haskell-cafe] fromString and toString
In-Reply-To: <CAPeieQGmjEUe1enEcmixnz0ZM+Y1fxZvguCrYGVH_7sOzwnCKg@mail.gmail.com>
References: <CADu1bNR8r1hZ9goukjoi+rjn=eQ6wLNedp1gFhQjPgAo=mbEiQ@mail.gmail.com>
 <loom.20140204T150905-533@post.gmane.org>
 <CAGigdocAVqXYa9R1t2oHKPQ1QawOZRLXhu8b6o2DYhf+2GbHTg@mail.gmail.com>
 <CAPeieQGmjEUe1enEcmixnz0ZM+Y1fxZvguCrYGVH_7sOzwnCKg@mail.gmail.com>
Message-ID: <52F22C4C.4020408@nh2.me>

On 05/02/14 09:35, Erik Hesselink wrote:
> Show is usually valid Haskell (at least derived instances are), and
> has instances for most types. This class would only be a conversion
> from types that *are* strings in some sense (like Text) to String.

Totally agree.


On 05/02/14 08:13, Atze van der Ploeg wrote:
> Isn't toString just show?

No, show is very different:

   show "hello" == "\"hello\""

While you would expect

   toString "hello" == "hello"


Personally, I would always recommend this:

* Make show represent the "programmer version" of your data type, e.g.
close to what "deriving Show" would give you, and implement it for every
data type:

  newtype MyString = MyS String

  instance Show MyString where
    show (MyS s) = "MyS "  ++ show s

* Use a different type class (e.g. a ToString) to represent the
stringyness of your type:

  instance ToString MyString where
    show (MyS s) = s

>From my experience, everything else makes programming really nasty,
outcomes unpredictable, and debugging very hard.
If you want an example, try GHC code / the GHC API, where many things
unfortunately do not have a show instance.


> We have a (very small) package for this called 'isstring' that we use
> internally. It has instances for String, Text (x2) and ByteString (x2)
> assuming UTF8 encoding. I'd be happy to open source it if people are
> interested.

Yes. And I think a `ToString` typeclass would be useful be in base.

Also, this existed once but is now deprecate it:
http://hackage.haskell.org/package/to-string-class

I speculate that it got deprecated because it is not nice to maintain
all the orphan instances - the class in base would fix that.

From mail at eax.me  Wed Feb  5 12:37:18 2014
From: mail at eax.me (Alexander Alexeev)
Date: Wed, 5 Feb 2014 16:37:18 +0400
Subject: [Haskell-cafe] Is it possible to declare assignment operators in
	Haskell?
Message-ID: <20140205163718.188430a0@portege>

Hello!

I'm wondering, is there any way to declare assignment operators
in Haskell? For example, strict assignment operators:

x .= y -- equals: let x = y `deepseq` y
x := y -- equals: x <- y `deepseq` y

As far as I can tell, Template Haskell is not able to do anything like
this, because I can't event quote expressions like `let x = y` or `x <-
y`. Is there any other way (plugin for GHC, etc)? Or maybe I'm doing
something wrong and TH is quite able to handle this task?

I'm pretty sure that I could use a preprocessor, but I wonted to find
a better solution.

-- 
Best regards,
Alexander Alexeev
http://eax.me/

From benjamin.foppa at gmail.com  Wed Feb  5 12:42:25 2014
From: benjamin.foppa at gmail.com (Ben Foppa)
Date: Wed, 5 Feb 2014 07:42:25 -0500
Subject: [Haskell-cafe] fromString and toString
In-Reply-To: <52F22C4C.4020408@nh2.me>
References: <CADu1bNR8r1hZ9goukjoi+rjn=eQ6wLNedp1gFhQjPgAo=mbEiQ@mail.gmail.com>
 <loom.20140204T150905-533@post.gmane.org>
 <CAGigdocAVqXYa9R1t2oHKPQ1QawOZRLXhu8b6o2DYhf+2GbHTg@mail.gmail.com>
 <CAPeieQGmjEUe1enEcmixnz0ZM+Y1fxZvguCrYGVH_7sOzwnCKg@mail.gmail.com>
 <52F22C4C.4020408@nh2.me>
Message-ID: <CADu1bNTvWFVqNPFEnDVmiM4-4coEaf_+5FETVVu3ujVYxpQEMg@mail.gmail.com>

I agree that exposing the isstring package would be useful.
Again, I think the name IsString for the class defining fromString is very
misleading, especially if we have an isstring package defining the inverse
relationship (i.e. toString). More appropriate would be StringIs, though
I'm not recommending changing Data.String.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140205/f12f0ccd/attachment.html>

From atze at uu.nl  Wed Feb  5 13:11:15 2014
From: atze at uu.nl (Atze Dijkstra)
Date: Wed, 5 Feb 2014 14:11:15 +0100
Subject: [Haskell-cafe] ANNOUNCE: Applied Functional Programming (AFP)
	Summerschool 7-18 July 2014, Utrecht, Netherlands
Message-ID: <5200A904-46F6-4E26-8568-71E51232FD47@uu.nl>

          =========== AFP Summerschool 2014 ===========

Applied Functional Programming (AFP) Summerschool
July 7-18, 2014
Utrecht University, Department of Information and Computing Sciences
Utrecht, The Netherlands

Summerschool & registration website: http://www.utrechtsummerschool.nl/courses/science/applied-functional-programming-in-haskell
AFP website with edition 2013 info : http://www.cs.uu.nl/wiki/USCS
contact                            : Uscs-afp at lists.science.uu.nl

***

The 2014 edition of the Applied Functional Programming (AFP)
Summerschool in Utrecht, Netherlands will be held from 7-18 July 2014.
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 an excerpt from the summerschool
website:

``Typed functional programming in Haskell allows for the development of
compact programs in minimal time and with maximal guarantees about
robustness and correctness. The course introduces Haskell as well as its
theoretical underpinnings such as typed lambda calculus, and
Damas-Milner type inference. There is ample opportunity to put this all
in practice during lab sessions.

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 reusability. This course introduces 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.''

***

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 at uu.nl ............... /   |___\




From mail at joachim-breitner.de  Wed Feb  5 13:47:30 2014
From: mail at joachim-breitner.de (Joachim Breitner)
Date: Wed, 05 Feb 2014 13:47:30 +0000
Subject: [Haskell-cafe] ANN: asynchronous-exceptions
In-Reply-To: <20140205112338.GA5055@sniper>
References: <20140205112338.GA5055@sniper>
Message-ID: <1391608050.2550.5.camel@kirk>

Hi,

I?m playing the ?do we really need more packages with <10 symbols? card
again:

Am Mittwoch, den 05.02.2014, 13:23 +0200 schrieb Roman Cheplyaka:
> base 4.7 (shipped with GHC 7.8) will have SomeAsyncException type that
> solves this problem.
> 
> asynchronous-exceptions is a new package that serves two purposes:
> * provide compatibility with older `base` versions that lack the
>   `SomeAsyncException` type

isn?t that better done in base-compat, which provides exactly that: 
        The scope of base-compat is to provides the same functionality
        as the latest version of base for a wider range of compilers.

> * define convenient functions for catching only synchronous exceptions

If they are convenient, maybe they should go into base?

(I don?t mind such micro-packages if they are a vehicle for design space
exploration and experiments, but I do think we should avoid too many
packages aimed for general, stable, real-world-use if we can help it.)


Greetings,
Joachim

-- 
Joachim ?nomeata? Breitner
  mail at joachim-breitner.de ? http://www.joachim-breitner.de/
  Jabber: nomeata at joachim-breitner.de  ? GPG-Key: 0x4743206C
  Debian Developer: nomeata at debian.org
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 181 bytes
Desc: This is a digitally signed message part
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140205/e3d585df/attachment.sig>

From roma at ro-che.info  Wed Feb  5 14:35:04 2014
From: roma at ro-che.info (Roman Cheplyaka)
Date: Wed, 5 Feb 2014 16:35:04 +0200
Subject: [Haskell-cafe] ANN: asynchronous-exceptions
In-Reply-To: <1391608050.2550.5.camel@kirk>
References: <20140205112338.GA5055@sniper>
 <1391608050.2550.5.camel@kirk>
Message-ID: <20140205143504.GA7497@sniper>

* Joachim Breitner <mail at joachim-breitner.de> [2014-02-05 13:47:30+0000]
> Hi,
> 
> I?m playing the ?do we really need more packages with <10 symbols? card
> again:

"We"? This is about the time I stop pretending that there are any "we"
with identical interests. "We" consist of many individuals, each one
with his/her own agenda.

Every decision is associated with different costs and benefits for each
agent. In this case, the cost for me is very low (a couple of hours or
less) and the benefit is huge ? the package does exactly what I need it
to do.

The alternative you propose below is very costly (time spent arguing for
the changes and waiting for them to be applied), and the benefit is the
same at best.

Of course, if you persuade me that my decision bears significant cost
for others, I'll be a nice guy and cooperate (esp. if others are willing
to put some effort, too, because it's them who the alternative decision
will presumably benefit).

But so far this cost is not obvious to me at all.

Furthermore, *assuming* there is indeed cost to others, they can improve
the situation directly. Indeed, I already did at least some part of the job
(wrote the code that can be directly copied to the packages you
mention). Why don't others do the second part of the job, that they like
to say is almost trivial, and put their time and effort where their
mouth is?

> Am Mittwoch, den 05.02.2014, 13:23 +0200 schrieb Roman Cheplyaka:
> > base 4.7 (shipped with GHC 7.8) will have SomeAsyncException type that
> > solves this problem.
> > 
> > asynchronous-exceptions is a new package that serves two purposes:
> > * provide compatibility with older `base` versions that lack the
> >   `SomeAsyncException` type
> 
> isn?t that better done in base-compat, which provides exactly that: 
>         The scope of base-compat is to provides the same functionality
>         as the latest version of base for a wider range of compilers.
> 
> > * define convenient functions for catching only synchronous exceptions
> 
> If they are convenient, maybe they should go into base?
> 
> (I don?t mind such micro-packages if they are a vehicle for design space
> exploration and experiments, but I do think we should avoid too many
> packages aimed for general, stable, real-world-use if we can help it.)
> 
> 
> Greetings,
> Joachim
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140205/96a7c6b2/attachment.sig>

From edskodevries at gmail.com  Wed Feb  5 14:43:06 2014
From: edskodevries at gmail.com (Edsko de Vries)
Date: Wed, 5 Feb 2014 14:43:06 +0000
Subject: [Haskell-cafe] ANN: asynchronous-exceptions
In-Reply-To: <20140205112338.GA5055@sniper>
References: <20140205112338.GA5055@sniper>
Message-ID: <CAETJ90SxBc9EP8PmdD6WLJaUP6bANvCzLTt1We23vDAux_oqhA@mail.gmail.com>

Be aware that "passing through" of asynchronous exceptions is not really
possible. There simply is no way to selectively catch an exception -- one
must always catch and rethrow, thus turning asynchronous exceptions into
synchronous exceptions. See http://www.edsko.net/2013/06/11/throwto/ for
details.

Edsko


On Wed, Feb 5, 2014 at 11:23 AM, Roman Cheplyaka <roma at ro-che.info> wrote:

> It is often useful to distinguish between synchronous and asynchronous
> exceptions. The common idiom is to run a user-supplied computation
> catching any synchronous exceptions but allowing asynchronous exceptions
> (such as user interrupt) pass through.
>
> base 4.7 (shipped with GHC 7.8) will have SomeAsyncException type that
> solves this problem.
>
> asynchronous-exceptions is a new package that serves two purposes:
> * provide compatibility with older `base` versions that lack the
>   `SomeAsyncException` type
> * define convenient functions for catching only synchronous exceptions
>
> Roman
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140205/a60cf786/attachment.html>

From creswick at gmail.com  Wed Feb  5 14:50:07 2014
From: creswick at gmail.com (Rogan Creswick)
Date: Wed, 5 Feb 2014 06:50:07 -0800
Subject: [Haskell-cafe] Google Summer of Code 2014 project suggestion
In-Reply-To: <CAGNhWDyjMwKP9S49Z98dwxFMjDk=Ho0YA0qvTm6j5HaC+p5qPQ@mail.gmail.com>
References: <CAGNhWDyjMwKP9S49Z98dwxFMjDk=Ho0YA0qvTm6j5HaC+p5qPQ@mail.gmail.com>
Message-ID: <CAHjep=w5039GHrGrPyjxXicgRWyv49=_16w=Ece8-ys_LUfLSg@mail.gmail.com>

On Wed, Feb 5, 2014 at 2:00 AM, Bjarki Geir Benediktsson <
bjarkigeirbenediktsson at gmail.com> wrote:

> Hi
> I  have a suggestion for a project for Google Summer of Code 2014
>
>
> Currently Cabal-Install is not a fully featured package manager and can be
> improved considerably by adding package management features to it.
>
> Features that could  be implemented include:
>       Interaction with ghc-pkg to be able to modify (upgrade/downgrade) or
> remove packages
>

This would be handy -- ghc-pkg / cabal sandbox hc-pkg help a lot here
already, though, and aren't so bad to use. It would be nice, though.

       Support for having multiple versions of the same package installed
>

I think there is a good bit of on-going work to support multiple versions
of one package in the same package db, and it's significantly less of an
issue with sandboxes. My understanding is that this is significantly more
challenging than it seems.


>       Automatic installation of build tools when needed (Alex, Happy)
>

Rather than implement tool installation directly, my preference would be to
solve this first:

https://github.com/haskell/cabal/issues/948

Then, once setup.hs has specific dependencies, write a simple EDSL /
library that makes it trivial to conditionally install tool dependencies
from within a custom build script.

I think the result would be much more generally applicable, and solve a
number of other issues along the way.  It would also make it possible for
anyone to prototype new cabal/cabal-install features without needing to
distribute a new version of cabal/cabal-install.

--Rogan
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140205/2ca93f20/attachment.html>

From michael at snoyman.com  Wed Feb  5 14:56:31 2014
From: michael at snoyman.com (Michael Snoyman)
Date: Wed, 5 Feb 2014 16:56:31 +0200
Subject: [Haskell-cafe] ANN: asynchronous-exceptions
In-Reply-To: <20140205112801.GA5306@sniper>
References: <20140205112338.GA5055@sniper> <20140205112801.GA5306@sniper>
Message-ID: <CAKA2JgKSWQ8An-KK4gCjcaRChyoXhzVg8k-S5XDDvQvLDWKD6Q@mail.gmail.com>

I don't think this package works as expected. Consider the following:

import           Control.Concurrent
import           Control.Exception.Async
import           System.Timeout

main :: IO ()
main = do
    timeout 1000000 $ do
        threadDelay 10000000 `catchSync` \e -> do
            print e
            threadDelay 10000000
    return ()

The expected behavior would be that the timeout- an async exception- would
kill the thread delay, the catch would ignore the async exception, and the
program would exit. In reality, catchSync treats the timeout as a
synchronous exception, prints it, and delays once again. Compare this to
classy-prelude's catchAny, which handles the situation correctly, via the
technique I described in "Catching all exceptions."[1]

In this case, the issue is that the timeout exception type is not
recognized as async, and a special case could be added to handle that
exception type[2]. However, I think the overall approach of determining
*how* an exception was thrown based on *what* was thrown is not tenable.

[1]
https://www.fpcomplete.com/user/snoyberg/general-haskell/exceptions/catching-all-exceptions
[2] It's a bit difficult to do so, since IIRC the type is never exported.
But a hack using the Typeable instance- while ugly- is likely possible.


On Wed, Feb 5, 2014 at 1:28 PM, Roman Cheplyaka <roma at ro-che.info> wrote:

> The links are:
>
> http://hackage.haskell.org/package/asynchronous-exceptions
> https://github.com/feuerbach/asynchronous-exceptions
>
> * Roman Cheplyaka <roma at ro-che.info> [2014-02-05 13:23:38+0200]
> > It is often useful to distinguish between synchronous and asynchronous
> > exceptions. The common idiom is to run a user-supplied computation
> > catching any synchronous exceptions but allowing asynchronous exceptions
> > (such as user interrupt) pass through.
> >
> > base 4.7 (shipped with GHC 7.8) will have SomeAsyncException type that
> > solves this problem.
> >
> > asynchronous-exceptions is a new package that serves two purposes:
> > * provide compatibility with older `base` versions that lack the
> >   `SomeAsyncException` type
> > * define convenient functions for catching only synchronous exceptions
> >
> > Roman
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140205/133d1a18/attachment.html>

From roma at ro-che.info  Wed Feb  5 15:19:26 2014
From: roma at ro-che.info (Roman Cheplyaka)
Date: Wed, 5 Feb 2014 17:19:26 +0200
Subject: [Haskell-cafe] ANN: asynchronous-exceptions
In-Reply-To: <CAKA2JgKSWQ8An-KK4gCjcaRChyoXhzVg8k-S5XDDvQvLDWKD6Q@mail.gmail.com>
References: <20140205112338.GA5055@sniper> <20140205112801.GA5306@sniper>
 <CAKA2JgKSWQ8An-KK4gCjcaRChyoXhzVg8k-S5XDDvQvLDWKD6Q@mail.gmail.com>
Message-ID: <20140205151926.GA9254@sniper>

It works as expected.

With GHC 7.8 it doesn't print the timeout exception.

With earlier GHC it does (again, as expected, because the timeout
exception isn't marked as asynchronous). In practice one should rarely
want to use System.Timeout anyway (because of the overflow issue), and
I'm going to patch one of the better timeout packages (such as
unbounded-delays) to support asynchronous-exceptions.

* Michael Snoyman <michael at snoyman.com> [2014-02-05 16:56:31+0200]
> I don't think this package works as expected. Consider the following:
> 
> import           Control.Concurrent
> import           Control.Exception.Async
> import           System.Timeout
> 
> main :: IO ()
> main = do
>     timeout 1000000 $ do
>         threadDelay 10000000 `catchSync` \e -> do
>             print e
>             threadDelay 10000000
>     return ()
> 
> The expected behavior would be that the timeout- an async exception- would
> kill the thread delay, the catch would ignore the async exception, and the
> program would exit. In reality, catchSync treats the timeout as a
> synchronous exception, prints it, and delays once again. Compare this to
> classy-prelude's catchAny, which handles the situation correctly, via the
> technique I described in "Catching all exceptions."[1]
> 
> In this case, the issue is that the timeout exception type is not
> recognized as async, and a special case could be added to handle that
> exception type[2]. However, I think the overall approach of determining
> *how* an exception was thrown based on *what* was thrown is not tenable.
> 
> [1]
> https://www.fpcomplete.com/user/snoyberg/general-haskell/exceptions/catching-all-exceptions
> [2] It's a bit difficult to do so, since IIRC the type is never exported.
> But a hack using the Typeable instance- while ugly- is likely possible.
> 
> 
> On Wed, Feb 5, 2014 at 1:28 PM, Roman Cheplyaka <roma at ro-che.info> wrote:
> 
> > The links are:
> >
> > http://hackage.haskell.org/package/asynchronous-exceptions
> > https://github.com/feuerbach/asynchronous-exceptions
> >
> > * Roman Cheplyaka <roma at ro-che.info> [2014-02-05 13:23:38+0200]
> > > It is often useful to distinguish between synchronous and asynchronous
> > > exceptions. The common idiom is to run a user-supplied computation
> > > catching any synchronous exceptions but allowing asynchronous exceptions
> > > (such as user interrupt) pass through.
> > >
> > > base 4.7 (shipped with GHC 7.8) will have SomeAsyncException type that
> > > solves this problem.
> > >
> > > asynchronous-exceptions is a new package that serves two purposes:
> > > * provide compatibility with older `base` versions that lack the
> > >   `SomeAsyncException` type
> > > * define convenient functions for catching only synchronous exceptions
> > >
> > > Roman
> >
> > _______________________________________________
> > Haskell-Cafe mailing list
> > Haskell-Cafe at haskell.org
> > http://www.haskell.org/mailman/listinfo/haskell-cafe
> >
> >
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140205/3894c426/attachment.sig>

From jmacristovao at gmail.com  Wed Feb  5 15:53:34 2014
From: jmacristovao at gmail.com (=?ISO-8859-1?B?Sm/jbyBDcmlzdPN2428=?=)
Date: Wed, 5 Feb 2014 15:53:34 +0000
Subject: [Haskell-cafe] ANN: asynchronous-exceptions
In-Reply-To: <20140205151926.GA9254@sniper>
References: <20140205112338.GA5055@sniper> <20140205112801.GA5306@sniper>
 <CAKA2JgKSWQ8An-KK4gCjcaRChyoXhzVg8k-S5XDDvQvLDWKD6Q@mail.gmail.com>
 <20140205151926.GA9254@sniper>
Message-ID: <CAAbu24rtK7O_=n5EVyuVdSPu-un=Lbv9vrDA9xO72XZkghCxiw@mail.gmail.com>

Hi Roman,

One other question: in Michael's article, he also mentions the possibility of:
"Consider that, for some strange reason, we decided to asynchronously
throw an IOException to a worker thread"

Meaning that you can throwTo any exception asynchronouly, even if it
is not a SomeAsyncException. At least from what I gathered from (GHC
Head) throwTo code, this does not seem to be a restriction.

Thus, your module will work for any well behaved code that does the
right thing, and respects the SomeAsyncException superclass, but not
for other spurious asynchronous exceptions, right?

I'm just trying to frame the possible use cases of your library.
Thanks
Joao

2014-02-05 Roman Cheplyaka <roma at ro-che.info>:
> It works as expected.
>
> With GHC 7.8 it doesn't print the timeout exception.
>
> With earlier GHC it does (again, as expected, because the timeout
> exception isn't marked as asynchronous). In practice one should rarely
> want to use System.Timeout anyway (because of the overflow issue), and
> I'm going to patch one of the better timeout packages (such as
> unbounded-delays) to support asynchronous-exceptions.
>
> * Michael Snoyman <michael at snoyman.com> [2014-02-05 16:56:31+0200]
>> I don't think this package works as expected. Consider the following:
>>
>> import           Control.Concurrent
>> import           Control.Exception.Async
>> import           System.Timeout
>>
>> main :: IO ()
>> main = do
>>     timeout 1000000 $ do
>>         threadDelay 10000000 `catchSync` \e -> do
>>             print e
>>             threadDelay 10000000
>>     return ()
>>
>> The expected behavior would be that the timeout- an async exception- would
>> kill the thread delay, the catch would ignore the async exception, and the
>> program would exit. In reality, catchSync treats the timeout as a
>> synchronous exception, prints it, and delays once again. Compare this to
>> classy-prelude's catchAny, which handles the situation correctly, via the
>> technique I described in "Catching all exceptions."[1]
>>
>> In this case, the issue is that the timeout exception type is not
>> recognized as async, and a special case could be added to handle that
>> exception type[2]. However, I think the overall approach of determining
>> *how* an exception was thrown based on *what* was thrown is not tenable.
>>
>> [1]
>> https://www.fpcomplete.com/user/snoyberg/general-haskell/exceptions/catching-all-exceptions
>> [2] It's a bit difficult to do so, since IIRC the type is never exported.
>> But a hack using the Typeable instance- while ugly- is likely possible.
>>
>>
>> On Wed, Feb 5, 2014 at 1:28 PM, Roman Cheplyaka <roma at ro-che.info> wrote:
>>
>> > The links are:
>> >
>> > http://hackage.haskell.org/package/asynchronous-exceptions
>> > https://github.com/feuerbach/asynchronous-exceptions
>> >
>> > * Roman Cheplyaka <roma at ro-che.info> [2014-02-05 13:23:38+0200]
>> > > It is often useful to distinguish between synchronous and asynchronous
>> > > exceptions. The common idiom is to run a user-supplied computation
>> > > catching any synchronous exceptions but allowing asynchronous exceptions
>> > > (such as user interrupt) pass through.
>> > >
>> > > base 4.7 (shipped with GHC 7.8) will have SomeAsyncException type that
>> > > solves this problem.
>> > >
>> > > asynchronous-exceptions is a new package that serves two purposes:
>> > > * provide compatibility with older `base` versions that lack the
>> > >   `SomeAsyncException` type
>> > > * define convenient functions for catching only synchronous exceptions
>> > >
>> > > Roman
>> >
>> > _______________________________________________
>> > Haskell-Cafe mailing list
>> > Haskell-Cafe at haskell.org
>> > http://www.haskell.org/mailman/listinfo/haskell-cafe
>> >
>> >
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>

From michael at snoyman.com  Wed Feb  5 15:55:10 2014
From: michael at snoyman.com (Michael Snoyman)
Date: Wed, 5 Feb 2014 17:55:10 +0200
Subject: [Haskell-cafe] ANN: asynchronous-exceptions
In-Reply-To: <20140205151926.GA9254@sniper>
References: <20140205112338.GA5055@sniper> <20140205112801.GA5306@sniper>
 <CAKA2JgKSWQ8An-KK4gCjcaRChyoXhzVg8k-S5XDDvQvLDWKD6Q@mail.gmail.com>
 <20140205151926.GA9254@sniper>
Message-ID: <CAKA2JgKWdLHYgyMWpHPo8vZB8RBXVmvba5xXceH+iNyGPcX-Cg@mail.gmail.com>

So you're saying that it's expected behavior for the shim library you're
providing to have drastically different behavior between different versions
of GHC? I don't think that's a good idea at all.

In any event, this approach is still predicated on the idea that you can
identify an asynchronous event from its type. There are multiple problems
with this:

* As demonstrated with my previous example, not all asynchronous exceptions
identify themselves as such.
* There is no requirement that only asynchronous-type exceptions be thrown
asynchronously. throwTo works with any instance of Exception.
* If an asynchronous-type exception is caught and then rethrown as a
synchronous exception, the type-based approach will still treat it as
asynchronous, though it should be recognized as synchronous at that point.

To demonstrate that last point, consider the example code below, which uses
your asynchronous type machinery and the async package. The usage of
`trySync` in `main` *should* catch that exception, since it is no longer
asynchronous, but a type-only approach cannot handle that situation.
ClassyPrelude's tryAny, on the other hand, gives the correct output.

{-# LANGUAGE DeriveDataTypeable #-}
import Control.Exception.Async
import Control.Concurrent.Async
import Control.Concurrent
import Control.Exception
import Data.Unique
import Data.Typeable

data Timeout = Timeout
    deriving (Typeable, Eq)
instance Show Timeout where
    show _ = "Async Timeout"
instance Exception Timeout where
    fromException = asyncExceptionFromException
    toException = asyncExceptionToException

asyncTimeout n f = do
    pid <- myThreadId
    killer <- forkIO $ do
        threadDelay n
        throwTo pid Timeout
    res <- f
    killThread pid
    return res

main :: IO ()
main = do
    res <- trySync f
    print res

f :: IO String
f = do
    x <- async $ asyncTimeout 1000000 $ do
        threadDelay 2000000
        return "Finished"
    wait x



On Wed, Feb 5, 2014 at 5:19 PM, Roman Cheplyaka <roma at ro-che.info> wrote:

> It works as expected.
>
> With GHC 7.8 it doesn't print the timeout exception.
>
> With earlier GHC it does (again, as expected, because the timeout
> exception isn't marked as asynchronous). In practice one should rarely
> want to use System.Timeout anyway (because of the overflow issue), and
> I'm going to patch one of the better timeout packages (such as
> unbounded-delays) to support asynchronous-exceptions.
>
> * Michael Snoyman <michael at snoyman.com> [2014-02-05 16:56:31+0200]
> > I don't think this package works as expected. Consider the following:
> >
> > import           Control.Concurrent
> > import           Control.Exception.Async
> > import           System.Timeout
> >
> > main :: IO ()
> > main = do
> >     timeout 1000000 $ do
> >         threadDelay 10000000 `catchSync` \e -> do
> >             print e
> >             threadDelay 10000000
> >     return ()
> >
> > The expected behavior would be that the timeout- an async exception-
> would
> > kill the thread delay, the catch would ignore the async exception, and
> the
> > program would exit. In reality, catchSync treats the timeout as a
> > synchronous exception, prints it, and delays once again. Compare this to
> > classy-prelude's catchAny, which handles the situation correctly, via the
> > technique I described in "Catching all exceptions."[1]
> >
> > In this case, the issue is that the timeout exception type is not
> > recognized as async, and a special case could be added to handle that
> > exception type[2]. However, I think the overall approach of determining
> > *how* an exception was thrown based on *what* was thrown is not tenable.
> >
> > [1]
> >
> https://www.fpcomplete.com/user/snoyberg/general-haskell/exceptions/catching-all-exceptions
> > [2] It's a bit difficult to do so, since IIRC the type is never exported.
> > But a hack using the Typeable instance- while ugly- is likely possible.
> >
> >
> > On Wed, Feb 5, 2014 at 1:28 PM, Roman Cheplyaka <roma at ro-che.info>
> wrote:
> >
> > > The links are:
> > >
> > > http://hackage.haskell.org/package/asynchronous-exceptions
> > > https://github.com/feuerbach/asynchronous-exceptions
> > >
> > > * Roman Cheplyaka <roma at ro-che.info> [2014-02-05 13:23:38+0200]
> > > > It is often useful to distinguish between synchronous and
> asynchronous
> > > > exceptions. The common idiom is to run a user-supplied computation
> > > > catching any synchronous exceptions but allowing asynchronous
> exceptions
> > > > (such as user interrupt) pass through.
> > > >
> > > > base 4.7 (shipped with GHC 7.8) will have SomeAsyncException type
> that
> > > > solves this problem.
> > > >
> > > > asynchronous-exceptions is a new package that serves two purposes:
> > > > * provide compatibility with older `base` versions that lack the
> > > >   `SomeAsyncException` type
> > > > * define convenient functions for catching only synchronous
> exceptions
> > > >
> > > > Roman
> > >
> > > _______________________________________________
> > > Haskell-Cafe mailing list
> > > Haskell-Cafe at haskell.org
> > > http://www.haskell.org/mailman/listinfo/haskell-cafe
> > >
> > >
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140205/13f6a2b9/attachment.html>

From roma at ro-che.info  Wed Feb  5 16:09:19 2014
From: roma at ro-che.info (Roman Cheplyaka)
Date: Wed, 5 Feb 2014 18:09:19 +0200
Subject: [Haskell-cafe] ANN: asynchronous-exceptions
In-Reply-To: <CAAbu24rtK7O_=n5EVyuVdSPu-un=Lbv9vrDA9xO72XZkghCxiw@mail.gmail.com>
References: <20140205112338.GA5055@sniper> <20140205112801.GA5306@sniper>
 <CAKA2JgKSWQ8An-KK4gCjcaRChyoXhzVg8k-S5XDDvQvLDWKD6Q@mail.gmail.com>
 <20140205151926.GA9254@sniper>
 <CAAbu24rtK7O_=n5EVyuVdSPu-un=Lbv9vrDA9xO72XZkghCxiw@mail.gmail.com>
Message-ID: <20140205160919.GA10049@sniper>

Hi Jo?o,

* Jo?o Crist?v?o <jmacristovao at gmail.com> [2014-02-05 15:53:34+0000]
> Hi Roman,
> 
> One other question: in Michael's article, he also mentions the possibility of:
> "Consider that, for some strange reason, we decided to asynchronously
> throw an IOException to a worker thread"
> 
> Meaning that you can throwTo any exception asynchronouly, even if it
> is not a SomeAsyncException. At least from what I gathered from (GHC
> Head) throwTo code, this does not seem to be a restriction.
> 
> Thus, your module will work for any well behaved code that does the
> right thing, and respects the SomeAsyncException superclass, but not
> for other spurious asynchronous exceptions, right?

Precisely.

> I'm just trying to frame the possible use cases of your library.
> Thanks
> Joao
> 
> 2014-02-05 Roman Cheplyaka <roma at ro-che.info>:
> > It works as expected.
> >
> > With GHC 7.8 it doesn't print the timeout exception.
> >
> > With earlier GHC it does (again, as expected, because the timeout
> > exception isn't marked as asynchronous). In practice one should rarely
> > want to use System.Timeout anyway (because of the overflow issue), and
> > I'm going to patch one of the better timeout packages (such as
> > unbounded-delays) to support asynchronous-exceptions.
> >
> > * Michael Snoyman <michael at snoyman.com> [2014-02-05 16:56:31+0200]
> >> I don't think this package works as expected. Consider the following:
> >>
> >> import           Control.Concurrent
> >> import           Control.Exception.Async
> >> import           System.Timeout
> >>
> >> main :: IO ()
> >> main = do
> >>     timeout 1000000 $ do
> >>         threadDelay 10000000 `catchSync` \e -> do
> >>             print e
> >>             threadDelay 10000000
> >>     return ()
> >>
> >> The expected behavior would be that the timeout- an async exception- would
> >> kill the thread delay, the catch would ignore the async exception, and the
> >> program would exit. In reality, catchSync treats the timeout as a
> >> synchronous exception, prints it, and delays once again. Compare this to
> >> classy-prelude's catchAny, which handles the situation correctly, via the
> >> technique I described in "Catching all exceptions."[1]
> >>
> >> In this case, the issue is that the timeout exception type is not
> >> recognized as async, and a special case could be added to handle that
> >> exception type[2]. However, I think the overall approach of determining
> >> *how* an exception was thrown based on *what* was thrown is not tenable.
> >>
> >> [1]
> >> https://www.fpcomplete.com/user/snoyberg/general-haskell/exceptions/catching-all-exceptions
> >> [2] It's a bit difficult to do so, since IIRC the type is never exported.
> >> But a hack using the Typeable instance- while ugly- is likely possible.
> >>
> >>
> >> On Wed, Feb 5, 2014 at 1:28 PM, Roman Cheplyaka <roma at ro-che.info> wrote:
> >>
> >> > The links are:
> >> >
> >> > http://hackage.haskell.org/package/asynchronous-exceptions
> >> > https://github.com/feuerbach/asynchronous-exceptions
> >> >
> >> > * Roman Cheplyaka <roma at ro-che.info> [2014-02-05 13:23:38+0200]
> >> > > It is often useful to distinguish between synchronous and asynchronous
> >> > > exceptions. The common idiom is to run a user-supplied computation
> >> > > catching any synchronous exceptions but allowing asynchronous exceptions
> >> > > (such as user interrupt) pass through.
> >> > >
> >> > > base 4.7 (shipped with GHC 7.8) will have SomeAsyncException type that
> >> > > solves this problem.
> >> > >
> >> > > asynchronous-exceptions is a new package that serves two purposes:
> >> > > * provide compatibility with older `base` versions that lack the
> >> > >   `SomeAsyncException` type
> >> > > * define convenient functions for catching only synchronous exceptions
> >> > >
> >> > > Roman
> >> >
> >> > _______________________________________________
> >> > Haskell-Cafe mailing list
> >> > Haskell-Cafe at haskell.org
> >> > http://www.haskell.org/mailman/listinfo/haskell-cafe
> >> >
> >> >
> >
> > _______________________________________________
> > Haskell-Cafe mailing list
> > Haskell-Cafe at haskell.org
> > http://www.haskell.org/mailman/listinfo/haskell-cafe
> >
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140205/3f9c4f66/attachment.sig>

From roma at ro-che.info  Wed Feb  5 16:28:49 2014
From: roma at ro-che.info (Roman Cheplyaka)
Date: Wed, 5 Feb 2014 18:28:49 +0200
Subject: [Haskell-cafe] ANN: asynchronous-exceptions
In-Reply-To: <CAKA2JgKWdLHYgyMWpHPo8vZB8RBXVmvba5xXceH+iNyGPcX-Cg@mail.gmail.com>
References: <20140205112338.GA5055@sniper> <20140205112801.GA5306@sniper>
 <CAKA2JgKSWQ8An-KK4gCjcaRChyoXhzVg8k-S5XDDvQvLDWKD6Q@mail.gmail.com>
 <20140205151926.GA9254@sniper>
 <CAKA2JgKWdLHYgyMWpHPo8vZB8RBXVmvba5xXceH+iNyGPcX-Cg@mail.gmail.com>
Message-ID: <20140205162849.GC10049@sniper>

* Michael Snoyman <michael at snoyman.com> [2014-02-05 17:55:10+0200]
> * If an asynchronous-type exception is caught and then rethrown as a
> synchronous exception, the type-based approach will still treat it as
> asynchronous, though it should be recognized as synchronous at that point.

I say it shouldn't. I usually don't care by what means an exception was
thrown. I care that exceptions that are meant to be thrown
asynchronously (that is: they do not originate from the currently
executing code in the current thread, but are some indication of an
outside event) are not treated the same as exceptions that arise from
the code in the current thread.

Example:

  {-# LANGUAGE ScopedTypeVariables #-}
  import System.Timeout
  import Control.Concurrent
  import Control.Exception
  import Control.Exception.Async

  main = do
    timeout (10^5) $
      (threadDelay (10^6) `catch` (\(_ :: IOException) -> print 1))
        `catchSync` (\_ -> print 2)

I don't expect any of the exception handlers here to fire because
threadDelay doesn't throw any exceptions. This is my intention. The fact
that, as Edsko points out, exception are re-thrown synchronously, is a
subtle technicality and I don't want to care about it. Remember that 

  threadDelay (10^6) `catch` (\(_ :: IOException) -> print 1)

sits somewhere deep inside a user-supplied action. Thus, the semantics
of my clear-intentioned code

  timeout (10^5) $ userAction `catchSync` (\_ -> print 2)

in the approach you advocate would depend on whether, somewhere deep
inside a library used by the user action, any exceptions are caught.
This is not compositional nor useful.

Roman
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140205/62a64f2a/attachment.sig>

From michael at snoyman.com  Wed Feb  5 16:48:22 2014
From: michael at snoyman.com (Michael Snoyman)
Date: Wed, 5 Feb 2014 18:48:22 +0200
Subject: [Haskell-cafe] ANN: asynchronous-exceptions
In-Reply-To: <20140205162849.GC10049@sniper>
References: <20140205112338.GA5055@sniper> <20140205112801.GA5306@sniper>
 <CAKA2JgKSWQ8An-KK4gCjcaRChyoXhzVg8k-S5XDDvQvLDWKD6Q@mail.gmail.com>
 <20140205151926.GA9254@sniper>
 <CAKA2JgKWdLHYgyMWpHPo8vZB8RBXVmvba5xXceH+iNyGPcX-Cg@mail.gmail.com>
 <20140205162849.GC10049@sniper>
Message-ID: <CAKA2JgJyonmwpscN_=9kXPTL0w7DT4LgB2wvvPyOc5z7BiinDQ@mail.gmail.com>

On Wed, Feb 5, 2014 at 6:28 PM, Roman Cheplyaka <roma at ro-che.info> wrote:

> * Michael Snoyman <michael at snoyman.com> [2014-02-05 17:55:10+0200]
> > * If an asynchronous-type exception is caught and then rethrown as a
> > synchronous exception, the type-based approach will still treat it as
> > asynchronous, though it should be recognized as synchronous at that
> point.
>
> I say it shouldn't. I usually don't care by what means an exception was
> thrown. I care that exceptions that are meant to be thrown
> asynchronously (that is: they do not originate from the currently
> executing code in the current thread, but are some indication of an
> outside event) are not treated the same as exceptions that arise from
> the code in the current thread.
>
> Example:
>
>   {-# LANGUAGE ScopedTypeVariables #-}
>   import System.Timeout
>   import Control.Concurrent
>   import Control.Exception
>   import Control.Exception.Async
>
>   main = do
>     timeout (10^5) $
>       (threadDelay (10^6) `catch` (\(_ :: IOException) -> print 1))
>         `catchSync` (\_ -> print 2)
>
> I don't expect any of the exception handlers here to fire because
> threadDelay doesn't throw any exceptions. This is my intention. The fact
>

And just to point out yet again: the second exception handler *does* fire
in GHC 7.6 and earlier.


> that, as Edsko points out, exception are re-thrown synchronously, is a
> subtle technicality and I don't want to care about it. Remember that
>
>   threadDelay (10^6) `catch` (\(_ :: IOException) -> print 1)
>
> sits somewhere deep inside a user-supplied action. Thus, the semantics
> of my clear-intentioned code
>
>   timeout (10^5) $ userAction `catchSync` (\_ -> print 2)
>
> in the approach you advocate would depend on whether, somewhere deep
> inside a library used by the user action, any exceptions are caught.
> This is not compositional nor useful.
>
> Roman
>

I can't think of any situation in which the semantics you're implying make
sense. To me, catching synchronous exception is a simple concept: if an
exception is generated internally to `userAction`, then it's a synchronous
exception. If it was terminated by something external, then it's
asynchronous. I'm not sure what you're getting at about my approach
requiring knowledge of what's going on deep inside a library.

The real question which is not explained in your package is what use case
you're actually trying to address. Here's a prime example I've run into:
you're writing a web application which uses a third-party library. If that
library throws an exception of any type, you want to catch the exception
and display an appropriate error message (or perhaps return some data from
another source). However, we still want the web application to respect
timeout messages from the server to avoid slowloris attacks. The handler
code would look like:

myHandler = do
    eres <- tryAnyDeep someLibraryFunction
    case eres of
        Left e -> tellUser "I'm sorry, there was an issue making the query"
        Right x -> displayData x

The goal is that, under no circumstances, should someLibraryFunction be
able to case the exception to escape tryAnyDeep. This includes rethrowing
some async exception that it received from, e.g., a timeout. This would not
be honored by trySync.

Michael
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140205/4b834249/attachment.html>

From ollie at ocharles.org.uk  Wed Feb  5 17:26:38 2014
From: ollie at ocharles.org.uk (Oliver Charles)
Date: Wed, 05 Feb 2014 17:26:38 +0000
Subject: [Haskell-cafe] Announcing Haskell bindings to libsystemd-journal
Message-ID: <87iost1ne9.fsf@nixos.i-did-not-set--mail-host-address--so-tickle-me>

Hi all,

Just a brief announcement - I've just released Haskell bindings to
libsystemd-journal, the systemd library for writing directly to the
journal.

I've tried to be moderately type safe without giving up flexibility or
ease of use. The documentation is at:

  http://hackage.haskell.org/package/libsystemd-journal-1.0.0/docs/Systemd-Journal.html

Note that some of the hyperlinks on this page don't work, and I can't be
bothered fighting with Hackage to make them work. Sorry! If you need
that, just install the library and you can read documentation
locally. To install this library, you'll need libsystemd-journal (which
you probably have if you're reading this) and then you can just run:

  cabal install libsystemd-journal

Happy logging!
- ocharles

From david.sorokin at gmail.com  Wed Feb  5 17:44:54 2014
From: david.sorokin at gmail.com (David Sorokin)
Date: Wed, 5 Feb 2014 21:44:54 +0400
Subject: [Haskell-cafe] ANN: asynchronous-exceptions
In-Reply-To: <CAKA2JgJyonmwpscN_=9kXPTL0w7DT4LgB2wvvPyOc5z7BiinDQ@mail.gmail.com>
References: <20140205112338.GA5055@sniper> <20140205112801.GA5306@sniper>
 <CAKA2JgKSWQ8An-KK4gCjcaRChyoXhzVg8k-S5XDDvQvLDWKD6Q@mail.gmail.com>
 <20140205151926.GA9254@sniper>
 <CAKA2JgKWdLHYgyMWpHPo8vZB8RBXVmvba5xXceH+iNyGPcX-Cg@mail.gmail.com>
 <20140205162849.GC10049@sniper>
 <CAKA2JgJyonmwpscN_=9kXPTL0w7DT4LgB2wvvPyOc5z7BiinDQ@mail.gmail.com>
Message-ID: <B77DB807-86D3-476F-9AF5-0E7FF1DE5465@gmail.com>

Hi!

Please let me add two cents to your discussion. Just for your information.

There is a working approach, when the exceptions can be indeed successfully caught within the asynchronous computation. Moreover, there is also the working try-finally block, which is more difficult to implement. This is the async workflow in F# and their Async<?T> type is actually a monad. Only they use the continuations, namely three continuations: (1) the main branch; (2) the branch for catching exceptions; (3) the branch for immediate canceling the computation. They have no special ?asynchronous? exceptions that would differ from synchronous ones.

By the way, I have implemented a similar approach in my library aivika available on hackage (module Simulation.Aivika.Internal.Cont). I can catch the IO exceptions as well as I can process so called the finally blocks, and my own tests show that it works in Haskell.

Thanks,
David

From hesselink at gmail.com  Wed Feb  5 19:34:40 2014
From: hesselink at gmail.com (Erik Hesselink)
Date: Wed, 5 Feb 2014 20:34:40 +0100
Subject: [Haskell-cafe] problem with happy and type identity
In-Reply-To: <20140202213219.GA238@ridcully.local>
References: <20140202213219.GA238@ridcully.local>
Message-ID: <CAPeieQHA3+xGnufwXbha2Av-jAYYzVmcW2u+v80-tvmejqVYjg@mail.gmail.com>

To be able to share code between your library and your tests, you should either

* Have a separate directory for the library sources and the test
sources. For example, put Ast.hs and Parser.y in 'src' and put
'Hs-source-dirs: src' in the library section. Put RunTests.hs in
'tests', and put 'Hs-source-dirs: tests' in the test-suite section.
This is the preferred way.
* Alternatively, don't specify 'sample' as a build-depends in the
test-suite. Note that this will mean that Ast and Parser will get
compiled twice.

Right now, cabal somehow mixes types from the files compiled as part
of the test suite with types imported from the library.

Regards,

Erik

On Sun, Feb 2, 2014 at 10:32 PM, Richard Cobbe <cobbe at ccs.neu.edu> wrote:
> I'm working on a small project that involves an Alex scanner and a Happy
> parser, and I'm getting an error from the type-checker that I do not
> understand.  Can anyone help shed some light on what's going on?
>
> I'm running Haskell Platform 2013.2.0.0, on MacOS 10.8.5 with XCode 4.6.3.
>
> I've reduced the problem to a very small example, which I've attached as a
> tar file.  It's a cabal package, and it contains a library with some test
> cases.
>
> If I run "cabal configure && cabal build" then the library builds with no
> problems whatsoever.
>
> But if I run
>
>     cabal clean && cabal configure --enable-tests && cabal build
>
> then I get the following error message:
>
>     RunTests.hs:16:27:
>         Couldn't match expected type `sample-0.4:Ast.Entry'
>                     with actual type `Entry'
>         In the return type of a call of `Entry'
>         In the second argument of `(~?=)', namely `Entry "mumble"'
>         In the expression: parse "entry" ~?= Entry "mumble"
>
> And this doesn't make any sense to me, because the two types are supposed
> to be the same.
>
> If I take Happy and Alex out of the picture by replacing the Parser module
> with a hand-written parser, the error goes away.  This is hardly feasible
> in the actual project, of course :-) so I'm hoping someone can shed some
> light on what I'm doing wrong here.
>
> Thanks!
>
> Richard
>
> (I apologize for the attachment, by the way, but since filesystem layout is
> potentially important here, and since it's only slightly larger than 1K, I
> figured it was the best way.  If there's a better way to do this in the
> future (which doesn't assume I can throw it on the web somewhere), then I'd
> love to hear about it.)
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>

From roma at ro-che.info  Wed Feb  5 21:23:08 2014
From: roma at ro-che.info (Roman Cheplyaka)
Date: Wed, 5 Feb 2014 23:23:08 +0200
Subject: [Haskell-cafe] ANN: asynchronous-exceptions
In-Reply-To: <CAKA2JgJyonmwpscN_=9kXPTL0w7DT4LgB2wvvPyOc5z7BiinDQ@mail.gmail.com>
References: <20140205112338.GA5055@sniper> <20140205112801.GA5306@sniper>
 <CAKA2JgKSWQ8An-KK4gCjcaRChyoXhzVg8k-S5XDDvQvLDWKD6Q@mail.gmail.com>
 <20140205151926.GA9254@sniper>
 <CAKA2JgKWdLHYgyMWpHPo8vZB8RBXVmvba5xXceH+iNyGPcX-Cg@mail.gmail.com>
 <20140205162849.GC10049@sniper>
 <CAKA2JgJyonmwpscN_=9kXPTL0w7DT4LgB2wvvPyOc5z7BiinDQ@mail.gmail.com>
Message-ID: <20140205212308.GA12415@sniper>

Ok, this clears things up. I misinterpreted your approach thinking that
you're also solving the problem of distinguishing async vs sync
exceptions, only based on how they were thrown instead of their type.

I now see that it isn't the case ? you're catching *all* exceptions.
(And run the timeout handler in a different thread.)

So no wonder that asynchronous-exceptions (whose description says that
it lets differentiate between sync and async exceptions, in a certain
sense) doesn't help you ? you simply don't want any exceptions at all.

My use case is simpler ? I write testing libraries. If a test throws an
exception, we have to decide whether we want to report it as a test's
failure or it's a bigger problem and we want to wrap up. 

I don't think there's a universally right way to make this decision. It
depends on what exceptions exist and what threads they can be thrown to.
E.g. if there existed something like UserInterrupt but which could be
thrown to any active thread, not only the main thread, then the approach
"run in a separate thread and log any exceptions from that thread"
simply wouldn't work.

For tasty, based on the async exceptions I'm aware of, I think your
approach is overall better. It's almost as simple, doesn't require
patching 3rd-party timeout libraries, and catches StackOverflow (which
is desirable). So I'll switch to it instead.

For smallcheck, the overhead of forkIO might be significant, because it
has to be performed for every single property check, and those can be
numerous and very quick. I put together a simple benchmark
(http://lpaste.net/99532 if anyone is interested) which shows that
overhead can be noticable (16% for async vs 4% for simple catch) but
tolerable, and it will be even less for more realistic properties.
So I'll probably use the async approach there, too, although I may
reconsider that in the future if I ever get to optimizing smallcheck and
squeezing out those percents.

As for the package itself, let's see if others will find any good use
cases for it. I'll update the docs with some conclusions from this
thread.

And thanks for your input.

Roman

* Michael Snoyman <michael at snoyman.com> [2014-02-05 18:48:22+0200]
> I can't think of any situation in which the semantics you're implying make
> sense. To me, catching synchronous exception is a simple concept: if an
> exception is generated internally to `userAction`, then it's a synchronous
> exception. If it was terminated by something external, then it's
> asynchronous. I'm not sure what you're getting at about my approach
> requiring knowledge of what's going on deep inside a library.
> 
> The real question which is not explained in your package is what use case
> you're actually trying to address. Here's a prime example I've run into:
> you're writing a web application which uses a third-party library. If that
> library throws an exception of any type, you want to catch the exception
> and display an appropriate error message (or perhaps return some data from
> another source). However, we still want the web application to respect
> timeout messages from the server to avoid slowloris attacks. The handler
> code would look like:
> 
> myHandler = do
>     eres <- tryAnyDeep someLibraryFunction
>     case eres of
>         Left e -> tellUser "I'm sorry, there was an issue making the query"
>         Right x -> displayData x
> 
> The goal is that, under no circumstances, should someLibraryFunction be
> able to case the exception to escape tryAnyDeep. This includes rethrowing
> some async exception that it received from, e.g., a timeout. This would not
> be honored by trySync.
> 
> Michael
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140205/12e11122/attachment.sig>

From headprogrammingczar at gmail.com  Wed Feb  5 21:52:31 2014
From: headprogrammingczar at gmail.com (Joe Quinn)
Date: Wed, 05 Feb 2014 16:52:31 -0500
Subject: [Haskell-cafe] Is it possible to declare assignment operators
 in Haskell?
In-Reply-To: <20140205163718.188430a0@portege>
References: <20140205163718.188430a0@portege>
Message-ID: <52F2B29F.7070107@gmail.com>

On 2/5/2014 7:37 AM, Alexander Alexeev wrote:
> Hello!
>
> I'm wondering, is there any way to declare assignment operators
> in Haskell? For example, strict assignment operators:
>
> x .= y -- equals: let x = y `deepseq` y
> x := y -- equals: x <- y `deepseq` y
>
> As far as I can tell, Template Haskell is not able to do anything like
> this, because I can't event quote expressions like `let x = y` or `x <-
> y`. Is there any other way (plugin for GHC, etc)? Or maybe I'm doing
> something wrong and TH is quite able to handle this task?
>
> I'm pretty sure that I could use a preprocessor, but I wonted to find
> a better solution.
>
There are things that "act like assignment", but quite differently than 
what you are after, which looks like a macro of some sort.
For instance, one of the OpenGL packages defines (:=) = writeIORef, to 
be used like

spoofel depth stencil = do
   stencilVals <- map (> 0.35) <$> readIORef depth
   stencil := stencilVals

What is the type of (.=) and (:=) that you desire? What is the larger 
problem you are trying to solve?

From vogt.adam at gmail.com  Wed Feb  5 22:01:30 2014
From: vogt.adam at gmail.com (adam vogt)
Date: Wed, 5 Feb 2014 17:01:30 -0500
Subject: [Haskell-cafe] Is it possible to declare assignment operators
	in Haskell?
In-Reply-To: <20140205163718.188430a0@portege>
References: <20140205163718.188430a0@portege>
Message-ID: <CAHfjoWmsjWqNq2G7vyK8UsMYUG=O4AX8gbVM6Mg3_Bb+VRNknQ@mail.gmail.com>

Hi Alexander,

You could quote the whole do-block:

> $(strictify [| do y .= x; ... |])

And then strictify :: ExpQ -> ExpQ manipulates the AST a bit: x .= y does
parse as an expression, so you can change a NoBindS containing that .=
function into a BindS or LetS. Unfortunately the quotes built into TH
complain about undefined variables, so you'll probably have to use a
quasiquote instead (haskell-src-meta can help here).

Also, you may want to desugar to "let !x = y `deepseq` y", or involve
(return $!) since "let x = y `deepseq` y where y = undefined :: Int" only
crashes when you seq the x.

Adam



On Wed, Feb 5, 2014 at 7:37 AM, Alexander Alexeev <mail at eax.me> wrote:

> Hello!
>
> I'm wondering, is there any way to declare assignment operators
> in Haskell? For example, strict assignment operators:
>
> x .= y -- equals: let x = y `deepseq` y
> x := y -- equals: x <- y `deepseq` y
>
> As far as I can tell, Template Haskell is not able to do anything like
> this, because I can't event quote expressions like `let x = y` or `x <-
> y`. Is there any other way (plugin for GHC, etc)? Or maybe I'm doing
> something wrong and TH is quite able to handle this task?
>
> I'm pretty sure that I could use a preprocessor, but I wonted to find
> a better solution.
>
> --
> Best regards,
> Alexander Alexeev
> http://eax.me/
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140205/97ac4731/attachment.html>

From jmacristovao at gmail.com  Wed Feb  5 22:13:19 2014
From: jmacristovao at gmail.com (=?ISO-8859-1?B?Sm/jbyBDcmlzdPN2428=?=)
Date: Wed, 5 Feb 2014 22:13:19 +0000
Subject: [Haskell-cafe] ANN: asynchronous-exceptions
In-Reply-To: <20140205212308.GA12415@sniper>
References: <20140205112338.GA5055@sniper> <20140205112801.GA5306@sniper>
 <CAKA2JgKSWQ8An-KK4gCjcaRChyoXhzVg8k-S5XDDvQvLDWKD6Q@mail.gmail.com>
 <20140205151926.GA9254@sniper>
 <CAKA2JgKWdLHYgyMWpHPo8vZB8RBXVmvba5xXceH+iNyGPcX-Cg@mail.gmail.com>
 <20140205162849.GC10049@sniper>
 <CAKA2JgJyonmwpscN_=9kXPTL0w7DT4LgB2wvvPyOc5z7BiinDQ@mail.gmail.com>
 <20140205212308.GA12415@sniper>
Message-ID: <CAAbu24o=zuOJQkEHxYyKgkjq=Au7QwBK0+h7BSu5X6WZnVZ-kw@mail.gmail.com>

Roman,

By mere chance today I was, about the same time you published your
library, working on the suggestion made by Michael in the end of his
original blog post: splitting the async exceptions part from
classy-prelude (he is ok with this).

https://github.com/jcristovao/async-exception

I was not yet sure about the namespace, I had opted for:
Control.Concurrent.Async.Exception

But yours makes more sense,
Control.Async.Exception

I agree that the two solutions address different problems, and as you
say, for controlled situations where performance is critical yours
indeed adds less overhead. But for more general solutions, Michael's
solution - split from Classy prelude, seems to be the way to go, and
thus my 'split' makes sense if you don't need the remaining classy
prelude.

As such, I was considering the namespace:
Control.Async.Exception.All

To differentiate from yours, signaling that it handles _all_ exceptions.
What do you think?

Anyhow, I also think Joachim suggestion (of at least implementing the
new exception classes in base-compat) makes sense, so I volunteer to
add to the work I already done here:
https://github.com/sol/base-compat/pull/2

(If the patch gets accepted, of course).

Cheers,
Jo?o

2014-02-05 Roman Cheplyaka <roma at ro-che.info>:
> Ok, this clears things up. I misinterpreted your approach thinking that
> you're also solving the problem of distinguishing async vs sync
> exceptions, only based on how they were thrown instead of their type.
>
> I now see that it isn't the case -- you're catching *all* exceptions.
> (And run the timeout handler in a different thread.)
>
> So no wonder that asynchronous-exceptions (whose description says that
> it lets differentiate between sync and async exceptions, in a certain
> sense) doesn't help you -- you simply don't want any exceptions at all.
>
> My use case is simpler -- I write testing libraries. If a test throws an
> exception, we have to decide whether we want to report it as a test's
> failure or it's a bigger problem and we want to wrap up.
>
> I don't think there's a universally right way to make this decision. It
> depends on what exceptions exist and what threads they can be thrown to.
> E.g. if there existed something like UserInterrupt but which could be
> thrown to any active thread, not only the main thread, then the approach
> "run in a separate thread and log any exceptions from that thread"
> simply wouldn't work.
>
> For tasty, based on the async exceptions I'm aware of, I think your
> approach is overall better. It's almost as simple, doesn't require
> patching 3rd-party timeout libraries, and catches StackOverflow (which
> is desirable). So I'll switch to it instead.
>
> For smallcheck, the overhead of forkIO might be significant, because it
> has to be performed for every single property check, and those can be
> numerous and very quick. I put together a simple benchmark
> (http://lpaste.net/99532 if anyone is interested) which shows that
> overhead can be noticable (16% for async vs 4% for simple catch) but
> tolerable, and it will be even less for more realistic properties.
> So I'll probably use the async approach there, too, although I may
> reconsider that in the future if I ever get to optimizing smallcheck and
> squeezing out those percents.
>
> As for the package itself, let's see if others will find any good use
> cases for it. I'll update the docs with some conclusions from this
> thread.
>
> And thanks for your input.
>
> Roman
>
> * Michael Snoyman <michael at snoyman.com> [2014-02-05 18:48:22+0200]
>> I can't think of any situation in which the semantics you're implying make
>> sense. To me, catching synchronous exception is a simple concept: if an
>> exception is generated internally to `userAction`, then it's a synchronous
>> exception. If it was terminated by something external, then it's
>> asynchronous. I'm not sure what you're getting at about my approach
>> requiring knowledge of what's going on deep inside a library.
>>
>> The real question which is not explained in your package is what use case
>> you're actually trying to address. Here's a prime example I've run into:
>> you're writing a web application which uses a third-party library. If that
>> library throws an exception of any type, you want to catch the exception
>> and display an appropriate error message (or perhaps return some data from
>> another source). However, we still want the web application to respect
>> timeout messages from the server to avoid slowloris attacks. The handler
>> code would look like:
>>
>> myHandler = do
>>     eres <- tryAnyDeep someLibraryFunction
>>     case eres of
>>         Left e -> tellUser "I'm sorry, there was an issue making the query"
>>         Right x -> displayData x
>>
>> The goal is that, under no circumstances, should someLibraryFunction be
>> able to case the exception to escape tryAnyDeep. This includes rethrowing
>> some async exception that it received from, e.g., a timeout. This would not
>> be honored by trySync.
>>
>> Michael
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>

From roma at ro-che.info  Wed Feb  5 22:33:53 2014
From: roma at ro-che.info (Roman Cheplyaka)
Date: Thu, 6 Feb 2014 00:33:53 +0200
Subject: [Haskell-cafe] ANN: asynchronous-exceptions
In-Reply-To: <CAAbu24o=zuOJQkEHxYyKgkjq=Au7QwBK0+h7BSu5X6WZnVZ-kw@mail.gmail.com>
References: <20140205112338.GA5055@sniper> <20140205112801.GA5306@sniper>
 <CAKA2JgKSWQ8An-KK4gCjcaRChyoXhzVg8k-S5XDDvQvLDWKD6Q@mail.gmail.com>
 <20140205151926.GA9254@sniper>
 <CAKA2JgKWdLHYgyMWpHPo8vZB8RBXVmvba5xXceH+iNyGPcX-Cg@mail.gmail.com>
 <20140205162849.GC10049@sniper>
 <CAKA2JgJyonmwpscN_=9kXPTL0w7DT4LgB2wvvPyOc5z7BiinDQ@mail.gmail.com>
 <20140205212308.GA12415@sniper>
 <CAAbu24o=zuOJQkEHxYyKgkjq=Au7QwBK0+h7BSu5X6WZnVZ-kw@mail.gmail.com>
Message-ID: <20140205223353.GA17748@sniper>

Well, since you happened to ask me (although I am as good a bikeshedder
as the next person), I think that you don't need to mention Async
anywhere in the module name, since the module doesn't make any attempt
to differentiate between sync and async exceptions.

And the fact that the module uses the 'async' library is just an
implementation detail.

I'd go with something like Control.Exception.CatchAny.

Roman

* Jo?o Crist?v?o <jmacristovao at gmail.com> [2014-02-05 22:13:19+0000]
> Roman,
> 
> By mere chance today I was, about the same time you published your
> library, working on the suggestion made by Michael in the end of his
> original blog post: splitting the async exceptions part from
> classy-prelude (he is ok with this).
> 
> https://github.com/jcristovao/async-exception
> 
> I was not yet sure about the namespace, I had opted for:
> Control.Concurrent.Async.Exception
> 
> But yours makes more sense,
> Control.Async.Exception
> 
> I agree that the two solutions address different problems, and as you
> say, for controlled situations where performance is critical yours
> indeed adds less overhead. But for more general solutions, Michael's
> solution - split from Classy prelude, seems to be the way to go, and
> thus my 'split' makes sense if you don't need the remaining classy
> prelude.
> 
> As such, I was considering the namespace:
> Control.Async.Exception.All
> 
> To differentiate from yours, signaling that it handles _all_ exceptions.
> What do you think?
> 
> Anyhow, I also think Joachim suggestion (of at least implementing the
> new exception classes in base-compat) makes sense, so I volunteer to
> add to the work I already done here:
> https://github.com/sol/base-compat/pull/2
> 
> (If the patch gets accepted, of course).
> 
> Cheers,
> Jo?o
> 
> 2014-02-05 Roman Cheplyaka <roma at ro-che.info>:
> > Ok, this clears things up. I misinterpreted your approach thinking that
> > you're also solving the problem of distinguishing async vs sync
> > exceptions, only based on how they were thrown instead of their type.
> >
> > I now see that it isn't the case -- you're catching *all* exceptions.
> > (And run the timeout handler in a different thread.)
> >
> > So no wonder that asynchronous-exceptions (whose description says that
> > it lets differentiate between sync and async exceptions, in a certain
> > sense) doesn't help you -- you simply don't want any exceptions at all.
> >
> > My use case is simpler -- I write testing libraries. If a test throws an
> > exception, we have to decide whether we want to report it as a test's
> > failure or it's a bigger problem and we want to wrap up.
> >
> > I don't think there's a universally right way to make this decision. It
> > depends on what exceptions exist and what threads they can be thrown to.
> > E.g. if there existed something like UserInterrupt but which could be
> > thrown to any active thread, not only the main thread, then the approach
> > "run in a separate thread and log any exceptions from that thread"
> > simply wouldn't work.
> >
> > For tasty, based on the async exceptions I'm aware of, I think your
> > approach is overall better. It's almost as simple, doesn't require
> > patching 3rd-party timeout libraries, and catches StackOverflow (which
> > is desirable). So I'll switch to it instead.
> >
> > For smallcheck, the overhead of forkIO might be significant, because it
> > has to be performed for every single property check, and those can be
> > numerous and very quick. I put together a simple benchmark
> > (http://lpaste.net/99532 if anyone is interested) which shows that
> > overhead can be noticable (16% for async vs 4% for simple catch) but
> > tolerable, and it will be even less for more realistic properties.
> > So I'll probably use the async approach there, too, although I may
> > reconsider that in the future if I ever get to optimizing smallcheck and
> > squeezing out those percents.
> >
> > As for the package itself, let's see if others will find any good use
> > cases for it. I'll update the docs with some conclusions from this
> > thread.
> >
> > And thanks for your input.
> >
> > Roman
> >
> > * Michael Snoyman <michael at snoyman.com> [2014-02-05 18:48:22+0200]
> >> I can't think of any situation in which the semantics you're implying make
> >> sense. To me, catching synchronous exception is a simple concept: if an
> >> exception is generated internally to `userAction`, then it's a synchronous
> >> exception. If it was terminated by something external, then it's
> >> asynchronous. I'm not sure what you're getting at about my approach
> >> requiring knowledge of what's going on deep inside a library.
> >>
> >> The real question which is not explained in your package is what use case
> >> you're actually trying to address. Here's a prime example I've run into:
> >> you're writing a web application which uses a third-party library. If that
> >> library throws an exception of any type, you want to catch the exception
> >> and display an appropriate error message (or perhaps return some data from
> >> another source). However, we still want the web application to respect
> >> timeout messages from the server to avoid slowloris attacks. The handler
> >> code would look like:
> >>
> >> myHandler = do
> >>     eres <- tryAnyDeep someLibraryFunction
> >>     case eres of
> >>         Left e -> tellUser "I'm sorry, there was an issue making the query"
> >>         Right x -> displayData x
> >>
> >> The goal is that, under no circumstances, should someLibraryFunction be
> >> able to case the exception to escape tryAnyDeep. This includes rethrowing
> >> some async exception that it received from, e.g., a timeout. This would not
> >> be honored by trySync.
> >>
> >> Michael
> >
> > _______________________________________________
> > Haskell-Cafe mailing list
> > Haskell-Cafe at haskell.org
> > http://www.haskell.org/mailman/listinfo/haskell-cafe
> >
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140206/e438ad3f/attachment.sig>

From jmacristovao at gmail.com  Thu Feb  6 00:16:06 2014
From: jmacristovao at gmail.com (=?ISO-8859-1?B?Sm/jbyBDcmlzdPN2428=?=)
Date: Thu, 6 Feb 2014 00:16:06 +0000
Subject: [Haskell-cafe] ANN: asynchronous-exceptions
In-Reply-To: <20140205223353.GA17748@sniper>
References: <20140205112338.GA5055@sniper> <20140205112801.GA5306@sniper>
 <CAKA2JgKSWQ8An-KK4gCjcaRChyoXhzVg8k-S5XDDvQvLDWKD6Q@mail.gmail.com>
 <20140205151926.GA9254@sniper>
 <CAKA2JgKWdLHYgyMWpHPo8vZB8RBXVmvba5xXceH+iNyGPcX-Cg@mail.gmail.com>
 <20140205162849.GC10049@sniper>
 <CAKA2JgJyonmwpscN_=9kXPTL0w7DT4LgB2wvvPyOc5z7BiinDQ@mail.gmail.com>
 <20140205212308.GA12415@sniper>
 <CAAbu24o=zuOJQkEHxYyKgkjq=Au7QwBK0+h7BSu5X6WZnVZ-kw@mail.gmail.com>
 <20140205223353.GA17748@sniper>
Message-ID: <CAAbu24p+G+GCmXtdt5brGUeNMCaBA0tJwCni_04TtVqoxpcBJQ@mail.gmail.com>

Hi again,

> since the module doesn't make any attempt to differentiate between sync and async exceptions.

Well... If I am understanding this correctly, and I might not be:
Michael code efectively distinguishes exceptions thrown asynchronously
with throwTo from synchronous exceptions generated inside the
catchAny. Since the code run by catchAny is run in a separate
'anonymous' thread created by withAsync, there's no way you can throw
it an asynchronous exception (ThreadKilled) with throwTo - you don't
know its thread id.

Any code using throwTo will just know the calling thread, and thus
you've got a way to distinguish between received asynchronous
exceptions (the timeout example) and synchronous exceptions generated
inside the function your passing to catchAny.

Thus, in one hand I do not think "CatchAny" makes justice to the fact
that async exceptions received by the thread using catchAny are _not_
caught by catchAny.

In the other hand, I was just thinking: what if the computation runing
in catchAny in the anonymous thread generates a Ctrl-C, if, for
example, it interacts with stdin.
However, Control.Exception states that:
"UserInterrupt: This exception is raised by default in the __main__
thread of the program when the user requests to terminate the program
via the usual mechanism(s) (e.g. Control-C in the console). "
(emphasis mine)

Thus, the problem does not pose it self. The remaining two
asynchronous exceptions (StackOverflow and HeapOverflow) are again a
result of the inner function execution, and could, from a certain
point of view, be considered synchronous.

So, for all intents and purposes, this catchAny and such _do_ allow to
distinguish between asynchronous exceptions (sent with throwTo) or
synchronous exceptions (generated as a result of the execution of the
computation passed to catchAny). Asynchronous exceptions do not occur
inside the CatchAny associated computation, except perhaps the
ThreadKilled signal forward by its calling thread/parent thread when
it self is killed - an in that particular case, it doesn't really
matter. That asynchronous exception would be caught by catchAny, but
the result returned by the exception handler would not be used - the
calling thread is also dying.

Am I getting this right?
Jo?o

2014-02-05 Roman Cheplyaka <roma at ro-che.info>:
> Well, since you happened to ask me (although I am as good a bikeshedder
> as the next person), I think that you don't need to mention Async
> anywhere in the module name, since the module doesn't make any attempt
> to differentiate between sync and async exceptions.
>
> And the fact that the module uses the 'async' library is just an
> implementation detail.
>
> I'd go with something like Control.Exception.CatchAny.
>
> Roman
>
> * Jo?o Crist?v?o <jmacristovao at gmail.com> [2014-02-05 22:13:19+0000]
>> Roman,
>>
>> By mere chance today I was, about the same time you published your
>> library, working on the suggestion made by Michael in the end of his
>> original blog post: splitting the async exceptions part from
>> classy-prelude (he is ok with this).
>>
>> https://github.com/jcristovao/async-exception
>>
>> I was not yet sure about the namespace, I had opted for:
>> Control.Concurrent.Async.Exception
>>
>> But yours makes more sense,
>> Control.Async.Exception
>>
>> I agree that the two solutions address different problems, and as you
>> say, for controlled situations where performance is critical yours
>> indeed adds less overhead. But for more general solutions, Michael's
>> solution - split from Classy prelude, seems to be the way to go, and
>> thus my 'split' makes sense if you don't need the remaining classy
>> prelude.
>>
>> As such, I was considering the namespace:
>> Control.Async.Exception.All
>>
>> To differentiate from yours, signaling that it handles _all_ exceptions.
>> What do you think?
>>
>> Anyhow, I also think Joachim suggestion (of at least implementing the
>> new exception classes in base-compat) makes sense, so I volunteer to
>> add to the work I already done here:
>> https://github.com/sol/base-compat/pull/2
>>
>> (If the patch gets accepted, of course).
>>
>> Cheers,
>> Jo?o
>>
>> 2014-02-05 Roman Cheplyaka <roma at ro-che.info>:
>> > Ok, this clears things up. I misinterpreted your approach thinking that
>> > you're also solving the problem of distinguishing async vs sync
>> > exceptions, only based on how they were thrown instead of their type.
>> >
>> > I now see that it isn't the case -- you're catching *all* exceptions.
>> > (And run the timeout handler in a different thread.)
>> >
>> > So no wonder that asynchronous-exceptions (whose description says that
>> > it lets differentiate between sync and async exceptions, in a certain
>> > sense) doesn't help you -- you simply don't want any exceptions at all.
>> >
>> > My use case is simpler -- I write testing libraries. If a test throws an
>> > exception, we have to decide whether we want to report it as a test's
>> > failure or it's a bigger problem and we want to wrap up.
>> >
>> > I don't think there's a universally right way to make this decision. It
>> > depends on what exceptions exist and what threads they can be thrown to.
>> > E.g. if there existed something like UserInterrupt but which could be
>> > thrown to any active thread, not only the main thread, then the approach
>> > "run in a separate thread and log any exceptions from that thread"
>> > simply wouldn't work.
>> >
>> > For tasty, based on the async exceptions I'm aware of, I think your
>> > approach is overall better. It's almost as simple, doesn't require
>> > patching 3rd-party timeout libraries, and catches StackOverflow (which
>> > is desirable). So I'll switch to it instead.
>> >
>> > For smallcheck, the overhead of forkIO might be significant, because it
>> > has to be performed for every single property check, and those can be
>> > numerous and very quick. I put together a simple benchmark
>> > (http://lpaste.net/99532 if anyone is interested) which shows that
>> > overhead can be noticable (16% for async vs 4% for simple catch) but
>> > tolerable, and it will be even less for more realistic properties.
>> > So I'll probably use the async approach there, too, although I may
>> > reconsider that in the future if I ever get to optimizing smallcheck and
>> > squeezing out those percents.
>> >
>> > As for the package itself, let's see if others will find any good use
>> > cases for it. I'll update the docs with some conclusions from this
>> > thread.
>> >
>> > And thanks for your input.
>> >
>> > Roman
>> >
>> > * Michael Snoyman <michael at snoyman.com> [2014-02-05 18:48:22+0200]
>> >> I can't think of any situation in which the semantics you're implying make
>> >> sense. To me, catching synchronous exception is a simple concept: if an
>> >> exception is generated internally to `userAction`, then it's a synchronous
>> >> exception. If it was terminated by something external, then it's
>> >> asynchronous. I'm not sure what you're getting at about my approach
>> >> requiring knowledge of what's going on deep inside a library.
>> >>
>> >> The real question which is not explained in your package is what use case
>> >> you're actually trying to address. Here's a prime example I've run into:
>> >> you're writing a web application which uses a third-party library. If that
>> >> library throws an exception of any type, you want to catch the exception
>> >> and display an appropriate error message (or perhaps return some data from
>> >> another source). However, we still want the web application to respect
>> >> timeout messages from the server to avoid slowloris attacks. The handler
>> >> code would look like:
>> >>
>> >> myHandler = do
>> >>     eres <- tryAnyDeep someLibraryFunction
>> >>     case eres of
>> >>         Left e -> tellUser "I'm sorry, there was an issue making the query"
>> >>         Right x -> displayData x
>> >>
>> >> The goal is that, under no circumstances, should someLibraryFunction be
>> >> able to case the exception to escape tryAnyDeep. This includes rethrowing
>> >> some async exception that it received from, e.g., a timeout. This would not
>> >> be honored by trySync.
>> >>
>> >> Michael
>> >
>> > _______________________________________________
>> > Haskell-Cafe mailing list
>> > Haskell-Cafe at haskell.org
>> > http://www.haskell.org/mailman/listinfo/haskell-cafe
>> >

From roma at ro-che.info  Thu Feb  6 06:17:07 2014
From: roma at ro-che.info (Roman Cheplyaka)
Date: Thu, 6 Feb 2014 08:17:07 +0200
Subject: [Haskell-cafe] ANN: asynchronous-exceptions
In-Reply-To: <CAAbu24p+G+GCmXtdt5brGUeNMCaBA0tJwCni_04TtVqoxpcBJQ@mail.gmail.com>
References: <20140205112801.GA5306@sniper>
 <CAKA2JgKSWQ8An-KK4gCjcaRChyoXhzVg8k-S5XDDvQvLDWKD6Q@mail.gmail.com>
 <20140205151926.GA9254@sniper>
 <CAKA2JgKWdLHYgyMWpHPo8vZB8RBXVmvba5xXceH+iNyGPcX-Cg@mail.gmail.com>
 <20140205162849.GC10049@sniper>
 <CAKA2JgJyonmwpscN_=9kXPTL0w7DT4LgB2wvvPyOc5z7BiinDQ@mail.gmail.com>
 <20140205212308.GA12415@sniper>
 <CAAbu24o=zuOJQkEHxYyKgkjq=Au7QwBK0+h7BSu5X6WZnVZ-kw@mail.gmail.com>
 <20140205223353.GA17748@sniper>
 <CAAbu24p+G+GCmXtdt5brGUeNMCaBA0tJwCni_04TtVqoxpcBJQ@mail.gmail.com>
Message-ID: <20140206061707.GA19197@sniper>

> Am I getting this right?

Not quite.

The enclosed computation may get asynchronous exceptions whatever
definition of 'asynchronous' you use ? the exact one (by throw method)
or the approximate one (by type).

Just a couple of examples:

* The thread may catch an async exception from the RTS (such as
  BlockedIndefinitelyOnMVar or StackOverflow)
* The thread may spawn other threads, passing its pid to them, and one
  of its children may eventually kill it

So I'd say this method allows to catch any exceptions "related" to
the computation, synchronous or asynchronous. It is this "relatedness"
that is enforced by running it in a separate thread.

Roman

* Jo?o Crist?v?o <jmacristovao at gmail.com> [2014-02-06 00:16:06+0000]
> Hi again,
> 
> > since the module doesn't make any attempt to differentiate between sync and async exceptions.
> 
> Well... If I am understanding this correctly, and I might not be:
> Michael code efectively distinguishes exceptions thrown asynchronously
> with throwTo from synchronous exceptions generated inside the
> catchAny. Since the code run by catchAny is run in a separate
> 'anonymous' thread created by withAsync, there's no way you can throw
> it an asynchronous exception (ThreadKilled) with throwTo - you don't
> know its thread id.
> 
> Any code using throwTo will just know the calling thread, and thus
> you've got a way to distinguish between received asynchronous
> exceptions (the timeout example) and synchronous exceptions generated
> inside the function your passing to catchAny.
> 
> Thus, in one hand I do not think "CatchAny" makes justice to the fact
> that async exceptions received by the thread using catchAny are _not_
> caught by catchAny.
> 
> In the other hand, I was just thinking: what if the computation runing
> in catchAny in the anonymous thread generates a Ctrl-C, if, for
> example, it interacts with stdin.
> However, Control.Exception states that:
> "UserInterrupt: This exception is raised by default in the __main__
> thread of the program when the user requests to terminate the program
> via the usual mechanism(s) (e.g. Control-C in the console). "
> (emphasis mine)
> 
> Thus, the problem does not pose it self. The remaining two
> asynchronous exceptions (StackOverflow and HeapOverflow) are again a
> result of the inner function execution, and could, from a certain
> point of view, be considered synchronous.
> 
> So, for all intents and purposes, this catchAny and such _do_ allow to
> distinguish between asynchronous exceptions (sent with throwTo) or
> synchronous exceptions (generated as a result of the execution of the
> computation passed to catchAny). Asynchronous exceptions do not occur
> inside the CatchAny associated computation, except perhaps the
> ThreadKilled signal forward by its calling thread/parent thread when
> it self is killed - an in that particular case, it doesn't really
> matter. That asynchronous exception would be caught by catchAny, but
> the result returned by the exception handler would not be used - the
> calling thread is also dying.
> 
> Am I getting this right?
> Jo?o
> 
> 2014-02-05 Roman Cheplyaka <roma at ro-che.info>:
> > Well, since you happened to ask me (although I am as good a bikeshedder
> > as the next person), I think that you don't need to mention Async
> > anywhere in the module name, since the module doesn't make any attempt
> > to differentiate between sync and async exceptions.
> >
> > And the fact that the module uses the 'async' library is just an
> > implementation detail.
> >
> > I'd go with something like Control.Exception.CatchAny.
> >
> > Roman
> >
> > * Jo?o Crist?v?o <jmacristovao at gmail.com> [2014-02-05 22:13:19+0000]
> >> Roman,
> >>
> >> By mere chance today I was, about the same time you published your
> >> library, working on the suggestion made by Michael in the end of his
> >> original blog post: splitting the async exceptions part from
> >> classy-prelude (he is ok with this).
> >>
> >> https://github.com/jcristovao/async-exception
> >>
> >> I was not yet sure about the namespace, I had opted for:
> >> Control.Concurrent.Async.Exception
> >>
> >> But yours makes more sense,
> >> Control.Async.Exception
> >>
> >> I agree that the two solutions address different problems, and as you
> >> say, for controlled situations where performance is critical yours
> >> indeed adds less overhead. But for more general solutions, Michael's
> >> solution - split from Classy prelude, seems to be the way to go, and
> >> thus my 'split' makes sense if you don't need the remaining classy
> >> prelude.
> >>
> >> As such, I was considering the namespace:
> >> Control.Async.Exception.All
> >>
> >> To differentiate from yours, signaling that it handles _all_ exceptions.
> >> What do you think?
> >>
> >> Anyhow, I also think Joachim suggestion (of at least implementing the
> >> new exception classes in base-compat) makes sense, so I volunteer to
> >> add to the work I already done here:
> >> https://github.com/sol/base-compat/pull/2
> >>
> >> (If the patch gets accepted, of course).
> >>
> >> Cheers,
> >> Jo?o
> >>
> >> 2014-02-05 Roman Cheplyaka <roma at ro-che.info>:
> >> > Ok, this clears things up. I misinterpreted your approach thinking that
> >> > you're also solving the problem of distinguishing async vs sync
> >> > exceptions, only based on how they were thrown instead of their type.
> >> >
> >> > I now see that it isn't the case -- you're catching *all* exceptions.
> >> > (And run the timeout handler in a different thread.)
> >> >
> >> > So no wonder that asynchronous-exceptions (whose description says that
> >> > it lets differentiate between sync and async exceptions, in a certain
> >> > sense) doesn't help you -- you simply don't want any exceptions at all.
> >> >
> >> > My use case is simpler -- I write testing libraries. If a test throws an
> >> > exception, we have to decide whether we want to report it as a test's
> >> > failure or it's a bigger problem and we want to wrap up.
> >> >
> >> > I don't think there's a universally right way to make this decision. It
> >> > depends on what exceptions exist and what threads they can be thrown to.
> >> > E.g. if there existed something like UserInterrupt but which could be
> >> > thrown to any active thread, not only the main thread, then the approach
> >> > "run in a separate thread and log any exceptions from that thread"
> >> > simply wouldn't work.
> >> >
> >> > For tasty, based on the async exceptions I'm aware of, I think your
> >> > approach is overall better. It's almost as simple, doesn't require
> >> > patching 3rd-party timeout libraries, and catches StackOverflow (which
> >> > is desirable). So I'll switch to it instead.
> >> >
> >> > For smallcheck, the overhead of forkIO might be significant, because it
> >> > has to be performed for every single property check, and those can be
> >> > numerous and very quick. I put together a simple benchmark
> >> > (http://lpaste.net/99532 if anyone is interested) which shows that
> >> > overhead can be noticable (16% for async vs 4% for simple catch) but
> >> > tolerable, and it will be even less for more realistic properties.
> >> > So I'll probably use the async approach there, too, although I may
> >> > reconsider that in the future if I ever get to optimizing smallcheck and
> >> > squeezing out those percents.
> >> >
> >> > As for the package itself, let's see if others will find any good use
> >> > cases for it. I'll update the docs with some conclusions from this
> >> > thread.
> >> >
> >> > And thanks for your input.
> >> >
> >> > Roman
> >> >
> >> > * Michael Snoyman <michael at snoyman.com> [2014-02-05 18:48:22+0200]
> >> >> I can't think of any situation in which the semantics you're implying make
> >> >> sense. To me, catching synchronous exception is a simple concept: if an
> >> >> exception is generated internally to `userAction`, then it's a synchronous
> >> >> exception. If it was terminated by something external, then it's
> >> >> asynchronous. I'm not sure what you're getting at about my approach
> >> >> requiring knowledge of what's going on deep inside a library.
> >> >>
> >> >> The real question which is not explained in your package is what use case
> >> >> you're actually trying to address. Here's a prime example I've run into:
> >> >> you're writing a web application which uses a third-party library. If that
> >> >> library throws an exception of any type, you want to catch the exception
> >> >> and display an appropriate error message (or perhaps return some data from
> >> >> another source). However, we still want the web application to respect
> >> >> timeout messages from the server to avoid slowloris attacks. The handler
> >> >> code would look like:
> >> >>
> >> >> myHandler = do
> >> >>     eres <- tryAnyDeep someLibraryFunction
> >> >>     case eres of
> >> >>         Left e -> tellUser "I'm sorry, there was an issue making the query"
> >> >>         Right x -> displayData x
> >> >>
> >> >> The goal is that, under no circumstances, should someLibraryFunction be
> >> >> able to case the exception to escape tryAnyDeep. This includes rethrowing
> >> >> some async exception that it received from, e.g., a timeout. This would not
> >> >> be honored by trySync.
> >> >>
> >> >> Michael
> >> >
> >> > _______________________________________________
> >> > Haskell-Cafe mailing list
> >> > Haskell-Cafe at haskell.org
> >> > http://www.haskell.org/mailman/listinfo/haskell-cafe
> >> >
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140206/20859a04/attachment.sig>

From genial at alva.ro  Thu Feb  6 07:59:50 2014
From: genial at alva.ro (Alvaro J. Genial)
Date: Thu, 6 Feb 2014 02:59:50 -0500
Subject: [Haskell-cafe] Thr Neat templating system
Message-ID: <CAF3sfDq=O78GMfj9wz+ROy2G5e2jLioViEY2g3_TwsSaL+Y=wQ@mail.gmail.com>

Howdy,

I wrote a template system that I've used in a few personal projects and I
thought it might be worth it to clean the core of it up a bit and show it
to the world. I named it `neat`, for no other reason than I found it so;
you can find the sources, an explanation of how it works and basic
instructions on how to try it and experiment with it here:

  https://github.com/ajg/neat

>From the synopsis:

"Neat is a slightly unusual templating tool that does not interpret
templates at runtime; rather, it compiles templates statically from the
source (input) language into the target (output) language. In that sense
neat can be thought of as a very flexible preprocessor masquerading as
something fancier. Of course, the result can then be embedded or compiled
directly in order to accept arbitrary data at runtime and transform it as
desired, dynamically."

I haven't released it as a proper package because I don't know whether
it'll be useful; for now it's just a pet project; it is MIT-licensed. I'd
like to get your ideas, suggestions, criticism, and other feedback.

Thank you,

Alvaro
http://alva.ro
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140206/58fbce36/attachment.html>

From genial at alva.ro  Thu Feb  6 08:25:06 2014
From: genial at alva.ro (Alvaro J. Genial)
Date: Thu, 6 Feb 2014 03:25:06 -0500
Subject: [Haskell-cafe] Thr Neat templating system
In-Reply-To: <CAF3sfDq=O78GMfj9wz+ROy2G5e2jLioViEY2g3_TwsSaL+Y=wQ@mail.gmail.com>
References: <CAF3sfDq=O78GMfj9wz+ROy2G5e2jLioViEY2g3_TwsSaL+Y=wQ@mail.gmail.com>
Message-ID: <CAF3sfDpJoEpi49qbOkdU0zthL2agRzcwmpKzd1y=5DDig5Szzg@mail.gmail.com>

That should have been *The--no affiliation to The Hollywood Reporter was
intended. :)

Alvaro

Alvaro
http://alva.ro


On Thu, Feb 6, 2014 at 2:59 AM, Alvaro J. Genial <genial at alva.ro> wrote:

> Howdy,
>
> I wrote a template system that I've used in a few personal projects and I
> thought it might be worth it to clean the core of it up a bit and show it
> to the world. I named it `neat`, for no other reason than I found it so;
> you can find the sources, an explanation of how it works and basic
> instructions on how to try it and experiment with it here:
>
>   https://github.com/ajg/neat
>
> From the synopsis:
>
> "Neat is a slightly unusual templating tool that does not interpret
> templates at runtime; rather, it compiles templates statically from the
> source (input) language into the target (output) language. In that sense
> neat can be thought of as a very flexible preprocessor masquerading as
> something fancier. Of course, the result can then be embedded or compiled
> directly in order to accept arbitrary data at runtime and transform it as
> desired, dynamically."
>
> I haven't released it as a proper package because I don't know whether
> it'll be useful; for now it's just a pet project; it is MIT-licensed. I'd
> like to get your ideas, suggestions, criticism, and other feedback.
>
> Thank you,
>
> Alvaro
> http://alva.ro
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140206/6ae8aa5f/attachment.html>

From michael at snoyman.com  Thu Feb  6 09:07:37 2014
From: michael at snoyman.com (Michael Snoyman)
Date: Thu, 6 Feb 2014 11:07:37 +0200
Subject: [Haskell-cafe] ANN: asynchronous-exceptions
In-Reply-To: <20140206061707.GA19197@sniper>
References: <20140205112801.GA5306@sniper>
 <CAKA2JgKSWQ8An-KK4gCjcaRChyoXhzVg8k-S5XDDvQvLDWKD6Q@mail.gmail.com>
 <20140205151926.GA9254@sniper>
 <CAKA2JgKWdLHYgyMWpHPo8vZB8RBXVmvba5xXceH+iNyGPcX-Cg@mail.gmail.com>
 <20140205162849.GC10049@sniper>
 <CAKA2JgJyonmwpscN_=9kXPTL0w7DT4LgB2wvvPyOc5z7BiinDQ@mail.gmail.com>
 <20140205212308.GA12415@sniper>
 <CAAbu24o=zuOJQkEHxYyKgkjq=Au7QwBK0+h7BSu5X6WZnVZ-kw@mail.gmail.com>
 <20140205223353.GA17748@sniper>
 <CAAbu24p+G+GCmXtdt5brGUeNMCaBA0tJwCni_04TtVqoxpcBJQ@mail.gmail.com>
 <20140206061707.GA19197@sniper>
Message-ID: <CAKA2JgL+N3_TzE-8vEVRTnfpi0SyK4fi7xFHjqmQwOOSxSeQPw@mail.gmail.com>

On Thu, Feb 6, 2014 at 8:17 AM, Roman Cheplyaka <roma at ro-che.info> wrote:

> > Am I getting this right?
>
> Not quite.
>
> The enclosed computation may get asynchronous exceptions whatever
> definition of 'asynchronous' you use -- the exact one (by throw method)
> or the approximate one (by type).
>
> Just a couple of examples:
>
> * The thread may catch an async exception from the RTS (such as
>   BlockedIndefinitelyOnMVar or StackOverflow)
> * The thread may spawn other threads, passing its pid to them, and one
>   of its children may eventually kill it
>
> So I'd say this method allows to catch any exceptions "related" to
> the computation, synchronous or asynchronous. It is this "relatedness"
> that is enforced by running it in a separate thread.
>
> Roman
>
>
I definitely think this is important to get our terminology right. A lot of
the scariness of async exceptions likely spawns from the fact that we use
the same term to refer to a number of very different cases. Let me give a
crack at breaking down exceptions:

* An exception with a synchronous type (e.g., IOException) thrown via
throwIO. This is the most synchronous of synchronous exceptions.
* An exception with an asynchronous type (e.g., UserInterrupt) thrown via
throwIO. There's legitimate room for debate as to what we should call this.
For my purposes, I'd want to call it a synchronous exception.
* An exception with a synchronous type thrown via throwTo. Similar to
previous bullet, but I'd consider this asynchronous.
* An exception with an asynchronous type thrown via throwTo. This is
solidly an asynchronous exception.

Then we have some more interesting questions:

* What *is* an asynchronous type? By including BlockedIndefinitelyOnMVar,
it seems like you're defining it to include any exception generated by the
RTS. However, I'd consider it a synchronous exception: it is generated in
direct consequence of performing an IO action. It just happens to be
generated by the RTS instead of via some library talking to the filesystem.
* What happens if an async exception is caught and then rethrown? Has it
transformed itself into a synchronous exception? That's a tricky question,
and likely depends on the exact manner in which is was caught.
* What happens if a function utilizes some form of asynchronous exception
mechanism to affect its behavior? The prime example of this is `timeout`,
or better, the `asyncTimeout` function I displayed above. Internally to
that function, I think that's an async exception. However, for a *caller*
of that function, the behavior is actually synchronous: there was no
notification from the outside world changing the behavior of this function,
it simply has the possibility to terminate by throwing a Timeout, the same
way a function may terminate by throwing an IOException.

That last bullet is crucial to the question of whether
classy-prelude's and Jo?o's
catching functions are asynchronous or not. But given how overloaded the
term is, I'd be in favor of coming up with a new term to represent what
these catch functions are intended to do.

Michael
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140206/da01b766/attachment.html>

From genial at alva.ro  Thu Feb  6 09:14:21 2014
From: genial at alva.ro (Alvaro J. Genial)
Date: Thu, 6 Feb 2014 04:14:21 -0500
Subject: [Haskell-cafe] Generalized null / zero
In-Reply-To: <CAAbu24o8Lud69F8mSbgh+xb2xOZHRW2AOXTrWR6iW9GMeAr2Vw@mail.gmail.com>
References: <CAF3sfDpKE64Eg5myQqi2m-MKrUqN8iTMRMRZY8OboqW3PRoEfQ@mail.gmail.com>
 <CAKA2JgLmx83bn9NwSBw+=RWBB3kJo-FGsPCBnpNRreCzyZZUHQ@mail.gmail.com>
 <52E8BF6C.7050908@informatik.uni-kiel.de>
 <CAAbu24o8Lud69F8mSbgh+xb2xOZHRW2AOXTrWR6iW9GMeAr2Vw@mail.gmail.com>
Message-ID: <CAF3sfDpzJyKtheQrMtX+AeLPo1dn1A80Yj3PEhMH4LxveOz74w@mail.gmail.com>

Hey Jo?o,

On Wed, Jan 29, 2014 at 5:13 AM, Jo?o Crist?v?o <jmacristovao at gmail.com>
 wrote:
>
> This leads to:
>
> zero (Product 1) = True.
>
> Is this what you wanted?
>

Indeed, it seems not. I'll have to think about this further.

Thank you,

Alvaro
http://alva.ro
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140206/82aca86c/attachment.html>

From genial at alva.ro  Thu Feb  6 09:17:14 2014
From: genial at alva.ro (Alvaro J. Genial)
Date: Thu, 6 Feb 2014 04:17:14 -0500
Subject: [Haskell-cafe] Generalized null / zero
In-Reply-To: <52ED2A0F.9030305@acanac.net>
References: <CAF3sfDpKE64Eg5myQqi2m-MKrUqN8iTMRMRZY8OboqW3PRoEfQ@mail.gmail.com>
 <52ED2A0F.9030305@acanac.net>
Message-ID: <CAF3sfDoaLdHo9cqsPNSvj1Jfxn5LQq40LuWwTZVyU-bmrT6Khg@mail.gmail.com>

On Sat, Feb 1, 2014 at 12:08 PM, Mario Bla?evi? <blamario at acanac.net> wrote:

> On 01/28/14 21:25, Alvaro J. Genial wrote:
>
>> 1. Is there a more general version of `null`? (e.g. for a Monad, Functor,
>> Applicative, Traversable or the like.)
>>
>
> There is the MonoidNull class from my monoid-subclasses library. It comes
> with plenty of standard instances.
>

This is very nice as it seems to mesh with my current thinking; I may end
up using it in Neat [1] shortly.

Thank you,

Alvaro
http://alva.ro

[1] https://github.com/ajg/neat
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140206/0461a12a/attachment.html>

From cobbe at ccs.neu.edu  Thu Feb  6 11:46:45 2014
From: cobbe at ccs.neu.edu (Richard Cobbe)
Date: Thu, 6 Feb 2014 06:46:45 -0500
Subject: [Haskell-cafe] problem with happy and type identity
In-Reply-To: <CAPeieQHA3+xGnufwXbha2Av-jAYYzVmcW2u+v80-tvmejqVYjg@mail.gmail.com>
References: <20140202213219.GA238@ridcully.local>
 <CAPeieQHA3+xGnufwXbha2Av-jAYYzVmcW2u+v80-tvmejqVYjg@mail.gmail.com>
Message-ID: <20140206114645.GA238@ridcully.home>

On Wed, Feb 05, 2014 at 08:34:40PM +0100, Erik Hesselink wrote:
> To be able to share code between your library and your tests, you should either
>
> * Have a separate directory for the library sources and the test
> sources. For example, put Ast.hs and Parser.y in 'src' and put
> 'Hs-source-dirs: src' in the library section. Put RunTests.hs in
> 'tests', and put 'Hs-source-dirs: tests' in the test-suite section.
> This is the preferred way.
> * Alternatively, don't specify 'sample' as a build-depends in the
> test-suite. Note that this will mean that Ast and Parser will get
> compiled twice.
>
> Right now, cabal somehow mixes types from the files compiled as part
> of the test suite with types imported from the library.

I see -- thanks!  I'll give that a shot as soon as I get a chance.

Richard

From P.Achten at cs.ru.nl  Thu Feb  6 13:33:12 2014
From: P.Achten at cs.ru.nl (Peter Achten)
Date: Thu, 06 Feb 2014 14:33:12 +0100
Subject: [Haskell-cafe] 2nd Call for Papers - TFPIE 2014
Message-ID: <52F38F18.7090305@cs.ru.nl>

All,

Please find below the call for papers for the 3rd International Workshop 
on Trends In Functional Programming in Education, TFPIE 2014. 
  Apologies in advance for multiple copies you may receive.

Best regards,
James Caldwell



Call for Papers
___________________________________________________________________________________

*3rd International Workshop on Trends in Functional Programming in 
Education (TFPIE 2014)*
May 25, 2014
Utrecht University
Soesterberg, The Netherlands
(http://www.cs.uwyo.edu/~jlc/tfpie14/ 
<http://www.cs.uwyo.edu/%7Ejlc/tfpie14/>)


The 3rd International Workshop on Trends in Functional Programming in 
Education, TFPIE 2014, will be co-located with the Symposium on Trends 
in Functional Programming (TFP 2014) <http://www.cs.uu.nl/wiki/TFP2014/> 
at Soesterberg, at the "Kontakt der Kontinenten" 
<http://www.kontaktderkontinenten.nl/conferentiehotel/home.aspx?lang=en-US> 
hotel in the Netherlands on Sunday, May 25th.  TFP will follow from May 
26-28.


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 2014 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 2014 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 journalElectronic Proceedings in Theoretical Computer Science 
(EPTCS) <http://published.eptcs.org/>. Articles not selected for 
presentation and extended abstracts will not be formally reviewed by the PC.

TFPIE workshops have previously been held in St Andrews, Scotland (2012) 
and in Provo Utah, USA (2013).

*Program Committee*

James Caldwell, (Program Chair) University of Wyoming
Peter Achten, Radboud University, Nijmgen
Edwin Brady, University of St Andrews, St Andrews
Jurriaan Hage, Universiteit Utrecht
Philip Holzenspies, University of Twente
Daniel R. Licata, Wesleyan University
Marco T Morazan, Seton Hall University
Christian Skalka, University of Vermont
David Van Horn, Northeastern University

*Submission Guidelines*

There will be two types of presentations at TFPIE 2014.  Regular papers 
and "best lecture" presentations.  The best lecture talks are intended 
to allow for presentations or short lectures of purely pedagogical 
material. Papers and abstracts can be submitted via easychair at the 
following link: https://www.easychair.org/conferences/?conf=tfpie2014

*Papers*

TFPIE 2014 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
* 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, this year we are requesting "best lecture" 
presentations.  What's 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.

*Important Dates*

* 1 February 2014: TFPIE submissions open on easychair.
* 7 April 2014: TFP and TFPIE registration opens
* 21 April 2014: Submission deadline for draft TFPIE papers and abstracts
* 27  April 2014: Notification of acceptance for presentation
* 25 May 2014: Presentations in Soesterberg, Netherlands
* 29 June 2014: Full papers for EPTCS proceedings due.
* 16 August 2014: Notification of acceptance for proceedings
*  8 September 2014: Camera ready copy due for EPTCS

Submission of an abstract implies no obligation to submit a full paper; 
abstracts with no corresponding full versions by the full paper deadline 
will be considered as withdrawn.  At least one author from each accepted 
presentation must attend the workshop.

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140206/506993d9/attachment.html>

From michael at snoyman.com  Thu Feb  6 12:35:02 2014
From: michael at snoyman.com (Michael Snoyman)
Date: Thu, 6 Feb 2014 14:35:02 +0200
Subject: [Haskell-cafe] ANN: asynchronous-exceptions
In-Reply-To: <CAAbu24qZuZLJofbvL+g4w1e4cBT6+1bBnV6B8VtU0W4AeANvQg@mail.gmail.com>
References: <20140205112801.GA5306@sniper>
 <CAKA2JgKSWQ8An-KK4gCjcaRChyoXhzVg8k-S5XDDvQvLDWKD6Q@mail.gmail.com>
 <20140205151926.GA9254@sniper>
 <CAKA2JgKWdLHYgyMWpHPo8vZB8RBXVmvba5xXceH+iNyGPcX-Cg@mail.gmail.com>
 <20140205162849.GC10049@sniper>
 <CAKA2JgJyonmwpscN_=9kXPTL0w7DT4LgB2wvvPyOc5z7BiinDQ@mail.gmail.com>
 <20140205212308.GA12415@sniper>
 <CAAbu24o=zuOJQkEHxYyKgkjq=Au7QwBK0+h7BSu5X6WZnVZ-kw@mail.gmail.com>
 <20140205223353.GA17748@sniper>
 <CAAbu24p+G+GCmXtdt5brGUeNMCaBA0tJwCni_04TtVqoxpcBJQ@mail.gmail.com>
 <20140206061707.GA19197@sniper>
 <CAKA2JgL+N3_TzE-8vEVRTnfpi0SyK4fi7xFHjqmQwOOSxSeQPw@mail.gmail.com>
 <CAAbu24qZuZLJofbvL+g4w1e4cBT6+1bBnV6B8VtU0W4AeANvQg@mail.gmail.com>
Message-ID: <CAKA2JgKCkWr2YE_JtCHFGcdm4T+YLXpBmw+qHJp4HExEMb9OaA@mail.gmail.com>

I like the idea of renaming the module to reflect this concept (I'm fine
with either Inner or Enclosed), but leaving the function names themselves
as-is.


On Thu, Feb 6, 2014 at 2:12 PM, Jo?o Crist?v?o <jmacristovao at gmail.com>wrote:

> Thanks Roman and Michael for the latest clarifications:
>
> I had indeed forgot the case where a thread runned in catchAny spawn
> child threads that kill their parent.
>
> > But given how overloaded the term is, I'd be in favor of coming up with
> a new term to represent what these catch functions are intended to do.
>
> The word currently in my head is 'inner', although Roman's suggestion
> of 'enclosed' looks fine too. Internal is also correct, but as it is
> regularly used to denote a package internal functions, it may lead to
> confusion.
>
> What these functions (classy prelude/my library spin-off) do is run a
> computation, isolating it from the calling thread (through async) and
> catching all inner exceptions (of either synchronous or asynchronous
> type, raised by either throwIO or throwTo instructions _present
> somewhere inside that computation_, or by the RTS but once again
> affecting only that computation, not the calling one.
>
> The calling one is thus 'free' to receive asynchronous exceptions in
> the meantime (the execution of the inner computation).
>
> Thus, I propose either:
>
> Control.Exception.Inner / Control.Exception.Enclosed
>
> And/or, possibly also rename the functions to something like:
>
> catchAnyInner / catchAnyEnclosed
>
> Although I do not like this last option so much, the function name
> gets too long, but that's a personal preference.
>
>
> What do you think?
> Jo?o
>
> 2014-02-06 Michael Snoyman <michael at snoyman.com>:
> >
> >
> >
> > On Thu, Feb 6, 2014 at 8:17 AM, Roman Cheplyaka <roma at ro-che.info>
> wrote:
> >>
> >> > Am I getting this right?
> >>
> >> Not quite.
> >>
> >> The enclosed computation may get asynchronous exceptions whatever
> >> definition of 'asynchronous' you use -- the exact one (by throw method)
> >> or the approximate one (by type).
> >>
> >> Just a couple of examples:
> >>
> >> * The thread may catch an async exception from the RTS (such as
> >>   BlockedIndefinitelyOnMVar or StackOverflow)
> >> * The thread may spawn other threads, passing its pid to them, and one
> >>   of its children may eventually kill it
> >>
> >> So I'd say this method allows to catch any exceptions "related" to
> >> the computation, synchronous or asynchronous. It is this "relatedness"
> >> that is enforced by running it in a separate thread.
> >>
> >> Roman
> >>
> >
> > I definitely think this is important to get our terminology right. A lot
> of
> > the scariness of async exceptions likely spawns from the fact that we use
> > the same term to refer to a number of very different cases. Let me give a
> > crack at breaking down exceptions:
> >
> > * An exception with a synchronous type (e.g., IOException) thrown via
> > throwIO. This is the most synchronous of synchronous exceptions.
> > * An exception with an asynchronous type (e.g., UserInterrupt) thrown via
> > throwIO. There's legitimate room for debate as to what we should call
> this.
> > For my purposes, I'd want to call it a synchronous exception.
> > * An exception with a synchronous type thrown via throwTo. Similar to
> > previous bullet, but I'd consider this asynchronous.
> > * An exception with an asynchronous type thrown via throwTo. This is
> solidly
> > an asynchronous exception.
> >
> > Then we have some more interesting questions:
> >
> > * What *is* an asynchronous type? By including
> BlockedIndefinitelyOnMVar, it
> > seems like you're defining it to include any exception generated by the
> RTS.
> > However, I'd consider it a synchronous exception: it is generated in
> direct
> > consequence of performing an IO action. It just happens to be generated
> by
> > the RTS instead of via some library talking to the filesystem.
> > * What happens if an async exception is caught and then rethrown? Has it
> > transformed itself into a synchronous exception? That's a tricky
> question,
> > and likely depends on the exact manner in which is was caught.
> > * What happens if a function utilizes some form of asynchronous exception
> > mechanism to affect its behavior? The prime example of this is
> `timeout`, or
> > better, the `asyncTimeout` function I displayed above. Internally to that
> > function, I think that's an async exception. However, for a *caller* of
> that
> > function, the behavior is actually synchronous: there was no notification
> > from the outside world changing the behavior of this function, it simply
> has
> > the possibility to terminate by throwing a Timeout, the same way a
> function
> > may terminate by throwing an IOException.
> >
> > That last bullet is crucial to the question of whether classy-prelude's
> and
> > Jo?o's catching functions are asynchronous or not. But given how
> overloaded
> > the term is, I'd be in favor of coming up with a new term to represent
> what
> > these catch functions are intended to do.
> >
> > Michael
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140206/534dfadc/attachment.html>

From jmacristovao at gmail.com  Thu Feb  6 12:12:29 2014
From: jmacristovao at gmail.com (=?ISO-8859-1?B?Sm/jbyBDcmlzdPN2428=?=)
Date: Thu, 6 Feb 2014 12:12:29 +0000
Subject: [Haskell-cafe] ANN: asynchronous-exceptions
In-Reply-To: <CAKA2JgL+N3_TzE-8vEVRTnfpi0SyK4fi7xFHjqmQwOOSxSeQPw@mail.gmail.com>
References: <20140205112801.GA5306@sniper>
 <CAKA2JgKSWQ8An-KK4gCjcaRChyoXhzVg8k-S5XDDvQvLDWKD6Q@mail.gmail.com>
 <20140205151926.GA9254@sniper>
 <CAKA2JgKWdLHYgyMWpHPo8vZB8RBXVmvba5xXceH+iNyGPcX-Cg@mail.gmail.com>
 <20140205162849.GC10049@sniper>
 <CAKA2JgJyonmwpscN_=9kXPTL0w7DT4LgB2wvvPyOc5z7BiinDQ@mail.gmail.com>
 <20140205212308.GA12415@sniper>
 <CAAbu24o=zuOJQkEHxYyKgkjq=Au7QwBK0+h7BSu5X6WZnVZ-kw@mail.gmail.com>
 <20140205223353.GA17748@sniper>
 <CAAbu24p+G+GCmXtdt5brGUeNMCaBA0tJwCni_04TtVqoxpcBJQ@mail.gmail.com>
 <20140206061707.GA19197@sniper>
 <CAKA2JgL+N3_TzE-8vEVRTnfpi0SyK4fi7xFHjqmQwOOSxSeQPw@mail.gmail.com>
Message-ID: <CAAbu24qZuZLJofbvL+g4w1e4cBT6+1bBnV6B8VtU0W4AeANvQg@mail.gmail.com>

Thanks Roman and Michael for the latest clarifications:

I had indeed forgot the case where a thread runned in catchAny spawn
child threads that kill their parent.

> But given how overloaded the term is, I'd be in favor of coming up with a new term to represent what these catch functions are intended to do.

The word currently in my head is 'inner', although Roman's suggestion
of 'enclosed' looks fine too. Internal is also correct, but as it is
regularly used to denote a package internal functions, it may lead to
confusion.

What these functions (classy prelude/my library spin-off) do is run a
computation, isolating it from the calling thread (through async) and
catching all inner exceptions (of either synchronous or asynchronous
type, raised by either throwIO or throwTo instructions _present
somewhere inside that computation_, or by the RTS but once again
affecting only that computation, not the calling one.

The calling one is thus 'free' to receive asynchronous exceptions in
the meantime (the execution of the inner computation).

Thus, I propose either:

Control.Exception.Inner / Control.Exception.Enclosed

And/or, possibly also rename the functions to something like:

catchAnyInner / catchAnyEnclosed

Although I do not like this last option so much, the function name
gets too long, but that's a personal preference.


What do you think?
Jo?o

2014-02-06 Michael Snoyman <michael at snoyman.com>:
>
>
>
> On Thu, Feb 6, 2014 at 8:17 AM, Roman Cheplyaka <roma at ro-che.info> wrote:
>>
>> > Am I getting this right?
>>
>> Not quite.
>>
>> The enclosed computation may get asynchronous exceptions whatever
>> definition of 'asynchronous' you use -- the exact one (by throw method)
>> or the approximate one (by type).
>>
>> Just a couple of examples:
>>
>> * The thread may catch an async exception from the RTS (such as
>>   BlockedIndefinitelyOnMVar or StackOverflow)
>> * The thread may spawn other threads, passing its pid to them, and one
>>   of its children may eventually kill it
>>
>> So I'd say this method allows to catch any exceptions "related" to
>> the computation, synchronous or asynchronous. It is this "relatedness"
>> that is enforced by running it in a separate thread.
>>
>> Roman
>>
>
> I definitely think this is important to get our terminology right. A lot of
> the scariness of async exceptions likely spawns from the fact that we use
> the same term to refer to a number of very different cases. Let me give a
> crack at breaking down exceptions:
>
> * An exception with a synchronous type (e.g., IOException) thrown via
> throwIO. This is the most synchronous of synchronous exceptions.
> * An exception with an asynchronous type (e.g., UserInterrupt) thrown via
> throwIO. There's legitimate room for debate as to what we should call this.
> For my purposes, I'd want to call it a synchronous exception.
> * An exception with a synchronous type thrown via throwTo. Similar to
> previous bullet, but I'd consider this asynchronous.
> * An exception with an asynchronous type thrown via throwTo. This is solidly
> an asynchronous exception.
>
> Then we have some more interesting questions:
>
> * What *is* an asynchronous type? By including BlockedIndefinitelyOnMVar, it
> seems like you're defining it to include any exception generated by the RTS.
> However, I'd consider it a synchronous exception: it is generated in direct
> consequence of performing an IO action. It just happens to be generated by
> the RTS instead of via some library talking to the filesystem.
> * What happens if an async exception is caught and then rethrown? Has it
> transformed itself into a synchronous exception? That's a tricky question,
> and likely depends on the exact manner in which is was caught.
> * What happens if a function utilizes some form of asynchronous exception
> mechanism to affect its behavior? The prime example of this is `timeout`, or
> better, the `asyncTimeout` function I displayed above. Internally to that
> function, I think that's an async exception. However, for a *caller* of that
> function, the behavior is actually synchronous: there was no notification
> from the outside world changing the behavior of this function, it simply has
> the possibility to terminate by throwing a Timeout, the same way a function
> may terminate by throwing an IOException.
>
> That last bullet is crucial to the question of whether classy-prelude's and
> Jo?o's catching functions are asynchronous or not. But given how overloaded
> the term is, I'd be in favor of coming up with a new term to represent what
> these catch functions are intended to do.
>
> Michael

From corentin.dupont at gmail.com  Thu Feb  6 14:50:06 2014
From: corentin.dupont at gmail.com (Corentin Dupont)
Date: Thu, 6 Feb 2014 15:50:06 +0100
Subject: [Haskell-cafe] manage effects in a DSL
In-Reply-To: <CAEyhvmr=s7xTk7DS3RgKzcJgCZf4u7OEiw7eCKsQ3AuDrYUwUw@mail.gmail.com>
References: <20140129033404.76144.qmail@www1.g3.pair.com>
 <CAEyhvmqiJCc8vs-LHpT=CW20yGjhr5G3LMB86c+w38v+e5BELw@mail.gmail.com>
 <CAEyhvmrti3-4B0KvtdQKZPTh8foX=yg__W3AATjunRLAvaF6CA@mail.gmail.com>
 <CAEyhvmow1XbdLJv00iDVA4uBWEXmMGeLsVg1g6jpUCt2=d8CPQ@mail.gmail.com>
 <CALnXJiqhPoKEpJKszGf4EskbSVU1xh+MX=R2dBU4cGv4o+fxoQ@mail.gmail.com>
 <CAEyhvmr=s7xTk7DS3RgKzcJgCZf4u7OEiw7eCKsQ3AuDrYUwUw@mail.gmail.com>
Message-ID: <CAEyhvmp0M5briL0e617++XH+djkvfHq78tDMhrz7ajWMwkYZ_Q@mail.gmail.com>

Hi guys,
I'm still exploring some design space for DSLs, following our interesting
discussion.

I'm trying to write the evaluator for the DSL (see below).
For the general case, the evaluator looks like:

eval :: Nomex r a -> State Game a

This eval function takes an expression (called Nomex), that can possibly
have effects.
It returns a state monad, to allow you to modify the game state.

But for effectless instructions, it would be better to run the evaluator in
the reader monad:

evalNoEffect :: Nomex NoEffect a -> Reader Game a

So you can have additional guaranties that evaluating your expression will
not have effects.
I tried (see below), but it doesn't work for the moment:


> {-# LANGUAGE GADTs #-}
> {-# LANGUAGE KindSignatures, DataKinds, ScopedTypeVariables,
>   MultiParamTypeClasses, FunctionalDependencies, FlexibleInstances,
UndecidableInstances #-}

> module DSLEffects where

> import Control.Monad.Error
> import Control.Monad.State
> import Control.Monad.Reader
> import Data.Typeable

This is the DSL:

> data Effects = Effect | NoEffect

> data Nomex :: Effects -> * -> * where
>   ReadAccount  :: Nomex r Int                --ReadAccount has no effect:
it can be run in whatever monad
>   WriteAccount :: Int -> Nomex Effect ()  --WriteAccount has effect
>   SetVictory   :: Nomex NoEffect Bool -> Nomex Effect () --SetVictory
don't accept effectful computations
>   Bind         :: Nomex m a -> (a -> Nomex m b) -> Nomex m b
>   Return       :: a -> Nomex r a  --wrapping a constant has no effect

> instance Monad (Nomex a) where
>   return = Return
>   (>>=) = Bind


> noEff :: Nomex NoEffect ()
> noEff = return ()

> hasEffect :: Nomex Effect ()
> hasEffect = do
>    a <- ReadAccount
>    WriteAccount a

> data Game = Game { victory :: Nomex NoEffect Bool,
>                    account :: Int}


> eval :: Nomex r a -> State Game a
> eval a at ReadAccount    = liftEval $ evalNoEffect a
> eval (WriteAccount a) = modify (\g -> g{account = a})
> eval (SetVictory v)   = modify (\g -> g{victory = v})
> eval a@(Return _)     = liftEval $ evalNoEffect a
> eval (Bind exp f)     = eval exp >>= eval . f

> evalNoEffect :: Nomex NoEffect a -> Reader Game a
> evalNoEffect ReadAccount  = asks account
> evalNoEffect (Return a)   = return a
> evalNoEffect (Bind exp f) = evalNoEffect exp >>= evalNoEffect . f

> liftEval :: Reader Game a -> State Game a
> liftEval r = get >>= return . runReader r


This is not compiling:

exceptEffect.lhs:60:15:
    Couldn't match type 'NoEffect with 'Effect
    Inaccessible code in
      a pattern with constructor
        WriteAccount :: Int -> Nomex 'Effect (),
      in an equation for `evalEffect'
    In the pattern: WriteAccount a
    In an equation for `evalEffect':
        evalEffect (WriteAccount a) = modify (\ g -> g {account = a})

It seems that the type of effectless computations (NoEffect) leaks in the
type of effectful ones (due to the pattern matching)...

Thanks,
Corentin



On Mon, Feb 3, 2014 at 12:44 PM, Corentin Dupont
<corentin.dupont at gmail.com>wrote:

> I saw that to write liftQD you decontruct (unwrap) the type and
> reconstruct it.
> I don't know if I can do that for my Exp (which is a full DSL)...
>
> Anyway, there should be a way to encode the Effect/NoEffect semantic at
> type level...
> Using Oleg's parametrized monad idea (
> http://hackage.haskell.org/package/monad-param-0.0.2/docs/Control-Monad-Parameterized.html),
> I tried:
>
> > {-# LANGUAGE KindSignatures, DataKinds, ScopedTypeVariables, GADTs
> >   MultiParamTypeClasses, FunctionalDependencies, FlexibleInstances,
> UndecidableInstances #-}
>
> > module DSLEffects where
> > import Prelude hiding (return, (>>), (>>=))
> > import Control.Monad.Parameterized
>
> This data type will be promoted to kind level (thanks to DataKinds):
>
>
> > data Eff = Effect | NoEffect
>
> This class allows to specify the semantic on Effects (Effect + NoEffect =
> Effect):
>
> > class Effects (m :: Eff) (n::Eff) (r::Eff) | m n -> r
> > instance Effects Effect n Effect
> > instance Effects NoEffect n n
>
> This is the DSL:
>
> > data Exp :: Eff -> * -> * where
> >   ReadAccount  :: Exp NoEffect Int      --ReadAccount has no effect
> >   WriteAccount :: Int -> Exp Effect ()  --WriteAccount has effect
> >   Const        :: a -> Exp r a
> >   Bind         :: Effects m n r => Exp m a -> (a -> Exp n b) -> Exp r b
> --Bind comes with a semantic on effects
> >   Fmap         :: (a -> b) -> Exp m a -> Exp m b
>
> > instance Functor (Exp r) where
> >   fmap = Fmap
>
> > instance Return (Exp r) where
> >    returnM = Const
>
> > instance (Effects m n r) => Bind (Exp m) (Exp n) (Exp r) where
> >    (>>=) = Bind
>
> > noEff :: Exp NoEffect ()
> > noEff = returnM ()
>
> > hasEffect :: Exp Effect ()
> > hasEffect = ReadAccount >> (returnM () :: Exp Effect ())
>
> This is working more or less, however I am obliged to put the type
> signature on the returnM (last line): why?
> Furthermore, I cannot write directly:
>
> > hasEffect :: Exp Effect ()
> > hasEffect = ReadAccount
>
>
> Do you have a better idea?
>
>
>
> On Sun, Feb 2, 2014 at 8:55 PM, Lindsey Kuper <lindsey at composition.al>wrote:
>
>> On Sun, Feb 2, 2014 at 2:42 PM, Corentin Dupont
>> <corentin.dupont at gmail.com> wrote:
>> > you should be able to run an effectless monad in an effectful one.
>> > How to encode this semantic?
>>
>> In LVish we just have a `liftQD` operation that will let you lift a
>> deterministic computation to a quasi-deterministic one (recall that
>> deterministic computations can perform fewer effects):
>>
>>   liftQD :: Par Det s a -> Par QuasiDet s a
>>
>> So, analogously, you could have a `liftEff` and then write `liftEff
>> noEff`.  This is also a little bit ugly, but you may find you don't
>> have to do it very often (we rarely use `liftQD`).
>>
>> Lindsey
>>
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140206/22ce775b/attachment.html>

From vogt.adam at gmail.com  Thu Feb  6 17:47:31 2014
From: vogt.adam at gmail.com (adam vogt)
Date: Thu, 6 Feb 2014 12:47:31 -0500
Subject: [Haskell-cafe] manage effects in a DSL
In-Reply-To: <CAEyhvmp0M5briL0e617++XH+djkvfHq78tDMhrz7ajWMwkYZ_Q@mail.gmail.com>
References: <20140129033404.76144.qmail@www1.g3.pair.com>
 <CAEyhvmqiJCc8vs-LHpT=CW20yGjhr5G3LMB86c+w38v+e5BELw@mail.gmail.com>
 <CAEyhvmrti3-4B0KvtdQKZPTh8foX=yg__W3AATjunRLAvaF6CA@mail.gmail.com>
 <CAEyhvmow1XbdLJv00iDVA4uBWEXmMGeLsVg1g6jpUCt2=d8CPQ@mail.gmail.com>
 <CALnXJiqhPoKEpJKszGf4EskbSVU1xh+MX=R2dBU4cGv4o+fxoQ@mail.gmail.com>
 <CAEyhvmr=s7xTk7DS3RgKzcJgCZf4u7OEiw7eCKsQ3AuDrYUwUw@mail.gmail.com>
 <CAEyhvmp0M5briL0e617++XH+djkvfHq78tDMhrz7ajWMwkYZ_Q@mail.gmail.com>
Message-ID: <CAHfjoWmOfwDYHTDFhn2RmOT53SdV==+HGjTJYMgLeZ_2e3mfOw@mail.gmail.com>

Hi Corentin,

You need change Effect to NoEffect to reuse the evalNoEffect:

> eval ReadAccount = liftEval $ evalNoEffect ReadAccount
> eval (Return a)     = liftEval $ evalNoEffect (Return a)

Or use a function like `unsafeCoerce :: Nomex Effect a -> Nomex NoEffect a`.

If you rename the types that tag effects to something that describes
exactly what the tags actually represent, maybe the above definition will
be more satisfying:

> data Effects
>  =
HasBeenCombinedWithSomethingThatHasEffectsButICan'tBeSureItActuallyHasEffectsAllByItself
>   | DefinitelyHasNoEffects


Regards,
Adam


On Thu, Feb 6, 2014 at 9:50 AM, Corentin Dupont
<corentin.dupont at gmail.com>wrote:

> Hi guys,
> I'm still exploring some design space for DSLs, following our interesting
> discussion.
>
> I'm trying to write the evaluator for the DSL (see below).
> For the general case, the evaluator looks like:
>
> eval :: Nomex r a -> State Game a
>
> This eval function takes an expression (called Nomex), that can possibly
> have effects.
> It returns a state monad, to allow you to modify the game state.
>
> But for effectless instructions, it would be better to run the evaluator
> in the reader monad:
>
> evalNoEffect :: Nomex NoEffect a -> Reader Game a
>
> So you can have additional guaranties that evaluating your expression will
> not have effects.
> I tried (see below), but it doesn't work for the moment:
>
>
> > {-# LANGUAGE GADTs #-}
>
> > {-# LANGUAGE KindSignatures, DataKinds, ScopedTypeVariables,
> >   MultiParamTypeClasses, FunctionalDependencies, FlexibleInstances,
> UndecidableInstances #-}
>
> > module DSLEffects where
>
> > import Control.Monad.Error
> > import Control.Monad.State
> > import Control.Monad.Reader
> > import Data.Typeable
>
> This is the DSL:
>
> > data Effects = Effect | NoEffect
>
> > data Nomex :: Effects -> * -> * where
> >   ReadAccount  :: Nomex r Int                --ReadAccount has no
> effect: it can be run in whatever monad
> >   WriteAccount :: Int -> Nomex Effect ()  --WriteAccount has effect
> >   SetVictory   :: Nomex NoEffect Bool -> Nomex Effect () --SetVictory
> don't accept effectful computations
> >   Bind         :: Nomex m a -> (a -> Nomex m b) -> Nomex m b
> >   Return       :: a -> Nomex r a  --wrapping a constant has no effect
>
> > instance Monad (Nomex a) where
> >   return = Return
> >   (>>=) = Bind
>
>
> > noEff :: Nomex NoEffect ()
> > noEff = return ()
>
> > hasEffect :: Nomex Effect ()
> > hasEffect = do
> >    a <- ReadAccount
> >    WriteAccount a
>
> > data Game = Game { victory :: Nomex NoEffect Bool,
> >                    account :: Int}
>
>
> > eval :: Nomex r a -> State Game a
> > eval a at ReadAccount    = liftEval $ evalNoEffect a
> > eval (WriteAccount a) = modify (\g -> g{account = a})
>
> > eval (SetVictory v)   = modify (\g -> g{victory = v})
> > eval a@(Return _)     = liftEval $ evalNoEffect a
> > eval (Bind exp f)     = eval exp >>= eval . f
>
> > evalNoEffect :: Nomex NoEffect a -> Reader Game a
> > evalNoEffect ReadAccount  = asks account
> > evalNoEffect (Return a)   = return a
> > evalNoEffect (Bind exp f) = evalNoEffect exp >>= evalNoEffect . f
>
> > liftEval :: Reader Game a -> State Game a
> > liftEval r = get >>= return . runReader r
>
>
> This is not compiling:
>
> exceptEffect.lhs:60:15:
>     Couldn't match type 'NoEffect with 'Effect
>     Inaccessible code in
>       a pattern with constructor
>         WriteAccount :: Int -> Nomex 'Effect (),
>       in an equation for `evalEffect'
>     In the pattern: WriteAccount a
>     In an equation for `evalEffect':
>         evalEffect (WriteAccount a) = modify (\ g -> g {account = a})
>
> It seems that the type of effectless computations (NoEffect) leaks in the
> type of effectful ones (due to the pattern matching)...
>
> Thanks,
> Corentin
>
>
>
> On Mon, Feb 3, 2014 at 12:44 PM, Corentin Dupont <
> corentin.dupont at gmail.com> wrote:
>
>> I saw that to write liftQD you decontruct (unwrap) the type and
>> reconstruct it.
>> I don't know if I can do that for my Exp (which is a full DSL)...
>>
>> Anyway, there should be a way to encode the Effect/NoEffect semantic at
>> type level...
>> Using Oleg's parametrized monad idea (
>> http://hackage.haskell.org/package/monad-param-0.0.2/docs/Control-Monad-Parameterized.html),
>> I tried:
>>
>> > {-# LANGUAGE KindSignatures, DataKinds, ScopedTypeVariables, GADTs
>> >   MultiParamTypeClasses, FunctionalDependencies, FlexibleInstances,
>> UndecidableInstances #-}
>>
>> > module DSLEffects where
>> > import Prelude hiding (return, (>>), (>>=))
>> > import Control.Monad.Parameterized
>>
>> This data type will be promoted to kind level (thanks to DataKinds):
>>
>>
>> > data Eff = Effect | NoEffect
>>
>> This class allows to specify the semantic on Effects (Effect + NoEffect =
>> Effect):
>>
>> > class Effects (m :: Eff) (n::Eff) (r::Eff) | m n -> r
>> > instance Effects Effect n Effect
>> > instance Effects NoEffect n n
>>
>> This is the DSL:
>>
>> > data Exp :: Eff -> * -> * where
>> >   ReadAccount  :: Exp NoEffect Int      --ReadAccount has no effect
>> >   WriteAccount :: Int -> Exp Effect ()  --WriteAccount has effect
>> >   Const        :: a -> Exp r a
>> >   Bind         :: Effects m n r => Exp m a -> (a -> Exp n b) -> Exp r b
>> --Bind comes with a semantic on effects
>> >   Fmap         :: (a -> b) -> Exp m a -> Exp m b
>>
>> > instance Functor (Exp r) where
>> >   fmap = Fmap
>>
>> > instance Return (Exp r) where
>> >    returnM = Const
>>
>> > instance (Effects m n r) => Bind (Exp m) (Exp n) (Exp r) where
>> >    (>>=) = Bind
>>
>> > noEff :: Exp NoEffect ()
>> > noEff = returnM ()
>>
>> > hasEffect :: Exp Effect ()
>> > hasEffect = ReadAccount >> (returnM () :: Exp Effect ())
>>
>> This is working more or less, however I am obliged to put the type
>> signature on the returnM (last line): why?
>> Furthermore, I cannot write directly:
>>
>> > hasEffect :: Exp Effect ()
>> > hasEffect = ReadAccount
>>
>>
>> Do you have a better idea?
>>
>>
>>
>> On Sun, Feb 2, 2014 at 8:55 PM, Lindsey Kuper <lindsey at composition.al>wrote:
>>
>>> On Sun, Feb 2, 2014 at 2:42 PM, Corentin Dupont
>>> <corentin.dupont at gmail.com> wrote:
>>> > you should be able to run an effectless monad in an effectful one.
>>> > How to encode this semantic?
>>>
>>> In LVish we just have a `liftQD` operation that will let you lift a
>>> deterministic computation to a quasi-deterministic one (recall that
>>> deterministic computations can perform fewer effects):
>>>
>>>   liftQD :: Par Det s a -> Par QuasiDet s a
>>>
>>> So, analogously, you could have a `liftEff` and then write `liftEff
>>> noEff`.  This is also a little bit ugly, but you may find you don't
>>> have to do it very often (we rarely use `liftQD`).
>>>
>>> Lindsey
>>>
>>
>>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140206/1d174f9b/attachment.html>

From jake.mcarthur at gmail.com  Thu Feb  6 20:35:27 2014
From: jake.mcarthur at gmail.com (Jake McArthur)
Date: Thu, 6 Feb 2014 15:35:27 -0500
Subject: [Haskell-cafe] manage effects in a DSL
In-Reply-To: <CAHfjoWmOfwDYHTDFhn2RmOT53SdV==+HGjTJYMgLeZ_2e3mfOw@mail.gmail.com>
References: <20140129033404.76144.qmail@www1.g3.pair.com>
 <CAEyhvmqiJCc8vs-LHpT=CW20yGjhr5G3LMB86c+w38v+e5BELw@mail.gmail.com>
 <CAEyhvmrti3-4B0KvtdQKZPTh8foX=yg__W3AATjunRLAvaF6CA@mail.gmail.com>
 <CAEyhvmow1XbdLJv00iDVA4uBWEXmMGeLsVg1g6jpUCt2=d8CPQ@mail.gmail.com>
 <CALnXJiqhPoKEpJKszGf4EskbSVU1xh+MX=R2dBU4cGv4o+fxoQ@mail.gmail.com>
 <CAEyhvmr=s7xTk7DS3RgKzcJgCZf4u7OEiw7eCKsQ3AuDrYUwUw@mail.gmail.com>
 <CAEyhvmp0M5briL0e617++XH+djkvfHq78tDMhrz7ajWMwkYZ_Q@mail.gmail.com>
 <CAHfjoWmOfwDYHTDFhn2RmOT53SdV==+HGjTJYMgLeZ_2e3mfOw@mail.gmail.com>
Message-ID: <CACN--9CDygTpySYJj5eLkwrCPLca_m_5xmyUkFOjLpNTxFUQ6g@mail.gmail.com>

I still think GADTs are a bit too much for this problem. Just using type
classes provides all the safety you need and even avoids the need for that
liftEval function.

{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
module DSLEffects where

import Control.Monad.State
import Control.Monad.Reader

class Monad m => Nomex m where
  readAccount :: m Int

class Nomex m => NomexEffect m where
  writeAccount :: Int -> m ()
  setVictory   :: (forall m. Nomex m => m Bool) -> m ()

data Game = Game { victory :: (forall m. Nomex m => m Bool)
                 , account :: Int
                 }

newtype Eval a = Eval { eval :: State Game a }
               deriving Monad

instance Nomex Eval where
  readAccount = Eval $ gets account

instance NomexEffect Eval where
  writeAccount n = Eval . modify $ \game -> game { account = n }
  setVictory   v = Eval . modify $ \game -> game { victory = v }

newtype EvalNoEffect a = EvalNoEffect { evalNoEffect :: Reader Game a }
                       deriving Monad

instance Nomex EvalNoEffect where
  readAccount = EvalNoEffect $ asks account

noEff :: Nomex m => m ()
noEff = return ()

hasEff :: NomexEffect m => m ()
hasEff = readAccount >>= writeAccount



On Thu, Feb 6, 2014 at 12:47 PM, adam vogt <vogt.adam at gmail.com> wrote:

> Hi Corentin,
>
> You need change Effect to NoEffect to reuse the evalNoEffect:
>
> > eval ReadAccount = liftEval $ evalNoEffect ReadAccount
> > eval (Return a)     = liftEval $ evalNoEffect (Return a)
>
> Or use a function like `unsafeCoerce :: Nomex Effect a -> Nomex NoEffect
> a`.
>
> If you rename the types that tag effects to something that describes
> exactly what the tags actually represent, maybe the above definition will
> be more satisfying:
>
> > data Effects
> >  =
> HasBeenCombinedWithSomethingThatHasEffectsButICan'tBeSureItActuallyHasEffectsAllByItself
> >   | DefinitelyHasNoEffects
>
>
> Regards,
> Adam
>
>
> On Thu, Feb 6, 2014 at 9:50 AM, Corentin Dupont <corentin.dupont at gmail.com
> > wrote:
>
>> Hi guys,
>> I'm still exploring some design space for DSLs, following our interesting
>> discussion.
>>
>> I'm trying to write the evaluator for the DSL (see below).
>> For the general case, the evaluator looks like:
>>
>> eval :: Nomex r a -> State Game a
>>
>> This eval function takes an expression (called Nomex), that can possibly
>> have effects.
>> It returns a state monad, to allow you to modify the game state.
>>
>> But for effectless instructions, it would be better to run the evaluator
>> in the reader monad:
>>
>> evalNoEffect :: Nomex NoEffect a -> Reader Game a
>>
>> So you can have additional guaranties that evaluating your expression
>> will not have effects.
>> I tried (see below), but it doesn't work for the moment:
>>
>>
>> > {-# LANGUAGE GADTs #-}
>>
>> > {-# LANGUAGE KindSignatures, DataKinds, ScopedTypeVariables,
>> >   MultiParamTypeClasses, FunctionalDependencies, FlexibleInstances,
>> UndecidableInstances #-}
>>
>> > module DSLEffects where
>>
>> > import Control.Monad.Error
>> > import Control.Monad.State
>> > import Control.Monad.Reader
>> > import Data.Typeable
>>
>> This is the DSL:
>>
>> > data Effects = Effect | NoEffect
>>
>> > data Nomex :: Effects -> * -> * where
>> >   ReadAccount  :: Nomex r Int                --ReadAccount has no
>> effect: it can be run in whatever monad
>> >   WriteAccount :: Int -> Nomex Effect ()  --WriteAccount has effect
>> >   SetVictory   :: Nomex NoEffect Bool -> Nomex Effect () --SetVictory
>> don't accept effectful computations
>> >   Bind         :: Nomex m a -> (a -> Nomex m b) -> Nomex m b
>> >   Return       :: a -> Nomex r a  --wrapping a constant has no effect
>>
>> > instance Monad (Nomex a) where
>> >   return = Return
>> >   (>>=) = Bind
>>
>>
>> > noEff :: Nomex NoEffect ()
>> > noEff = return ()
>>
>> > hasEffect :: Nomex Effect ()
>> > hasEffect = do
>> >    a <- ReadAccount
>> >    WriteAccount a
>>
>> > data Game = Game { victory :: Nomex NoEffect Bool,
>> >                    account :: Int}
>>
>>
>> > eval :: Nomex r a -> State Game a
>> > eval a at ReadAccount    = liftEval $ evalNoEffect a
>> > eval (WriteAccount a) = modify (\g -> g{account = a})
>>
>> > eval (SetVictory v)   = modify (\g -> g{victory = v})
>> > eval a@(Return _)     = liftEval $ evalNoEffect a
>> > eval (Bind exp f)     = eval exp >>= eval . f
>>
>> > evalNoEffect :: Nomex NoEffect a -> Reader Game a
>> > evalNoEffect ReadAccount  = asks account
>> > evalNoEffect (Return a)   = return a
>> > evalNoEffect (Bind exp f) = evalNoEffect exp >>= evalNoEffect . f
>>
>> > liftEval :: Reader Game a -> State Game a
>> > liftEval r = get >>= return . runReader r
>>
>>
>> This is not compiling:
>>
>> exceptEffect.lhs:60:15:
>>     Couldn't match type 'NoEffect with 'Effect
>>     Inaccessible code in
>>       a pattern with constructor
>>         WriteAccount :: Int -> Nomex 'Effect (),
>>       in an equation for `evalEffect'
>>     In the pattern: WriteAccount a
>>     In an equation for `evalEffect':
>>         evalEffect (WriteAccount a) = modify (\ g -> g {account = a})
>>
>> It seems that the type of effectless computations (NoEffect) leaks in the
>> type of effectful ones (due to the pattern matching)...
>>
>> Thanks,
>> Corentin
>>
>>
>>
>> On Mon, Feb 3, 2014 at 12:44 PM, Corentin Dupont <
>> corentin.dupont at gmail.com> wrote:
>>
>>> I saw that to write liftQD you decontruct (unwrap) the type and
>>> reconstruct it.
>>> I don't know if I can do that for my Exp (which is a full DSL)...
>>>
>>> Anyway, there should be a way to encode the Effect/NoEffect semantic at
>>> type level...
>>> Using Oleg's parametrized monad idea (
>>> http://hackage.haskell.org/package/monad-param-0.0.2/docs/Control-Monad-Parameterized.html),
>>> I tried:
>>>
>>> > {-# LANGUAGE KindSignatures, DataKinds, ScopedTypeVariables, GADTs
>>> >   MultiParamTypeClasses, FunctionalDependencies, FlexibleInstances,
>>> UndecidableInstances #-}
>>>
>>> > module DSLEffects where
>>> > import Prelude hiding (return, (>>), (>>=))
>>> > import Control.Monad.Parameterized
>>>
>>> This data type will be promoted to kind level (thanks to DataKinds):
>>>
>>>
>>> > data Eff = Effect | NoEffect
>>>
>>> This class allows to specify the semantic on Effects (Effect + NoEffect
>>> = Effect):
>>>
>>> > class Effects (m :: Eff) (n::Eff) (r::Eff) | m n -> r
>>> > instance Effects Effect n Effect
>>> > instance Effects NoEffect n n
>>>
>>> This is the DSL:
>>>
>>> > data Exp :: Eff -> * -> * where
>>> >   ReadAccount  :: Exp NoEffect Int      --ReadAccount has no effect
>>> >   WriteAccount :: Int -> Exp Effect ()  --WriteAccount has effect
>>> >   Const        :: a -> Exp r a
>>> >   Bind         :: Effects m n r => Exp m a -> (a -> Exp n b) -> Exp r
>>> b --Bind comes with a semantic on effects
>>> >   Fmap         :: (a -> b) -> Exp m a -> Exp m b
>>>
>>> > instance Functor (Exp r) where
>>> >   fmap = Fmap
>>>
>>> > instance Return (Exp r) where
>>> >    returnM = Const
>>>
>>> > instance (Effects m n r) => Bind (Exp m) (Exp n) (Exp r) where
>>> >    (>>=) = Bind
>>>
>>> > noEff :: Exp NoEffect ()
>>> > noEff = returnM ()
>>>
>>> > hasEffect :: Exp Effect ()
>>> > hasEffect = ReadAccount >> (returnM () :: Exp Effect ())
>>>
>>> This is working more or less, however I am obliged to put the type
>>> signature on the returnM (last line): why?
>>> Furthermore, I cannot write directly:
>>>
>>> > hasEffect :: Exp Effect ()
>>> > hasEffect = ReadAccount
>>>
>>>
>>> Do you have a better idea?
>>>
>>>
>>>
>>> On Sun, Feb 2, 2014 at 8:55 PM, Lindsey Kuper <lindsey at composition.al>wrote:
>>>
>>>> On Sun, Feb 2, 2014 at 2:42 PM, Corentin Dupont
>>>> <corentin.dupont at gmail.com> wrote:
>>>> > you should be able to run an effectless monad in an effectful one.
>>>> > How to encode this semantic?
>>>>
>>>> In LVish we just have a `liftQD` operation that will let you lift a
>>>> deterministic computation to a quasi-deterministic one (recall that
>>>> deterministic computations can perform fewer effects):
>>>>
>>>>   liftQD :: Par Det s a -> Par QuasiDet s a
>>>>
>>>> So, analogously, you could have a `liftEff` and then write `liftEff
>>>> noEff`.  This is also a little bit ugly, but you may find you don't
>>>> have to do it very often (we rarely use `liftQD`).
>>>>
>>>> Lindsey
>>>>
>>>
>>>
>>
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140206/15548c9c/attachment-0001.html>

From tikhon at jelv.is  Fri Feb  7 02:53:00 2014
From: tikhon at jelv.is (Tikhon Jelvis)
Date: Thu, 6 Feb 2014 18:53:00 -0800
Subject: [Haskell-cafe] Naming scheme for partial functions
In-Reply-To: <CAGigdoeH495PqqCa+sfkNfCpqB7HwbGTReMg_JDg1SD30A24hg@mail.gmail.com>
References: <CAKA2JgKUDSpS3Etmm4gdepd5UuiLnF1RTVbx62eTs2yEdMzUcg@mail.gmail.com>
 <CAGigdoeH495PqqCa+sfkNfCpqB7HwbGTReMg_JDg1SD30A24hg@mail.gmail.com>
Message-ID: <CAJN5CVKhTjAY7Njzv9FZChzxEbRY8dyj6g9Q3cE8bpcx+AL=Kw@mail.gmail.com>

For what it's worth, OCaml's Core library does this with _exn, so they
would call a partial last "last_exn". I would actually prefer an
abbreviation of some sort (like exn) as long as it's a consistent
convention. Using a full word like "exception" or "partial" adds to much
noise in my opinion, especially if the base name (like "last") is shorter
than the suffix!

Also, I think a suffix would be better than a prefix, if only to group
things conveniently when sorted alphabetically.


On Thu, Jan 30, 2014 at 9:36 AM, Atze van der Ploeg <atzeus at gmail.com>wrote:

> unprovenLast ?
> On Jan 30, 2014 6:33 PM, "Michael Snoyman" <michael at snoyman.com> wrote:
>
>> Greg Weber and I have been discussing some changes to
>> mono-traversable[1]. One of the modules we provide is Data.NonNull, which
>> provides total versions of functions like `last`. A change we're looking at
>> would require having a partial version of `last` defined in a separate
>> typeclass (IsSequence), which would allowing for more optimized
>> implementations of the total `last` function for datatypes which support it
>> (e.g., strict ByteStrings).
>>
>> But what should we name it? I'm sure everyone's familiar with the
>> `unsafe` naming convention, but that's not appropriate here: standard usage
>> shows `unsafe` meaning a function which can cause a segfault.
>>
>> I initially named it `partialLast`, but partial can also imply partial
>> function application. Greg brought up the idea of suffixing the function
>> with something like `Throws` or `Errors`, which I think I'm a bit partial
>> to myself[2].
>>
>> So my questions are:
>>
>> * Is there some already used naming scheme out there for partial
>> functions which I've missed?
>> * Do people have any ideas to throw into the mix?
>>
>> Michael
>>
>> [1] https://github.com/snoyberg/mono-traversable/pull/21
>> [2] Pardon the pun.
>>
>> _______________________________________________
>> Haskell-Cafe mailing list
>> Haskell-Cafe at haskell.org
>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>
>>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140206/8f62b1e0/attachment.html>

From michael at snoyman.com  Fri Feb  7 02:59:36 2014
From: michael at snoyman.com (Michael Snoyman)
Date: Fri, 7 Feb 2014 04:59:36 +0200
Subject: [Haskell-cafe] Naming scheme for partial functions
In-Reply-To: <CAJN5CVKhTjAY7Njzv9FZChzxEbRY8dyj6g9Q3cE8bpcx+AL=Kw@mail.gmail.com>
References: <CAKA2JgKUDSpS3Etmm4gdepd5UuiLnF1RTVbx62eTs2yEdMzUcg@mail.gmail.com>
 <CAGigdoeH495PqqCa+sfkNfCpqB7HwbGTReMg_JDg1SD30A24hg@mail.gmail.com>
 <CAJN5CVKhTjAY7Njzv9FZChzxEbRY8dyj6g9Q3cE8bpcx+AL=Kw@mail.gmail.com>
Message-ID: <CAKA2JgJzRMOQO6vqobC86ZN=adHqYn-wR92akOPWqGfH=Pptxg@mail.gmail.com>

Thanks for the input. We ended up going with an `Ex` suffix, e.g. headEx,
lastEx.


On Fri, Feb 7, 2014 at 4:53 AM, Tikhon Jelvis <tikhon at jelv.is> wrote:

> For what it's worth, OCaml's Core library does this with _exn, so they
> would call a partial last "last_exn". I would actually prefer an
> abbreviation of some sort (like exn) as long as it's a consistent
> convention. Using a full word like "exception" or "partial" adds to much
> noise in my opinion, especially if the base name (like "last") is shorter
> than the suffix!
>
> Also, I think a suffix would be better than a prefix, if only to group
> things conveniently when sorted alphabetically.
>
>
> On Thu, Jan 30, 2014 at 9:36 AM, Atze van der Ploeg <atzeus at gmail.com>wrote:
>
>> unprovenLast ?
>> On Jan 30, 2014 6:33 PM, "Michael Snoyman" <michael at snoyman.com> wrote:
>>
>>> Greg Weber and I have been discussing some changes to
>>> mono-traversable[1]. One of the modules we provide is Data.NonNull, which
>>> provides total versions of functions like `last`. A change we're looking at
>>> would require having a partial version of `last` defined in a separate
>>> typeclass (IsSequence), which would allowing for more optimized
>>> implementations of the total `last` function for datatypes which support it
>>> (e.g., strict ByteStrings).
>>>
>>> But what should we name it? I'm sure everyone's familiar with the
>>> `unsafe` naming convention, but that's not appropriate here: standard usage
>>> shows `unsafe` meaning a function which can cause a segfault.
>>>
>>> I initially named it `partialLast`, but partial can also imply partial
>>> function application. Greg brought up the idea of suffixing the function
>>> with something like `Throws` or `Errors`, which I think I'm a bit partial
>>> to myself[2].
>>>
>>> So my questions are:
>>>
>>> * Is there some already used naming scheme out there for partial
>>> functions which I've missed?
>>> * Do people have any ideas to throw into the mix?
>>>
>>> Michael
>>>
>>> [1] https://github.com/snoyberg/mono-traversable/pull/21
>>> [2] Pardon the pun.
>>>
>>> _______________________________________________
>>> Haskell-Cafe mailing list
>>> Haskell-Cafe at haskell.org
>>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>>
>>>
>> _______________________________________________
>> Haskell-Cafe mailing list
>> Haskell-Cafe at haskell.org
>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>
>>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140207/e15826a5/attachment.html>

From zefciu at gmail.com  Fri Feb  7 08:08:20 2014
From: zefciu at gmail.com (=?UTF-8?B?U3p5bW9uIFB5xbxhbHNraQ==?=)
Date: Fri, 07 Feb 2014 09:08:20 +0100
Subject: [Haskell-cafe] Filing bugs for haskell packages
Message-ID: <52F49474.8080102@gmail.com>

Hello!

I am new to haskell and I found a bug in package 
http://hackage.haskell.org/package/regex-compat-0.92/docs/Text-Regex.html

On the hackage page it says that the maintainer e-mail of this package 
is: libraries at haskell.org. So i sent a bug report there, but bounced 
back to me because of quota. So apparently nobody reads these e-mails.

How can I file a bug report for this package? I don't feel good enough 
in haskell to try and fix it myself.

Greetings
Szymon Py?alski

From chrisyco+haskell-cafe at gmail.com  Fri Feb  7 08:14:31 2014
From: chrisyco+haskell-cafe at gmail.com (Chris Wong)
Date: Fri, 7 Feb 2014 21:14:31 +1300
Subject: [Haskell-cafe] Filing bugs for haskell packages
In-Reply-To: <52F49474.8080102@gmail.com>
References: <52F49474.8080102@gmail.com>
Message-ID: <CA+qNEzLLC-QFDDMNS9=EVNy9gCaENVN=rcgUa_Eriju7nWMqmg@mail.gmail.com>

Hi Szymon,

I can't answer your question directly, but if you want a less buggy
regex library regex-tdfa[1] is a fine choice.

[1] http://hackage.haskell.org/package/regex-tdfa

On Fri, Feb 7, 2014 at 9:08 PM, Szymon Py?alski <zefciu at gmail.com> wrote:
> Hello!
>
> I am new to haskell and I found a bug in package
> http://hackage.haskell.org/package/regex-compat-0.92/docs/Text-Regex.html
>
> On the hackage page it says that the maintainer e-mail of this package is:
> libraries at haskell.org. So i sent a bug report there, but bounced back to me
> because of quota. So apparently nobody reads these e-mails.
>
> How can I file a bug report for this package? I don't feel good enough in
> haskell to try and fix it myself.
>
> Greetings
> Szymon Py?alski
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe



-- 
Chris Wong, fixpoint conjurer
  e: lambda.fairy at gmail.com
  w: http://lfairy.github.io

From mle+hs at mega-nerd.com  Fri Feb  7 08:18:31 2014
From: mle+hs at mega-nerd.com (Erik de Castro Lopo)
Date: Fri, 7 Feb 2014 19:18:31 +1100
Subject: [Haskell-cafe] Filing bugs for haskell packages
In-Reply-To: <52F49474.8080102@gmail.com>
References: <52F49474.8080102@gmail.com>
Message-ID: <20140207191831.07e23f621fb61dc7eba149b9@mega-nerd.com>

Szymon Py?alski wrote:

> I am new to haskell and I found a bug in package 
> http://hackage.haskell.org/package/regex-compat-0.92/docs/Text-Regex.html
> 
> On the hackage page it says that the maintainer e-mail of this package 
> is: libraries at haskell.org. So i sent a bug report there, but bounced 
> back to me because of quota.

Thats likely to be a transitory issue.

> So apparently nobody reads these e-mails.

They very definitely do. libraries at haskell.org is as mailing list which
has dozens of subscribers and usually sees a couple of emails a day.

> How can I file a bug report for this package?

Wait a day or so and try sending to the libraries list again.

Erik
-- 
----------------------------------------------------------------------
Erik de Castro Lopo
http://www.mega-nerd.com/

From roma at ro-che.info  Fri Feb  7 08:20:13 2014
From: roma at ro-che.info (Roman Cheplyaka)
Date: Fri, 7 Feb 2014 10:20:13 +0200
Subject: [Haskell-cafe] Filing bugs for haskell packages
In-Reply-To: <52F49474.8080102@gmail.com>
References: <52F49474.8080102@gmail.com>
Message-ID: <20140207082013.GA7240@sniper>

Hi Szymon,

* Szymon Py?alski <zefciu at gmail.com> [2014-02-07 09:08:20+0100]
> I am new to haskell and I found a bug in package http://hackage.haskell.org/package/regex-compat-0.92/docs/Text-Regex.html
> 
> On the hackage page it says that the maintainer e-mail of this
> package is: libraries at haskell.org.

Where does it say that? The page http://hackage.haskell.org/package/regex-compat
lists TextRegexLazy at ... as the maintainer's email.

> So i sent a bug report there, but bounced back to me because of quota.
> So apparently nobody reads these e-mails.

libraries at haskell.org is a public Haskell mailing list. If you want to
send emails there, you have to subscribe first.
http://www.haskell.org/mailman/listinfo/libraries

> How can I file a bug report for this package? I don't feel good
> enough in haskell to try and fix it myself.

IIUC, regex-compat is a compatibility layer on top of regex-posix. Is
there any reason you're not using regex-posix directly?

(Of course, I cannot tell whether the bug you've hit is in regex-posix
or is introduced by regex-compat.)

Roman
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140207/00a185ec/attachment.sig>

From mle+hs at mega-nerd.com  Fri Feb  7 08:22:58 2014
From: mle+hs at mega-nerd.com (Erik de Castro Lopo)
Date: Fri, 7 Feb 2014 19:22:58 +1100
Subject: [Haskell-cafe] Filing bugs for haskell packages
In-Reply-To: <20140207191831.07e23f621fb61dc7eba149b9@mega-nerd.com>
References: <52F49474.8080102@gmail.com>
 <20140207191831.07e23f621fb61dc7eba149b9@mega-nerd.com>
Message-ID: <20140207192258.703c1b6c86dd75a3ef0891f0@mega-nerd.com>

Erik de Castro Lopo wrote:

> > On the hackage page it says that the maintainer e-mail of this package 
> > is: libraries at haskell.org. So i sent a bug report there, but bounced 
> > back to me because of quota.
> 
> Thats likely to be a transitory issue.

Actually no, you probably got a message like:

> You are not allowed to post to this mailing list, and your message has
> been automatically rejected.  If you think that your messages are
> being rejected in error, contact the mailing list owner at
> libraries-owner at haskell.org.

because the list only accepts emails from people who are subscribed
to the list. YOu can subscribe here:

    http://www.haskell.org/mailman/listinfo/libraries

Erik
-- 
----------------------------------------------------------------------
Erik de Castro Lopo
http://www.mega-nerd.com/

From chriswarbo at googlemail.com  Fri Feb  7 14:27:07 2014
From: chriswarbo at googlemail.com (Chris Warburton)
Date: Fri, 07 Feb 2014 14:27:07 +0000
Subject: [Haskell-cafe] Lazy Lambda Calculus implementation
Message-ID: <86d2izroas.fsf@gmail.com>

Hello all, I've written the following implementation of Lambda Calculus,
which will evaluate its Terms non-strictly. I've verified this since the
Y combinator works without diverging:

data Term a = Const a
            | Var Nat
            | Lam (Term a)
            | Term a :@ Term a

data Val a = C a
           | F (Partial (Val a) -> Partial (Val a))

type Env a = [Partial (Val a)]

eval' :: Term a -> Env a -> Partial (Val a)
eval' (Const c) env = Now (C c)
eval' (Var   n) env = let Just x = lookUp env n in x
eval' (Lam   f) env = Now (F (\a -> eval' f (a:env)))
eval' (f :@  x) env = do F f' <- eval' f env
                         Later (f' (eval' x env))

eval t = eval' [] t

Nat, Partial, lookUp, etc. have pretty obvious implementations.

My question is, will this behave lazily? In other words will the
contents of the 'env' lists be shared between the different contexts,
such that forcing an element the be evaluated twice will only perform
the evaluation once? Note that the first "do" line is the only place
where evaluation is forced.

If anyone could point out an 'obvious' reason why it will or will not be
shared, or approaches I can take to check or infer this myself (eg. a
Term which would show wildly different RAM usage in each case), I'd be
very interested to know. I'd also be interested if someone spots a bug ;)

For those who are curious, the code is living at
https://gitorious.org/lazy-lambda-calculus and I've written a blog post
detailing the iteration's I've been through at
http://chriswarbo.net/index.php?page=news&type=view&id=admin-s-blog%2Flazy-lambda-calculus

Cheers,
Chris

From agocorona at gmail.com  Fri Feb  7 14:51:38 2014
From: agocorona at gmail.com (Alberto G. Corona )
Date: Fri, 7 Feb 2014 15:51:38 +0100
Subject: [Haskell-cafe] STM and unsafePerformIO/bracket
In-Reply-To: <20140204140611.GA3202@24f89f8c-e6a1-4e75-85ee-bb8a3743bb9f>
References: <C7C695A2-437A-4B95-82FB-2A3C2AA10437@mars.org>
 <20140204140611.GA3202@24f89f8c-e6a1-4e75-85ee-bb8a3743bb9f>
Message-ID: <CAArEJmZWw2u53Pj08V=y3qM_uXXtDudMVaKaNskNnZd9QWFETg@mail.gmail.com>

I use this trick, that unlike the previous workarounds permits concurrency
and does handle the IO computation in a civilized way, that is, it permits
brackets and so on:

notReallySafeButNotAsUnsafeAsUnsafeIOToSTM= safeIOToSTM

safeIOToSTM ?  IO a ? STM a
safeIOToSTM req= unsafeIOToSTM  $ do
  tv   ?  newEmptyMVar
  forkIO $ (req  ? putMVar  tv . Right)
          `Control.Exception.catch`
            (?(e ?  SomeException) ? putMVar tv $ Left e )
  r ?  takeMVar tv
  case r of
   Right x ? return x
   Left e ? throw e

Here the IO computation is run in another thread. Even If the STM
transaction is aborted, the IO computation finalizes. If the STM
transaction is retried, the IO computation is re-executed, so it is up to
you to take this into account depending on what you intend to do.
If the IO computation throws an exception the STM transaction throws it. As
far as I remember, this trick was used in a package time ago to do solve
the problem.


2014-02-04 Bertram Felgenhauer <bertram.felgenhauer at googlemail.com>:

> Rob Leslie wrote:
> > I?ve run into a difficulty I?d appreciate some advice to solve.
> [unsafePerformIO and bracket, within an STM transaction]
>
> There's a long-standing bug report for this issue,
>
>   https://ghc.haskell.org/trac/ghc/ticket/2401
>
> So the current situation is that bracket within unsafePerformIO
> (and unsafeIOToSTM) and STM transactions don't mix. I'm a bit
> surprised that this doesn't bite more people.
>
> Cheers,
>
> Bertram
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>



-- 
Alberto.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140207/fb711fd2/attachment.html>

From hanooter at gmail.com  Fri Feb  7 18:07:43 2014
From: hanooter at gmail.com (Kyle Hanson)
Date: Fri, 7 Feb 2014 10:07:43 -0800
Subject: [Haskell-cafe] ANN: Wheb -- A WAI framework
Message-ID: <CA+RnCFb6-K4Mu8zoShigahsSrZomsC_TQ-nZy0RGQ_Did6WuyQ@mail.gmail.com>

Hello all,

I was rather frustrated with the use of Template Haskell as the main entry
point for the big framework projects (Yesod, Snap, etc.) While these
frameworks offer template-free options, they seem like second class
citizens. So I started work on Wheb with the goal that out of the box I
could start a project quickly, without Template Haskell and without the
dreaded long list of Language Pragma's at the top.  I was inspired by the
simplicity of the Scotty project which showed how easy a Haskell server
could be to write.

I have included a couple of plugin examples for handling Auth and Sessions.
Wheb is database and template agnostic, but I plan to write some plugins
soon to make it easier to use the major libraries with Wheb.

I just started work on it last weekend but wanted to share my progress.
Take a look if it interests you!

http://hackage.haskell.org/package/Wheb-0.0.1.1

https://github.com/hansonkd/Wheb-Framework

Thanks,
Kyle Hanson
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140207/b8166b72/attachment.html>

From ltclifton at gmail.com  Sat Feb  8 01:13:07 2014
From: ltclifton at gmail.com (Luke Clifton)
Date: Sat, 8 Feb 2014 09:13:07 +0800
Subject: [Haskell-cafe] ANN: Wheb -- A WAI framework
In-Reply-To: <CA+RnCFb6-K4Mu8zoShigahsSrZomsC_TQ-nZy0RGQ_Did6WuyQ@mail.gmail.com>
References: <CA+RnCFb6-K4Mu8zoShigahsSrZomsC_TQ-nZy0RGQ_Did6WuyQ@mail.gmail.com>
Message-ID: <51A799E2-2E31-4859-8F5F-F243D61FFEC8@gmail.com>


> I was rather frustrated with the use of Template Haskell as the main entry point for the big framework projects (Yesod, Snap, etc.) 

Perhaps slightly off topic, but can someone outline why Template Haskell has so much negativity?

I've used Yesod a bit, and from my limited experience, the TH does a good job at removing a lot of boilerplate code, while still keeping things readable and type safe.

The main negatives I see are somewhat complicated error messages if you make a mistake, but the issue is usually pretty easy to spot because the TH is pretty simple.

Is portability an issue? How do the other Haskell compilers go with it?

Not to detract from your work, I think it's great to have options! I'm just curious.

From cdsmith at gmail.com  Sat Feb  8 02:03:33 2014
From: cdsmith at gmail.com (Chris Smith)
Date: Fri, 7 Feb 2014 18:03:33 -0800
Subject: [Haskell-cafe] ANN: Wheb -- A WAI framework
In-Reply-To: <51A799E2-2E31-4859-8F5F-F243D61FFEC8@gmail.com>
References: <CA+RnCFb6-K4Mu8zoShigahsSrZomsC_TQ-nZy0RGQ_Did6WuyQ@mail.gmail.com>
 <51A799E2-2E31-4859-8F5F-F243D61FFEC8@gmail.com>
Message-ID: <CAPq5PvLANExWkQQc-bzjJunGAW9uH48R5cUZ7s=UEzBnm15UKw@mail.gmail.com>

The main disadvantage of TH for me is that it's not amenable to static
analysis or reasoning.  Because the meaning of a TH splice is in no way
related to its type, it both breaks tools, and breaks my patterns of
understanding how things work by navigating the consistent generated
documentation on Hackage.

There are also portability concerns.  Not with non-GHC compilers (no one
uses anything but GHC), but with cross-compiling and such, including
projects like GHCJS (last time I checked anyway).
On Feb 7, 2014 5:14 PM, "Luke Clifton" <ltclifton at gmail.com> wrote:

>
> > I was rather frustrated with the use of Template Haskell as the main
> entry point for the big framework projects (Yesod, Snap, etc.)
>
> Perhaps slightly off topic, but can someone outline why Template Haskell
> has so much negativity?
>
> I've used Yesod a bit, and from my limited experience, the TH does a good
> job at removing a lot of boilerplate code, while still keeping things
> readable and type safe.
>
> The main negatives I see are somewhat complicated error messages if you
> make a mistake, but the issue is usually pretty easy to spot because the TH
> is pretty simple.
>
> Is portability an issue? How do the other Haskell compilers go with it?
>
> Not to detract from your work, I think it's great to have options! I'm
> just curious.
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140207/4cce8b3a/attachment.html>

From hanooter at gmail.com  Sat Feb  8 03:43:45 2014
From: hanooter at gmail.com (Kyle Hanson)
Date: Fri, 7 Feb 2014 19:43:45 -0800
Subject: [Haskell-cafe] ANN: Wheb -- A WAI framework
In-Reply-To: <51A799E2-2E31-4859-8F5F-F243D61FFEC8@gmail.com>
References: <CA+RnCFb6-K4Mu8zoShigahsSrZomsC_TQ-nZy0RGQ_Did6WuyQ@mail.gmail.com>
 <51A799E2-2E31-4859-8F5F-F243D61FFEC8@gmail.com>
Message-ID: <CA+RnCFaxycTaU2vCLH7_RX_gH0LKD1xDWOTx1Z6obf0pLOZ1wQ@mail.gmail.com>

Hi Luke!

I can tell you why I didn't want to include TH.

You are correct that TH does have many benefits and does indeed make a lot
of things easier in Haskell. However, easier does not always mean more
understandable.

Haskell has a pretty steep learning curve. Just learning the core Haskell98
is pretty difficult to grasp for a beginner. Adding TH haskell on top of
that is bad news. There is an inherit disconnect between a template haskell
function and the code it generates, because you can't see it. Type
signatures in Haskell provide much more than hints to the compiler about
types, they are also a good source of documentation. That is why I hate TH
functions. Take for example Yesod's mkYesod type signature:

*mkYesod :: String -> [Resource String] -> Q [Dec]*

That doesn't give me any information about what to expect as a result.
About the only way to know how to use this function is to find examples of
it or start digging into the code. It would probably help some if it were
standard practice for package maintainers to put the expected
type-signatures along with the TH functions.

Another problem that I see is that TH is not that discoverable. I would
wager that most Haskell users know how to use Template Haskell functions
but not how to implement them. TH is a sort of black box if you are
beginner where you can't look at the source code for a TH function because
once you look under the hood, it a bunch of VarTs, ConsTs, Decs.

--
Kyle Hanson


On Fri, Feb 7, 2014 at 5:13 PM, Luke Clifton <ltclifton at gmail.com> wrote:

>
> > I was rather frustrated with the use of Template Haskell as the main
> entry point for the big framework projects (Yesod, Snap, etc.)
>
> Perhaps slightly off topic, but can someone outline why Template Haskell
> has so much negativity?
>
> I've used Yesod a bit, and from my limited experience, the TH does a good
> job at removing a lot of boilerplate code, while still keeping things
> readable and type safe.
>
> The main negatives I see are somewhat complicated error messages if you
> make a mistake, but the issue is usually pretty easy to spot because the TH
> is pretty simple.
>
> Is portability an issue? How do the other Haskell compilers go with it?
>
> Not to detract from your work, I think it's great to have options! I'm
> just curious.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140207/f6a87a0c/attachment.html>

From miguelimo38 at yandex.ru  Sat Feb  8 09:19:42 2014
From: miguelimo38 at yandex.ru (MigMit)
Date: Sat, 8 Feb 2014 13:19:42 +0400
Subject: [Haskell-cafe] ANN: Wheb -- A WAI framework
In-Reply-To: <51A799E2-2E31-4859-8F5F-F243D61FFEC8@gmail.com>
References: <CA+RnCFb6-K4Mu8zoShigahsSrZomsC_TQ-nZy0RGQ_Did6WuyQ@mail.gmail.com>
 <51A799E2-2E31-4859-8F5F-F243D61FFEC8@gmail.com>
Message-ID: <CFDC575A-839B-4EE6-8F50-635EDDEE8FA2@yandex.ru>

Haskell is itself quite good at removing boilerplate code. In fact, we Haskellers sometimes take pride in writing clean and boilerplate-free code. Forcing us to use metaprogramming undermines our pride. That's why Template Haskell is much more disliked than other forms of metaprogramming ? CPP, C++ templates, Lisp macros, Tcl, Forth, etc. It essentially boils down to this: Template Haskell is hated because Haskell itself is so damn good. Of course, if you have a shitty language to start with, then metaprogramming can only be seen as great help.

Personally, I'm opposed to any form of metaprogramming. I prefer simplicity (says the guy who once asked SPJ if we're going to have polymorphic kinds), so I like having abstractions that semantically lie in the problem domain. Metaprogramming constructs, by definition, have their semantics defined in terms of the code they generate. I don't want to think about code. Ideally, I'd prefer not to see any code, but that's not on the plate right now. That's why I don't like metaprogramming, except for C++ templates, they have some sort of beautiful ugliness.

On 08 Feb 2014, at 05:13, Luke Clifton <ltclifton at gmail.com> wrote:

> 
>> I was rather frustrated with the use of Template Haskell as the main entry point for the big framework projects (Yesod, Snap, etc.) 
> 
> Perhaps slightly off topic, but can someone outline why Template Haskell has so much negativity?
> 
> I've used Yesod a bit, and from my limited experience, the TH does a good job at removing a lot of boilerplate code, while still keeping things readable and type safe.
> 
> The main negatives I see are somewhat complicated error messages if you make a mistake, but the issue is usually pretty easy to spot because the TH is pretty simple.
> 
> Is portability an issue? How do the other Haskell compilers go with it?
> 
> Not to detract from your work, I think it's great to have options! I'm just curious.
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe


From miguelimo38 at yandex.ru  Sat Feb  8 09:23:56 2014
From: miguelimo38 at yandex.ru (MigMit)
Date: Sat, 8 Feb 2014 13:23:56 +0400
Subject: [Haskell-cafe] ANN: Wheb -- A WAI framework
In-Reply-To: <CA+RnCFb6-K4Mu8zoShigahsSrZomsC_TQ-nZy0RGQ_Did6WuyQ@mail.gmail.com>
References: <CA+RnCFb6-K4Mu8zoShigahsSrZomsC_TQ-nZy0RGQ_Did6WuyQ@mail.gmail.com>
Message-ID: <B478F810-8B2C-4BD8-8B2F-63F043E33084@yandex.ru>

Kyle,

have you tried Happstack? It doesn't need Template Haskell, or a long list of pragmas, and it doesn't care what template or database engine you use.

It's main disadvantage is that it's not WAI, which seems to be ideologically superior; I've heard (or imagined) that there were some plans to make it WAI.

On 07 Feb 2014, at 22:07, Kyle Hanson <hanooter at gmail.com> wrote:

> Hello all,
> 
> I was rather frustrated with the use of Template Haskell as the main entry point for the big framework projects (Yesod, Snap, etc.) While these frameworks offer template-free options, they seem like second class citizens. So I started work on Wheb with the goal that out of the box I could start a project quickly, without Template Haskell and without the dreaded long list of Language Pragma's at the top.  I was inspired by the simplicity of the Scotty project which showed how easy a Haskell server could be to write.
> 
> I have included a couple of plugin examples for handling Auth and Sessions. Wheb is database and template agnostic, but I plan to write some plugins soon to make it easier to use the major libraries with Wheb.
> 
> I just started work on it last weekend but wanted to share my progress. Take a look if it interests you!
> 
> http://hackage.haskell.org/package/Wheb-0.0.1.1
> 
> https://github.com/hansonkd/Wheb-Framework
> 
> Thanks,
> Kyle Hanson
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe


From roma at ro-che.info  Sat Feb  8 17:12:47 2014
From: roma at ro-che.info (Roman Cheplyaka)
Date: Sat, 8 Feb 2014 19:12:47 +0200
Subject: [Haskell-cafe] An arrow transformer
Message-ID: <20140208171247.GA783@sniper>

I wrote (and found useful) the following arrow transformer:

  data Partial ar a b
    = Partial (ErrorArrow () ar a b)
    | Total (ar a b)

  toPartial :: ArrowChoice ar => Partial ar a b -> ErrorArrow () ar a b
  toPartial (Partial f) = f
  toPartial (Total sf) = liftError sf

  instance ArrowChoice ar => Category (Partial ar) where
    id = Total id
    Total f . Total g = Total $ f . g
    f . g = Partial $ toPartial f . toPartial g

  instance ArrowChoice ar => Arrow (Partial ar) where
    arr = Total . arr
    first (Total f) = Total $ first f
    first (Partial f) = Partial $ first f

It allows to work with partial functions/arrows and at the same time
tracks which of them are actually total.

I wonder if it is already defined somewhere or is perhaps an instance of
a more general construction.

Roman
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140208/35a54ea6/attachment.sig>

From omari at smileystation.com  Sat Feb  8 20:06:18 2014
From: omari at smileystation.com (Omari Norman)
Date: Sat, 8 Feb 2014 15:06:18 -0500
Subject: [Haskell-cafe] [ANN] deka - decimal arithmetic
Message-ID: <CA+aFgYCfPjRVe9D1FvZwB1x9-bn22d-ZatvLqg1jW5+bnFi5Eg@mail.gmail.com>

Announcing deka, a library for decimal arithmetic.

Why decimal arithmetic is important is discussed at length at

http://speleotrove.com/decimal/

but for a short explanation, go into ghci and type:

print $ 0.1 + 0.1 + 0.1

This is 0.3, right? But on my machine I get 0.3 plus a small fraction,
which is simply not acceptable for applications where it is essential to
get exact results, such as financial applications.

deka is a binding to the decNumber C library, a thoroughly tested and fast
implementation of decimal arithmetic.  deka is fully tested and I encourage
you to run the tests using the usual "cabal test" method.

deka is available at

http://hackage.haskell.org/package/deka

and is on Github at

https://github.com/massysett/deka

Because deka is a binding to the decNumber C library, first you will need
to install decNumber.  An easy to install version with the GNU autotools is
at:

https://github.com/massysett/decnumber/releases

decNumber's website is at

http://speleotrove.com/decimal/decnumber.html

A literate Haskell file illustrating the use of deka is available at

https://github.com/massysett/deka/blob/master/lib/Data/Deka/Docs/Examples.lhs
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140208/ae455056/attachment.html>

From nicolas at incubaid.com  Sat Feb  8 20:39:40 2014
From: nicolas at incubaid.com (Nicolas Trangez)
Date: Sat, 08 Feb 2014 21:39:40 +0100
Subject: [Haskell-cafe] [ANN] deka - decimal arithmetic
In-Reply-To: <CA+aFgYCfPjRVe9D1FvZwB1x9-bn22d-ZatvLqg1jW5+bnFi5Eg@mail.gmail.com>
References: <CA+aFgYCfPjRVe9D1FvZwB1x9-bn22d-ZatvLqg1jW5+bnFi5Eg@mail.gmail.com>
Message-ID: <1391891980.30777.1.camel@chi.nicolast.be>

Note there's some existing support for this in `base`:

On Sat, 2014-02-08 at 15:06 -0500, Omari Norman wrote:
> but for a short explanation, go into ghci and type:
> 
> print $ 0.1 + 0.1 + 0.1

? print $ (0.1 + 0.1 + 0.1 :: Double)
0.30000000000000004

? :m + Data.Fixed
? print $ (0.1 :: Fixed E1) + (0.1 :: Fixed E1) + (0.1 :: Fixed E1)
0.3

Nicolas


From omari at smileystation.com  Sat Feb  8 20:46:49 2014
From: omari at smileystation.com (Omari Norman)
Date: Sat, 8 Feb 2014 15:46:49 -0500
Subject: [Haskell-cafe] [ANN] deka - decimal arithmetic
In-Reply-To: <1391891980.30777.1.camel@chi.nicolast.be>
References: <CA+aFgYCfPjRVe9D1FvZwB1x9-bn22d-ZatvLqg1jW5+bnFi5Eg@mail.gmail.com>
 <1391891980.30777.1.camel@chi.nicolast.be>
Message-ID: <CA+aFgYAt2xgOu1Wd5muOps1CWEpBvXAAEkC4K26Da1z6kWzV0Q@mail.gmail.com>

On Sat, Feb 8, 2014 at 3:39 PM, Nicolas Trangez <nicolas at incubaid.com>wrote:

> Note there's some existing support for this in `base`:
>
> On Sat, 2014-02-08 at 15:06 -0500, Omari Norman wrote:
> > but for a short explanation, go into ghci and type:
> >
> > print $ 0.1 + 0.1 + 0.1
>
> ? print $ (0.1 + 0.1 + 0.1 :: Double)
> 0.30000000000000004
>
> ? :m + Data.Fixed
>

Key word there is "Fixed"; deka supports floating point with up to 34
digits of precision but, yes, Data.Fixed does solve some of this problem.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140208/1fde9055/attachment.html>

From roma at ro-che.info  Sat Feb  8 21:12:11 2014
From: roma at ro-che.info (Roman Cheplyaka)
Date: Sat, 8 Feb 2014 23:12:11 +0200
Subject: [Haskell-cafe] [ANN] deka - decimal arithmetic
In-Reply-To: <CA+aFgYAt2xgOu1Wd5muOps1CWEpBvXAAEkC4K26Da1z6kWzV0Q@mail.gmail.com>
References: <CA+aFgYCfPjRVe9D1FvZwB1x9-bn22d-ZatvLqg1jW5+bnFi5Eg@mail.gmail.com>
 <1391891980.30777.1.camel@chi.nicolast.be>
 <CA+aFgYAt2xgOu1Wd5muOps1CWEpBvXAAEkC4K26Da1z6kWzV0Q@mail.gmail.com>
Message-ID: <20140208211211.GA24002@sniper>

* Omari Norman <omari at smileystation.com> [2014-02-08 15:46:49-0500]
> On Sat, Feb 8, 2014 at 3:39 PM, Nicolas Trangez <nicolas at incubaid.com>wrote:
> 
> > Note there's some existing support for this in `base`:
> >
> > On Sat, 2014-02-08 at 15:06 -0500, Omari Norman wrote:
> > > but for a short explanation, go into ghci and type:
> > >
> > > print $ 0.1 + 0.1 + 0.1
> >
> > ? print $ (0.1 + 0.1 + 0.1 :: Double)
> > 0.30000000000000004
> >
> > ? :m + Data.Fixed
> >
> 
> Key word there is "Fixed"; deka supports floating point with up to 34
> digits of precision but

So it is fixed, too? I'm not sure "Fixed" qualifies as a key word, then :)

Note that Data.Fixed doesn't put any restrictions on the (fixed)
precision. You could easily define E34.

So yeah, a comparison with Data.Fixed would be nice to see.
Is deka faster? By how much? Does it support any additional operations?
Which ones?

Roman
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140208/a96635a2/attachment.sig>

From omari at smileystation.com  Sat Feb  8 21:45:02 2014
From: omari at smileystation.com (Omari Norman)
Date: Sat, 8 Feb 2014 16:45:02 -0500
Subject: [Haskell-cafe] [ANN] deka - decimal arithmetic
In-Reply-To: <20140208211211.GA24002@sniper>
References: <CA+aFgYCfPjRVe9D1FvZwB1x9-bn22d-ZatvLqg1jW5+bnFi5Eg@mail.gmail.com>
 <1391891980.30777.1.camel@chi.nicolast.be>
 <CA+aFgYAt2xgOu1Wd5muOps1CWEpBvXAAEkC4K26Da1z6kWzV0Q@mail.gmail.com>
 <20140208211211.GA24002@sniper>
Message-ID: <CA+aFgYD4T35OOvKjhck9qonzjWOOHD+zm6MQP69mvPEKMZJ6dQ@mail.gmail.com>

On Sat, Feb 8, 2014 at 4:12 PM, Roman Cheplyaka <roma at ro-che.info> wrote:

> So it is fixed, too? I'm not sure "Fixed" qualifies as a key word, then :)
>
> Note that Data.Fixed doesn't put any restrictions on the (fixed)
> precision. You could easily define E34.
>

No, it is not fixed.

>>> digits . unDeka . fromJust . strToDeka $ "3.00"
3

>>> digits . unDeka . fromJust . strToDeka $ "3.0000"
5

The precision is determined at runtime.  In contrast, with Data.Fixed, the
programmer sets the precision at compile time.  There is no difference
between

>>> 3 :: Fixed E6

and

>>> 3.00 :: Fixed E6

These issues are discussed at

http://speleotrove.com/decimal/decifaq1.html#tzeros

but if your reaction is "so what, it's just some extra zeroes and at
compile time I can just use E34", then by all means, keep using Fixed :)

Also, note that you get 34 significant digits, but that doesn't mean the
exponent is limited to 34.

>>> let x = fromJust . strToDeka $ "3E-200"
>>> let y = fromJust . strToDeka $ "4E-200"
>>> x + y
Deka {unDeka = 7E-200}

...which you could do in Fixed, true.  If you defined E200 first.  But,
oops, now I need E250...

Really this is a binding to decNumber, which implements the General Decimal
Arithmetic Specification, so see if decNumber and that specification
scratch an itch.  If they don't, use Fixed, or Decimal (also on Hackage) or
something else...
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140208/b816928e/attachment.html>

From roma at ro-che.info  Sat Feb  8 22:00:56 2014
From: roma at ro-che.info (Roman Cheplyaka)
Date: Sun, 9 Feb 2014 00:00:56 +0200
Subject: [Haskell-cafe] [ANN] deka - decimal arithmetic
In-Reply-To: <CA+aFgYD4T35OOvKjhck9qonzjWOOHD+zm6MQP69mvPEKMZJ6dQ@mail.gmail.com>
References: <CA+aFgYCfPjRVe9D1FvZwB1x9-bn22d-ZatvLqg1jW5+bnFi5Eg@mail.gmail.com>
 <1391891980.30777.1.camel@chi.nicolast.be>
 <CA+aFgYAt2xgOu1Wd5muOps1CWEpBvXAAEkC4K26Da1z6kWzV0Q@mail.gmail.com>
 <20140208211211.GA24002@sniper>
 <CA+aFgYD4T35OOvKjhck9qonzjWOOHD+zm6MQP69mvPEKMZJ6dQ@mail.gmail.com>
Message-ID: <20140208220056.GA25797@sniper>

* Omari Norman <omari at smileystation.com> [2014-02-08 16:45:02-0500]
> Also, note that you get 34 significant digits, but that doesn't mean the
> exponent is limited to 34.
> 
> >>> let x = fromJust . strToDeka $ "3E-200"
> >>> let y = fromJust . strToDeka $ "4E-200"
> >>> x + y
> Deka {unDeka = 7E-200}
> 
> ...which you could do in Fixed, true.  If you defined E200 first.  But,
> oops, now I need E250...

I see now. So this is a decimal floating-point numbers library, which
also attempts to track the precision of numbers. Does this sound right?

Roman
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140209/58e192a0/attachment.sig>

From omari at smileystation.com  Sat Feb  8 23:25:37 2014
From: omari at smileystation.com (Omari Norman)
Date: Sat, 8 Feb 2014 18:25:37 -0500
Subject: [Haskell-cafe] [ANN] deka - decimal arithmetic
In-Reply-To: <20140208220056.GA25797@sniper>
References: <CA+aFgYCfPjRVe9D1FvZwB1x9-bn22d-ZatvLqg1jW5+bnFi5Eg@mail.gmail.com>
 <1391891980.30777.1.camel@chi.nicolast.be>
 <CA+aFgYAt2xgOu1Wd5muOps1CWEpBvXAAEkC4K26Da1z6kWzV0Q@mail.gmail.com>
 <20140208211211.GA24002@sniper>
 <CA+aFgYD4T35OOvKjhck9qonzjWOOHD+zm6MQP69mvPEKMZJ6dQ@mail.gmail.com>
 <20140208220056.GA25797@sniper>
Message-ID: <CA+aFgYCyJHbz2PiSti0dkUHo7AuHJ5n0ozpRAuNm+KE6cNrYag@mail.gmail.com>

On Sat, Feb 8, 2014 at 5:00 PM, Roman Cheplyaka <roma at ro-che.info> wrote:

> * Omari Norman <omari at smileystation.com> [2014-02-08 16:45:02-0500]
> > Also, note that you get 34 significant digits, but that doesn't mean the
> > exponent is limited to 34.
> >
> > >>> let x = fromJust . strToDeka $ "3E-200"
> > >>> let y = fromJust . strToDeka $ "4E-200"
> > >>> x + y
> > Deka {unDeka = 7E-200}
> >
> > ...which you could do in Fixed, true.  If you defined E200 first.  But,
> > oops, now I need E250...
>
> I see now. So this is a decimal floating-point numbers library, which
> also attempts to track the precision of numbers. Does this sound right?


That's roughly right, yes. I would say"attempts" is too soft a word.
decNumber and, therefore, deka, tracks every significant digit and at least
maintains that significance.  If it trashes significant digits without
notifying you, it's a bug; please report it.

The differences between Data.Fixed and this library are so huge (Fixed
manipulates Integers alone; decNumber stores numbers as binary-coded
decimal coefficients and integer exponents) that I didn't even think to
compare them, and I won't be the one to draw performance comparisons
between the two because deka is for situations where solutions like Fixed
are simply wrong.  Fixed does me no good, no matter how fast it is, so
there's no reason for me to know how it performs.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140208/0dbce861/attachment.html>

From aslatter at gmail.com  Sun Feb  9 03:04:58 2014
From: aslatter at gmail.com (Antoine Latter)
Date: Sat, 8 Feb 2014 21:04:58 -0600
Subject: [Haskell-cafe] Naming scheme for partial functions
In-Reply-To: <CAKA2JgJzRMOQO6vqobC86ZN=adHqYn-wR92akOPWqGfH=Pptxg@mail.gmail.com>
References: <CAKA2JgKUDSpS3Etmm4gdepd5UuiLnF1RTVbx62eTs2yEdMzUcg@mail.gmail.com>
 <CAGigdoeH495PqqCa+sfkNfCpqB7HwbGTReMg_JDg1SD30A24hg@mail.gmail.com>
 <CAJN5CVKhTjAY7Njzv9FZChzxEbRY8dyj6g9Q3cE8bpcx+AL=Kw@mail.gmail.com>
 <CAKA2JgJzRMOQO6vqobC86ZN=adHqYn-wR92akOPWqGfH=Pptxg@mail.gmail.com>
Message-ID: <CAKjSnQGj5UXWEtQDCAtB6f4ETMho25-=HN7BqKYDbETa+SF9_w@mail.gmail.com>

What does "Ex" mean?


On Thu, Feb 6, 2014 at 8:59 PM, Michael Snoyman <michael at snoyman.com> wrote:

> Thanks for the input. We ended up going with an `Ex` suffix, e.g. headEx,
> lastEx.
>
>
> On Fri, Feb 7, 2014 at 4:53 AM, Tikhon Jelvis <tikhon at jelv.is> wrote:
>
>> For what it's worth, OCaml's Core library does this with _exn, so they
>> would call a partial last "last_exn". I would actually prefer an
>> abbreviation of some sort (like exn) as long as it's a consistent
>> convention. Using a full word like "exception" or "partial" adds to much
>> noise in my opinion, especially if the base name (like "last") is shorter
>> than the suffix!
>>
>> Also, I think a suffix would be better than a prefix, if only to group
>> things conveniently when sorted alphabetically.
>>
>>
>> On Thu, Jan 30, 2014 at 9:36 AM, Atze van der Ploeg <atzeus at gmail.com>wrote:
>>
>>> unprovenLast ?
>>> On Jan 30, 2014 6:33 PM, "Michael Snoyman" <michael at snoyman.com> wrote:
>>>
>>>> Greg Weber and I have been discussing some changes to
>>>> mono-traversable[1]. One of the modules we provide is Data.NonNull, which
>>>> provides total versions of functions like `last`. A change we're looking at
>>>> would require having a partial version of `last` defined in a separate
>>>> typeclass (IsSequence), which would allowing for more optimized
>>>> implementations of the total `last` function for datatypes which support it
>>>> (e.g., strict ByteStrings).
>>>>
>>>> But what should we name it? I'm sure everyone's familiar with the
>>>> `unsafe` naming convention, but that's not appropriate here: standard usage
>>>> shows `unsafe` meaning a function which can cause a segfault.
>>>>
>>>> I initially named it `partialLast`, but partial can also imply partial
>>>> function application. Greg brought up the idea of suffixing the function
>>>> with something like `Throws` or `Errors`, which I think I'm a bit partial
>>>> to myself[2].
>>>>
>>>> So my questions are:
>>>>
>>>> * Is there some already used naming scheme out there for partial
>>>> functions which I've missed?
>>>> * Do people have any ideas to throw into the mix?
>>>>
>>>> Michael
>>>>
>>>> [1] https://github.com/snoyberg/mono-traversable/pull/21
>>>> [2] Pardon the pun.
>>>>
>>>> _______________________________________________
>>>> Haskell-Cafe mailing list
>>>> Haskell-Cafe at haskell.org
>>>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>>>
>>>>
>>> _______________________________________________
>>> Haskell-Cafe mailing list
>>> Haskell-Cafe at haskell.org
>>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>>
>>>
>>
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140208/2c0d3607/attachment.html>

From andrew.pennebaker at gmail.com  Sun Feb  9 04:01:55 2014
From: andrew.pennebaker at gmail.com (Andrew Pennebaker)
Date: Sat, 8 Feb 2014 23:01:55 -0500
Subject: [Haskell-cafe] Puppet module for installing cabal packages?
Message-ID: <CAHXt_SUOfOxwCRPSW8jFhmiQyd-co_Yx0ce9gJRC8gU-1Rix6g@mail.gmail.com>

I'm using Vagrant <http://www.vagrantup.com/> and
Puppet<http://puppetlabs.com/puppet/what-is-puppet> to
automate setting up development, testing, and production environments.  For
now, I'm executing shell commands to install my favorite Cabal packages
(`cabal update`, `cabal install <package>`), but I'd prefer to use
something a bit more high level.

Would anyone be interested in creating a Puppet module for Cabal? This
could encourage more use of awesome packages like Darcs and ShellCheck by
non-Haskellers.

-- 
Cheers,

Andrew Pennebaker
www.yellosoft.us
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140208/c24d43e3/attachment.html>

From michael at snoyman.com  Sun Feb  9 05:25:40 2014
From: michael at snoyman.com (Michael Snoyman)
Date: Sun, 9 Feb 2014 07:25:40 +0200
Subject: [Haskell-cafe] Naming scheme for partial functions
In-Reply-To: <CAKjSnQGj5UXWEtQDCAtB6f4ETMho25-=HN7BqKYDbETa+SF9_w@mail.gmail.com>
References: <CAKA2JgKUDSpS3Etmm4gdepd5UuiLnF1RTVbx62eTs2yEdMzUcg@mail.gmail.com>
 <CAGigdoeH495PqqCa+sfkNfCpqB7HwbGTReMg_JDg1SD30A24hg@mail.gmail.com>
 <CAJN5CVKhTjAY7Njzv9FZChzxEbRY8dyj6g9Q3cE8bpcx+AL=Kw@mail.gmail.com>
 <CAKA2JgJzRMOQO6vqobC86ZN=adHqYn-wR92akOPWqGfH=Pptxg@mail.gmail.com>
 <CAKjSnQGj5UXWEtQDCAtB6f4ETMho25-=HN7BqKYDbETa+SF9_w@mail.gmail.com>
Message-ID: <CAKA2JgJURJEo5-01yOtN1KOdA5HPzBT_BrmcKTCQ1b=rA6a0Dg@mail.gmail.com>

It means "throws an *ex*ception."


On Sun, Feb 9, 2014 at 5:04 AM, Antoine Latter <aslatter at gmail.com> wrote:

> What does "Ex" mean?
>
>
> On Thu, Feb 6, 2014 at 8:59 PM, Michael Snoyman <michael at snoyman.com>wrote:
>
>> Thanks for the input. We ended up going with an `Ex` suffix, e.g. headEx,
>> lastEx.
>>
>>
>> On Fri, Feb 7, 2014 at 4:53 AM, Tikhon Jelvis <tikhon at jelv.is> wrote:
>>
>>> For what it's worth, OCaml's Core library does this with _exn, so they
>>> would call a partial last "last_exn". I would actually prefer an
>>> abbreviation of some sort (like exn) as long as it's a consistent
>>> convention. Using a full word like "exception" or "partial" adds to much
>>> noise in my opinion, especially if the base name (like "last") is shorter
>>> than the suffix!
>>>
>>> Also, I think a suffix would be better than a prefix, if only to group
>>> things conveniently when sorted alphabetically.
>>>
>>>
>>> On Thu, Jan 30, 2014 at 9:36 AM, Atze van der Ploeg <atzeus at gmail.com>wrote:
>>>
>>>> unprovenLast ?
>>>> On Jan 30, 2014 6:33 PM, "Michael Snoyman" <michael at snoyman.com> wrote:
>>>>
>>>>> Greg Weber and I have been discussing some changes to
>>>>> mono-traversable[1]. One of the modules we provide is Data.NonNull, which
>>>>> provides total versions of functions like `last`. A change we're looking at
>>>>> would require having a partial version of `last` defined in a separate
>>>>> typeclass (IsSequence), which would allowing for more optimized
>>>>> implementations of the total `last` function for datatypes which support it
>>>>> (e.g., strict ByteStrings).
>>>>>
>>>>> But what should we name it? I'm sure everyone's familiar with the
>>>>> `unsafe` naming convention, but that's not appropriate here: standard usage
>>>>> shows `unsafe` meaning a function which can cause a segfault.
>>>>>
>>>>> I initially named it `partialLast`, but partial can also imply partial
>>>>> function application. Greg brought up the idea of suffixing the function
>>>>> with something like `Throws` or `Errors`, which I think I'm a bit partial
>>>>> to myself[2].
>>>>>
>>>>> So my questions are:
>>>>>
>>>>> * Is there some already used naming scheme out there for partial
>>>>> functions which I've missed?
>>>>> * Do people have any ideas to throw into the mix?
>>>>>
>>>>> Michael
>>>>>
>>>>> [1] https://github.com/snoyberg/mono-traversable/pull/21
>>>>> [2] Pardon the pun.
>>>>>
>>>>> _______________________________________________
>>>>> Haskell-Cafe mailing list
>>>>> Haskell-Cafe at haskell.org
>>>>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>>>>
>>>>>
>>>> _______________________________________________
>>>> Haskell-Cafe mailing list
>>>> Haskell-Cafe at haskell.org
>>>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>>>
>>>>
>>>
>>
>> _______________________________________________
>> Haskell-Cafe mailing list
>> Haskell-Cafe at haskell.org
>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>
>>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140209/fc29d21b/attachment.html>

From carter.schonwald at gmail.com  Sun Feb  9 05:54:03 2014
From: carter.schonwald at gmail.com (Carter Schonwald)
Date: Sun, 9 Feb 2014 00:54:03 -0500
Subject: [Haskell-cafe] Puppet module for installing cabal packages?
In-Reply-To: <CAHXt_SUOfOxwCRPSW8jFhmiQyd-co_Yx0ce9gJRC8gU-1Rix6g@mail.gmail.com>
References: <CAHXt_SUOfOxwCRPSW8jFhmiQyd-co_Yx0ce9gJRC8gU-1Rix6g@mail.gmail.com>
Message-ID: <CAHYVw0ybHwrLbAU+jn3aLeT2wt05CWK5ipwfVKno2JszYfRadw@mail.gmail.com>

andrew, have at it! (if its a need you care about, whack at it and if you
get stuck ask for help!)
if you get stuck / hit any issues, shoot an email at
cabal-devel at haskell.org or ask for help #hackage on IRC



On Sat, Feb 8, 2014 at 11:01 PM, Andrew Pennebaker <
andrew.pennebaker at gmail.com> wrote:

> I'm using Vagrant <http://www.vagrantup.com/> and Puppet<http://puppetlabs.com/puppet/what-is-puppet> to
> automate setting up development, testing, and production environments.  For
> now, I'm executing shell commands to install my favorite Cabal packages
> (`cabal update`, `cabal install <package>`), but I'd prefer to use
> something a bit more high level.
>
> Would anyone be interested in creating a Puppet module for Cabal? This
> could encourage more use of awesome packages like Darcs and ShellCheck by
> non-Haskellers.
>
> --
> Cheers,
>
> Andrew Pennebaker
> www.yellosoft.us
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140209/936436f6/attachment.html>

From slyich at gmail.com  Sun Feb  9 07:00:21 2014
From: slyich at gmail.com (Sergei Trofimovich)
Date: Sun, 9 Feb 2014 10:00:21 +0300
Subject: [Haskell-cafe] Unmaintained packages and hackage upload rights
In-Reply-To: <20140130163055.GA19868@sniper>
References: <20140130163055.GA19868@sniper>
Message-ID: <20140209100021.45f49428@sf>

On Thu, 30 Jan 2014 18:30:55 +0200
Roman Cheplyaka <roma at ro-che.info> wrote:

> In the recent past I took over two unmaintained packages: bert and
> ansi-terminal. I don't mind spending a bit of time to keep our ecosystem
> from bitrotting.
> 
> However, both times I had to go through an irritating procedure of
> contacting hackage admins, asking them to grant me upload rights,
> explaining why the maintainers can't do that themselves and why I think
> the packages are abandoned.
> 
> Instead of a feeling that I'm doing something good and useful, I have
> a feeling that I'm bothering people with my own problems. It also adds
> unnecessary latency to my work.
> 
> So from now on I'll simply fork the packages I need to fix.
> 
> Others are of course welcome to use my forks.
> 
> (This email was prompted by regex-tdfa which doesn't build on GHC 7.8,
> and whose maintainer hasn't responded. My fork is at
> http://hackage.haskell.org/package/regex-tdfa-rc .)
> 
> Roman

Driven here by http://ro-che.info//articles/2014-02-08-my-haskell-will.html

Now as regex-tdfa-1.2.0 is on hackage.

What status of your regex-tdfa-rc? May I bug you with performance problems
compared to regex-dfa?

-- 

  Sergei
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 198 bytes
Desc: not available
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140209/50a16afb/attachment.sig>

From roma at ro-che.info  Sun Feb  9 07:32:45 2014
From: roma at ro-che.info (Roman Cheplyaka)
Date: Sun, 9 Feb 2014 09:32:45 +0200
Subject: [Haskell-cafe] Unmaintained packages and hackage upload rights
In-Reply-To: <20140209100021.45f49428@sf>
References: <20140130163055.GA19868@sniper>
 <20140209100021.45f49428@sf>
Message-ID: <20140209073245.GA29009@sniper>

* Sergei Trofimovich <slyich at gmail.com> [2014-02-09 10:00:21+0300]
> Now as regex-tdfa-1.2.0 is on hackage.
> 
> What status of your regex-tdfa-rc?

Thanks for the reminder. I just marked it as deprecated in favor of
regex-tdfa.

> May I bug you with performance problems compared to regex-dfa?

No, I don't know much about how it works. My sole reason for forking was
to keep it buildable.

Roman
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140209/c058cf69/attachment.sig>

From difrumin at gmail.com  Sun Feb  9 11:14:17 2014
From: difrumin at gmail.com (Daniil Frumin)
Date: Sun, 9 Feb 2014 15:14:17 +0400
Subject: [Haskell-cafe] Package for regular expressions
Message-ID: <CACxkR4Bp9iNPHBnDEGhD03JPMd8kEXfbmO-1t9e_wbw7Pw2q7Q@mail.gmail.com>

Hi, everyone!

Due to the recent discussions discussions about regex- packages on
libraries@ and cafe, as well as due to the unicode bug in darcs that
Erik Kow and I have stumbled upon I wanted to ask the Haskell
community the following:

What is up with the regular expression packages? Which one is the go-to package?
There are really a bunch of them around (regex-compat, regex-tdfa,
regex-posicx, regex-compat-tdfa,, ..) and it's not obvious at all what
is the difference between them and which one should I use.

Any advice or comments are appreciated.

Sincerely yours,
-- Daniil Frumin

From magnus at therning.org  Sun Feb  9 12:28:23 2014
From: magnus at therning.org (Magnus Therning)
Date: Sun, 9 Feb 2014 13:28:23 +0100
Subject: [Haskell-cafe] Installing Ghc 7.8 - ghc-split missing
Message-ID: <20140209122823.GA30840@tatooine.lan>

I've put together an experimental package of Ghc 7.8 for ArchLinux.
It's pulling the sources from git (the branch ghc-7.8 from
git.haskell.org) and it basically performs the following steps to
build and install:

    ./sync-all -r git://git.haskell.org get -b ghc-7.8
    ./boot
    ./configure --prefix=/usr
    make -j 5
    make DESTDIR=<the packaging dir> install

The build and install completes successfully, and some trivial tests
work (compiling hello-world, playing a bit with ghci, that sort of
thing).  However, compiling mtl fails, with this message:

    Configuring mtl-2.1.2...
    Building mtl-2.1.2...
    Preprocessing library mtl-2.1.2...
    [ 1 of 21] Compiling Control.Monad.Writer.Class ( Control/Monad/Writer/Class.hs, dist/build/Control/Monad/Writer/Class.o )
    ghc: could not execute: /usr/lib/ghc-7.8.0.20140204/ghc-split

And indeed, ghc-split is not installed using `make install`.  Is this
a known bug?

/M

-- 
Magnus Therning                      OpenPGP: 0xAB4DFBA4 
email: magnus at therning.org   jabber: magnus at therning.org
twitter: magthe               http://therning.org/magnus

I invented the term Object-Oriented, and I can tell you I did not have
C++ in mind.
     -- Alan Kay
-------------- next part --------------
A non-text attachment was scrubbed...
Name: not available
Type: application/pgp-signature
Size: 198 bytes
Desc: not available
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140209/f9537ec4/attachment.sig>

From simon at banquise.net  Sun Feb  9 13:38:32 2014
From: simon at banquise.net (Simon Marechal)
Date: Sun, 09 Feb 2014 14:38:32 +0100
Subject: [Haskell-cafe] Package for regular expressions
In-Reply-To: <CACxkR4Bp9iNPHBnDEGhD03JPMd8kEXfbmO-1t9e_wbw7Pw2q7Q@mail.gmail.com>
References: <CACxkR4Bp9iNPHBnDEGhD03JPMd8kEXfbmO-1t9e_wbw7Pw2q7Q@mail.gmail.com>
Message-ID: <52F784D8.6060109@banquise.net>

On 02/09/2014 12:14 PM, Daniil Frumin wrote:
> What is up with the regular expression packages? Which one is the go-to package?
> There are really a bunch of them around (regex-compat, regex-tdfa,
> regex-posicx, regex-compat-tdfa,, ..) and it's not obvious at all what
> is the difference between them and which one should I use.

This might be outdated, but provides a good comparison :

http://www.haskell.org/haskellwiki/Regular_expressions

I went fairly quickly to regex-pcre-builtin, as it's actually Perl
compatible, which I believe is the most common regex dialect in use. It
is also straightforward to use.

From omari at smileystation.com  Sun Feb  9 15:15:07 2014
From: omari at smileystation.com (Omari Norman)
Date: Sun, 9 Feb 2014 10:15:07 -0500
Subject: [Haskell-cafe] Package for regular expressions
In-Reply-To: <CACxkR4Bp9iNPHBnDEGhD03JPMd8kEXfbmO-1t9e_wbw7Pw2q7Q@mail.gmail.com>
References: <CACxkR4Bp9iNPHBnDEGhD03JPMd8kEXfbmO-1t9e_wbw7Pw2q7Q@mail.gmail.com>
Message-ID: <CA+aFgYDr9hsDbcSKL=4E+vQHe4SP=GOTZs5pbQ-L8WB68Zts7A@mail.gmail.com>

On Sun, Feb 9, 2014 at 6:14 AM, Daniil Frumin <difrumin at gmail.com> wrote:
>
> What is up with the regular expression packages? Which one is the go-to package?
> There are really a bunch of them around (regex-compat, regex-tdfa,
> regex-posicx, regex-compat-tdfa,, ..) and it's not obvious at all what
> is the difference between them and which one should I use.

The great bulk of those packages accompany regex-base.  They provide
"backends" which you then use through the pcre-base interface.

pcre-base has a heavily overloaded interface. It's novel, but I think
understanding what it is really doing is not at all straightforward.
This is exemplified by the chapter about regular expressions in Real
World Haskell, which dismisses explaining what one of the functions
does with "As a result, the type signature of the (=~) operator is
difficult to understand, so we will not explain it here."

http://book.realworldhaskell.org/read/efficient-file-processing-regular-expressions-and-file-name-matching.html

For something easier to understand, I recommend pcre-light.  Its types
are straightforward.

From berdario at gmail.com  Sun Feb  9 16:12:53 2014
From: berdario at gmail.com (Dario Bertini)
Date: Sun, 9 Feb 2014 17:12:53 +0100
Subject: [Haskell-cafe] Package for regular expressions
In-Reply-To: <CA+aFgYDr9hsDbcSKL=4E+vQHe4SP=GOTZs5pbQ-L8WB68Zts7A@mail.gmail.com>
References: <CACxkR4Bp9iNPHBnDEGhD03JPMd8kEXfbmO-1t9e_wbw7Pw2q7Q@mail.gmail.com>
 <CA+aFgYDr9hsDbcSKL=4E+vQHe4SP=GOTZs5pbQ-L8WB68Zts7A@mail.gmail.com>
Message-ID: <CAFdyfB1ezRSP=pOn4_eqsM_=jVXtmNA3R2NmWJxAW26FJ1BPtw@mail.gmail.com>

I kinda like regex-applicative

https://github.com/feuerbach/regex-applicative

-- 
xmpp: berdario at gmail.com
bitmessage: BM-2cTYXfGiSTsnx3righ6aHcJSWe4MV17jDP
gpg fingerprint: 3F8D53518012716C4EEF7DF67B498306B3BF75A0 (used just
for signing commits)

From aslatter at gmail.com  Sun Feb  9 16:41:25 2014
From: aslatter at gmail.com (Antoine Latter)
Date: Sun, 9 Feb 2014 10:41:25 -0600
Subject: [Haskell-cafe] Naming scheme for partial functions
In-Reply-To: <CAKA2JgJURJEo5-01yOtN1KOdA5HPzBT_BrmcKTCQ1b=rA6a0Dg@mail.gmail.com>
References: <CAKA2JgKUDSpS3Etmm4gdepd5UuiLnF1RTVbx62eTs2yEdMzUcg@mail.gmail.com>
 <CAGigdoeH495PqqCa+sfkNfCpqB7HwbGTReMg_JDg1SD30A24hg@mail.gmail.com>
 <CAJN5CVKhTjAY7Njzv9FZChzxEbRY8dyj6g9Q3cE8bpcx+AL=Kw@mail.gmail.com>
 <CAKA2JgJzRMOQO6vqobC86ZN=adHqYn-wR92akOPWqGfH=Pptxg@mail.gmail.com>
 <CAKjSnQGj5UXWEtQDCAtB6f4ETMho25-=HN7BqKYDbETa+SF9_w@mail.gmail.com>
 <CAKA2JgJURJEo5-01yOtN1KOdA5HPzBT_BrmcKTCQ1b=rA6a0Dg@mail.gmail.com>
Message-ID: <CAKjSnQFa_yza4hz+hM4Zk2EKTnF=msNVA3mz4+R+tYrq8Kywug@mail.gmail.com>

Not that it matters, but I think I prefer the "Unsafe" suffix. I'm not
calling this version of "head" because I *want* an exception - I'm calling
it because I want "Unsafe" (non-typechecked) behavior - I'm asserting that
I've already validated some preconditions that aren't reflected in the type.

But on the other hand I've always found functions like "fromMaybe" easier
to work with than functions like "fromJust".

Enough bikeshedding! If it works in your packages that's fine, and these
are the sort of functions I have no complaints about reimplementing on my
own.


On Sat, Feb 8, 2014 at 11:25 PM, Michael Snoyman <michael at snoyman.com>wrote:

> It means "throws an *ex*ception."
>
>
> On Sun, Feb 9, 2014 at 5:04 AM, Antoine Latter <aslatter at gmail.com> wrote:
>
>> What does "Ex" mean?
>>
>>
>> On Thu, Feb 6, 2014 at 8:59 PM, Michael Snoyman <michael at snoyman.com>wrote:
>>
>>> Thanks for the input. We ended up going with an `Ex` suffix, e.g.
>>> headEx, lastEx.
>>>
>>>
>>> On Fri, Feb 7, 2014 at 4:53 AM, Tikhon Jelvis <tikhon at jelv.is> wrote:
>>>
>>>> For what it's worth, OCaml's Core library does this with _exn, so they
>>>> would call a partial last "last_exn". I would actually prefer an
>>>> abbreviation of some sort (like exn) as long as it's a consistent
>>>> convention. Using a full word like "exception" or "partial" adds to much
>>>> noise in my opinion, especially if the base name (like "last") is shorter
>>>> than the suffix!
>>>>
>>>> Also, I think a suffix would be better than a prefix, if only to group
>>>> things conveniently when sorted alphabetically.
>>>>
>>>>
>>>> On Thu, Jan 30, 2014 at 9:36 AM, Atze van der Ploeg <atzeus at gmail.com>wrote:
>>>>
>>>>> unprovenLast ?
>>>>> On Jan 30, 2014 6:33 PM, "Michael Snoyman" <michael at snoyman.com>
>>>>> wrote:
>>>>>
>>>>>> Greg Weber and I have been discussing some changes to
>>>>>> mono-traversable[1]. One of the modules we provide is Data.NonNull, which
>>>>>> provides total versions of functions like `last`. A change we're looking at
>>>>>> would require having a partial version of `last` defined in a separate
>>>>>> typeclass (IsSequence), which would allowing for more optimized
>>>>>> implementations of the total `last` function for datatypes which support it
>>>>>> (e.g., strict ByteStrings).
>>>>>>
>>>>>> But what should we name it? I'm sure everyone's familiar with the
>>>>>> `unsafe` naming convention, but that's not appropriate here: standard usage
>>>>>> shows `unsafe` meaning a function which can cause a segfault.
>>>>>>
>>>>>> I initially named it `partialLast`, but partial can also imply
>>>>>> partial function application. Greg brought up the idea of suffixing the
>>>>>> function with something like `Throws` or `Errors`, which I think I'm a bit
>>>>>> partial to myself[2].
>>>>>>
>>>>>> So my questions are:
>>>>>>
>>>>>> * Is there some already used naming scheme out there for partial
>>>>>> functions which I've missed?
>>>>>> * Do people have any ideas to throw into the mix?
>>>>>>
>>>>>> Michael
>>>>>>
>>>>>> [1] https://github.com/snoyberg/mono-traversable/pull/21
>>>>>> [2] Pardon the pun.
>>>>>>
>>>>>> _______________________________________________
>>>>>> Haskell-Cafe mailing list
>>>>>> Haskell-Cafe at haskell.org
>>>>>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>>>>>
>>>>>>
>>>>> _______________________________________________
>>>>> Haskell-Cafe mailing list
>>>>> Haskell-Cafe at haskell.org
>>>>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>>>>
>>>>>
>>>>
>>>
>>> _______________________________________________
>>> Haskell-Cafe mailing list
>>> Haskell-Cafe at haskell.org
>>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>>
>>>
>>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140209/8fbdd146/attachment.html>

From roma at ro-che.info  Sun Feb  9 16:44:56 2014
From: roma at ro-che.info (Roman Cheplyaka)
Date: Sun, 9 Feb 2014 18:44:56 +0200
Subject: [Haskell-cafe] Package for regular expressions
In-Reply-To: <CAFdyfB1ezRSP=pOn4_eqsM_=jVXtmNA3R2NmWJxAW26FJ1BPtw@mail.gmail.com>
References: <CACxkR4Bp9iNPHBnDEGhD03JPMd8kEXfbmO-1t9e_wbw7Pw2q7Q@mail.gmail.com>
 <CA+aFgYDr9hsDbcSKL=4E+vQHe4SP=GOTZs5pbQ-L8WB68Zts7A@mail.gmail.com>
 <CAFdyfB1ezRSP=pOn4_eqsM_=jVXtmNA3R2NmWJxAW26FJ1BPtw@mail.gmail.com>
Message-ID: <20140209164456.GA4815@sniper>

* Dario Bertini <berdario at gmail.com> [2014-02-09 17:12:53+0100]
> I kinda like regex-applicative
> 
> https://github.com/feuerbach/regex-applicative

It is rather slow compared to ordinary regex packages. (Although it is
more powerful, as it allows real parsing.)

Roman
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140209/43c14be7/attachment.sig>

From m at j4.pe  Sun Feb  9 17:46:43 2014
From: m at j4.pe (m at j4.pe)
Date: Sun, 09 Feb 2014 18:46:43 +0100
Subject: [Haskell-cafe] haskell-search.org | research tools for Haskell
Message-ID: <87mwi0b2m4.fsf@x220.j4.pe>


Hello,

I would like to introduce http://haskell-search.org/. The idea is to
index the most common Haskell sites to facilitate research on
Haskell. It is a version for testing. If you like it, I can leave it
running.

Regards

From fuuzetsu at fuuzetsu.co.uk  Sun Feb  9 18:15:03 2014
From: fuuzetsu at fuuzetsu.co.uk (Mateusz Kowalczyk)
Date: Sun, 09 Feb 2014 18:15:03 +0000
Subject: [Haskell-cafe] haskell-search.org | research tools for Haskell
In-Reply-To: <87mwi0b2m4.fsf@x220.j4.pe>
References: <87mwi0b2m4.fsf@x220.j4.pe>
Message-ID: <52F7C5A7.7050903@fuuzetsu.co.uk>

On 09/02/14 17:46, m at j4.pe wrote:
> 
> Hello,
> 
> I would like to introduce http://haskell-search.org/. The idea is to
> index the most common Haskell sites to facilitate research on
> Haskell. It is a version for testing. If you like it, I can leave it
> running.
> 
> Regards
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
> 

Hi,

I have found a 2 bugs and 2 annoyances in the first 20 seconds. First bug:

1. Go to the main page
2. Type something in the search, such as ?functor? and wait for the
suggestion list to appear.
3. Press return

We now get results but the suggestion list stays open, resulting in the
results being obscured.

Second bug:
The ?Previous? button is always clickable even if we're on the first page.

First annoyance:
It's all a single page! The browser ?back? buttons &c do not work!
Please stop this if at all possible, it makes browsing close to
impossible. It's the same thing with the ?Next? and ?Previous? buttons.
Same for results with 0 pages.

Second annoyance:
We're not told which page we're on at all.

Let me know if you prefer these as bugs on GitHub instead.

Other than those problems, I think this might turn out to be useful
although it definitely needs some usability polish.

PS: It'd be much cooler if the code running the site was in Haskell!

-- 
Mateusz K.

From m at j4.pe  Sun Feb  9 18:27:04 2014
From: m at j4.pe (m at j4.pe)
Date: Sun, 09 Feb 2014 19:27:04 +0100
Subject: [Haskell-cafe] haskell-search.org | research tools for Haskell
In-Reply-To: <52F7C5A7.7050903@fuuzetsu.co.uk>
References: <87mwi0b2m4.fsf@x220.j4.pe> <52F7C5A7.7050903@fuuzetsu.co.uk>
Message-ID: <871tzcywef.fsf@x220.j4.pe>


You can add the bugs on github this will push me to solve it. At the
moment this is a POC. The principle is very simple. HTML / JS to call a
REST webservice (i use www.open-search-server.com). I can write the
front with Yesod or Snap but rewrite the search engine in haskell is
just impossible for me. Before I want to see if it useful or not.

regards

fuuzetsu at fuuzetsu.co.uk writes:

> On 09/02/14 17:46, m at j4.pe wrote:
>> 
>> Hello,
>> 
>> I would like to introduce http://haskell-search.org/. The idea is to
>> index the most common Haskell sites to facilitate research on
>> Haskell. It is a version for testing. If you like it, I can leave it
>> running.
>> 
>> Regards _______________________________________________ Haskell-Cafe
>> mailing list Haskell-Cafe at haskell.org
>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>> 
>
> Hi,
>
> I have found a 2 bugs and 2 annoyances in the first 20 seconds. First
> bug:
>
> 1. Go to the main page 2. Type something in the search, such as
> ?functor? and wait for the suggestion list to appear.  3. Press return
>
> We now get results but the suggestion list stays open, resulting in
> the results being obscured.
>
> Second bug: The ?Previous? button is always clickable even if we're on
> the first page.
>
> First annoyance: It's all a single page! The browser ?back? buttons &c
> do not work!  Please stop this if at all possible, it makes browsing
> close to impossible. It's the same thing with the ?Next? and
> ?Previous? buttons.  Same for results with 0 pages.
>
> Second annoyance: We're not told which page we're on at all.
>
> Let me know if you prefer these as bugs on GitHub instead.
>
> Other than those problems, I think this might turn out to be useful
> although it definitely needs some usability polish.
>
> PS: It'd be much cooler if the code running the site was in Haskell!


From tyler.huffman at tylerh.org  Mon Feb 10 02:50:55 2014
From: tyler.huffman at tylerh.org (Tyler Huffman)
Date: Sun, 9 Feb 2014 19:50:55 -0700
Subject: [Haskell-cafe] Master's Thesis: Open areas of research in Haskell
Message-ID: <CAMYb46C3QX+n=D06ePFTPGuPJMK5T7Ac=ERZtyzge0qZNveyRw@mail.gmail.com>

Hello all!

Beginning in September, I'll begin my Master's program in Computer Science,
and I'm completely set on doing my thesis in some form of functional
programming and/or Haskell. I've seen the Internship opportunities and
areas of research for GHC (https://ghc.haskell.org/trac/ghc/wiki/Internships)
but they all seem to apply to Ph.D candidates.

That said, are there open areas of research that I could look into, or more
resources in Haskell that would be useful for a two-year program's
research? I'm hoping to have a set thesis by the time I begin my Master's
program, which is why I'm giving myself six months in advance.

Any help would be highly appreciated!


Regards
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140209/691f7e0c/attachment.html>

From michael at snoyman.com  Mon Feb 10 05:38:17 2014
From: michael at snoyman.com (Michael Snoyman)
Date: Mon, 10 Feb 2014 07:38:17 +0200
Subject: [Haskell-cafe] Naming scheme for partial functions
In-Reply-To: <CAKjSnQFa_yza4hz+hM4Zk2EKTnF=msNVA3mz4+R+tYrq8Kywug@mail.gmail.com>
References: <CAKA2JgKUDSpS3Etmm4gdepd5UuiLnF1RTVbx62eTs2yEdMzUcg@mail.gmail.com>
 <CAGigdoeH495PqqCa+sfkNfCpqB7HwbGTReMg_JDg1SD30A24hg@mail.gmail.com>
 <CAJN5CVKhTjAY7Njzv9FZChzxEbRY8dyj6g9Q3cE8bpcx+AL=Kw@mail.gmail.com>
 <CAKA2JgJzRMOQO6vqobC86ZN=adHqYn-wR92akOPWqGfH=Pptxg@mail.gmail.com>
 <CAKjSnQGj5UXWEtQDCAtB6f4ETMho25-=HN7BqKYDbETa+SF9_w@mail.gmail.com>
 <CAKA2JgJURJEo5-01yOtN1KOdA5HPzBT_BrmcKTCQ1b=rA6a0Dg@mail.gmail.com>
 <CAKjSnQFa_yza4hz+hM4Zk2EKTnF=msNVA3mz4+R+tYrq8Kywug@mail.gmail.com>
Message-ID: <CAKA2Jg+utH5gprJ_x10YVhQ_-xNfQRP5A7Lqdyq9-A9E5F=+5w@mail.gmail.com>

I don't want to drag out bikeshedding either. But I *do* want to point out
that mono-traversable also includes a function unsafeHead, separate from
headEx. While headEx guarantees that it will throw an exception in the case
of an empty Foldable, unsafeHead may crash your program. This is the same
kind of distinction as vector and bytestring make between head and
unsafeHead.


On Sun, Feb 9, 2014 at 6:41 PM, Antoine Latter <aslatter at gmail.com> wrote:

> Not that it matters, but I think I prefer the "Unsafe" suffix. I'm not
> calling this version of "head" because I *want* an exception - I'm calling
> it because I want "Unsafe" (non-typechecked) behavior - I'm asserting that
> I've already validated some preconditions that aren't reflected in the type.
>
> But on the other hand I've always found functions like "fromMaybe" easier
> to work with than functions like "fromJust".
>
> Enough bikeshedding! If it works in your packages that's fine, and these
> are the sort of functions I have no complaints about reimplementing on my
> own.
>
>
> On Sat, Feb 8, 2014 at 11:25 PM, Michael Snoyman <michael at snoyman.com>wrote:
>
>> It means "throws an *ex*ception."
>>
>>
>> On Sun, Feb 9, 2014 at 5:04 AM, Antoine Latter <aslatter at gmail.com>wrote:
>>
>>> What does "Ex" mean?
>>>
>>>
>>> On Thu, Feb 6, 2014 at 8:59 PM, Michael Snoyman <michael at snoyman.com>wrote:
>>>
>>>> Thanks for the input. We ended up going with an `Ex` suffix, e.g.
>>>> headEx, lastEx.
>>>>
>>>>
>>>> On Fri, Feb 7, 2014 at 4:53 AM, Tikhon Jelvis <tikhon at jelv.is> wrote:
>>>>
>>>>> For what it's worth, OCaml's Core library does this with _exn, so they
>>>>> would call a partial last "last_exn". I would actually prefer an
>>>>> abbreviation of some sort (like exn) as long as it's a consistent
>>>>> convention. Using a full word like "exception" or "partial" adds to much
>>>>> noise in my opinion, especially if the base name (like "last") is shorter
>>>>> than the suffix!
>>>>>
>>>>> Also, I think a suffix would be better than a prefix, if only to group
>>>>> things conveniently when sorted alphabetically.
>>>>>
>>>>>
>>>>> On Thu, Jan 30, 2014 at 9:36 AM, Atze van der Ploeg <atzeus at gmail.com>wrote:
>>>>>
>>>>>> unprovenLast ?
>>>>>> On Jan 30, 2014 6:33 PM, "Michael Snoyman" <michael at snoyman.com>
>>>>>> wrote:
>>>>>>
>>>>>>> Greg Weber and I have been discussing some changes to
>>>>>>> mono-traversable[1]. One of the modules we provide is Data.NonNull, which
>>>>>>> provides total versions of functions like `last`. A change we're looking at
>>>>>>> would require having a partial version of `last` defined in a separate
>>>>>>> typeclass (IsSequence), which would allowing for more optimized
>>>>>>> implementations of the total `last` function for datatypes which support it
>>>>>>> (e.g., strict ByteStrings).
>>>>>>>
>>>>>>> But what should we name it? I'm sure everyone's familiar with the
>>>>>>> `unsafe` naming convention, but that's not appropriate here: standard usage
>>>>>>> shows `unsafe` meaning a function which can cause a segfault.
>>>>>>>
>>>>>>> I initially named it `partialLast`, but partial can also imply
>>>>>>> partial function application. Greg brought up the idea of suffixing the
>>>>>>> function with something like `Throws` or `Errors`, which I think I'm a bit
>>>>>>> partial to myself[2].
>>>>>>>
>>>>>>> So my questions are:
>>>>>>>
>>>>>>> * Is there some already used naming scheme out there for partial
>>>>>>> functions which I've missed?
>>>>>>> * Do people have any ideas to throw into the mix?
>>>>>>>
>>>>>>> Michael
>>>>>>>
>>>>>>> [1] https://github.com/snoyberg/mono-traversable/pull/21
>>>>>>> [2] Pardon the pun.
>>>>>>>
>>>>>>> _______________________________________________
>>>>>>> Haskell-Cafe mailing list
>>>>>>> Haskell-Cafe at haskell.org
>>>>>>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>>>>>>
>>>>>>>
>>>>>> _______________________________________________
>>>>>> Haskell-Cafe mailing list
>>>>>> Haskell-Cafe at haskell.org
>>>>>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>>>>>
>>>>>>
>>>>>
>>>>
>>>> _______________________________________________
>>>> Haskell-Cafe mailing list
>>>> Haskell-Cafe at haskell.org
>>>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>>>
>>>>
>>>
>>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140210/c1db7c77/attachment.html>

From ky3 at atamo.com  Mon Feb 10 06:32:26 2014
From: ky3 at atamo.com (Kim-Ee Yeoh)
Date: Mon, 10 Feb 2014 13:32:26 +0700
Subject: [Haskell-cafe] Master's Thesis: Open areas of research in
	Haskell
In-Reply-To: <CAMYb46C3QX+n=D06ePFTPGuPJMK5T7Ac=ERZtyzge0qZNveyRw@mail.gmail.com>
References: <CAMYb46C3QX+n=D06ePFTPGuPJMK5T7Ac=ERZtyzge0qZNveyRw@mail.gmail.com>
Message-ID: <CAPY+ZdTWfNgsTQo-6zJSnXRu9o_2s=Yi=ko0+1LbuB=cQSHQkA@mail.gmail.com>

On Mon, Feb 10, 2014 at 9:50 AM, Tyler Huffman <tyler.huffman at tylerh.org>wrote:

> I've seen the Internship opportunities and areas of research for GHC (
> https://ghc.haskell.org/trac/ghc/wiki/Internships) but they all seem to
> apply to Ph.D candidates.
>

I wouldn't worry about these restrictions, they aren't set in stone. It's
better to look at the slate of people (and what they've done, not their
paper qualifications) who have actually gotten in previously to get a sense
of the benchmark.

If you've hacked GHC in interesting ways before applying, you'll definitely
turn heads.


> That said, are there open areas of research that I could look into
>

Skim the titles of previous years ICFP and Haskell Symposium proceedings.
Read the abstracts. Look at the references. Does anything strike the eye?

-- Kim-Ee
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140210/9b2cb3c5/attachment.html>

From dominique.devriese at cs.kuleuven.be  Mon Feb 10 07:46:58 2014
From: dominique.devriese at cs.kuleuven.be (Dominique Devriese)
Date: Mon, 10 Feb 2014 08:46:58 +0100
Subject: [Haskell-cafe] manage effects in a DSL
In-Reply-To: <CACN--9CDygTpySYJj5eLkwrCPLca_m_5xmyUkFOjLpNTxFUQ6g@mail.gmail.com>
References: <20140129033404.76144.qmail@www1.g3.pair.com>
 <CAEyhvmqiJCc8vs-LHpT=CW20yGjhr5G3LMB86c+w38v+e5BELw@mail.gmail.com>
 <CAEyhvmrti3-4B0KvtdQKZPTh8foX=yg__W3AATjunRLAvaF6CA@mail.gmail.com>
 <CAEyhvmow1XbdLJv00iDVA4uBWEXmMGeLsVg1g6jpUCt2=d8CPQ@mail.gmail.com>
 <CALnXJiqhPoKEpJKszGf4EskbSVU1xh+MX=R2dBU4cGv4o+fxoQ@mail.gmail.com>
 <CAEyhvmr=s7xTk7DS3RgKzcJgCZf4u7OEiw7eCKsQ3AuDrYUwUw@mail.gmail.com>
 <CAEyhvmp0M5briL0e617++XH+djkvfHq78tDMhrz7ajWMwkYZ_Q@mail.gmail.com>
 <CAHfjoWmOfwDYHTDFhn2RmOT53SdV==+HGjTJYMgLeZ_2e3mfOw@mail.gmail.com>
 <CACN--9CDygTpySYJj5eLkwrCPLca_m_5xmyUkFOjLpNTxFUQ6g@mail.gmail.com>
Message-ID: <CAML5wvujBXCnAAuP60Xmc0hk7+SPmsG=wgNzi+mnezp2cw+_eg@mail.gmail.com>

Fully agree with Jake.  Corentin's effect system is rather simple so that
indexed monads are overkill here and Jake's solution is simpler.

I just want to point out that the key component of Jake's proposed
solution is not
really type classes, but rather an (underappreciated) pattern that I
call /effect polymorphism/: monadic computations that are polymorphic
over the monad in which they produce effects:

> noEff :: Nomex m => m ()
> noEff = return ()
>
> hasEff :: NomexEffect m => m ()
> hasEff = readAccount >>= writeAccount

I would say that type classes are not the key here, since you could
use the same pattern, but replace type classes with dictionaries and
get the same benefits, although with a bit more administration to be
done by the user.

Such computations have many useful properties, thanks to the
parametricity of the polymorphic quantification.   This has been well
explained by Voigtlaender:
http://wwwtcs.inf.tu-dresden.de/~voigt/icfp09.pdf.  Effect
polymorphism has also been used by Oliveira, Schrijvers and Cook in a
model of (among other features) aspect composition:
http://users.ugent.be/~tschrijv/Research/papers/jfp_mri.pdf.

Note by the way that Jake's proposal is still compatible with the
previously suggested solutions based on indexed monads, since you can
write:

instance Nomex (Exp r) where
  readAccount = ReadAccount

instance NomexEffect (Exp Effect) where
  ...

Regards,
Dominique

2014-02-06 21:35 GMT+01:00 Jake McArthur <jake.mcarthur at gmail.com>:
> I still think GADTs are a bit too much for this problem. Just using type
> classes provides all the safety you need and even avoids the need for that
> liftEval function.
>
> {-# LANGUAGE RankNTypes #-}
> {-# LANGUAGE GeneralizedNewtypeDeriving #-}
> module DSLEffects where
>
> import Control.Monad.State
> import Control.Monad.Reader
>
> class Monad m => Nomex m where
>   readAccount :: m Int
>
> class Nomex m => NomexEffect m where
>   writeAccount :: Int -> m ()
>   setVictory   :: (forall m. Nomex m => m Bool) -> m ()
>
> data Game = Game { victory :: (forall m. Nomex m => m Bool)
>                  , account :: Int
>                  }
>
> newtype Eval a = Eval { eval :: State Game a }
>                deriving Monad
>
> instance Nomex Eval where
>   readAccount = Eval $ gets account
>
> instance NomexEffect Eval where
>   writeAccount n = Eval . modify $ \game -> game { account = n }
>   setVictory   v = Eval . modify $ \game -> game { victory = v }
>
> newtype EvalNoEffect a = EvalNoEffect { evalNoEffect :: Reader Game a }
>                        deriving Monad
>
> instance Nomex EvalNoEffect where
>   readAccount = EvalNoEffect $ asks account
>
>
>
>
> On Thu, Feb 6, 2014 at 12:47 PM, adam vogt <vogt.adam at gmail.com> wrote:
>>
>> Hi Corentin,
>>
>> You need change Effect to NoEffect to reuse the evalNoEffect:
>>
>> > eval ReadAccount = liftEval $ evalNoEffect ReadAccount
>> > eval (Return a)     = liftEval $ evalNoEffect (Return a)
>>
>> Or use a function like `unsafeCoerce :: Nomex Effect a -> Nomex NoEffect
>> a`.
>>
>> If you rename the types that tag effects to something that describes
>> exactly what the tags actually represent, maybe the above definition will be
>> more satisfying:
>>
>> > data Effects
>> >  =
>> > HasBeenCombinedWithSomethingThatHasEffectsButICan'tBeSureItActuallyHasEffectsAllByItself
>> >   | DefinitelyHasNoEffects
>>
>>
>> Regards,
>> Adam
>>
>>
>> On Thu, Feb 6, 2014 at 9:50 AM, Corentin Dupont
>> <corentin.dupont at gmail.com> wrote:
>>>
>>> Hi guys,
>>> I'm still exploring some design space for DSLs, following our interesting
>>> discussion.
>>>
>>> I'm trying to write the evaluator for the DSL (see below).
>>> For the general case, the evaluator looks like:
>>>
>>> eval :: Nomex r a -> State Game a
>>>
>>> This eval function takes an expression (called Nomex), that can possibly
>>> have effects.
>>> It returns a state monad, to allow you to modify the game state.
>>>
>>> But for effectless instructions, it would be better to run the evaluator
>>> in the reader monad:
>>>
>>> evalNoEffect :: Nomex NoEffect a -> Reader Game a
>>>
>>> So you can have additional guaranties that evaluating your expression
>>> will not have effects.
>>> I tried (see below), but it doesn't work for the moment:
>>>
>>>
>>> > {-# LANGUAGE GADTs #-}
>>>
>>> > {-# LANGUAGE KindSignatures, DataKinds, ScopedTypeVariables,
>>> >   MultiParamTypeClasses, FunctionalDependencies, FlexibleInstances,
>>> > UndecidableInstances #-}
>>>
>>> > module DSLEffects where
>>>
>>> > import Control.Monad.Error
>>> > import Control.Monad.State
>>> > import Control.Monad.Reader
>>> > import Data.Typeable
>>>
>>> This is the DSL:
>>>
>>> > data Effects = Effect | NoEffect
>>>
>>> > data Nomex :: Effects -> * -> * where
>>> >   ReadAccount  :: Nomex r Int                --ReadAccount has no
>>> > effect: it can be run in whatever monad
>>> >   WriteAccount :: Int -> Nomex Effect ()  --WriteAccount has effect
>>> >   SetVictory   :: Nomex NoEffect Bool -> Nomex Effect () --SetVictory
>>> > don't accept effectful computations
>>> >   Bind         :: Nomex m a -> (a -> Nomex m b) -> Nomex m b
>>> >   Return       :: a -> Nomex r a  --wrapping a constant has no effect
>>>
>>> > instance Monad (Nomex a) where
>>> >   return = Return
>>> >   (>>=) = Bind
>>>
>>>
>>> > noEff :: Nomex NoEffect ()
>>> > noEff = return ()
>>>
>>> > hasEffect :: Nomex Effect ()
>>> > hasEffect = do
>>> >    a <- ReadAccount
>>> >    WriteAccount a
>>>
>>> > data Game = Game { victory :: Nomex NoEffect Bool,
>>> >                    account :: Int}
>>>
>>>
>>> > eval :: Nomex r a -> State Game a
>>> > eval a at ReadAccount    = liftEval $ evalNoEffect a
>>> > eval (WriteAccount a) = modify (\g -> g{account = a})
>>>
>>> > eval (SetVictory v)   = modify (\g -> g{victory = v})
>>> > eval a@(Return _)     = liftEval $ evalNoEffect a
>>> > eval (Bind exp f)     = eval exp >>= eval . f
>>>
>>> > evalNoEffect :: Nomex NoEffect a -> Reader Game a
>>> > evalNoEffect ReadAccount  = asks account
>>> > evalNoEffect (Return a)   = return a
>>> > evalNoEffect (Bind exp f) = evalNoEffect exp >>= evalNoEffect . f
>>>
>>> > liftEval :: Reader Game a -> State Game a
>>> > liftEval r = get >>= return . runReader r
>>>
>>>
>>> This is not compiling:
>>>
>>> exceptEffect.lhs:60:15:
>>>     Couldn't match type 'NoEffect with 'Effect
>>>     Inaccessible code in
>>>       a pattern with constructor
>>>         WriteAccount :: Int -> Nomex 'Effect (),
>>>       in an equation for `evalEffect'
>>>     In the pattern: WriteAccount a
>>>     In an equation for `evalEffect':
>>>         evalEffect (WriteAccount a) = modify (\ g -> g {account = a})
>>>
>>> It seems that the type of effectless computations (NoEffect) leaks in the
>>> type of effectful ones (due to the pattern matching)...
>>>
>>> Thanks,
>>> Corentin
>>>
>>>
>>>
>>> On Mon, Feb 3, 2014 at 12:44 PM, Corentin Dupont
>>> <corentin.dupont at gmail.com> wrote:
>>>>
>>>> I saw that to write liftQD you decontruct (unwrap) the type and
>>>> reconstruct it.
>>>> I don't know if I can do that for my Exp (which is a full DSL)...
>>>>
>>>> Anyway, there should be a way to encode the Effect/NoEffect semantic at
>>>> type level...
>>>> Using Oleg's parametrized monad idea
>>>> (http://hackage.haskell.org/package/monad-param-0.0.2/docs/Control-Monad-Parameterized.html),
>>>> I tried:
>>>>
>>>> > {-# LANGUAGE KindSignatures, DataKinds, ScopedTypeVariables, GADTs
>>>> >   MultiParamTypeClasses, FunctionalDependencies, FlexibleInstances,
>>>> > UndecidableInstances #-}
>>>>
>>>> > module DSLEffects where
>>>> > import Prelude hiding (return, (>>), (>>=))
>>>> > import Control.Monad.Parameterized
>>>>
>>>> This data type will be promoted to kind level (thanks to DataKinds):
>>>>
>>>>
>>>> > data Eff = Effect | NoEffect
>>>>
>>>> This class allows to specify the semantic on Effects (Effect + NoEffect
>>>> = Effect):
>>>>
>>>> > class Effects (m :: Eff) (n::Eff) (r::Eff) | m n -> r
>>>> > instance Effects Effect n Effect
>>>> > instance Effects NoEffect n n
>>>>
>>>> This is the DSL:
>>>>
>>>> > data Exp :: Eff -> * -> * where
>>>> >   ReadAccount  :: Exp NoEffect Int      --ReadAccount has no effect
>>>> >   WriteAccount :: Int -> Exp Effect ()  --WriteAccount has effect
>>>> >   Const        :: a -> Exp r a
>>>> >   Bind         :: Effects m n r => Exp m a -> (a -> Exp n b) -> Exp r
>>>> > b --Bind comes with a semantic on effects
>>>> >   Fmap         :: (a -> b) -> Exp m a -> Exp m b
>>>>
>>>> > instance Functor (Exp r) where
>>>> >   fmap = Fmap
>>>>
>>>> > instance Return (Exp r) where
>>>> >    returnM = Const
>>>>
>>>> > instance (Effects m n r) => Bind (Exp m) (Exp n) (Exp r) where
>>>> >    (>>=) = Bind
>>>>
>>>> > noEff :: Exp NoEffect ()
>>>> > noEff = returnM ()
>>>>
>>>> > hasEffect :: Exp Effect ()
>>>> > hasEffect = ReadAccount >> (returnM () :: Exp Effect ())
>>>>
>>>> This is working more or less, however I am obliged to put the type
>>>> signature on the returnM (last line): why?
>>>> Furthermore, I cannot write directly:
>>>>
>>>> > hasEffect :: Exp Effect ()
>>>> > hasEffect = ReadAccount
>>>>
>>>>
>>>> Do you have a better idea?
>>>>
>>>>
>>>>
>>>> On Sun, Feb 2, 2014 at 8:55 PM, Lindsey Kuper <lindsey at composition.al>
>>>> wrote:
>>>>>
>>>>> On Sun, Feb 2, 2014 at 2:42 PM, Corentin Dupont
>>>>> <corentin.dupont at gmail.com> wrote:
>>>>> > you should be able to run an effectless monad in an effectful one.
>>>>> > How to encode this semantic?
>>>>>
>>>>> In LVish we just have a `liftQD` operation that will let you lift a
>>>>> deterministic computation to a quasi-deterministic one (recall that
>>>>> deterministic computations can perform fewer effects):
>>>>>
>>>>>   liftQD :: Par Det s a -> Par QuasiDet s a
>>>>>
>>>>> So, analogously, you could have a `liftEff` and then write `liftEff
>>>>> noEff`.  This is also a little bit ugly, but you may find you don't
>>>>> have to do it very often (we rarely use `liftQD`).
>>>>>
>>>>> Lindsey
>>>>
>>>>
>>>
>>
>>
>> _______________________________________________
>> Haskell-Cafe mailing list
>> Haskell-Cafe at haskell.org
>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>
>
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>

From corentin.dupont at gmail.com  Mon Feb 10 09:48:02 2014
From: corentin.dupont at gmail.com (Corentin Dupont)
Date: Mon, 10 Feb 2014 10:48:02 +0100
Subject: [Haskell-cafe] manage effects in a DSL
In-Reply-To: <CAML5wvujBXCnAAuP60Xmc0hk7+SPmsG=wgNzi+mnezp2cw+_eg@mail.gmail.com>
References: <20140129033404.76144.qmail@www1.g3.pair.com>
 <CAEyhvmqiJCc8vs-LHpT=CW20yGjhr5G3LMB86c+w38v+e5BELw@mail.gmail.com>
 <CAEyhvmrti3-4B0KvtdQKZPTh8foX=yg__W3AATjunRLAvaF6CA@mail.gmail.com>
 <CAEyhvmow1XbdLJv00iDVA4uBWEXmMGeLsVg1g6jpUCt2=d8CPQ@mail.gmail.com>
 <CALnXJiqhPoKEpJKszGf4EskbSVU1xh+MX=R2dBU4cGv4o+fxoQ@mail.gmail.com>
 <CAEyhvmr=s7xTk7DS3RgKzcJgCZf4u7OEiw7eCKsQ3AuDrYUwUw@mail.gmail.com>
 <CAEyhvmp0M5briL0e617++XH+djkvfHq78tDMhrz7ajWMwkYZ_Q@mail.gmail.com>
 <CAHfjoWmOfwDYHTDFhn2RmOT53SdV==+HGjTJYMgLeZ_2e3mfOw@mail.gmail.com>
 <CACN--9CDygTpySYJj5eLkwrCPLca_m_5xmyUkFOjLpNTxFUQ6g@mail.gmail.com>
 <CAML5wvujBXCnAAuP60Xmc0hk7+SPmsG=wgNzi+mnezp2cw+_eg@mail.gmail.com>
Message-ID: <CAEyhvmpgbR6EeTMMXBGPq3X7NK8umV=9GLSgV-ETBauMpv5xfg@mail.gmail.com>

That is really interesting. In fact, I didn't have the time to experiment
with it, but I definitely want to (have to find some spare time!).
I must say I am less used to type classes.
At first, my concern with the technique was that two things that belong
together, "ReadAccount" and "WriteAccount", are separated.
I was also confused that the evaluator is wrapped in a newtype, and that it
is an instance of Nomex.
Beside, I suppose it is possible to factorize EvalNoEffect with Eval? Maybe
using liftEval anyway...




On Mon, Feb 10, 2014 at 8:46 AM, Dominique Devriese <
dominique.devriese at cs.kuleuven.be> wrote:

> Fully agree with Jake.  Corentin's effect system is rather simple so that
> indexed monads are overkill here and Jake's solution is simpler.
>
> I just want to point out that the key component of Jake's proposed
> solution is not
> really type classes, but rather an (underappreciated) pattern that I
> call /effect polymorphism/: monadic computations that are polymorphic
> over the monad in which they produce effects:
>
> > noEff :: Nomex m => m ()
> > noEff = return ()
> >
> > hasEff :: NomexEffect m => m ()
> > hasEff = readAccount >>= writeAccount
>
> I would say that type classes are not the key here, since you could
> use the same pattern, but replace type classes with dictionaries and
> get the same benefits, although with a bit more administration to be
> done by the user.
>
> Such computations have many useful properties, thanks to the
> parametricity of the polymorphic quantification.   This has been well
> explained by Voigtlaender:
> http://wwwtcs.inf.tu-dresden.de/~voigt/icfp09.pdf.  Effect
> polymorphism has also been used by Oliveira, Schrijvers and Cook in a
> model of (among other features) aspect composition:
> http://users.ugent.be/~tschrijv/Research/papers/jfp_mri.pdf.
>
> Note by the way that Jake's proposal is still compatible with the
> previously suggested solutions based on indexed monads, since you can
> write:
>
> instance Nomex (Exp r) where
>   readAccount = ReadAccount
>
> instance NomexEffect (Exp Effect) where
>   ...
>
> Regards,
> Dominique
>
> 2014-02-06 21:35 GMT+01:00 Jake McArthur <jake.mcarthur at gmail.com>:
> > I still think GADTs are a bit too much for this problem. Just using type
> > classes provides all the safety you need and even avoids the need for
> that
> > liftEval function.
> >
> > {-# LANGUAGE RankNTypes #-}
> > {-# LANGUAGE GeneralizedNewtypeDeriving #-}
> > module DSLEffects where
> >
> > import Control.Monad.State
> > import Control.Monad.Reader
> >
> > class Monad m => Nomex m where
> >   readAccount :: m Int
> >
> > class Nomex m => NomexEffect m where
> >   writeAccount :: Int -> m ()
> >   setVictory   :: (forall m. Nomex m => m Bool) -> m ()
> >
> > data Game = Game { victory :: (forall m. Nomex m => m Bool)
> >                  , account :: Int
> >                  }
> >
> > newtype Eval a = Eval { eval :: State Game a }
> >                deriving Monad
> >
> > instance Nomex Eval where
> >   readAccount = Eval $ gets account
> >
> > instance NomexEffect Eval where
> >   writeAccount n = Eval . modify $ \game -> game { account = n }
> >   setVictory   v = Eval . modify $ \game -> game { victory = v }
> >
> > newtype EvalNoEffect a = EvalNoEffect { evalNoEffect :: Reader Game a }
> >                        deriving Monad
> >
> > instance Nomex EvalNoEffect where
> >   readAccount = EvalNoEffect $ asks account
> >
> >
> >
> >
> > On Thu, Feb 6, 2014 at 12:47 PM, adam vogt <vogt.adam at gmail.com> wrote:
> >>
> >> Hi Corentin,
> >>
> >> You need change Effect to NoEffect to reuse the evalNoEffect:
> >>
> >> > eval ReadAccount = liftEval $ evalNoEffect ReadAccount
> >> > eval (Return a)     = liftEval $ evalNoEffect (Return a)
> >>
> >> Or use a function like `unsafeCoerce :: Nomex Effect a -> Nomex NoEffect
> >> a`.
> >>
> >> If you rename the types that tag effects to something that describes
> >> exactly what the tags actually represent, maybe the above definition
> will be
> >> more satisfying:
> >>
> >> > data Effects
> >> >  =
> >> >
> HasBeenCombinedWithSomethingThatHasEffectsButICan'tBeSureItActuallyHasEffectsAllByItself
> >> >   | DefinitelyHasNoEffects
> >>
> >>
> >> Regards,
> >> Adam
> >>
> >>
> >> On Thu, Feb 6, 2014 at 9:50 AM, Corentin Dupont
> >> <corentin.dupont at gmail.com> wrote:
> >>>
> >>> Hi guys,
> >>> I'm still exploring some design space for DSLs, following our
> interesting
> >>> discussion.
> >>>
> >>> I'm trying to write the evaluator for the DSL (see below).
> >>> For the general case, the evaluator looks like:
> >>>
> >>> eval :: Nomex r a -> State Game a
> >>>
> >>> This eval function takes an expression (called Nomex), that can
> possibly
> >>> have effects.
> >>> It returns a state monad, to allow you to modify the game state.
> >>>
> >>> But for effectless instructions, it would be better to run the
> evaluator
> >>> in the reader monad:
> >>>
> >>> evalNoEffect :: Nomex NoEffect a -> Reader Game a
> >>>
> >>> So you can have additional guaranties that evaluating your expression
> >>> will not have effects.
> >>> I tried (see below), but it doesn't work for the moment:
> >>>
> >>>
> >>> > {-# LANGUAGE GADTs #-}
> >>>
> >>> > {-# LANGUAGE KindSignatures, DataKinds, ScopedTypeVariables,
> >>> >   MultiParamTypeClasses, FunctionalDependencies, FlexibleInstances,
> >>> > UndecidableInstances #-}
> >>>
> >>> > module DSLEffects where
> >>>
> >>> > import Control.Monad.Error
> >>> > import Control.Monad.State
> >>> > import Control.Monad.Reader
> >>> > import Data.Typeable
> >>>
> >>> This is the DSL:
> >>>
> >>> > data Effects = Effect | NoEffect
> >>>
> >>> > data Nomex :: Effects -> * -> * where
> >>> >   ReadAccount  :: Nomex r Int                --ReadAccount has no
> >>> > effect: it can be run in whatever monad
> >>> >   WriteAccount :: Int -> Nomex Effect ()  --WriteAccount has effect
> >>> >   SetVictory   :: Nomex NoEffect Bool -> Nomex Effect () --SetVictory
> >>> > don't accept effectful computations
> >>> >   Bind         :: Nomex m a -> (a -> Nomex m b) -> Nomex m b
> >>> >   Return       :: a -> Nomex r a  --wrapping a constant has no effect
> >>>
> >>> > instance Monad (Nomex a) where
> >>> >   return = Return
> >>> >   (>>=) = Bind
> >>>
> >>>
> >>> > noEff :: Nomex NoEffect ()
> >>> > noEff = return ()
> >>>
> >>> > hasEffect :: Nomex Effect ()
> >>> > hasEffect = do
> >>> >    a <- ReadAccount
> >>> >    WriteAccount a
> >>>
> >>> > data Game = Game { victory :: Nomex NoEffect Bool,
> >>> >                    account :: Int}
> >>>
> >>>
> >>> > eval :: Nomex r a -> State Game a
> >>> > eval a at ReadAccount    = liftEval $ evalNoEffect a
> >>> > eval (WriteAccount a) = modify (\g -> g{account = a})
> >>>
> >>> > eval (SetVictory v)   = modify (\g -> g{victory = v})
> >>> > eval a@(Return _)     = liftEval $ evalNoEffect a
> >>> > eval (Bind exp f)     = eval exp >>= eval . f
> >>>
> >>> > evalNoEffect :: Nomex NoEffect a -> Reader Game a
> >>> > evalNoEffect ReadAccount  = asks account
> >>> > evalNoEffect (Return a)   = return a
> >>> > evalNoEffect (Bind exp f) = evalNoEffect exp >>= evalNoEffect . f
> >>>
> >>> > liftEval :: Reader Game a -> State Game a
> >>> > liftEval r = get >>= return . runReader r
> >>>
> >>>
> >>> This is not compiling:
> >>>
> >>> exceptEffect.lhs:60:15:
> >>>     Couldn't match type 'NoEffect with 'Effect
> >>>     Inaccessible code in
> >>>       a pattern with constructor
> >>>         WriteAccount :: Int -> Nomex 'Effect (),
> >>>       in an equation for `evalEffect'
> >>>     In the pattern: WriteAccount a
> >>>     In an equation for `evalEffect':
> >>>         evalEffect (WriteAccount a) = modify (\ g -> g {account = a})
> >>>
> >>> It seems that the type of effectless computations (NoEffect) leaks in
> the
> >>> type of effectful ones (due to the pattern matching)...
> >>>
> >>> Thanks,
> >>> Corentin
> >>>
> >>>
> >>>
> >>> On Mon, Feb 3, 2014 at 12:44 PM, Corentin Dupont
> >>> <corentin.dupont at gmail.com> wrote:
> >>>>
> >>>> I saw that to write liftQD you decontruct (unwrap) the type and
> >>>> reconstruct it.
> >>>> I don't know if I can do that for my Exp (which is a full DSL)...
> >>>>
> >>>> Anyway, there should be a way to encode the Effect/NoEffect semantic
> at
> >>>> type level...
> >>>> Using Oleg's parametrized monad idea
> >>>> (
> http://hackage.haskell.org/package/monad-param-0.0.2/docs/Control-Monad-Parameterized.html
> ),
> >>>> I tried:
> >>>>
> >>>> > {-# LANGUAGE KindSignatures, DataKinds, ScopedTypeVariables, GADTs
> >>>> >   MultiParamTypeClasses, FunctionalDependencies, FlexibleInstances,
> >>>> > UndecidableInstances #-}
> >>>>
> >>>> > module DSLEffects where
> >>>> > import Prelude hiding (return, (>>), (>>=))
> >>>> > import Control.Monad.Parameterized
> >>>>
> >>>> This data type will be promoted to kind level (thanks to DataKinds):
> >>>>
> >>>>
> >>>> > data Eff = Effect | NoEffect
> >>>>
> >>>> This class allows to specify the semantic on Effects (Effect +
> NoEffect
> >>>> = Effect):
> >>>>
> >>>> > class Effects (m :: Eff) (n::Eff) (r::Eff) | m n -> r
> >>>> > instance Effects Effect n Effect
> >>>> > instance Effects NoEffect n n
> >>>>
> >>>> This is the DSL:
> >>>>
> >>>> > data Exp :: Eff -> * -> * where
> >>>> >   ReadAccount  :: Exp NoEffect Int      --ReadAccount has no effect
> >>>> >   WriteAccount :: Int -> Exp Effect ()  --WriteAccount has effect
> >>>> >   Const        :: a -> Exp r a
> >>>> >   Bind         :: Effects m n r => Exp m a -> (a -> Exp n b) -> Exp
> r
> >>>> > b --Bind comes with a semantic on effects
> >>>> >   Fmap         :: (a -> b) -> Exp m a -> Exp m b
> >>>>
> >>>> > instance Functor (Exp r) where
> >>>> >   fmap = Fmap
> >>>>
> >>>> > instance Return (Exp r) where
> >>>> >    returnM = Const
> >>>>
> >>>> > instance (Effects m n r) => Bind (Exp m) (Exp n) (Exp r) where
> >>>> >    (>>=) = Bind
> >>>>
> >>>> > noEff :: Exp NoEffect ()
> >>>> > noEff = returnM ()
> >>>>
> >>>> > hasEffect :: Exp Effect ()
> >>>> > hasEffect = ReadAccount >> (returnM () :: Exp Effect ())
> >>>>
> >>>> This is working more or less, however I am obliged to put the type
> >>>> signature on the returnM (last line): why?
> >>>> Furthermore, I cannot write directly:
> >>>>
> >>>> > hasEffect :: Exp Effect ()
> >>>> > hasEffect = ReadAccount
> >>>>
> >>>>
> >>>> Do you have a better idea?
> >>>>
> >>>>
> >>>>
> >>>> On Sun, Feb 2, 2014 at 8:55 PM, Lindsey Kuper <lindsey at composition.al
> >
> >>>> wrote:
> >>>>>
> >>>>> On Sun, Feb 2, 2014 at 2:42 PM, Corentin Dupont
> >>>>> <corentin.dupont at gmail.com> wrote:
> >>>>> > you should be able to run an effectless monad in an effectful one.
> >>>>> > How to encode this semantic?
> >>>>>
> >>>>> In LVish we just have a `liftQD` operation that will let you lift a
> >>>>> deterministic computation to a quasi-deterministic one (recall that
> >>>>> deterministic computations can perform fewer effects):
> >>>>>
> >>>>>   liftQD :: Par Det s a -> Par QuasiDet s a
> >>>>>
> >>>>> So, analogously, you could have a `liftEff` and then write `liftEff
> >>>>> noEff`.  This is also a little bit ugly, but you may find you don't
> >>>>> have to do it very often (we rarely use `liftQD`).
> >>>>>
> >>>>> Lindsey
> >>>>
> >>>>
> >>>
> >>
> >>
> >> _______________________________________________
> >> Haskell-Cafe mailing list
> >> Haskell-Cafe at haskell.org
> >> http://www.haskell.org/mailman/listinfo/haskell-cafe
> >>
> >
> >
> > _______________________________________________
> > Haskell-Cafe mailing list
> > Haskell-Cafe at haskell.org
> > http://www.haskell.org/mailman/listinfo/haskell-cafe
> >
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140210/3b666ee3/attachment-0001.html>

From dominique.devriese at cs.kuleuven.be  Mon Feb 10 10:33:27 2014
From: dominique.devriese at cs.kuleuven.be (Dominique Devriese)
Date: Mon, 10 Feb 2014 11:33:27 +0100
Subject: [Haskell-cafe] manage effects in a DSL
In-Reply-To: <CAEyhvmpgbR6EeTMMXBGPq3X7NK8umV=9GLSgV-ETBauMpv5xfg@mail.gmail.com>
References: <20140129033404.76144.qmail@www1.g3.pair.com>
 <CAEyhvmqiJCc8vs-LHpT=CW20yGjhr5G3LMB86c+w38v+e5BELw@mail.gmail.com>
 <CAEyhvmrti3-4B0KvtdQKZPTh8foX=yg__W3AATjunRLAvaF6CA@mail.gmail.com>
 <CAEyhvmow1XbdLJv00iDVA4uBWEXmMGeLsVg1g6jpUCt2=d8CPQ@mail.gmail.com>
 <CALnXJiqhPoKEpJKszGf4EskbSVU1xh+MX=R2dBU4cGv4o+fxoQ@mail.gmail.com>
 <CAEyhvmr=s7xTk7DS3RgKzcJgCZf4u7OEiw7eCKsQ3AuDrYUwUw@mail.gmail.com>
 <CAEyhvmp0M5briL0e617++XH+djkvfHq78tDMhrz7ajWMwkYZ_Q@mail.gmail.com>
 <CAHfjoWmOfwDYHTDFhn2RmOT53SdV==+HGjTJYMgLeZ_2e3mfOw@mail.gmail.com>
 <CACN--9CDygTpySYJj5eLkwrCPLca_m_5xmyUkFOjLpNTxFUQ6g@mail.gmail.com>
 <CAML5wvujBXCnAAuP60Xmc0hk7+SPmsG=wgNzi+mnezp2cw+_eg@mail.gmail.com>
 <CAEyhvmpgbR6EeTMMXBGPq3X7NK8umV=9GLSgV-ETBauMpv5xfg@mail.gmail.com>
Message-ID: <CAML5wvv-1aKAVkgBRvs-Ue7mxzaefGMnY5hvQdTP3gAnF_feEg@mail.gmail.com>

Corentin,

2014-02-10 10:48 GMT+01:00 Corentin Dupont <corentin.dupont at gmail.com>:
> That is really interesting. In fact, I didn't have the time to experiment
> with it, but I definitely want to (have to find some spare time!).
> I must say I am less used to type classes.
> At first, my concern with the technique was that two things that belong
> together, "ReadAccount" and "WriteAccount", are separated.

Yes, this separation of ReadAccount and WriteAccount into Nomex vs
NomexEffect is how the two parts (read-only vs read-write) of the DSL
are distinguished in this approach..

> I was also confused that the evaluator is wrapped in a newtype, and that it
> is an instance of Nomex.

That is non-essential.  You can also use

  instance Nomex (State Game) where

but it's just cleaner with a newtype...

> Beside, I suppose it is possible to factorize EvalNoEffect with Eval? Maybe
> using liftEval anyway...

If I understand correctly, you're asking about how to remove the
duplication between EvalNoEffect and Eval?

This is a very good question.  My answer is basically that Haskell is
missing some type-class-related features to allow for the perfect
solution, specifically a form of local instances.

The long story is that instead of the above instances of Nomex and
NomexEffect for Eval and EvalNoEffect separately, we would like to be
able to write the following instances:

  instance MonadReader Game m => Nomex m where
    readAccount = asks account

  instance (MonadReader Game m, MonadState Game m) => NomexEffect m where
    writeAccount n = modify $ \game -> game { account = n }
    setVictory   v = modify $ \game -> game { victory = v }

and then we can declare
  newtype Eval a = Eval { eval :: State Game a }
                 deriving (Monad, MonadState Game, MonadReader Game)

  newtype EvalNoEffect a = EvalNoEffect { evalNoEffect :: Reader Game a }
                         deriving (Monad, MonadReader Game)

and reuse the single implementation of Nomex for both Eval and
EvalNoEffect.  However, there are various problems with this solution:

* the instances are not permitted without UndecidableInstances (which
I recommend against),
* the derivation of MonadReader from State won't work because
MonadReader is not treated as a superclass of MonadState in Haskell,
despite the fact that functionality-wise it is.

What is needed to solve these problems is a feature that is in my
opinion strongly missing in Haskell: a form of local instances.  This
means that we would be able to explicitly specify what implementation
of a certain type class should be used to satisfy a certain type class
constraint, e.g.

  sort :: Ord a => [a] -> [a]
  sortBy :: forall a. (a -> a -> Bool) -> [a] -> [a]
  sortBy f = let instance ordDict :: Ord.Dict a
                                        ordDict = constructOrdDict f
                   in sort :: Ord a => [a] -> [a]

Local instances were already considered by Wadler when he proposed
type classes, but they are problematic to combine with type inference.
 However, it seems likely that this is not an issue if we require
sufficiently informative type annotations.

For the problem above, this would allow to construct, use and lift
(together with newtype coercions) a MonadReader dictionary for the
State monad without necessarily having it derived automatically if
this is not desired.  Also, this would allow to write the undecidable
instances as normal functions that need to be explicitly invoked
instead of inferred by type inference, avoiding the
UndecidableInstances problem.

Regards
Dominique

From andres at well-typed.com  Mon Feb 10 10:47:07 2014
From: andres at well-typed.com (=?ISO-8859-1?Q?Andres_L=F6h?=)
Date: Mon, 10 Feb 2014 11:47:07 +0100
Subject: [Haskell-cafe] Haskell meeting in Regensburg, 2014-02-11, 20:00
Message-ID: <CALjd_v5K-i8Ji5UPrC29YkBCP7moVEG_g49uGHbYCJ=vC7ubRw@mail.gmail.com>

Hi.

Tomorrow, there will be another Haskell meeting in Regensburg, Germany:

Tuesday, 11 February 2014
20:00
Binary Kitchen, Walderdorffstr. 13b, 93053 Regensburg

There'll be no official talk or presentation, but the theme of the
session is going to be "Performance". If you have Haskell sample code
that runs slower than expected, feel free to bring it along. The plan
is to discuss a number of small demo problems and consider best
practices for improving performance of Haskell programs.

Everyone who's interested in Haskell is welcome. No actual knowledge
of Haskell is expected or required. We'll speak German and/or English,
depending on who's going to be there.

If you'd like to get updates about future Regensburg Haskell meetings
or vote on when we meet next, please join our mailing list at
http://lists.binary-kitchen.de/listinfo/haskell If you have any
questions and for some reason don't want to join the mailing list, you
can also email me :)

Cheers,
  Andres

-- 
Andres L?h, Haskell Consultant
Well-Typed LLP, http://www.well-typed.com

From allbery.b at gmail.com  Mon Feb 10 15:03:43 2014
From: allbery.b at gmail.com (Brandon Allbery)
Date: Mon, 10 Feb 2014 10:03:43 -0500
Subject: [Haskell-cafe] manage effects in a DSL
In-Reply-To: <CAML5wvv-1aKAVkgBRvs-Ue7mxzaefGMnY5hvQdTP3gAnF_feEg@mail.gmail.com>
References: <20140129033404.76144.qmail@www1.g3.pair.com>
 <CAEyhvmqiJCc8vs-LHpT=CW20yGjhr5G3LMB86c+w38v+e5BELw@mail.gmail.com>
 <CAEyhvmrti3-4B0KvtdQKZPTh8foX=yg__W3AATjunRLAvaF6CA@mail.gmail.com>
 <CAEyhvmow1XbdLJv00iDVA4uBWEXmMGeLsVg1g6jpUCt2=d8CPQ@mail.gmail.com>
 <CALnXJiqhPoKEpJKszGf4EskbSVU1xh+MX=R2dBU4cGv4o+fxoQ@mail.gmail.com>
 <CAEyhvmr=s7xTk7DS3RgKzcJgCZf4u7OEiw7eCKsQ3AuDrYUwUw@mail.gmail.com>
 <CAEyhvmp0M5briL0e617++XH+djkvfHq78tDMhrz7ajWMwkYZ_Q@mail.gmail.com>
 <CAHfjoWmOfwDYHTDFhn2RmOT53SdV==+HGjTJYMgLeZ_2e3mfOw@mail.gmail.com>
 <CACN--9CDygTpySYJj5eLkwrCPLca_m_5xmyUkFOjLpNTxFUQ6g@mail.gmail.com>
 <CAML5wvujBXCnAAuP60Xmc0hk7+SPmsG=wgNzi+mnezp2cw+_eg@mail.gmail.com>
 <CAEyhvmpgbR6EeTMMXBGPq3X7NK8umV=9GLSgV-ETBauMpv5xfg@mail.gmail.com>
 <CAML5wvv-1aKAVkgBRvs-Ue7mxzaefGMnY5hvQdTP3gAnF_feEg@mail.gmail.com>
Message-ID: <CAKFCL4UQzviQNc_o4Z9Dkd3A+7W7nA=OaX-jqC5rpt7689SNRg@mail.gmail.com>

On Mon, Feb 10, 2014 at 5:33 AM, Dominique Devriese <
dominique.devriese at cs.kuleuven.be> wrote:

> Local instances were already considered by Wadler when he proposed
> type classes, but they are problematic to combine with type inference
>

Local instances have a bigger problem: you can use them to trivially
violate invariants. Consider a local replacement for Ord on a Data.Map.
They're not going to happen.

-- 
brandon s allbery kf8nh                               sine nomine associates
allbery.b at gmail.com                                  ballbery at sinenomine.net
unix, openafs, kerberos, infrastructure, xmonad        http://sinenomine.net
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140210/de3b82c9/attachment.html>

From dominique.devriese at cs.kuleuven.be  Mon Feb 10 15:55:52 2014
From: dominique.devriese at cs.kuleuven.be (Dominique Devriese)
Date: Mon, 10 Feb 2014 16:55:52 +0100
Subject: [Haskell-cafe] manage effects in a DSL
In-Reply-To: <CAKFCL4UQzviQNc_o4Z9Dkd3A+7W7nA=OaX-jqC5rpt7689SNRg@mail.gmail.com>
References: <20140129033404.76144.qmail@www1.g3.pair.com>
 <CAEyhvmqiJCc8vs-LHpT=CW20yGjhr5G3LMB86c+w38v+e5BELw@mail.gmail.com>
 <CAEyhvmrti3-4B0KvtdQKZPTh8foX=yg__W3AATjunRLAvaF6CA@mail.gmail.com>
 <CAEyhvmow1XbdLJv00iDVA4uBWEXmMGeLsVg1g6jpUCt2=d8CPQ@mail.gmail.com>
 <CALnXJiqhPoKEpJKszGf4EskbSVU1xh+MX=R2dBU4cGv4o+fxoQ@mail.gmail.com>
 <CAEyhvmr=s7xTk7DS3RgKzcJgCZf4u7OEiw7eCKsQ3AuDrYUwUw@mail.gmail.com>
 <CAEyhvmp0M5briL0e617++XH+djkvfHq78tDMhrz7ajWMwkYZ_Q@mail.gmail.com>
 <CAHfjoWmOfwDYHTDFhn2RmOT53SdV==+HGjTJYMgLeZ_2e3mfOw@mail.gmail.com>
 <CACN--9CDygTpySYJj5eLkwrCPLca_m_5xmyUkFOjLpNTxFUQ6g@mail.gmail.com>
 <CAML5wvujBXCnAAuP60Xmc0hk7+SPmsG=wgNzi+mnezp2cw+_eg@mail.gmail.com>
 <CAEyhvmpgbR6EeTMMXBGPq3X7NK8umV=9GLSgV-ETBauMpv5xfg@mail.gmail.com>
 <CAML5wvv-1aKAVkgBRvs-Ue7mxzaefGMnY5hvQdTP3gAnF_feEg@mail.gmail.com>
 <CAKFCL4UQzviQNc_o4Z9Dkd3A+7W7nA=OaX-jqC5rpt7689SNRg@mail.gmail.com>
Message-ID: <CAML5wvsfcpWMYKv7aPpRwFpYMxsu3kGXqY2uND7gfuO6+P67RA@mail.gmail.com>

Hm. Interesting point, I guess this is the same problem as the whole
orphan instances debate...  I didn't think of the connection to that
problem.  Still, I'm convinced there are situations where local
instances are *exactly* what we need, so there must be some way to
avoid this problem...

Regards,
Dominique

2014-02-10 16:03 GMT+01:00 Brandon Allbery <allbery.b at gmail.com>:
> On Mon, Feb 10, 2014 at 5:33 AM, Dominique Devriese
> <dominique.devriese at cs.kuleuven.be> wrote:
>>
>> Local instances were already considered by Wadler when he proposed
>> type classes, but they are problematic to combine with type inference
>
>
> Local instances have a bigger problem: you can use them to trivially violate
> invariants. Consider a local replacement for Ord on a Data.Map. They're not
> going to happen.
>
> --
> brandon s allbery kf8nh                               sine nomine associates
> allbery.b at gmail.com                                  ballbery at sinenomine.net
> unix, openafs, kerberos, infrastructure, xmonad        http://sinenomine.net

From daniel.trstenjak at gmail.com  Mon Feb 10 16:10:01 2014
From: daniel.trstenjak at gmail.com (Daniel Trstenjak)
Date: Mon, 10 Feb 2014 17:10:01 +0100
Subject: [Haskell-cafe] manage effects in a DSL
In-Reply-To: <CAML5wvsfcpWMYKv7aPpRwFpYMxsu3kGXqY2uND7gfuO6+P67RA@mail.gmail.com>
References: <CALnXJiqhPoKEpJKszGf4EskbSVU1xh+MX=R2dBU4cGv4o+fxoQ@mail.gmail.com>
 <CAEyhvmr=s7xTk7DS3RgKzcJgCZf4u7OEiw7eCKsQ3AuDrYUwUw@mail.gmail.com>
 <CAEyhvmp0M5briL0e617++XH+djkvfHq78tDMhrz7ajWMwkYZ_Q@mail.gmail.com>
 <CAHfjoWmOfwDYHTDFhn2RmOT53SdV==+HGjTJYMgLeZ_2e3mfOw@mail.gmail.com>
 <CACN--9CDygTpySYJj5eLkwrCPLca_m_5xmyUkFOjLpNTxFUQ6g@mail.gmail.com>
 <CAML5wvujBXCnAAuP60Xmc0hk7+SPmsG=wgNzi+mnezp2cw+_eg@mail.gmail.com>
 <CAEyhvmpgbR6EeTMMXBGPq3X7NK8umV=9GLSgV-ETBauMpv5xfg@mail.gmail.com>
 <CAML5wvv-1aKAVkgBRvs-Ue7mxzaefGMnY5hvQdTP3gAnF_feEg@mail.gmail.com>
 <CAKFCL4UQzviQNc_o4Z9Dkd3A+7W7nA=OaX-jqC5rpt7689SNRg@mail.gmail.com>
 <CAML5wvsfcpWMYKv7aPpRwFpYMxsu3kGXqY2uND7gfuO6+P67RA@mail.gmail.com>
Message-ID: <20140210161001.GA11167@machine>


Hi Dominique,

On Mon, Feb 10, 2014 at 04:55:52PM +0100, Dominique Devriese wrote:
> Hm. Interesting point, I guess this is the same problem as the whole
> orphan instances debate...  I didn't think of the connection to that
> problem.  Still, I'm convinced there are situations where local
> instances are *exactly* what we need, so there must be some way to
> avoid this problem...

If a type class has a clear semantical meaning, what should then
be the point of having multiple instances for the same data type?

A clear semantical meaning contradicts multiple instances, they would
only make reasoning about your code harder.

The few use cases where it might be nice to be able to define a new
instance aren't IMHO worth the drawbacks.

You would just open Haskell for Ruby like monkey patching.


Greetings,
Daniel

From dominique.devriese at cs.kuleuven.be  Mon Feb 10 16:26:37 2014
From: dominique.devriese at cs.kuleuven.be (Dominique Devriese)
Date: Mon, 10 Feb 2014 17:26:37 +0100
Subject: [Haskell-cafe] manage effects in a DSL
In-Reply-To: <20140210161001.GA11167@machine>
References: <CALnXJiqhPoKEpJKszGf4EskbSVU1xh+MX=R2dBU4cGv4o+fxoQ@mail.gmail.com>
 <CAEyhvmr=s7xTk7DS3RgKzcJgCZf4u7OEiw7eCKsQ3AuDrYUwUw@mail.gmail.com>
 <CAEyhvmp0M5briL0e617++XH+djkvfHq78tDMhrz7ajWMwkYZ_Q@mail.gmail.com>
 <CAHfjoWmOfwDYHTDFhn2RmOT53SdV==+HGjTJYMgLeZ_2e3mfOw@mail.gmail.com>
 <CACN--9CDygTpySYJj5eLkwrCPLca_m_5xmyUkFOjLpNTxFUQ6g@mail.gmail.com>
 <CAML5wvujBXCnAAuP60Xmc0hk7+SPmsG=wgNzi+mnezp2cw+_eg@mail.gmail.com>
 <CAEyhvmpgbR6EeTMMXBGPq3X7NK8umV=9GLSgV-ETBauMpv5xfg@mail.gmail.com>
 <CAML5wvv-1aKAVkgBRvs-Ue7mxzaefGMnY5hvQdTP3gAnF_feEg@mail.gmail.com>
 <CAKFCL4UQzviQNc_o4Z9Dkd3A+7W7nA=OaX-jqC5rpt7689SNRg@mail.gmail.com>
 <CAML5wvsfcpWMYKv7aPpRwFpYMxsu3kGXqY2uND7gfuO6+P67RA@mail.gmail.com>
 <20140210161001.GA11167@machine>
Message-ID: <CAML5wvtVkvvkj715oZMAKMae+n27_iNhy0oXKxZ78FqA0Eq8rQ@mail.gmail.com>

Hi Daniel,

2014-02-10 17:10 GMT+01:00 Daniel Trstenjak <daniel.trstenjak at gmail.com>:
> On Mon, Feb 10, 2014 at 04:55:52PM +0100, Dominique Devriese wrote:
>> Hm. Interesting point, I guess this is the same problem as the whole
>> orphan instances debate...  I didn't think of the connection to that
>> problem.  Still, I'm convinced there are situations where local
>> instances are *exactly* what we need, so there must be some way to
>> avoid this problem...
>
> If a type class has a clear semantical meaning, what should then
> be the point of having multiple instances for the same data type?
>
> A clear semantical meaning contradicts multiple instances, they would
> only make reasoning about your code harder.

I disagree. Just think about the Ord type class.  A decidable order
relation for a type is definitely something I would consider a clear
semantical meaning, but different sensible instances can be defined
for many types...  The same thing goes for Eq or Monoid or MonadState
or...

Regards,
Dominique

From allbery.b at gmail.com  Mon Feb 10 17:16:12 2014
From: allbery.b at gmail.com (Brandon Allbery)
Date: Mon, 10 Feb 2014 12:16:12 -0500
Subject: [Haskell-cafe] manage effects in a DSL
In-Reply-To: <CAML5wvtVkvvkj715oZMAKMae+n27_iNhy0oXKxZ78FqA0Eq8rQ@mail.gmail.com>
References: <CALnXJiqhPoKEpJKszGf4EskbSVU1xh+MX=R2dBU4cGv4o+fxoQ@mail.gmail.com>
 <CAEyhvmr=s7xTk7DS3RgKzcJgCZf4u7OEiw7eCKsQ3AuDrYUwUw@mail.gmail.com>
 <CAEyhvmp0M5briL0e617++XH+djkvfHq78tDMhrz7ajWMwkYZ_Q@mail.gmail.com>
 <CAHfjoWmOfwDYHTDFhn2RmOT53SdV==+HGjTJYMgLeZ_2e3mfOw@mail.gmail.com>
 <CACN--9CDygTpySYJj5eLkwrCPLca_m_5xmyUkFOjLpNTxFUQ6g@mail.gmail.com>
 <CAML5wvujBXCnAAuP60Xmc0hk7+SPmsG=wgNzi+mnezp2cw+_eg@mail.gmail.com>
 <CAEyhvmpgbR6EeTMMXBGPq3X7NK8umV=9GLSgV-ETBauMpv5xfg@mail.gmail.com>
 <CAML5wvv-1aKAVkgBRvs-Ue7mxzaefGMnY5hvQdTP3gAnF_feEg@mail.gmail.com>
 <CAKFCL4UQzviQNc_o4Z9Dkd3A+7W7nA=OaX-jqC5rpt7689SNRg@mail.gmail.com>
 <CAML5wvsfcpWMYKv7aPpRwFpYMxsu3kGXqY2uND7gfuO6+P67RA@mail.gmail.com>
 <20140210161001.GA11167@machine>
 <CAML5wvtVkvvkj715oZMAKMae+n27_iNhy0oXKxZ78FqA0Eq8rQ@mail.gmail.com>
Message-ID: <CAKFCL4VRd7HLhaoQ_zmQ0xbze-cMniGXo6J0H8YRYkyHh90bPg@mail.gmail.com>

On Mon, Feb 10, 2014 at 11:26 AM, Dominique Devriese <
dominique.devriese at cs.kuleuven.be> wrote:

> I disagree. Just think about the Ord type class.  A decidable order
> relation for a type is definitely something I would consider a clear
> semantical meaning, but different sensible instances can be defined
> for many types...  The same thing goes for Eq or Monoid or MonadState
> or...
>

Sure... but now you have to make sure everything agrees about it. The way
you do this in Haskell is to give your custom instance a distinct type to
go with it. (Now go look at the Sum and Product monoids).

-- 
brandon s allbery kf8nh                               sine nomine associates
allbery.b at gmail.com                                  ballbery at sinenomine.net
unix, openafs, kerberos, infrastructure, xmonad        http://sinenomine.net
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140210/a294e20b/attachment.html>

From roma at ro-che.info  Mon Feb 10 17:22:20 2014
From: roma at ro-che.info (Roman Cheplyaka)
Date: Mon, 10 Feb 2014 19:22:20 +0200
Subject: [Haskell-cafe] manage effects in a DSL
In-Reply-To: <20140210161001.GA11167@machine>
References: <CAEyhvmr=s7xTk7DS3RgKzcJgCZf4u7OEiw7eCKsQ3AuDrYUwUw@mail.gmail.com>
 <CAEyhvmp0M5briL0e617++XH+djkvfHq78tDMhrz7ajWMwkYZ_Q@mail.gmail.com>
 <CAHfjoWmOfwDYHTDFhn2RmOT53SdV==+HGjTJYMgLeZ_2e3mfOw@mail.gmail.com>
 <CACN--9CDygTpySYJj5eLkwrCPLca_m_5xmyUkFOjLpNTxFUQ6g@mail.gmail.com>
 <CAML5wvujBXCnAAuP60Xmc0hk7+SPmsG=wgNzi+mnezp2cw+_eg@mail.gmail.com>
 <CAEyhvmpgbR6EeTMMXBGPq3X7NK8umV=9GLSgV-ETBauMpv5xfg@mail.gmail.com>
 <CAML5wvv-1aKAVkgBRvs-Ue7mxzaefGMnY5hvQdTP3gAnF_feEg@mail.gmail.com>
 <CAKFCL4UQzviQNc_o4Z9Dkd3A+7W7nA=OaX-jqC5rpt7689SNRg@mail.gmail.com>
 <CAML5wvsfcpWMYKv7aPpRwFpYMxsu3kGXqY2uND7gfuO6+P67RA@mail.gmail.com>
 <20140210161001.GA11167@machine>
Message-ID: <20140210172220.GA10487@sniper>

* Daniel Trstenjak <daniel.trstenjak at gmail.com> [2014-02-10 17:10:01+0100]
> 
> Hi Dominique,
> 
> On Mon, Feb 10, 2014 at 04:55:52PM +0100, Dominique Devriese wrote:
> > Hm. Interesting point, I guess this is the same problem as the whole
> > orphan instances debate...  I didn't think of the connection to that
> > problem.  Still, I'm convinced there are situations where local
> > instances are *exactly* what we need, so there must be some way to
> > avoid this problem...
> 
> If a type class has a clear semantical meaning, what should then
> be the point of having multiple instances for the same data type?
> 
> A clear semantical meaning contradicts multiple instances, they would
> only make reasoning about your code harder.
> 
> The few use cases where it might be nice to be able to define a new
> instance aren't IMHO worth the drawbacks.
> 
> You would just open Haskell for Ruby like monkey patching.

How about a compromise. We already have a way to introduce fresh type
names: using existential types. They look like good candidates for local
instances (by definition, they can't have global instances, because the
names themselves are necessarily local). Of course, you can define an
instance only once, as for usual types.

This would cover the case when "dynamic" instances are needed without
compromising soundness. Example:

  data IsoInt = forall a . IsoInt (Int -> a) (a -> Int)

  foo modulus =
    case IsoInt id id of
      IsoInt (fromInt :: Int -> a) toInt ->
        let
          eqMod x1 x2 = (toInt x1 - toInt x2) `mod` modulus == 0

          -- note: a is rigid here
          instance Eq a where
            (==) = eqMod
        in ...

Roman
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140210/94b1ce00/attachment.sig>

From christopher.howard at frigidcode.com  Mon Feb 10 17:33:22 2014
From: christopher.howard at frigidcode.com (Christopher Howard)
Date: Mon, 10 Feb 2014 08:33:22 -0900
Subject: [Haskell-cafe] Lisp Style Restarts in Haskell
Message-ID: <52F90D62.20308@frigidcode.com>

Hi. I was curious if Haskell has something like "restarts" in Common
Lisp. My search engines didn't give relevant results for "Haskell
restarts". However, there were several results for "Haskell coroutines"
and, from what I can gather, restarts and coroutines are a similar or
related subject.

-- 
http://www.lugod.org/presentations/pgp/why.html

-------------- next part --------------
A non-text attachment was scrubbed...
Name: 0x25C6C407.asc
Type: application/pgp-keys
Size: 1748 bytes
Desc: not available
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140210/eaf36ab5/attachment.key>
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 551 bytes
Desc: OpenPGP digital signature
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140210/eaf36ab5/attachment.sig>

From davidleothomas at gmail.com  Mon Feb 10 17:38:47 2014
From: davidleothomas at gmail.com (David Thomas)
Date: Mon, 10 Feb 2014 09:38:47 -0800
Subject: [Haskell-cafe] manage effects in a DSL
In-Reply-To: <CAKFCL4VRd7HLhaoQ_zmQ0xbze-cMniGXo6J0H8YRYkyHh90bPg@mail.gmail.com>
References: <CALnXJiqhPoKEpJKszGf4EskbSVU1xh+MX=R2dBU4cGv4o+fxoQ@mail.gmail.com>
 <CAEyhvmr=s7xTk7DS3RgKzcJgCZf4u7OEiw7eCKsQ3AuDrYUwUw@mail.gmail.com>
 <CAEyhvmp0M5briL0e617++XH+djkvfHq78tDMhrz7ajWMwkYZ_Q@mail.gmail.com>
 <CAHfjoWmOfwDYHTDFhn2RmOT53SdV==+HGjTJYMgLeZ_2e3mfOw@mail.gmail.com>
 <CACN--9CDygTpySYJj5eLkwrCPLca_m_5xmyUkFOjLpNTxFUQ6g@mail.gmail.com>
 <CAML5wvujBXCnAAuP60Xmc0hk7+SPmsG=wgNzi+mnezp2cw+_eg@mail.gmail.com>
 <CAEyhvmpgbR6EeTMMXBGPq3X7NK8umV=9GLSgV-ETBauMpv5xfg@mail.gmail.com>
 <CAML5wvv-1aKAVkgBRvs-Ue7mxzaefGMnY5hvQdTP3gAnF_feEg@mail.gmail.com>
 <CAKFCL4UQzviQNc_o4Z9Dkd3A+7W7nA=OaX-jqC5rpt7689SNRg@mail.gmail.com>
 <CAML5wvsfcpWMYKv7aPpRwFpYMxsu3kGXqY2uND7gfuO6+P67RA@mail.gmail.com>
 <20140210161001.GA11167@machine>
 <CAML5wvtVkvvkj715oZMAKMae+n27_iNhy0oXKxZ78FqA0Eq8rQ@mail.gmail.com>
 <CAKFCL4VRd7HLhaoQ_zmQ0xbze-cMniGXo6J0H8YRYkyHh90bPg@mail.gmail.com>
Message-ID: <CAJUDvchiQ75Y-6=aa6d5m+Ji_PeQNBSePcA_AAZBUM=7oH5Z8Q@mail.gmail.com>

I think what we're running into is a slight mismatch between a natural
understanding of types-as-sets and types-as-ADTs.  In the former sense -
particularly about things we're used to thinking of as sets (say, Integer)
- we want to be able to say "this is still integers, we just want to couple
them with this operation and get a monoid here, and that operation and get
a different monoid over there, but the objects are all still integers".
Viewed as ADTs, it's more intuitive to say "there is some data here behind
this interface, and the combination yields a single type", and that's what
we're doing with typeclasses in Haskell.  I don't *think* there is actually
a need to express the former more directly, and I'm not convinced there's a
way to do it that's actually cleaner, but I think that's the origin of the
impulse (and I don't think the impulse itself is "wrong" - you just need to
remember the translation).

On Mon, Feb 10, 2014 at 9:16 AM, Brandon Allbery <allbery.b at gmail.com>wrote:

> On Mon, Feb 10, 2014 at 11:26 AM, Dominique Devriese <
> dominique.devriese at cs.kuleuven.be> wrote:
>
>> I disagree. Just think about the Ord type class.  A decidable order
>> relation for a type is definitely something I would consider a clear
>> semantical meaning, but different sensible instances can be defined
>> for many types...  The same thing goes for Eq or Monoid or MonadState
>> or...
>>
>
> Sure... but now you have to make sure everything agrees about it. The way
> you do this in Haskell is to give your custom instance a distinct type to
> go with it. (Now go look at the Sum and Product monoids).
>
>
> --
> brandon s allbery kf8nh                               sine nomine
> associates
> allbery.b at gmail.com
> ballbery at sinenomine.net
> unix, openafs, kerberos, infrastructure, xmonad
> http://sinenomine.net
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140210/200079f8/attachment.html>

From dominique.devriese at cs.kuleuven.be  Mon Feb 10 19:07:37 2014
From: dominique.devriese at cs.kuleuven.be (Dominique Devriese)
Date: Mon, 10 Feb 2014 20:07:37 +0100
Subject: [Haskell-cafe] manage effects in a DSL
In-Reply-To: <20140210172220.GA10487@sniper>
References: <CAEyhvmr=s7xTk7DS3RgKzcJgCZf4u7OEiw7eCKsQ3AuDrYUwUw@mail.gmail.com>
 <CAEyhvmp0M5briL0e617++XH+djkvfHq78tDMhrz7ajWMwkYZ_Q@mail.gmail.com>
 <CAHfjoWmOfwDYHTDFhn2RmOT53SdV==+HGjTJYMgLeZ_2e3mfOw@mail.gmail.com>
 <CACN--9CDygTpySYJj5eLkwrCPLca_m_5xmyUkFOjLpNTxFUQ6g@mail.gmail.com>
 <CAML5wvujBXCnAAuP60Xmc0hk7+SPmsG=wgNzi+mnezp2cw+_eg@mail.gmail.com>
 <CAEyhvmpgbR6EeTMMXBGPq3X7NK8umV=9GLSgV-ETBauMpv5xfg@mail.gmail.com>
 <CAML5wvv-1aKAVkgBRvs-Ue7mxzaefGMnY5hvQdTP3gAnF_feEg@mail.gmail.com>
 <CAKFCL4UQzviQNc_o4Z9Dkd3A+7W7nA=OaX-jqC5rpt7689SNRg@mail.gmail.com>
 <CAML5wvsfcpWMYKv7aPpRwFpYMxsu3kGXqY2uND7gfuO6+P67RA@mail.gmail.com>
 <20140210161001.GA11167@machine> <20140210172220.GA10487@sniper>
Message-ID: <CAML5wvtuA0=rf15ino3Oc=4bPpgjUtUsCfLvzixi1KrL43_E5g@mail.gmail.com>

Roman,

2014-02-10 18:22 GMT+01:00 Roman Cheplyaka <roma at ro-che.info>:
> * Daniel Trstenjak <daniel.trstenjak at gmail.com> [2014-02-10 17:10:01+0100]
>> On Mon, Feb 10, 2014 at 04:55:52PM +0100, Dominique Devriese wrote:
>> > Hm. Interesting point, I guess this is the same problem as the whole
>> > orphan instances debate...  I didn't think of the connection to that
>> > problem.  Still, I'm convinced there are situations where local
>> > instances are *exactly* what we need, so there must be some way to
>> > avoid this problem...
>>
>> If a type class has a clear semantical meaning, what should then
>> be the point of having multiple instances for the same data type?
>>
>> A clear semantical meaning contradicts multiple instances, they would
>> only make reasoning about your code harder.
>>
>> The few use cases where it might be nice to be able to define a new
>> instance aren't IMHO worth the drawbacks.
>>
>> You would just open Haskell for Ruby like monkey patching.
>
> How about a compromise. We already have a way to introduce fresh type
> names: using existential types. They look like good candidates for local
> instances (by definition, they can't have global instances, because the
> names themselves are necessarily local). Of course, you can define an
> instance only once, as for usual types.
>
> This would cover the case when "dynamic" instances are needed without
> compromising soundness. Example:
>
>   data IsoInt = forall a . IsoInt (Int -> a) (a -> Int)
>
>   foo modulus =
>     case IsoInt id id of
>       IsoInt (fromInt :: Int -> a) toInt ->
>         let
>           eqMod x1 x2 = (toInt x1 - toInt x2) `mod` modulus == 0
>
>           -- note: a is rigid here
>           instance Eq a where
>             (==) = eqMod
>         in ...

Just a note that your proposal seems very related to what Kiselyov and
Shan propose in their paper on "Implicit Configurations"
(http://dl.acm.org/citation.cfm?id=1017481).

Anyway, I still think that there are cases where I want to say that I
want to use "real" local instances.

Another interesting example by the way is instancing MonadState for
IO.  Consider how every IORef a can be used to build a MonadState a
instance for IO:

  data MonadStateD a m = MonadStateD { putM :: a -> m (), getM :: m a }
  ioRefStateD :: IORef a -> MonadStateD a IO
  ioRefStateD ref = MonadStateD (writeIORef ref) (readIORef ref)

I have the feeling that Brandon's argument (that multiple instances
cannot be permitted because, for example, Data.Map should only be used
with a single Ord instance) in some way comes down to solving a lack
for an ML-like module system by imposing an otherwise artificial
restriction on type classes:  to enforce that a type class instance is
unique within a module parameterised by it, we simply require that the
instance be globally unique...

That being said, Brendan is clearly right that we can't just drop a
guarantee that is widely relied upon.

Regards,
Dominique

From miguelimo38 at yandex.ru  Mon Feb 10 19:31:08 2014
From: miguelimo38 at yandex.ru (MigMit)
Date: Mon, 10 Feb 2014 23:31:08 +0400
Subject: [Haskell-cafe] manage effects in a DSL
In-Reply-To: <CAKFCL4UQzviQNc_o4Z9Dkd3A+7W7nA=OaX-jqC5rpt7689SNRg@mail.gmail.com>
References: <20140129033404.76144.qmail@www1.g3.pair.com>
 <CAEyhvmqiJCc8vs-LHpT=CW20yGjhr5G3LMB86c+w38v+e5BELw@mail.gmail.com>
 <CAEyhvmrti3-4B0KvtdQKZPTh8foX=yg__W3AATjunRLAvaF6CA@mail.gmail.com>
 <CAEyhvmow1XbdLJv00iDVA4uBWEXmMGeLsVg1g6jpUCt2=d8CPQ@mail.gmail.com>
 <CALnXJiqhPoKEpJKszGf4EskbSVU1xh+MX=R2dBU4cGv4o+fxoQ@mail.gmail.com>
 <CAEyhvmr=s7xTk7DS3RgKzcJgCZf4u7OEiw7eCKsQ3AuDrYUwUw@mail.gmail.com>
 <CAEyhvmp0M5briL0e617++XH+djkvfHq78tDMhrz7ajWMwkYZ_Q@mail.gmail.com>
 <CAHfjoWmOfwDYHTDFhn2RmOT53SdV==+HGjTJYMgLeZ_2e3mfOw@mail.gmail.com>
 <CACN--9CDygTpySYJj5eLkwrCPLca_m_5xmyUkFOjLpNTxFUQ6g@mail.gmail.com>
 <CAML5wvujBXCnAAuP60Xmc0hk7+SPmsG=wgNzi+mnezp2cw+_eg@mail.gmail.com>
 <CAEyhvmpgbR6EeTMMXBGPq3X7NK8umV=9GLSgV-ETBauMpv5xfg@mail.gmail.com>
 <CAML5wvv-1aKAVkgBRvs-Ue7mxzaefGMnY5hvQdTP3gAnF_feEg@mail.gmail.com>
 <CAKFCL4UQzviQNc_o4Z9Dkd3A+7W7nA=OaX-jqC5rpt7689SNRg@mail.gmail.com>
Message-ID: <BD2C4C30-634C-4FE9-8765-71FC5602B25C@yandex.ru>


On 10 Feb 2014, at 19:03, Brandon Allbery <allbery.b at gmail.com> wrote:

> On Mon, Feb 10, 2014 at 5:33 AM, Dominique Devriese <dominique.devriese at cs.kuleuven.be> wrote:
> Local instances were already considered by Wadler when he proposed
> type classes, but they are problematic to combine with type inference
> 
> Local instances have a bigger problem: you can use them to trivially violate invariants. Consider a local replacement for Ord on a Data.Map. They're not going to happen.

You can easily achieve the same thing with orphan instances, and they only result in a compiler warning.

From daniel.trstenjak at gmail.com  Mon Feb 10 19:47:33 2014
From: daniel.trstenjak at gmail.com (Daniel Trstenjak)
Date: Mon, 10 Feb 2014 20:47:33 +0100
Subject: [Haskell-cafe] manage effects in a DSL
In-Reply-To: <CAML5wvtVkvvkj715oZMAKMae+n27_iNhy0oXKxZ78FqA0Eq8rQ@mail.gmail.com>
References: <CALnXJiqhPoKEpJKszGf4EskbSVU1xh+MX=R2dBU4cGv4o+fxoQ@mail.gmail.com>
 <CAEyhvmr=s7xTk7DS3RgKzcJgCZf4u7OEiw7eCKsQ3AuDrYUwUw@mail.gmail.com>
 <CAEyhvmp0M5briL0e617++XH+djkvfHq78tDMhrz7ajWMwkYZ_Q@mail.gmail.com>
 <CAHfjoWmOfwDYHTDFhn2RmOT53SdV==+HGjTJYMgLeZ_2e3mfOw@mail.gmail.com>
 <CACN--9CDygTpySYJj5eLkwrCPLca_m_5xmyUkFOjLpNTxFUQ6g@mail.gmail.com>
 <CAML5wvujBXCnAAuP60Xmc0hk7+SPmsG=wgNzi+mnezp2cw+_eg@mail.gmail.com>
 <CAEyhvmpgbR6EeTMMXBGPq3X7NK8umV=9GLSgV-ETBauMpv5xfg@mail.gmail.com>
 <CAML5wvv-1aKAVkgBRvs-Ue7mxzaefGMnY5hvQdTP3gAnF_feEg@mail.gmail.com>
 <CAKFCL4UQzviQNc_o4Z9Dkd3A+7W7nA=OaX-jqC5rpt7689SNRg@mail.gmail.com>
 <CAML5wvsfcpWMYKv7aPpRwFpYMxsu3kGXqY2uND7gfuO6+P67RA@mail.gmail.com>
 <20140210161001.GA11167@machine>
 <CAML5wvtVkvvkj715oZMAKMae+n27_iNhy0oXKxZ78FqA0Eq8rQ@mail.gmail.com>
Message-ID: <014D6EBE-14E6-48F0-B0D1-6571A926CFF6@gmail.com>

Am 10.02.2014 um 17:26 schrieb Dominique Devriese <dominique.devriese at cs.kuleuven.be>:
> I disagree. Just think about the Ord type class.  A decidable order
> relation for a type is definitely something I would consider a clear
> semantical meaning ...

Why shouldn't be the kind of ordering part of the semantical meaning of Ord?

Otherwise what could you then say about the result of the 'sort' function?

  sort :: Ord a => [a] -> [a]


My gut feeling is, that if the effective range of the active instance is too narrow,
then it's not very useful, but if you widen it, then you're getting all of the possible 
drawbacks.


Greetings,
Daniel

From tyler.huffman at tylerh.org  Tue Feb 11 03:16:47 2014
From: tyler.huffman at tylerh.org (Tyler Huffman)
Date: Mon, 10 Feb 2014 20:16:47 -0700
Subject: [Haskell-cafe] Master's Thesis: Open areas of research in
	Haskell
In-Reply-To: <CAPY+ZdTWfNgsTQo-6zJSnXRu9o_2s=Yi=ko0+1LbuB=cQSHQkA@mail.gmail.com>
References: <CAMYb46C3QX+n=D06ePFTPGuPJMK5T7Ac=ERZtyzge0qZNveyRw@mail.gmail.com>
 <CAPY+ZdTWfNgsTQo-6zJSnXRu9o_2s=Yi=ko0+1LbuB=cQSHQkA@mail.gmail.com>
Message-ID: <CAMYb46BNTKF-oH4ZVyM+faEDLjyYHyM2v9dz7fiV-jvD8GtUDA@mail.gmail.com>

Perfect!

Thank you very much for the pointers!


Regards


On Sun, Feb 9, 2014 at 11:32 PM, Kim-Ee Yeoh <ky3 at atamo.com> wrote:

>
> On Mon, Feb 10, 2014 at 9:50 AM, Tyler Huffman <tyler.huffman at tylerh.org>wrote:
>
>> I've seen the Internship opportunities and areas of research for GHC (
>> https://ghc.haskell.org/trac/ghc/wiki/Internships) but they all seem to
>> apply to Ph.D candidates.
>>
>
> I wouldn't worry about these restrictions, they aren't set in stone. It's
> better to look at the slate of people (and what they've done, not their
> paper qualifications) who have actually gotten in previously to get a sense
> of the benchmark.
>
> If you've hacked GHC in interesting ways before applying, you'll
> definitely turn heads.
>
>
>> That said, are there open areas of research that I could look into
>>
>
> Skim the titles of previous years ICFP and Haskell Symposium proceedings.
> Read the abstracts. Look at the references. Does anything strike the eye?
>
> -- Kim-Ee
>



-- 
Tyler Huffman

Computer Science/Software Engineer
tyler.huffman at tylerh.org
(406) 480-6148
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140210/9bb62648/attachment.html>

From jmitdase at gmail.com  Tue Feb 11 05:15:43 2014
From: jmitdase at gmail.com (Joey)
Date: Mon, 10 Feb 2014 23:15:43 -0600
Subject: [Haskell-cafe] How Plugins works with a Cabal sandbox
Message-ID: <52F9B1FF.9070901@gmail.com>

I was wondering, could somebody talk me through how the Plugins package 
works with a Cabal sandbox, or Cabal in general?

Basically, I'm writing a program where I want to dynamically load and 
run user-supplied code. There are two cabal DBs in question: the sandbox 
which I'm using to build my program, and my "global" sandbox located in 
/home/user/.cabal.

Which database, if either, does a program I load with 
System.Plugins.Load.load have access to via "import" statements? How can 
I avoid double-loading of packages?

In particular, I'm currently getting this error when I try to load my 
code. Any thoughts?

GHCi runtime linker: fatal error: I found a duplicate definition for symbol
transformerszm0zi3zi0zi0_ControlziMonadziTransziError_mapErrorT1_closure
whilst processing object file
/home/joey/.cabal/lib/transformers-0.3.0.0/ghc-7.6.3/HStransformers-0.3.0.0.o 

This could be caused by:
    * Loading two different object files which export the same symbol
    * Specifying the same object file twice on the GHCi command line
    * An incorrect `package.conf' entry, causing some object to be
      loaded twice.
GHCi cannot safely continue in this situation.  Exiting now.  Sorry.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140210/10a9faf3/attachment.html>

From michael at snoyman.com  Tue Feb 11 10:02:42 2014
From: michael at snoyman.com (Michael Snoyman)
Date: Tue, 11 Feb 2014 12:02:42 +0200
Subject: [Haskell-cafe] A new yaml module
In-Reply-To: <CAKA2JgJOV-jZhOL7FN0W21JVyumSfByWX2D2C+z7=syayx2u+g@mail.gmail.com>
References: <CAKA2JgJOV-jZhOL7FN0W21JVyumSfByWX2D2C+z7=syayx2u+g@mail.gmail.com>
Message-ID: <CAKA2JgJJfG7sVmZVa9dwktPUDyttYm1623Xmm7iFNeNhPyPxGg@mail.gmail.com>

I've made an initial stab at this new API. It lives in two modules:
Data.Yaml.Builder, and Data.Yaml.Parser. Both of these modules are highly
inspired by the aeson equivalents, but they allow for more control of
serialization, and proper handling of ambiguous values like 12345, which
can now be parsed as either an Int or a Text.

In order to make it easier to experiment with this API, I've included these
two modules in the most recent version of the yaml package on Hackage[1].
Note that:

* The API isn't fully fleshed out. In particular, many ToYaml and FromYaml
instances need to be written.
* The API is subject to change over the next few iterations, so please
don't start depending on it yet.

Discussion on this API has been taking place on the issue tracker[2]. You
can see some simple example usages of the API at [3][4].

[1] http://hackage.haskell.org/package/yaml-0.8.7
[2] https://github.com/snoyberg/yaml/issues/38
[3] https://github.com/snoyberg/yaml/blob/master/builder-test.hs
[4] https://github.com/snoyberg/yaml/blob/master/parser-test.hs


On Mon, Feb 3, 2014 at 10:57 AM, Michael Snoyman <michael at snoyman.com>wrote:

> The yaml package[1] currently provides two modules. Text.Libyaml is a
> lower level, streaming API which is essentially a raw exposure of the
> underlying libyaml C library. Data.Yaml uses the aeson Value data type and
> ToJSON/FromJSON type classes for higher level serialization. For many
> cases, this approach works well, though there are problems:
>
> * There are problems with roundtripping, since YAML allows for ambiguity
> about the data type of values[2]. For example, in the yaml snippet `foo:
> 1234`, is 1234 intended to be numeric or a string? Either is valid.
> * YAML is intended to be human-readable output. But Data.Yaml provides no
> control over the encoded representation, e.g. should we use single or
> double quotes for a string (or no quotes at all), or the order of values in
> a mapping[3].
>
> For other examples, just look at the issue tracker for yaml[4].
>
> I don't want to drop the current aeson-based functionality, since I think
> it's still valid and useful in many cases. But I do think it's worthwhile
> to add in an alternative API which handles YAML-specific constructs better.
> My idea is:
>
> * Create a new Data.Yaml.Aeson module, and have it mirror Data.Yaml.
> * Deprecate Data.Yaml.
> * Create a new Data.Yaml.? module to contain this YAML-specific API.
>
> I'm asking for feedback on that last point. I have some basic ideas on
> what such an API would look like, but given that there are many people
> using YAML in ways different than how I'm using it, I don't think an API
> designed entirely by me will suit all use cases.
>
> I've opened up a new issue[5] to track this work. If you're interested in
> participating in this design, please contact me. I'm happy to have the
> discussion on this mailing list, but if (as I suspect) there are just a
> handful of people who are interested in pushing this forward, it likely
> makes sense to take the discussion offlist.
>
> Michael
>
> [1] http://hackage.haskell.org/package/yaml
> [2] https://github.com/snoyberg/yaml/issues/22
> [3] https://github.com/snoyberg/yaml/issues/37
> [4] https://github.com/snoyberg/yaml/issues
> [5] https://github.com/snoyberg/yaml/issues/38
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140211/29034962/attachment.html>

From horstmey at Mathematik.Uni-Marburg.de  Tue Feb 11 16:00:12 2014
From: horstmey at Mathematik.Uni-Marburg.de (Thomas Horstmeyer)
Date: Tue, 11 Feb 2014 17:00:12 +0100
Subject: [Haskell-cafe] Lazy Lambda Calculus implementation
In-Reply-To: <86d2izroas.fsf@gmail.com>
References: <86d2izroas.fsf@gmail.com>
Message-ID: <52FA490C.8070902@informatik.uni-marburg.de>

Hello Chris,

it looks to me like it should be shared.

One approach to test this is "println-debugging". The Module Debug.Trace 
has functions to let you write to stdout as side-effect, outside the IO 
monad.


import Debug.Trace(trace)

eval' (Lam   f) env
   = Now (F (\a -> eval' f (trace "evaluating element" a:env)))


With this, you would get the output "evaluating element" whenever an 
entry in the list env is evaluated.

HTH
Thomas


Am 07.02.2014 15:27, schrieb Chris Warburton:
> Hello all, I've written the following implementation of Lambda Calculus,
> which will evaluate its Terms non-strictly. I've verified this since the
> Y combinator works without diverging:
>
> data Term a = Const a
>              | Var Nat
>              | Lam (Term a)
>              | Term a :@ Term a
>
> data Val a = C a
>             | F (Partial (Val a) -> Partial (Val a))
>
> type Env a = [Partial (Val a)]
>
> eval' :: Term a -> Env a -> Partial (Val a)
> eval' (Const c) env = Now (C c)
> eval' (Var   n) env = let Just x = lookUp env n in x
> eval' (Lam   f) env = Now (F (\a -> eval' f (a:env)))
> eval' (f :@  x) env = do F f' <- eval' f env
>                           Later (f' (eval' x env))
>
> eval t = eval' [] t
>
> Nat, Partial, lookUp, etc. have pretty obvious implementations.
>
> My question is, will this behave lazily? In other words will the
> contents of the 'env' lists be shared between the different contexts,
> such that forcing an element the be evaluated twice will only perform
> the evaluation once? Note that the first "do" line is the only place
> where evaluation is forced.
>
> If anyone could point out an 'obvious' reason why it will or will not be
> shared, or approaches I can take to check or infer this myself (eg. a
> Term which would show wildly different RAM usage in each case), I'd be
> very interested to know. I'd also be interested if someone spots a bug ;)
>
> For those who are curious, the code is living at
> https://gitorious.org/lazy-lambda-calculus and I've written a blog post
> detailing the iteration's I've been through at
> http://chriswarbo.net/index.php?page=news&type=view&id=admin-s-blog%2Flazy-lambda-calculus
>
> Cheers,
> Chris
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>

From flickyfrans at gmail.com  Tue Feb 11 21:46:47 2014
From: flickyfrans at gmail.com (flicky frans)
Date: Wed, 12 Feb 2014 00:46:47 +0300
Subject: [Haskell-cafe] Lazy lists with with call-by-value reduction
	strategy.
Message-ID: <CAJHfH3NJBb63A6Am=WwsYgYGhaeA69xqKTHkx3RD8=+G7u3WjA@mail.gmail.com>

Hello. I am currently writing lists with lazy semantics in the pure
lambda-calculus with call-by-value reduction strategy.
Here is an example: http://pastebin.com/SvQ5hCSD
Here is a simple interpetator: http://pastebin.com/mejCWqpu
Am I reinventing the wheel? Are there some sources, from where i can
learn more about lazy evaluation in the strict languages?

From kyle.marek.spartz at gmail.com  Tue Feb 11 21:54:34 2014
From: kyle.marek.spartz at gmail.com (Kyle Marek-Spartz)
Date: Tue, 11 Feb 2014 15:54:34 -0600
Subject: [Haskell-cafe] Lazy lists with with call-by-value reduction
 strategy.
In-Reply-To: <CAJHfH3NJBb63A6Am=WwsYgYGhaeA69xqKTHkx3RD8=+G7u3WjA@mail.gmail.com>
References: <CAJHfH3NJBb63A6Am=WwsYgYGhaeA69xqKTHkx3RD8=+G7u3WjA@mail.gmail.com>
Message-ID: <etPan.52fa9c1a.6763845e.b08a@highlander>

SICP comes to mind:?http://mitpress.mit.edu/sicp/full-text/sicp/book/node70.html

--  
Kyle Marek-Spartz

On February 11, 2014 at 3:47:09 PM, flicky frans (flickyfrans at gmail.com) wrote:
>  
> Hello. I am currently writing lists with lazy semantics in the  
> pure
> lambda-calculus with call-by-value reduction strategy.
> Here is an example: http://pastebin.com/SvQ5hCSD
> Here is a simple interpetator: http://pastebin.com/mejCWqpu  
> Am I reinventing the wheel? Are there some sources, from where  
> i can
> learn more about lazy evaluation in the strict languages?
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe  
>  


From flickyfrans at gmail.com  Tue Feb 11 22:42:02 2014
From: flickyfrans at gmail.com (flicky frans)
Date: Wed, 12 Feb 2014 01:42:02 +0300
Subject: [Haskell-cafe] Lazy lists with with call-by-value reduction
	strategy.
In-Reply-To: <etPan.52fa9c1a.6763845e.b08a@highlander>
References: <CAJHfH3NJBb63A6Am=WwsYgYGhaeA69xqKTHkx3RD8=+G7u3WjA@mail.gmail.com>
 <etPan.52fa9c1a.6763845e.b08a@highlander>
Message-ID: <CAJHfH3P8uHLqsnmOo9pQvsTu9hRR1ysdBYS7M3UoJxTqdsKfYg@mail.gmail.com>

>interpetator
Sorry, interpreter.
Thanks, Kyle Marek-Spartz. I've read SICP a few years ago, but
completely forgot about this chapter. That's what I wrote modulo CPS,
but CPS is a significant part.

2014-02-12 0:54 GMT+03:00, Kyle Marek-Spartz <kyle.marek.spartz at gmail.com>:
> SICP comes to
> mind:?http://mitpress.mit.edu/sicp/full-text/sicp/book/node70.html
>
> --
> Kyle Marek-Spartz
>
> On February 11, 2014 at 3:47:09 PM, flicky frans (flickyfrans at gmail.com)
> wrote:
>>
>> Hello. I am currently writing lists with lazy semantics in the
>> pure
>> lambda-calculus with call-by-value reduction strategy.
>> Here is an example: http://pastebin.com/SvQ5hCSD
>> Here is a simple interpetator: http://pastebin.com/mejCWqpu
>> Am I reinventing the wheel? Are there some sources, from where
>> i can
>> learn more about lazy evaluation in the strict languages?
>> _______________________________________________
>> Haskell-Cafe mailing list
>> Haskell-Cafe at haskell.org
>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>
>
>

From roma at ro-che.info  Tue Feb 11 22:52:07 2014
From: roma at ro-che.info (Roman Cheplyaka)
Date: Wed, 12 Feb 2014 00:52:07 +0200
Subject: [Haskell-cafe] Lazy lists with with call-by-value reduction
 strategy.
In-Reply-To: <etPan.52fa9c1a.6763845e.b08a@highlander>
References: <CAJHfH3NJBb63A6Am=WwsYgYGhaeA69xqKTHkx3RD8=+G7u3WjA@mail.gmail.com>
 <etPan.52fa9c1a.6763845e.b08a@highlander>
Message-ID: <20140211225207.GA3885@sniper>

Except Scheme is not pure ? they use set! to achieve memoisation.

I don't think the OP bothers with memoisation in his/her encoding,
though.

Roman

* Kyle Marek-Spartz <kyle.marek.spartz at gmail.com> [2014-02-11 15:54:34-0600]
> SICP comes to mind:?http://mitpress.mit.edu/sicp/full-text/sicp/book/node70.html
> 
> --  
> Kyle Marek-Spartz
> 
> On February 11, 2014 at 3:47:09 PM, flicky frans (flickyfrans at gmail.com) wrote:
> >  
> > Hello. I am currently writing lists with lazy semantics in the  
> > pure
> > lambda-calculus with call-by-value reduction strategy.
> > Here is an example: http://pastebin.com/SvQ5hCSD
> > Here is a simple interpetator: http://pastebin.com/mejCWqpu  
> > Am I reinventing the wheel? Are there some sources, from where  
> > i can
> > learn more about lazy evaluation in the strict languages?
> > _______________________________________________
> > Haskell-Cafe mailing list
> > Haskell-Cafe at haskell.org
> > http://www.haskell.org/mailman/listinfo/haskell-cafe  
> >  
> 
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140212/bcbb2ce5/attachment.sig>

From roma at ro-che.info  Tue Feb 11 23:31:05 2014
From: roma at ro-che.info (Roman Cheplyaka)
Date: Wed, 12 Feb 2014 01:31:05 +0200
Subject: [Haskell-cafe] Lazy lists with with call-by-value reduction
 strategy.
In-Reply-To: <CAJHfH3NJBb63A6Am=WwsYgYGhaeA69xqKTHkx3RD8=+G7u3WjA@mail.gmail.com>
References: <CAJHfH3NJBb63A6Am=WwsYgYGhaeA69xqKTHkx3RD8=+G7u3WjA@mail.gmail.com>
Message-ID: <20140211233105.GA4451@sniper>

Do you know about the Church encoding?

I don't quite understand your encoding. Consider your cons function:

  cons    = \x xs f z. f (\_. x) (\f' _. xs f' z);

1. Why do you pass (\_. x) instead of x to f? This looks like an attempt
   to delay evaluation of x, but by the time cons is applied, x must
   have been evaluated already due to CBV.

2. Why do you ask for a new f' but ignore the new z' (as compared to f
   and z)?

Also, your interpreter doesn't seem to finish in a reasonable time on
your own input.

Roman

* flicky frans <flickyfrans at gmail.com> [2014-02-12 00:46:47+0300]
> Hello. I am currently writing lists with lazy semantics in the pure
> lambda-calculus with call-by-value reduction strategy.
> Here is an example: http://pastebin.com/SvQ5hCSD
> Here is a simple interpetator: http://pastebin.com/mejCWqpu
> Am I reinventing the wheel? Are there some sources, from where i can
> learn more about lazy evaluation in the strict languages?
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140212/a2595610/attachment.sig>

From flickyfrans at gmail.com  Wed Feb 12 00:02:55 2014
From: flickyfrans at gmail.com (flicky frans)
Date: Wed, 12 Feb 2014 03:02:55 +0300
Subject: [Haskell-cafe] Lazy lists with with call-by-value reduction
	strategy.
In-Reply-To: <20140211233105.GA4451@sniper>
References: <CAJHfH3NJBb63A6Am=WwsYgYGhaeA69xqKTHkx3RD8=+G7u3WjA@mail.gmail.com>
 <20140211233105.GA4451@sniper>
Message-ID: <CAJHfH3PJjExc0zA2zCD3C=3SAJLjXTzEL+Qw-VxocUguLY+oog@mail.gmail.com>

>Do you know about the Church encoding?
Yes.
>1. Why do you pass (\_. x) instead of x to f? This looks like an attempt
>to delay evaluation of x, but by the time cons is applied, x must
>have been evaluated already due to CBV.
It's for constructing lists from the evaluated values. For lazy
purposes there is consC.
2. Why do you ask for a new f' but ignore the new z' (as compared to f
>and z)?
It's for the tail function, which is problematic in the standard
Church encoding. Here it is O(1). While folding, actual f passes over
the whole list.
>Also, your interpreter doesn't seem to finish in a reasonable time on
your own input.
It's very simple and unoptimized. And there is much arithmetic in the
code. It finishes, but if you don't want to wait, you can try "sum
(take (s (s z)) (cycle (take (s (s z)) (filter (leq (s z)) nats))))".

2014-02-12 2:31 GMT+03:00, Roman Cheplyaka <roma at ro-che.info>:
> Do you know about the Church encoding?
>
> I don't quite understand your encoding. Consider your cons function:
>
>   cons    = \x xs f z. f (\_. x) (\f' _. xs f' z);
>
> 1. Why do you pass (\_. x) instead of x to f? This looks like an attempt
>    to delay evaluation of x, but by the time cons is applied, x must
>    have been evaluated already due to CBV.
>
> 2. Why do you ask for a new f' but ignore the new z' (as compared to f
>    and z)?
>
> Also, your interpreter doesn't seem to finish in a reasonable time on
> your own input.
>
> Roman
>
> * flicky frans <flickyfrans at gmail.com> [2014-02-12 00:46:47+0300]
>> Hello. I am currently writing lists with lazy semantics in the pure
>> lambda-calculus with call-by-value reduction strategy.
>> Here is an example: http://pastebin.com/SvQ5hCSD
>> Here is a simple interpetator: http://pastebin.com/mejCWqpu
>> Am I reinventing the wheel? Are there some sources, from where i can
>> learn more about lazy evaluation in the strict languages?
>> _______________________________________________
>> Haskell-Cafe mailing list
>> Haskell-Cafe at haskell.org
>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>

From kmill31415 at gmail.com  Wed Feb 12 03:24:40 2014
From: kmill31415 at gmail.com (Kyle Miller)
Date: Tue, 11 Feb 2014 22:24:40 -0500
Subject: [Haskell-cafe] Lazy lists with with call-by-value reduction
	strategy.
In-Reply-To: <20140211225207.GA3885@sniper>
References: <CAJHfH3NJBb63A6Am=WwsYgYGhaeA69xqKTHkx3RD8=+G7u3WjA@mail.gmail.com>
 <etPan.52fa9c1a.6763845e.b08a@highlander>
 <20140211225207.GA3885@sniper>
Message-ID: <CABV1e4EEZtRVmz0fAp7mKdv3QBZPEZ88KtC7ns_tocMb6oP1Yw@mail.gmail.com>

Please correct me if I'm wrong, but isn't Haskell secretly doing a set!
when parts of an ADT are evaluated to memoize them?  In the vein of lazy
lists, taking the tail of a list in Haskell would be one such example.

I noticed this secret set! when I was learning about its garbage collector:
I was surprised at first that objects in older generations could ever have
pointers to objects in newer generations!

Kyle


On Tue, Feb 11, 2014 at 5:52 PM, Roman Cheplyaka <roma at ro-che.info> wrote:

> Except Scheme is not pure -- they use set! to achieve memoisation.
>
> I don't think the OP bothers with memoisation in his/her encoding,
> though.
>
> Roman
>
> * Kyle Marek-Spartz <kyle.marek.spartz at gmail.com> [2014-02-11
> 15:54:34-0600]
> > SICP comes to mind:
> http://mitpress.mit.edu/sicp/full-text/sicp/book/node70.html
> >
> > --
> > Kyle Marek-Spartz
> >
> > On February 11, 2014 at 3:47:09 PM, flicky frans (flickyfrans at gmail.com)
> wrote:
> > >
> > > Hello. I am currently writing lists with lazy semantics in the
> > > pure
> > > lambda-calculus with call-by-value reduction strategy.
> > > Here is an example: http://pastebin.com/SvQ5hCSD
> > > Here is a simple interpetator: http://pastebin.com/mejCWqpu
> > > Am I reinventing the wheel? Are there some sources, from where
> > > i can
> > > learn more about lazy evaluation in the strict languages?
> > > _______________________________________________
> > > Haskell-Cafe mailing list
> > > Haskell-Cafe at haskell.org
> > > http://www.haskell.org/mailman/listinfo/haskell-cafe
> > >
> >
> > _______________________________________________
> > Haskell-Cafe mailing list
> > Haskell-Cafe at haskell.org
> > http://www.haskell.org/mailman/listinfo/haskell-cafe
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140211/51ce9017/attachment.html>

From danny.gratzer at gmail.com  Wed Feb 12 03:45:19 2014
From: danny.gratzer at gmail.com (Danny Gratzer)
Date: Tue, 11 Feb 2014 21:45:19 -0600
Subject: [Haskell-cafe] Lazy lists with with call-by-value reduction
	strategy.
In-Reply-To: <CABV1e4EEZtRVmz0fAp7mKdv3QBZPEZ88KtC7ns_tocMb6oP1Yw@mail.gmail.com>
References: <CAJHfH3NJBb63A6Am=WwsYgYGhaeA69xqKTHkx3RD8=+G7u3WjA@mail.gmail.com>
 <etPan.52fa9c1a.6763845e.b08a@highlander> <20140211225207.GA3885@sniper>
 <CABV1e4EEZtRVmz0fAp7mKdv3QBZPEZ88KtC7ns_tocMb6oP1Yw@mail.gmail.com>
Message-ID: <CACbeAXCJJsRKxKVMURzNThAF7G4tZBYv==PHD0fimS-_yXuVmw@mail.gmail.com>

Yes. Edward Yang has a wonderful series on how Haskell's (GHC's) runtime
works under the hood http://blog.ezyang.com/2011/04/the-haskell-heap/.


Cheers,
Danny Gratzer


On Tue, Feb 11, 2014 at 9:24 PM, Kyle Miller <kmill31415 at gmail.com> wrote:

> Please correct me if I'm wrong, but isn't Haskell secretly doing a set!
> when parts of an ADT are evaluated to memoize them?  In the vein of lazy
> lists, taking the tail of a list in Haskell would be one such example.
>
> I noticed this secret set! when I was learning about its garbage
> collector: I was surprised at first that objects in older generations could
> ever have pointers to objects in newer generations!
>
> Kyle
>
>
> On Tue, Feb 11, 2014 at 5:52 PM, Roman Cheplyaka <roma at ro-che.info> wrote:
>
>> Except Scheme is not pure ? they use set! to achieve memoisation.
>>
>> I don't think the OP bothers with memoisation in his/her encoding,
>> though.
>>
>> Roman
>>
>> * Kyle Marek-Spartz <kyle.marek.spartz at gmail.com> [2014-02-11
>> 15:54:34-0600]
>> > SICP comes to mind:
>> http://mitpress.mit.edu/sicp/full-text/sicp/book/node70.html
>> >
>> > --
>> > Kyle Marek-Spartz
>> >
>> > On February 11, 2014 at 3:47:09 PM, flicky frans (flickyfrans at gmail.com)
>> wrote:
>> > >
>> > > Hello. I am currently writing lists with lazy semantics in the
>> > > pure
>> > > lambda-calculus with call-by-value reduction strategy.
>> > > Here is an example: http://pastebin.com/SvQ5hCSD
>> > > Here is a simple interpetator: http://pastebin.com/mejCWqpu
>> > > Am I reinventing the wheel? Are there some sources, from where
>> > > i can
>> > > learn more about lazy evaluation in the strict languages?
>> > > _______________________________________________
>> > > Haskell-Cafe mailing list
>> > > Haskell-Cafe at haskell.org
>> > > http://www.haskell.org/mailman/listinfo/haskell-cafe
>> > >
>> >
>> > _______________________________________________
>> > Haskell-Cafe mailing list
>> > Haskell-Cafe at haskell.org
>> > http://www.haskell.org/mailman/listinfo/haskell-cafe
>>
>> _______________________________________________
>> Haskell-Cafe mailing list
>> Haskell-Cafe at haskell.org
>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>
>>
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140211/a27a17fe/attachment.html>

From jonathangfischoff at gmail.com  Wed Feb 12 04:51:38 2014
From: jonathangfischoff at gmail.com (Jonathan Fischoff)
Date: Tue, 11 Feb 2014 20:51:38 -0800
Subject: [Haskell-cafe] ANN: generic-maybe-0.3.0.2
Message-ID: <CABZ0FHGzfcicD4BBQ3SNL5r0Eq6E4q=JfZ76feP1S3wfr2j9KQ@mail.gmail.com>

generic-maybe utilizes GHC.Generics to generalize the functions of
Data.Maybe to arbitrary sum types with two constructors, with one "empty."

Here is a quick example:

?> :set -XDeriveGeneric
?> import GHC.Generics

?> data Result a = Success a | Fail deriving (Show, Generic)

?> fromMaybe 'a' Fail
'a'
?> fromMaybe 'a' $ Success 'b'
'b'

Additionally, it lets you convert between two representations:

?> convert (Just 'a') :: Result Char
 Success 'a'

Documentation on Hackage:
http://hackage.haskell.org/package/generic-maybe-0.3.0.2/docs/Data-Generics-Maybe.html

-Jonathan Fischoff
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140211/2c77898d/attachment.html>

From corentin.dupont at gmail.com  Wed Feb 12 16:44:17 2014
From: corentin.dupont at gmail.com (Corentin Dupont)
Date: Wed, 12 Feb 2014 17:44:17 +0100
Subject: [Haskell-cafe] manage effects in a DSL
In-Reply-To: <CAML5wvv-1aKAVkgBRvs-Ue7mxzaefGMnY5hvQdTP3gAnF_feEg@mail.gmail.com>
References: <20140129033404.76144.qmail@www1.g3.pair.com>
 <CAEyhvmqiJCc8vs-LHpT=CW20yGjhr5G3LMB86c+w38v+e5BELw@mail.gmail.com>
 <CAEyhvmrti3-4B0KvtdQKZPTh8foX=yg__W3AATjunRLAvaF6CA@mail.gmail.com>
 <CAEyhvmow1XbdLJv00iDVA4uBWEXmMGeLsVg1g6jpUCt2=d8CPQ@mail.gmail.com>
 <CALnXJiqhPoKEpJKszGf4EskbSVU1xh+MX=R2dBU4cGv4o+fxoQ@mail.gmail.com>
 <CAEyhvmr=s7xTk7DS3RgKzcJgCZf4u7OEiw7eCKsQ3AuDrYUwUw@mail.gmail.com>
 <CAEyhvmp0M5briL0e617++XH+djkvfHq78tDMhrz7ajWMwkYZ_Q@mail.gmail.com>
 <CAHfjoWmOfwDYHTDFhn2RmOT53SdV==+HGjTJYMgLeZ_2e3mfOw@mail.gmail.com>
 <CACN--9CDygTpySYJj5eLkwrCPLca_m_5xmyUkFOjLpNTxFUQ6g@mail.gmail.com>
 <CAML5wvujBXCnAAuP60Xmc0hk7+SPmsG=wgNzi+mnezp2cw+_eg@mail.gmail.com>
 <CAEyhvmpgbR6EeTMMXBGPq3X7NK8umV=9GLSgV-ETBauMpv5xfg@mail.gmail.com>
 <CAML5wvv-1aKAVkgBRvs-Ue7mxzaefGMnY5hvQdTP3gAnF_feEg@mail.gmail.com>
Message-ID: <CAEyhvmp1g_0yWR8q4h-Yr-vwVqjrETbo590=0b4KogLiWr1h1A@mail.gmail.com>

Hi guys,
so I tried to implement fully the proposition (see below).
It works well. However I find it a bit redundant. Can we reduce the
repetitions?
Perhaps I didn't understand how to write the evaluation...


{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE TypeSynonymInstances #-}
{-# LANGUAGE FlexibleInstances #-}
module Main where

import Control.Monad.State
import Control.Monad.Reader

class Monad m => Nomex m where
  readAccount :: m Int

class Nomex m => NomexEffect m where
  writeAccount :: Int -> m ()
  setVictory   :: (forall n. Nomex n => n Bool) -> m ()

data Exp a where
   ReadAccount  :: Exp Int
   WriteAccount :: Int -> Exp ()
   SetVictory   :: (forall m. Nomex m => m Bool) -> Exp ()
   Bind         :: Exp a -> (a -> Exp b) -> Exp b
   Return       :: a -> Exp a

instance Monad Exp where
   return = Return
   (>>=) = Bind

instance Nomex Exp where
  readAccount = ReadAccount

instance NomexEffect Exp where
  writeAccount = WriteAccount
  setVictory   = SetVictory

data Game = Game { victory :: (forall m. Nomex m => m Bool)
                 , account :: Int
                 }

instance Nomex (State Game) where
  readAccount = gets account

instance NomexEffect (State Game) where
  writeAccount n = modify $ \game -> game { account = n }
  setVictory   v = modify $ \game -> game { victory = v }

instance Nomex (Reader Game) where
  readAccount = asks account

evaluate :: Exp a -> State Game a
evaluate (WriteAccount i) = writeAccount i
evaluate ReadAccount = readAccount
evaluate (SetVictory v) = setVictory v
evaluate (Return a) = return a
evaluate (Bind a f) = (evaluate a) >>= evaluate . f

evalNoEff :: Exp a -> Reader Game a
evalNoEff ReadAccount = readAccount
evalNoEff (Return a) = return a
evalNoEff (Bind a f) = (evalNoEff a) >>= evalNoEff . f

isVictory :: Game -> Bool
isVictory g = runReader (evalNoEff (victory g)) g

incrAccount :: NomexEffect m => m ()
incrAccount = readAccount >>= writeAccount . (+101)

winOnBigMoney :: NomexEffect m => m ()
winOnBigMoney = setVictory $ do
   i <- readAccount
   --writeAccount 100
   return (i > 100)

play = do
   winOnBigMoney
   incrAccount

initGame = Game (return False) 0

main = do
   let g = execState (evaluate jeu) initGame
   putStrLn $ show $ isVictory g



On Mon, Feb 10, 2014 at 11:33 AM, Dominique Devriese <
dominique.devriese at cs.kuleuven.be> wrote:

> Corentin,
>
> 2014-02-10 10:48 GMT+01:00 Corentin Dupont <corentin.dupont at gmail.com>:
> > That is really interesting. In fact, I didn't have the time to experiment
> > with it, but I definitely want to (have to find some spare time!).
> > I must say I am less used to type classes.
> > At first, my concern with the technique was that two things that belong
> > together, "ReadAccount" and "WriteAccount", are separated.
>
> Yes, this separation of ReadAccount and WriteAccount into Nomex vs
> NomexEffect is how the two parts (read-only vs read-write) of the DSL
> are distinguished in this approach..
>
> > I was also confused that the evaluator is wrapped in a newtype, and that
> it
> > is an instance of Nomex.
>
> That is non-essential.  You can also use
>
>   instance Nomex (State Game) where
>
> but it's just cleaner with a newtype...
>
> > Beside, I suppose it is possible to factorize EvalNoEffect with Eval?
> Maybe
> > using liftEval anyway...
>
> If I understand correctly, you're asking about how to remove the
> duplication between EvalNoEffect and Eval?
>
> This is a very good question.  My answer is basically that Haskell is
> missing some type-class-related features to allow for the perfect
> solution, specifically a form of local instances.
>
> The long story is that instead of the above instances of Nomex and
> NomexEffect for Eval and EvalNoEffect separately, we would like to be
> able to write the following instances:
>
>   instance MonadReader Game m => Nomex m where
>     readAccount = asks account
>
>   instance (MonadReader Game m, MonadState Game m) => NomexEffect m where
>     writeAccount n = modify $ \game -> game { account = n }
>     setVictory   v = modify $ \game -> game { victory = v }
>
> and then we can declare
>   newtype Eval a = Eval { eval :: State Game a }
>                  deriving (Monad, MonadState Game, MonadReader Game)
>
>   newtype EvalNoEffect a = EvalNoEffect { evalNoEffect :: Reader Game a }
>                          deriving (Monad, MonadReader Game)
>
> and reuse the single implementation of Nomex for both Eval and
> EvalNoEffect.  However, there are various problems with this solution:
>
> * the instances are not permitted without UndecidableInstances (which
> I recommend against),
> * the derivation of MonadReader from State won't work because
> MonadReader is not treated as a superclass of MonadState in Haskell,
> despite the fact that functionality-wise it is.
>
> What is needed to solve these problems is a feature that is in my
> opinion strongly missing in Haskell: a form of local instances.  This
> means that we would be able to explicitly specify what implementation
> of a certain type class should be used to satisfy a certain type class
> constraint, e.g.
>
>   sort :: Ord a => [a] -> [a]
>   sortBy :: forall a. (a -> a -> Bool) -> [a] -> [a]
>   sortBy f = let instance ordDict :: Ord.Dict a
>                                         ordDict = constructOrdDict f
>                    in sort :: Ord a => [a] -> [a]
>
> Local instances were already considered by Wadler when he proposed
> type classes, but they are problematic to combine with type inference.
>  However, it seems likely that this is not an issue if we require
> sufficiently informative type annotations.
>
> For the problem above, this would allow to construct, use and lift
> (together with newtype coercions) a MonadReader dictionary for the
> State monad without necessarily having it derived automatically if
> this is not desired.  Also, this would allow to write the undecidable
> instances as normal functions that need to be explicitly invoked
> instead of inferred by type inference, avoiding the
> UndecidableInstances problem.
>
> Regards
> Dominique
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140212/d9514ca4/attachment.html>

From erik.dominikus71 at gmail.com  Wed Feb 12 18:16:39 2014
From: erik.dominikus71 at gmail.com (Erik Dominikus)
Date: Thu, 13 Feb 2014 01:16:39 +0700
Subject: [Haskell-cafe] Lisp Style Restarts in Haskell
In-Reply-To: <52F90D62.20308@frigidcode.com>
References: <52F90D62.20308@frigidcode.com>
Message-ID: <CAOopUj=w0iSWXWRjNVcN+kSV6o=tnnYBMQrP5V8PrEqbEeWuUg@mail.gmail.com>

How about the Control.Retry module in the 'retry' package?

http://hackage.haskell.org/package/retry
On Feb 11, 2014 12:51 AM, "Christopher Howard" <
christopher.howard at frigidcode.com> wrote:

> Hi. I was curious if Haskell has something like "restarts" in Common
> Lisp. My search engines didn't give relevant results for "Haskell
> restarts". However, there were several results for "Haskell coroutines"
> and, from what I can gather, restarts and coroutines are a similar or
> related subject.
>
> --
> http://www.lugod.org/presentations/pgp/why.html
>
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140213/1b1f5c58/attachment.html>

From chrisyco+haskell-cafe at gmail.com  Wed Feb 12 21:08:30 2014
From: chrisyco+haskell-cafe at gmail.com (Chris Wong)
Date: Thu, 13 Feb 2014 10:08:30 +1300
Subject: [Haskell-cafe] manage effects in a DSL
In-Reply-To: <CAEyhvmp1g_0yWR8q4h-Yr-vwVqjrETbo590=0b4KogLiWr1h1A@mail.gmail.com>
References: <20140129033404.76144.qmail@www1.g3.pair.com>
 <CAEyhvmqiJCc8vs-LHpT=CW20yGjhr5G3LMB86c+w38v+e5BELw@mail.gmail.com>
 <CAEyhvmrti3-4B0KvtdQKZPTh8foX=yg__W3AATjunRLAvaF6CA@mail.gmail.com>
 <CAEyhvmow1XbdLJv00iDVA4uBWEXmMGeLsVg1g6jpUCt2=d8CPQ@mail.gmail.com>
 <CALnXJiqhPoKEpJKszGf4EskbSVU1xh+MX=R2dBU4cGv4o+fxoQ@mail.gmail.com>
 <CAEyhvmr=s7xTk7DS3RgKzcJgCZf4u7OEiw7eCKsQ3AuDrYUwUw@mail.gmail.com>
 <CAEyhvmp0M5briL0e617++XH+djkvfHq78tDMhrz7ajWMwkYZ_Q@mail.gmail.com>
 <CAHfjoWmOfwDYHTDFhn2RmOT53SdV==+HGjTJYMgLeZ_2e3mfOw@mail.gmail.com>
 <CACN--9CDygTpySYJj5eLkwrCPLca_m_5xmyUkFOjLpNTxFUQ6g@mail.gmail.com>
 <CAML5wvujBXCnAAuP60Xmc0hk7+SPmsG=wgNzi+mnezp2cw+_eg@mail.gmail.com>
 <CAEyhvmpgbR6EeTMMXBGPq3X7NK8umV=9GLSgV-ETBauMpv5xfg@mail.gmail.com>
 <CAML5wvv-1aKAVkgBRvs-Ue7mxzaefGMnY5hvQdTP3gAnF_feEg@mail.gmail.com>
 <CAEyhvmp1g_0yWR8q4h-Yr-vwVqjrETbo590=0b4KogLiWr1h1A@mail.gmail.com>
Message-ID: <CA+qNEzL1skuvcET==xYQOAZcy+fcyqkZ-hL=s1mh3Kj2kySNkA@mail.gmail.com>

Hi Corentin,

If I read this correctly, once we have the type class representation,
we no longer need the GADT.

Try removing Exp, evaluate, and evalNoEff, and just use the procedures directly.

On Thu, Feb 13, 2014 at 5:44 AM, Corentin Dupont
<corentin.dupont at gmail.com> wrote:
>
> Hi guys,
> so I tried to implement fully the proposition (see below).
> It works well. However I find it a bit redundant. Can we reduce the
> repetitions?
> Perhaps I didn't understand how to write the evaluation...
>
>
> {-# LANGUAGE RankNTypes #-}
> {-# LANGUAGE GeneralizedNewtypeDeriving #-}
> {-# LANGUAGE GADTs #-}
> {-# LANGUAGE TypeSynonymInstances #-}
> {-# LANGUAGE FlexibleInstances #-}
> module Main where
>
> import Control.Monad.State
> import Control.Monad.Reader
>
> class Monad m => Nomex m where
>   readAccount :: m Int
>
> class Nomex m => NomexEffect m where
>   writeAccount :: Int -> m ()
>   setVictory   :: (forall n. Nomex n => n Bool) -> m ()
>
> data Exp a where
>    ReadAccount  :: Exp Int
>    WriteAccount :: Int -> Exp ()
>    SetVictory   :: (forall m. Nomex m => m Bool) -> Exp ()
>    Bind         :: Exp a -> (a -> Exp b) -> Exp b
>    Return       :: a -> Exp a
>
> instance Monad Exp where
>    return = Return
>    (>>=) = Bind
>
> instance Nomex Exp where
>   readAccount = ReadAccount
>
> instance NomexEffect Exp where
>   writeAccount = WriteAccount
>   setVictory   = SetVictory
>
> data Game = Game { victory :: (forall m. Nomex m => m Bool)
>                  , account :: Int
>                  }
>
> instance Nomex (State Game) where
>   readAccount = gets account
>
> instance NomexEffect (State Game) where
>   writeAccount n = modify $ \game -> game { account = n }
>   setVictory   v = modify $ \game -> game { victory = v }
>
> instance Nomex (Reader Game) where
>   readAccount = asks account
>
> evaluate :: Exp a -> State Game a
> evaluate (WriteAccount i) = writeAccount i
> evaluate ReadAccount = readAccount
> evaluate (SetVictory v) = setVictory v
> evaluate (Return a) = return a
> evaluate (Bind a f) = (evaluate a) >>= evaluate . f
>
> evalNoEff :: Exp a -> Reader Game a
> evalNoEff ReadAccount = readAccount
> evalNoEff (Return a) = return a
> evalNoEff (Bind a f) = (evalNoEff a) >>= evalNoEff . f
>
> isVictory :: Game -> Bool
> isVictory g = runReader (evalNoEff (victory g)) g
>
> incrAccount :: NomexEffect m => m ()
> incrAccount = readAccount >>= writeAccount . (+101)
>
> winOnBigMoney :: NomexEffect m => m ()
> winOnBigMoney = setVictory $ do
>    i <- readAccount
>    --writeAccount 100
>    return (i > 100)
>
> play = do
>    winOnBigMoney
>    incrAccount
>
> initGame = Game (return False) 0
>
> main = do
>    let g = execState (evaluate jeu) initGame
>    putStrLn $ show $ isVictory g
>
>
>
> On Mon, Feb 10, 2014 at 11:33 AM, Dominique Devriese
> <dominique.devriese at cs.kuleuven.be> wrote:
>>
>> Corentin,
>>
>> 2014-02-10 10:48 GMT+01:00 Corentin Dupont <corentin.dupont at gmail.com>:
>> > That is really interesting. In fact, I didn't have the time to
>> > experiment
>> > with it, but I definitely want to (have to find some spare time!).
>> > I must say I am less used to type classes.
>> > At first, my concern with the technique was that two things that belong
>> > together, "ReadAccount" and "WriteAccount", are separated.
>>
>> Yes, this separation of ReadAccount and WriteAccount into Nomex vs
>> NomexEffect is how the two parts (read-only vs read-write) of the DSL
>> are distinguished in this approach..
>>
>> > I was also confused that the evaluator is wrapped in a newtype, and that
>> > it
>> > is an instance of Nomex.
>>
>> That is non-essential.  You can also use
>>
>>   instance Nomex (State Game) where
>>
>> but it's just cleaner with a newtype...
>>
>> > Beside, I suppose it is possible to factorize EvalNoEffect with Eval?
>> > Maybe
>> > using liftEval anyway...
>>
>> If I understand correctly, you're asking about how to remove the
>> duplication between EvalNoEffect and Eval?
>>
>> This is a very good question.  My answer is basically that Haskell is
>> missing some type-class-related features to allow for the perfect
>> solution, specifically a form of local instances.
>>
>> The long story is that instead of the above instances of Nomex and
>> NomexEffect for Eval and EvalNoEffect separately, we would like to be
>> able to write the following instances:
>>
>>   instance MonadReader Game m => Nomex m where
>>     readAccount = asks account
>>
>>   instance (MonadReader Game m, MonadState Game m) => NomexEffect m where
>>     writeAccount n = modify $ \game -> game { account = n }
>>     setVictory   v = modify $ \game -> game { victory = v }
>>
>> and then we can declare
>>   newtype Eval a = Eval { eval :: State Game a }
>>                  deriving (Monad, MonadState Game, MonadReader Game)
>>
>>   newtype EvalNoEffect a = EvalNoEffect { evalNoEffect :: Reader Game a }
>>                          deriving (Monad, MonadReader Game)
>>
>> and reuse the single implementation of Nomex for both Eval and
>> EvalNoEffect.  However, there are various problems with this solution:
>>
>> * the instances are not permitted without UndecidableInstances (which
>> I recommend against),
>> * the derivation of MonadReader from State won't work because
>> MonadReader is not treated as a superclass of MonadState in Haskell,
>> despite the fact that functionality-wise it is.
>>
>> What is needed to solve these problems is a feature that is in my
>> opinion strongly missing in Haskell: a form of local instances.  This
>> means that we would be able to explicitly specify what implementation
>> of a certain type class should be used to satisfy a certain type class
>> constraint, e.g.
>>
>>   sort :: Ord a => [a] -> [a]
>>   sortBy :: forall a. (a -> a -> Bool) -> [a] -> [a]
>>   sortBy f = let instance ordDict :: Ord.Dict a
>>                                         ordDict = constructOrdDict f
>>                    in sort :: Ord a => [a] -> [a]
>>
>> Local instances were already considered by Wadler when he proposed
>> type classes, but they are problematic to combine with type inference.
>>  However, it seems likely that this is not an issue if we require
>> sufficiently informative type annotations.
>>
>> For the problem above, this would allow to construct, use and lift
>> (together with newtype coercions) a MonadReader dictionary for the
>> State monad without necessarily having it derived automatically if
>> this is not desired.  Also, this would allow to write the undecidable
>> instances as normal functions that need to be explicitly invoked
>> instead of inferred by type inference, avoiding the
>> UndecidableInstances problem.
>>
>> Regards
>> Dominique
>
>
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>



-- 
Chris Wong, fixpoint conjurer
  e: lambda.fairy at gmail.com
  w: http://lfairy.github.io

From hjgtuyl at chello.nl  Wed Feb 12 22:17:07 2014
From: hjgtuyl at chello.nl (Henk-Jan van Tuyl)
Date: Wed, 12 Feb 2014 23:17:07 +0100
Subject: [Haskell-cafe] Lisp Style Restarts in Haskell
In-Reply-To: <CAOopUj=w0iSWXWRjNVcN+kSV6o=tnnYBMQrP5V8PrEqbEeWuUg@mail.gmail.com>
References: <52F90D62.20308@frigidcode.com>
 <CAOopUj=w0iSWXWRjNVcN+kSV6o=tnnYBMQrP5V8PrEqbEeWuUg@mail.gmail.com>
Message-ID: <op.xa6v6to2pz0j5l@zen5.arnhem.chello.nl>


Or Control.Exception in the base package?

On Wed, 12 Feb 2014 19:16:39 +0100, Erik Dominikus  
<erik.dominikus71 at gmail.com> wrote:

> How about the Control.Retry module in the 'retry' package?
>
> http://hackage.haskell.org/package/retry
> On Feb 11, 2014 12:51 AM, "Christopher Howard" <
> christopher.howard at frigidcode.com> wrote:
>
>> Hi. I was curious if Haskell has something like "restarts" in Common
>> Lisp. My search engines didn't give relevant results for "Haskell
>> restarts". However, there were several results for "Haskell coroutines"
>> and, from what I can gather, restarts and coroutines are a similar or
>> related subject.
>>


Regards,
Henk-Jan van Tuyl


-- 
Folding at 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
--

From ky3 at atamo.com  Wed Feb 12 22:58:29 2014
From: ky3 at atamo.com (Kim-Ee Yeoh)
Date: Thu, 13 Feb 2014 05:58:29 +0700
Subject: [Haskell-cafe] Lisp Style Restarts in Haskell
In-Reply-To: <52F90D62.20308@frigidcode.com>
References: <52F90D62.20308@frigidcode.com>
Message-ID: <CAPY+ZdRBCEathhr8RZaC5eUktDiWdR+x9McUDb-mh4Etfy_2mw@mail.gmail.com>

On Tue, Feb 11, 2014 at 12:33 AM, Christopher Howard <
christopher.howard at frigidcode.com> wrote:

> I was curious if Haskell has something like "restarts" in Common
> Lisp. My search engines didn't give relevant results for "Haskell
> restarts".
>

Searching "lisp style restarts" brings up this Haskell-relevant link:

http://lambda-the-ultimate.org/node/1544

-- Kim-Ee
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140213/da03b0c4/attachment.html>

From jake.mcarthur at gmail.com  Wed Feb 12 23:44:46 2014
From: jake.mcarthur at gmail.com (Jake McArthur)
Date: Wed, 12 Feb 2014 18:44:46 -0500
Subject: [Haskell-cafe] manage effects in a DSL
In-Reply-To: <CAEyhvmp1g_0yWR8q4h-Yr-vwVqjrETbo590=0b4KogLiWr1h1A@mail.gmail.com>
References: <20140129033404.76144.qmail@www1.g3.pair.com>
 <CAEyhvmqiJCc8vs-LHpT=CW20yGjhr5G3LMB86c+w38v+e5BELw@mail.gmail.com>
 <CAEyhvmrti3-4B0KvtdQKZPTh8foX=yg__W3AATjunRLAvaF6CA@mail.gmail.com>
 <CAEyhvmow1XbdLJv00iDVA4uBWEXmMGeLsVg1g6jpUCt2=d8CPQ@mail.gmail.com>
 <CALnXJiqhPoKEpJKszGf4EskbSVU1xh+MX=R2dBU4cGv4o+fxoQ@mail.gmail.com>
 <CAEyhvmr=s7xTk7DS3RgKzcJgCZf4u7OEiw7eCKsQ3AuDrYUwUw@mail.gmail.com>
 <CAEyhvmp0M5briL0e617++XH+djkvfHq78tDMhrz7ajWMwkYZ_Q@mail.gmail.com>
 <CAHfjoWmOfwDYHTDFhn2RmOT53SdV==+HGjTJYMgLeZ_2e3mfOw@mail.gmail.com>
 <CACN--9CDygTpySYJj5eLkwrCPLca_m_5xmyUkFOjLpNTxFUQ6g@mail.gmail.com>
 <CAML5wvujBXCnAAuP60Xmc0hk7+SPmsG=wgNzi+mnezp2cw+_eg@mail.gmail.com>
 <CAEyhvmpgbR6EeTMMXBGPq3X7NK8umV=9GLSgV-ETBauMpv5xfg@mail.gmail.com>
 <CAML5wvv-1aKAVkgBRvs-Ue7mxzaefGMnY5hvQdTP3gAnF_feEg@mail.gmail.com>
 <CAEyhvmp1g_0yWR8q4h-Yr-vwVqjrETbo590=0b4KogLiWr1h1A@mail.gmail.com>
Message-ID: <CACN--9A0o_Ce8R44bUPaF2h-=3quNhUF4H-Jt14OwxqWLDYPiw@mail.gmail.com>

As Chris says, you no longer need the GADT at all.

{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE FlexibleInstances #-}

import Control.Monad.Identity
import Control.Monad.State
import Control.Monad.Reader

class Monad m => Nomex m where
  readAccount :: m Int

class Nomex m => NomexEffect m where
  writeAccount :: Int -> m ()
  setVictory   :: (forall n. Nomex n => n Bool) -> m ()


data Game = Game { victory :: (forall m. Nomex m => m Bool)
                 , account :: Int
                 }

instance Nomex (State Game) where
  readAccount = gets account

instance NomexEffect (State Game) where

  writeAccount n = modify $ \game -> game { account = n }
  setVictory   v = modify $ \game -> game { victory = v }

instance Nomex (Reader Game) where
  readAccount = asks account

isVictory :: Game -> Bool
isVictory = join (runReader . victory)

incrAccount :: NomexEffect m => m ()
incrAccount = readAccount >>= writeAccount . (+101)

winOnBigMoney :: NomexEffect m => m ()
winOnBigMoney = setVictory $ do
   i <- readAccount
   --writeAccount 100
   return (i > 100)

play :: StateT Game Identity ()
play = do
   winOnBigMoney
   incrAccount

initGame :: Game
initGame = Game (return False) 0

main :: IO ()
main = do
   let g = execState play initGame
   putStrLn $ show $ isVictory g



On Wed, Feb 12, 2014 at 11:44 AM, Corentin Dupont <corentin.dupont at gmail.com
> wrote:

>
> Hi guys,
> so I tried to implement fully the proposition (see below).
> It works well. However I find it a bit redundant. Can we reduce the
> repetitions?
> Perhaps I didn't understand how to write the evaluation...
>
>
> {-# LANGUAGE RankNTypes #-}
> {-# LANGUAGE GeneralizedNewtypeDeriving #-}
> {-# LANGUAGE GADTs #-}
> {-# LANGUAGE TypeSynonymInstances #-}
> {-# LANGUAGE FlexibleInstances #-}
> module Main where
>
>
> import Control.Monad.State
> import Control.Monad.Reader
>
> class Monad m => Nomex m where
>   readAccount :: m Int
>
> class Nomex m => NomexEffect m where
>   writeAccount :: Int -> m ()
>   setVictory   :: (forall n. Nomex n => n Bool) -> m ()
>
>
> data Exp a where
>    ReadAccount  :: Exp Int
>    WriteAccount :: Int -> Exp ()
>    SetVictory   :: (forall m. Nomex m => m Bool) -> Exp ()
>    Bind         :: Exp a -> (a -> Exp b) -> Exp b
>
>    Return       :: a -> Exp a
>
> instance Monad Exp where
>
>    return = Return
>    (>>=) = Bind
>
> instance Nomex Exp where
>   readAccount = ReadAccount
>
> instance NomexEffect Exp where
>   writeAccount = WriteAccount
>   setVictory   = SetVictory
>
>
> data Game = Game { victory :: (forall m. Nomex m => m Bool)
>                  , account :: Int
>                  }
>
> instance Nomex (State Game) where
>   readAccount = gets account
>
> instance NomexEffect (State Game) where
>
>   writeAccount n = modify $ \game -> game { account = n }
>   setVictory   v = modify $ \game -> game { victory = v }
>
> instance Nomex (Reader Game) where
>   readAccount = asks account
>
> evaluate :: Exp a -> State Game a
> evaluate (WriteAccount i) = writeAccount i
> evaluate ReadAccount = readAccount
> evaluate (SetVictory v) = setVictory v
> evaluate (Return a) = return a
> evaluate (Bind a f) = (evaluate a) >>= evaluate . f
>
> evalNoEff :: Exp a -> Reader Game a
> evalNoEff ReadAccount = readAccount
> evalNoEff (Return a) = return a
> evalNoEff (Bind a f) = (evalNoEff a) >>= evalNoEff . f
>
> isVictory :: Game -> Bool
> isVictory g = runReader (evalNoEff (victory g)) g
>
> incrAccount :: NomexEffect m => m ()
> incrAccount = readAccount >>= writeAccount . (+101)
>
> winOnBigMoney :: NomexEffect m => m ()
> winOnBigMoney = setVictory $ do
>    i <- readAccount
>    --writeAccount 100
>    return (i > 100)
>
> play = do
>    winOnBigMoney
>    incrAccount
>
> initGame = Game (return False) 0
>
> main = do
>    let g = execState (evaluate jeu) initGame
>    putStrLn $ show $ isVictory g
>
>
>
> On Mon, Feb 10, 2014 at 11:33 AM, Dominique Devriese <
> dominique.devriese at cs.kuleuven.be> wrote:
>
>> Corentin,
>>
>> 2014-02-10 10:48 GMT+01:00 Corentin Dupont <corentin.dupont at gmail.com>:
>> > That is really interesting. In fact, I didn't have the time to
>> experiment
>> > with it, but I definitely want to (have to find some spare time!).
>> > I must say I am less used to type classes.
>> > At first, my concern with the technique was that two things that belong
>> > together, "ReadAccount" and "WriteAccount", are separated.
>>
>> Yes, this separation of ReadAccount and WriteAccount into Nomex vs
>> NomexEffect is how the two parts (read-only vs read-write) of the DSL
>> are distinguished in this approach..
>>
>> > I was also confused that the evaluator is wrapped in a newtype, and
>> that it
>> > is an instance of Nomex.
>>
>> That is non-essential.  You can also use
>>
>>   instance Nomex (State Game) where
>>
>> but it's just cleaner with a newtype...
>>
>> > Beside, I suppose it is possible to factorize EvalNoEffect with Eval?
>> Maybe
>> > using liftEval anyway...
>>
>> If I understand correctly, you're asking about how to remove the
>> duplication between EvalNoEffect and Eval?
>>
>> This is a very good question.  My answer is basically that Haskell is
>> missing some type-class-related features to allow for the perfect
>> solution, specifically a form of local instances.
>>
>> The long story is that instead of the above instances of Nomex and
>> NomexEffect for Eval and EvalNoEffect separately, we would like to be
>> able to write the following instances:
>>
>>   instance MonadReader Game m => Nomex m where
>>     readAccount = asks account
>>
>>   instance (MonadReader Game m, MonadState Game m) => NomexEffect m where
>>     writeAccount n = modify $ \game -> game { account = n }
>>     setVictory   v = modify $ \game -> game { victory = v }
>>
>> and then we can declare
>>   newtype Eval a = Eval { eval :: State Game a }
>>                  deriving (Monad, MonadState Game, MonadReader Game)
>>
>>   newtype EvalNoEffect a = EvalNoEffect { evalNoEffect :: Reader Game a }
>>                          deriving (Monad, MonadReader Game)
>>
>> and reuse the single implementation of Nomex for both Eval and
>> EvalNoEffect.  However, there are various problems with this solution:
>>
>> * the instances are not permitted without UndecidableInstances (which
>> I recommend against),
>> * the derivation of MonadReader from State won't work because
>> MonadReader is not treated as a superclass of MonadState in Haskell,
>> despite the fact that functionality-wise it is.
>>
>> What is needed to solve these problems is a feature that is in my
>> opinion strongly missing in Haskell: a form of local instances.  This
>> means that we would be able to explicitly specify what implementation
>> of a certain type class should be used to satisfy a certain type class
>> constraint, e.g.
>>
>>   sort :: Ord a => [a] -> [a]
>>   sortBy :: forall a. (a -> a -> Bool) -> [a] -> [a]
>>   sortBy f = let instance ordDict :: Ord.Dict a
>>                                         ordDict = constructOrdDict f
>>                    in sort :: Ord a => [a] -> [a]
>>
>> Local instances were already considered by Wadler when he proposed
>> type classes, but they are problematic to combine with type inference.
>>  However, it seems likely that this is not an issue if we require
>> sufficiently informative type annotations.
>>
>> For the problem above, this would allow to construct, use and lift
>> (together with newtype coercions) a MonadReader dictionary for the
>> State monad without necessarily having it derived automatically if
>> this is not desired.  Also, this would allow to write the undecidable
>> instances as normal functions that need to be explicitly invoked
>> instead of inferred by type inference, avoiding the
>> UndecidableInstances problem.
>>
>> Regards
>> Dominique
>>
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140212/78360d97/attachment.html>

From oleg at okmij.org  Thu Feb 13 07:28:25 2014
From: oleg at okmij.org (oleg at okmij.org)
Date: 13 Feb 2014 07:28:25 -0000
Subject: [Haskell-cafe] manage effects in a DSL
In-Reply-To: <CAEyhvmow1XbdLJv00iDVA4uBWEXmMGeLsVg1g6jpUCt2=d8CPQ@mail.gmail.com>
Message-ID: <20140213072825.96930.qmail@www1.g3.pair.com>


Sorry for the very late and probably no longer relevant reply. 

> Building up on the exemple below, I have a problem with mixing
> effectful/effectless computations. For example, this would not compile:
>
> > noEff :: Exp NoEffect ()
> > noEff = return ()
>
> > hasEffect :: Exp Effect ()
> > hasEffect = do
> >   noEff                    <--- won't compile
> >   return ()
>
> But it should: you should be able to run an effectless monad in an
> effectful one.  How to encode this semantic?

This is a very, very common problem. We have an expression e of type
T1, and we want to use it in the context that requires the type T2 (e.g.,
we want to pass 'e' to a function whose argument type is T2). We feel
that we ought to be able to do that. One example is the one you
cited: a computation that performs no effect can be regarded as a
computation that _may_ perform an effect, and so we should be able to
use a non-effectful expression in an effectful context. Another
example is numerics: natural numbers are subset of rationals; so it
should be morally OK to use a natural number where a rational is
required.

There are two ways of solving this problem. One is polymorphism,
another is subtyping. In the first approach, we define noEff above
with the polymorphic type:

> noEff :: forall r. Exp r ()
> noEff = return ()

This says that noEff can be used either in NoEffect or Effect
contexts.  Polymorphic terms can be regarded as `macros', at least
conceptually, -- sort of as an abbreviation for the family of definitions

noEff_1 :: Exp NoEffect ()
noEff_1 = return ()

noEff_2 :: Exp Effect ()
noEff_2 = return ()

When you use noEff in the program, the compiler chooses either noEff_1 or
noEff_2 depending on the type required by the context. (GHC actually
does that in some circumstances).

Subtyping means defining a (partial) order among types T2 >= T1
and adding a subsumption rule to the type system

        e :: T1  T2 >= T1
        -----------------
        e :: T2

That is, if e has type T1 and T2 is at least as great, e can be given
the type T2. Such a rule is very common in various object systems. Since
we can't add new rules into the Haskell type system, we have to use a
work-around, the explicit coercion. We introduce a function
        coerce :: T1 -> T2
(often an identity), which is a proof that it is really
OK to use (e::T1) at the type T2. We have to explicitly write this
coercion function:

> hasEffect :: Exp Effect ()
> hasEffect = do
>   coerceEff noEff
>   return ()

We are all familiar with this approach, explicitly writing 'return 1'
to, say, return an integer result from a monadic function. Here, return
is the explicit coercion, from 1::Int (the pure expression) to m Int
(the potentially effectful expression).

Other familiar example is newtype:
        newtype Speed = Speed{unSpeed :: Float}
Then expressions (Speed 1.0) or (unSpeed x) / 10.0 etc. are all
examples of explicit coercions (which are operationally identity).
[Here were do want the coercions to be explicit, at least the
Float->Speed coercion. The other could be implicit.]

Haskell uses this approach for numeric literals. When we want to
use an integer 1 where a rational number is required, we have to write
fromInteger 1. Here fromInteger being the explicit coercion.

Only we don't have to write 'fromInteger' because GHC inserts it
implicitly. The latter example makes too points: explicit coercions
are cumbersome to write and we'd rather had them out of sight. The
second point is that the coercion is not a single function, but an
overloaded function (e.g., return fromInteger). The coercions return
and fromInteger are also not operationally identity, which actually do
something at run-time.

Let's go back to our example and change it to be more interesting,
splitting Effect into Read and Write effects, with the order
NoEffect < ReadEff < WriteEff. To witness the order, we define

class Coerce t1 t2 where coerce :: Exp t1 a -> Exp t2 a

instance Coerce NoEffect   ReadEff where ...
instance Coerce NoEffect   WriteEff where ...
instance Coerce ReadEffect WriteEff where ...

so that we can define 

> noEff :: Exp NoEffect ()
> noEff = return ()

and write (coerce noEff) if we want to use noEff in effectful
situations. We observe that if we make Coerce reflexive, that is, add

instance Coerce NoEffect NoEffect where coerce = id
...

then we can write (coerce noEff) all the time. And if we do
that, why not to fuse coerce into the definition of noEff:

> noEff :: Coerce Noeff r => Exp r ()
> noEff = coerce (return ())

We come the full circle to polymorphism -- although generally bounded
polymorphism. (In noEff example above we can drop the Coerce
constraint since Noeff can be coerced to any other effect. Not so for
ReadEffect).


> > data Exp :: Eff -> * -> * where
> >   ReadAccount  :: Exp NoEffect Int      --ReadAccount has no effect
> >   Bind         :: Effects m n r => Exp m a -> (a -> Exp n b) -> Exp r b
> >  ...
> > hasEffect :: Exp Effect ()
> > hasEffect = ReadAccount >> (returnM () :: Exp Effect ())

> This is working more or less, however I am obliged to put the type
> signature on the returnM (last line): why?

This is the infamous read-show problem. See for example
http://book.realworldhaskell.org/read/using-typeclasses.html#typeclasses.wellknown.read

> eval :: Nomex r a -> State Game a
> eval a at ReadAccount    = liftEval $ evalNoEffect a
> eval (WriteAccount a) = modify (\g -> g{account = a})
> eval (SetVictory v)   = modify (\g -> g{victory = v})
> eval a@(Return _)     = liftEval $ evalNoEffect a
> eval (Bind exp f)     = eval exp >>= eval . f

This is a common pitfall. We should write

> eval :: Nomex r a -> State Game a
> eval ReadAccount    = liftEval $ evalNoEffect ReadAccount
> eval (Return x)     = liftEval $ evalNoEffect (Return x)
> ...

It seems like a boilerplate: why do we have to write the same
'ReadAccount' on the left hand side and on the right-hand side (ditto
for Return x). Can't we just share, like in the original code? The
answer is no: The ReadAccount on the left hand side of the eval
equation is different from ReadAccount on the right-hand side.
They are spelled the same, but their types differ. On the
left-hand-side, ReadAccount :: Nomex Effect (), but on the right-hand
side, ReadAccount :: Nomex Effect (). This is a frequent problem with
constants like [] which may have more than one type.



From drowland at lincoln.ac.uk  Thu Feb 13 08:29:31 2014
From: drowland at lincoln.ac.uk (Duncan Rowland)
Date: Thu, 13 Feb 2014 08:29:31 +0000
Subject: [Haskell-cafe] ghci in gallery
Message-ID: <CAKfy0KD9h26rGK-z+sfVGP3QJNR9KuAqH_Fqe1J843bSymJtxA@mail.gmail.com>

Dear All,

   new to haskell, so this might be obvious, but...

   I'm setting up a gallery installation (OSX) that exposes a command
line haskell to the visitors.
   The process is run with user 'nobody', so hopefully that will be a
bit safer, i.e.

cat visitor_commands_pipe | sudo -u nobody ghci -XOverloadedStrings

   But how question are:
      1) what sort of damage could a malicious user do to my system by
entering commands into the pipe?
      2) what should I do to protect my system? I can filter the user
commands as I like, but I do not want to run 'in a webpage'.

   Thanks in advance,
      -Duncan.

From haskell at ibotty.net  Thu Feb 13 09:01:32 2014
From: haskell at ibotty.net (Tobias Florek)
Date: Thu, 13 Feb 2014 10:01:32 +0100
Subject: [Haskell-cafe] ghci in gallery
In-Reply-To: <CAKfy0KD9h26rGK-z+sfVGP3QJNR9KuAqH_Fqe1J843bSymJtxA@mail.gmail.com>
References: <CAKfy0KD9h26rGK-z+sfVGP3QJNR9KuAqH_Fqe1J843bSymJtxA@mail.gmail.com>
Message-ID: <52FC89EC.2020008@ibotty.net>

hi,

>    The process is run with user 'nobody', so hopefully that will be a
> bit safer, i.e.

a bit, yes. apart from breaking out of the account (and becoming root)
via os vulnerabilities the user can send any network traffic they like,
which might or might not be ok. also there might be any number of
important processes running for user nobody. you better use a dedicated
user for running ghci. that might also allow you to sandbox the account
easier (firewall and dac's/mac's, etc. i don't know what's available on
mac os x).

you might also like to look into SafeHaskell to restrict what users can do.

good luck,
 tobias florek




From haskell at ibotty.net  Thu Feb 13 09:01:41 2014
From: haskell at ibotty.net (Tobias Florek)
Date: Thu, 13 Feb 2014 10:01:41 +0100
Subject: [Haskell-cafe] ghci in gallery
In-Reply-To: <CAKfy0KD9h26rGK-z+sfVGP3QJNR9KuAqH_Fqe1J843bSymJtxA@mail.gmail.com>
References: <CAKfy0KD9h26rGK-z+sfVGP3QJNR9KuAqH_Fqe1J843bSymJtxA@mail.gmail.com>
Message-ID: <52FC89F5.6060306@ibotty.net>

hi,

>    The process is run with user 'nobody', so hopefully that will be a
> bit safer, i.e.

a bit, yes. apart from breaking out of the account (and becoming root)
via os vulnerabilities the user can send any network traffic they like,
which might or might not be ok. also there might be any number of
important processes running for user nobody. you better use a dedicated
user for running ghci. that might also allow you to sandbox the account
easier (firewall and dac's/mac's, etc. i don't know what's available on
mac os x).

you might also like to look into SafeHaskell to restrict what users can do.

good luck,
 tobias florek




From mlen at mlen.pl  Thu Feb 13 09:51:32 2014
From: mlen at mlen.pl (Mateusz Lenik)
Date: Thu, 13 Feb 2014 10:51:32 +0100
Subject: [Haskell-cafe] ghci in gallery
In-Reply-To: <CAKfy0KD9h26rGK-z+sfVGP3QJNR9KuAqH_Fqe1J843bSymJtxA@mail.gmail.com>
References: <CAKfy0KD9h26rGK-z+sfVGP3QJNR9KuAqH_Fqe1J843bSymJtxA@mail.gmail.com>
Message-ID: <20140213095132.GA19735@polaris.local>

Hi Duncan,

I'd highly recommend using something like mueval:
http://hackage.haskell.org/package/mueval

In the setup you suggested malicious user can:
1) execute other processes (to create a remote shell using nc, or to try to
   exploit suid binaries),
2) do any network IO (to send spam for example),
3) read files readable to all users (kind of obvious, but /etc/passwd can be
   read by anyone on the system -- attackers can learn who uses the system,
   what services are running),
4) it allows access to loopback interface which it makes it very hard to
   firewall it properly.

And this is only the stuff that came up to my mind in 5 minutes.
Basically this setup is like giving anyone access to shell.

Cheers,
Mateusz

On Thu, Feb 13, 2014 at 08:29:31AM +0000, Duncan Rowland wrote:
> Dear All,
>
>    new to haskell, so this might be obvious, but...
>
>    I'm setting up a gallery installation (OSX) that exposes a command
> line haskell to the visitors.
>    The process is run with user 'nobody', so hopefully that will be a
> bit safer, i.e.
>
> cat visitor_commands_pipe | sudo -u nobody ghci -XOverloadedStrings
>
>    But how question are:
>       1) what sort of damage could a malicious user do to my system by
> entering commands into the pipe?
>       2) what should I do to protect my system? I can filter the user
> commands as I like, but I do not want to run 'in a webpage'.
>
>    Thanks in advance,
>       -Duncan.
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
-------------- next part --------------
A non-text attachment was scrubbed...
Name: not available
Type: application/pgp-signature
Size: 833 bytes
Desc: not available
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140213/dbcb9af9/attachment.sig>

From chriswarbo at googlemail.com  Thu Feb 13 09:58:38 2014
From: chriswarbo at googlemail.com (Chris Warburton)
Date: Thu, 13 Feb 2014 09:58:38 +0000
Subject: [Haskell-cafe] ghci in gallery
In-Reply-To: <CAKfy0KD9h26rGK-z+sfVGP3QJNR9KuAqH_Fqe1J843bSymJtxA@mail.gmail.com>
 (Duncan Rowland's message of "Thu, 13 Feb 2014 08:29:31 +0000")
References: <CAKfy0KD9h26rGK-z+sfVGP3QJNR9KuAqH_Fqe1J843bSymJtxA@mail.gmail.com>
Message-ID: <86iosjs59t.fsf@gmail.com>

Duncan Rowland <drowland at lincoln.ac.uk> writes:

>       2) what should I do to protect my system? I can filter the user
> commands as I like, but I do not want to run 'in a webpage'.

You might want to read
http://www.haskell.org/haskellwiki/Safely_running_untrusted_Haskell_code
which explains the security measures taken by "lambdabot" (an IRC bot
which executes any Haskell code it's sent)

Cheers,
Chris

From mbrock at goula.sh  Thu Feb 13 11:10:28 2014
From: mbrock at goula.sh (Mikael Brockman)
Date: Thu, 13 Feb 2014 12:10:28 +0100
Subject: [Haskell-cafe] Lisp Style Restarts in Haskell
References: <52F90D62.20308@frigidcode.com>
 <CAOopUj=w0iSWXWRjNVcN+kSV6o=tnnYBMQrP5V8PrEqbEeWuUg@mail.gmail.com>
 <op.xa6v6to2pz0j5l@zen5.arnhem.chello.nl>
Message-ID: <m21tz72rq3.fsf@goula.sh>

"Henk-Jan van Tuyl" <hjgtuyl at chello.nl> writes:

> Or Control.Exception in the base package?

With Lisp-style restarts, exceptions (Common Lisp calls them
"conditions") don't necessarily "unwind the stack."  Instead, they
provide a set of alternatives for how to proceed.  Calls to the throwing
function can be wrapped in a handler that chooses, say, whether to skip
or abort.

To take a Haskell example, Data.Text.Encoding has an API for doing
Unicode decoding with "controllable error handling."  It's pretty
simple, and not very flexible.

> type OnDecodeError = String -> Maybe Word8 -> Maybe Char
>
> decodeUtf8With :: OnDecodeError -> ByteString -> Text

Considering some different possibilities for this API...  Something like
this (a kind of defunctionalized version) might be more familiar to a CL
programmer:

> data DecodeCondition = InvalidWord Word8 | UnexpectedEOF
> data DecodeRestart   = Ignore | UseChar Char
>
> decodeUtf8With :: (DecodeCondition -> DecodeRestart)
>                -> ByteString -> Text

We can use ImplicitParams to approximate the dynamic scope behavior, and
LambdaCase to write what CL calls the "restart-case":

> decodeUtf8 :: (?restart :: DecodeCondition -> DecodeRestart)
>            -> ByteString -> Text

Usage:

> myDecode s =
>   let ?restart = \case InvalidWord _ -> UseChar '*'
>                        UnexpectedEOF -> Ignore
>   in decodeUtf8 s

                                 * * *

One of the cool things about CL's condition system that this
implementation doesn't capture is the way the runtime environment can
provide interactive prompts for restarting uncaught conditions.  An
example session:

> CL-USER 6 > (restartable-gethash 'mango *fruits-and-vegetables*)
>
>  Error: RESTARTABLE-GETHASH error getting MANGO [...]
>    1 (continue) Return not having found the value.
>    2 Try getting the key from the hash again.
>    3 Use a new key.
>    4 Use a new hash.
>    5 (abort) Return to level 0.
>    6 Return to top loop level 0.
>
>  Type :b for backtrace, :c <option number> to proceed,
>    or :? for other options

To increase the flexibility of our purely functional restarts, we can
use monads:

> decodeUtf8With :: Monad m => (DecodeCondition -> m DecodeRestart)
>                -> ByteString -> m Text
>
> myDecode :: ByteString -> IO Text
> myDecode = decodeUtf8With (\c -> askUserAbout c >>= decide)

We can also use other monads:

> cautiousDecode :: ByteString -> Maybe Text
> cautiousDecode = decodeUtf8With (const Nothing)

This of course opens up a whole world of bizarre control flow
possibilities.

--
Mikael Brockman
@mbrock


From nick.rudnick at gmail.com  Thu Feb 13 11:43:51 2014
From: nick.rudnick at gmail.com (Nick Rudnick)
Date: Thu, 13 Feb 2014 12:43:51 +0100
Subject: [Haskell-cafe]  C++ exception (from *.so) catchable by Haskell??
Message-ID: <CA+XUKchkD5pSigEBqp77JQe3xwq6PL=Q_ZVuLeS1c9V67yXxRA@mail.gmail.com>

Dear all,

after trying around a while this seems to be a good question for
Haskell-cafe to me: Is somewhere a place (e.g. some Hackage package) where
intercepting exceptions from C++ library code is done, so one can look
*how* it is done?

Generally, it is the following:
1) Injecting code that throws a an exception in C++ library code, e.g.,

throw runtime_error("OOOPS...");


2) then, I tried out everything in reach (Haskell docs, Hackage interfaces
to C++ considered to be well-done) to get it caught (try, catch, bracket,
finally; various exception types; forkOS).

3) To my surprise, every time the output stays the same:

terminate called after throwing an instance of 'std::runtime_error'
  what():  OOOPS...

Is it possible at all to get a grip of this? Is there some place where it
is done? Does the terminate call already happen with the C++ execution?

Any comment welcome, cheers, Nick
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140213/1abf5399/attachment.html>

From alexander.kjeldaas at gmail.com  Thu Feb 13 12:11:02 2014
From: alexander.kjeldaas at gmail.com (Alexander Kjeldaas)
Date: Thu, 13 Feb 2014 13:11:02 +0100
Subject: [Haskell-cafe] C++ exception (from *.so) catchable by Haskell??
In-Reply-To: <CA+XUKchkD5pSigEBqp77JQe3xwq6PL=Q_ZVuLeS1c9V67yXxRA@mail.gmail.com>
References: <CA+XUKchkD5pSigEBqp77JQe3xwq6PL=Q_ZVuLeS1c9V67yXxRA@mail.gmail.com>
Message-ID: <CAHVSqQd+zuV8AvvSMtvZ=55F083UrK+N5Djv3T02gJYWkB5zGw@mail.gmail.com>

Two approaches:

1. Use set_unexpected.
http://www.cplusplus.com/reference/exception/set_unexpected/

2. Wrap your FFI code in try/catch.

Alexander


On Thu, Feb 13, 2014 at 12:43 PM, Nick Rudnick <nick.rudnick at gmail.com>wrote:

> Dear all,
>
> after trying around a while this seems to be a good question for
> Haskell-cafe to me: Is somewhere a place (e.g. some Hackage package) where
> intercepting exceptions from C++ library code is done, so one can look
> *how* it is done?
>
> Generally, it is the following:
> 1) Injecting code that throws a an exception in C++ library code, e.g.,
>
> throw runtime_error("OOOPS...");
>
>
> 2) then, I tried out everything in reach (Haskell docs, Hackage interfaces
> to C++ considered to be well-done) to get it caught (try, catch, bracket,
> finally; various exception types; forkOS).
>
> 3) To my surprise, every time the output stays the same:
>
> terminate called after throwing an instance of 'std::runtime_error'
>   what():  OOOPS...
>
> Is it possible at all to get a grip of this? Is there some place where it
> is done? Does the terminate call already happen with the C++ execution?
>
> Any comment welcome, cheers, Nick
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140213/1f967573/attachment.html>

From allbery.b at gmail.com  Thu Feb 13 14:44:06 2014
From: allbery.b at gmail.com (Brandon Allbery)
Date: Thu, 13 Feb 2014 09:44:06 -0500
Subject: [Haskell-cafe] C++ exception (from *.so) catchable by Haskell??
In-Reply-To: <CA+XUKchkD5pSigEBqp77JQe3xwq6PL=Q_ZVuLeS1c9V67yXxRA@mail.gmail.com>
References: <CA+XUKchkD5pSigEBqp77JQe3xwq6PL=Q_ZVuLeS1c9V67yXxRA@mail.gmail.com>
Message-ID: <CAKFCL4UJwDBZny9J2BSv40YWk263DJH_0yWsWVhXw_FhkuZbmw@mail.gmail.com>

On Thu, Feb 13, 2014 at 6:43 AM, Nick Rudnick <nick.rudnick at gmail.com>wrote:

> 3) To my surprise, every time the output stays the same:
>
> terminate called after throwing an instance of 'std::runtime_error'
>   what():  OOOPS.
>

It's calling terminate which calls exit(), in the C++ runtime. You can't
catch it at that level.

set_unexpected() may or may not help you since it's not clear that you can
make it pop back to the FFI call and no further. Maybe you can use
setjmp()/longjmp() or setcontext() and friends, but I'm betting its
interaction with C++ is undefined (and in particular C++
finalizers/destructors don't get called).

Your best bet is to catch the exception in C++, in whatever code you are
invoking from the (C context) FFI call.

Upshot: there is no global concept of exceptions that applies across all
languages unless you're using something like JVM or CLR.

-- 
brandon s allbery kf8nh                               sine nomine associates
allbery.b at gmail.com                                  ballbery at sinenomine.net
unix, openafs, kerberos, infrastructure, xmonad        http://sinenomine.net
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140213/41e02c59/attachment.html>

From corentin.dupont at gmail.com  Thu Feb 13 16:29:20 2014
From: corentin.dupont at gmail.com (Corentin Dupont)
Date: Thu, 13 Feb 2014 17:29:20 +0100
Subject: [Haskell-cafe] manage effects in a DSL
In-Reply-To: <CACN--9A0o_Ce8R44bUPaF2h-=3quNhUF4H-Jt14OwxqWLDYPiw@mail.gmail.com>
References: <20140129033404.76144.qmail@www1.g3.pair.com>
 <CAEyhvmqiJCc8vs-LHpT=CW20yGjhr5G3LMB86c+w38v+e5BELw@mail.gmail.com>
 <CAEyhvmrti3-4B0KvtdQKZPTh8foX=yg__W3AATjunRLAvaF6CA@mail.gmail.com>
 <CAEyhvmow1XbdLJv00iDVA4uBWEXmMGeLsVg1g6jpUCt2=d8CPQ@mail.gmail.com>
 <CALnXJiqhPoKEpJKszGf4EskbSVU1xh+MX=R2dBU4cGv4o+fxoQ@mail.gmail.com>
 <CAEyhvmr=s7xTk7DS3RgKzcJgCZf4u7OEiw7eCKsQ3AuDrYUwUw@mail.gmail.com>
 <CAEyhvmp0M5briL0e617++XH+djkvfHq78tDMhrz7ajWMwkYZ_Q@mail.gmail.com>
 <CAHfjoWmOfwDYHTDFhn2RmOT53SdV==+HGjTJYMgLeZ_2e3mfOw@mail.gmail.com>
 <CACN--9CDygTpySYJj5eLkwrCPLca_m_5xmyUkFOjLpNTxFUQ6g@mail.gmail.com>
 <CAML5wvujBXCnAAuP60Xmc0hk7+SPmsG=wgNzi+mnezp2cw+_eg@mail.gmail.com>
 <CAEyhvmpgbR6EeTMMXBGPq3X7NK8umV=9GLSgV-ETBauMpv5xfg@mail.gmail.com>
 <CAML5wvv-1aKAVkgBRvs-Ue7mxzaefGMnY5hvQdTP3gAnF_feEg@mail.gmail.com>
 <CAEyhvmp1g_0yWR8q4h-Yr-vwVqjrETbo590=0b4KogLiWr1h1A@mail.gmail.com>
 <CACN--9A0o_Ce8R44bUPaF2h-=3quNhUF4H-Jt14OwxqWLDYPiw@mail.gmail.com>
Message-ID: <CAEyhvmopR8HcyXgH0qWdZjyiEuDTuaoj+KzPjGPGcDoOC9Paww@mail.gmail.com>

Ho, that is great. Very elegant.


On Thu, Feb 13, 2014 at 12:44 AM, Jake McArthur <jake.mcarthur at gmail.com>wrote:

> As Chris says, you no longer need the GADT at all.
>
> {-# LANGUAGE RankNTypes #-}
> {-# LANGUAGE FlexibleInstances #-}
>
> import Control.Monad.Identity
> import Control.Monad.State
> import Control.Monad.Reader
>
> class Monad m => Nomex m where
>   readAccount :: m Int
>
> class Nomex m => NomexEffect m where
>   writeAccount :: Int -> m ()
>   setVictory   :: (forall n. Nomex n => n Bool) -> m ()
>
>
> data Game = Game { victory :: (forall m. Nomex m => m Bool)
>                  , account :: Int
>                  }
>
> instance Nomex (State Game) where
>   readAccount = gets account
>
> instance NomexEffect (State Game) where
>
>   writeAccount n = modify $ \game -> game { account = n }
>   setVictory   v = modify $ \game -> game { victory = v }
>
> instance Nomex (Reader Game) where
>   readAccount = asks account
>
> isVictory :: Game -> Bool
> isVictory = join (runReader . victory)
>
> incrAccount :: NomexEffect m => m ()
> incrAccount = readAccount >>= writeAccount . (+101)
>
> winOnBigMoney :: NomexEffect m => m ()
> winOnBigMoney = setVictory $ do
>    i <- readAccount
>    --writeAccount 100
>    return (i > 100)
>
> play :: StateT Game Identity ()
> play = do
>    winOnBigMoney
>    incrAccount
>
> initGame :: Game
> initGame = Game (return False) 0
>
> main :: IO ()
> main = do
>    let g = execState play initGame
>    putStrLn $ show $ isVictory g
>
>
>
> On Wed, Feb 12, 2014 at 11:44 AM, Corentin Dupont <
> corentin.dupont at gmail.com> wrote:
>
>>
>> Hi guys,
>> so I tried to implement fully the proposition (see below).
>> It works well. However I find it a bit redundant. Can we reduce the
>> repetitions?
>> Perhaps I didn't understand how to write the evaluation...
>>
>>
>> {-# LANGUAGE RankNTypes #-}
>> {-# LANGUAGE GeneralizedNewtypeDeriving #-}
>> {-# LANGUAGE GADTs #-}
>> {-# LANGUAGE TypeSynonymInstances #-}
>> {-# LANGUAGE FlexibleInstances #-}
>> module Main where
>>
>>
>> import Control.Monad.State
>> import Control.Monad.Reader
>>
>> class Monad m => Nomex m where
>>   readAccount :: m Int
>>
>> class Nomex m => NomexEffect m where
>>   writeAccount :: Int -> m ()
>>   setVictory   :: (forall n. Nomex n => n Bool) -> m ()
>>
>>
>> data Exp a where
>>    ReadAccount  :: Exp Int
>>    WriteAccount :: Int -> Exp ()
>>    SetVictory   :: (forall m. Nomex m => m Bool) -> Exp ()
>>    Bind         :: Exp a -> (a -> Exp b) -> Exp b
>>
>>    Return       :: a -> Exp a
>>
>> instance Monad Exp where
>>
>>    return = Return
>>    (>>=) = Bind
>>
>> instance Nomex Exp where
>>   readAccount = ReadAccount
>>
>> instance NomexEffect Exp where
>>   writeAccount = WriteAccount
>>   setVictory   = SetVictory
>>
>>
>> data Game = Game { victory :: (forall m. Nomex m => m Bool)
>>                  , account :: Int
>>                  }
>>
>> instance Nomex (State Game) where
>>   readAccount = gets account
>>
>> instance NomexEffect (State Game) where
>>
>>   writeAccount n = modify $ \game -> game { account = n }
>>   setVictory   v = modify $ \game -> game { victory = v }
>>
>> instance Nomex (Reader Game) where
>>   readAccount = asks account
>>
>> evaluate :: Exp a -> State Game a
>> evaluate (WriteAccount i) = writeAccount i
>> evaluate ReadAccount = readAccount
>> evaluate (SetVictory v) = setVictory v
>> evaluate (Return a) = return a
>> evaluate (Bind a f) = (evaluate a) >>= evaluate . f
>>
>> evalNoEff :: Exp a -> Reader Game a
>> evalNoEff ReadAccount = readAccount
>> evalNoEff (Return a) = return a
>> evalNoEff (Bind a f) = (evalNoEff a) >>= evalNoEff . f
>>
>> isVictory :: Game -> Bool
>> isVictory g = runReader (evalNoEff (victory g)) g
>>
>> incrAccount :: NomexEffect m => m ()
>> incrAccount = readAccount >>= writeAccount . (+101)
>>
>> winOnBigMoney :: NomexEffect m => m ()
>> winOnBigMoney = setVictory $ do
>>    i <- readAccount
>>    --writeAccount 100
>>    return (i > 100)
>>
>> play = do
>>    winOnBigMoney
>>    incrAccount
>>
>> initGame = Game (return False) 0
>>
>> main = do
>>    let g = execState (evaluate jeu) initGame
>>    putStrLn $ show $ isVictory g
>>
>>
>>
>> On Mon, Feb 10, 2014 at 11:33 AM, Dominique Devriese <
>> dominique.devriese at cs.kuleuven.be> wrote:
>>
>>> Corentin,
>>>
>>> 2014-02-10 10:48 GMT+01:00 Corentin Dupont <corentin.dupont at gmail.com>:
>>> > That is really interesting. In fact, I didn't have the time to
>>> experiment
>>> > with it, but I definitely want to (have to find some spare time!).
>>> > I must say I am less used to type classes.
>>> > At first, my concern with the technique was that two things that belong
>>> > together, "ReadAccount" and "WriteAccount", are separated.
>>>
>>> Yes, this separation of ReadAccount and WriteAccount into Nomex vs
>>> NomexEffect is how the two parts (read-only vs read-write) of the DSL
>>> are distinguished in this approach..
>>>
>>> > I was also confused that the evaluator is wrapped in a newtype, and
>>> that it
>>> > is an instance of Nomex.
>>>
>>> That is non-essential.  You can also use
>>>
>>>   instance Nomex (State Game) where
>>>
>>> but it's just cleaner with a newtype...
>>>
>>> > Beside, I suppose it is possible to factorize EvalNoEffect with Eval?
>>> Maybe
>>> > using liftEval anyway...
>>>
>>> If I understand correctly, you're asking about how to remove the
>>> duplication between EvalNoEffect and Eval?
>>>
>>> This is a very good question.  My answer is basically that Haskell is
>>> missing some type-class-related features to allow for the perfect
>>> solution, specifically a form of local instances.
>>>
>>> The long story is that instead of the above instances of Nomex and
>>> NomexEffect for Eval and EvalNoEffect separately, we would like to be
>>> able to write the following instances:
>>>
>>>   instance MonadReader Game m => Nomex m where
>>>     readAccount = asks account
>>>
>>>   instance (MonadReader Game m, MonadState Game m) => NomexEffect m where
>>>     writeAccount n = modify $ \game -> game { account = n }
>>>     setVictory   v = modify $ \game -> game { victory = v }
>>>
>>> and then we can declare
>>>   newtype Eval a = Eval { eval :: State Game a }
>>>                  deriving (Monad, MonadState Game, MonadReader Game)
>>>
>>>   newtype EvalNoEffect a = EvalNoEffect { evalNoEffect :: Reader Game a }
>>>                          deriving (Monad, MonadReader Game)
>>>
>>> and reuse the single implementation of Nomex for both Eval and
>>> EvalNoEffect.  However, there are various problems with this solution:
>>>
>>> * the instances are not permitted without UndecidableInstances (which
>>> I recommend against),
>>> * the derivation of MonadReader from State won't work because
>>> MonadReader is not treated as a superclass of MonadState in Haskell,
>>> despite the fact that functionality-wise it is.
>>>
>>> What is needed to solve these problems is a feature that is in my
>>> opinion strongly missing in Haskell: a form of local instances.  This
>>> means that we would be able to explicitly specify what implementation
>>> of a certain type class should be used to satisfy a certain type class
>>> constraint, e.g.
>>>
>>>   sort :: Ord a => [a] -> [a]
>>>   sortBy :: forall a. (a -> a -> Bool) -> [a] -> [a]
>>>   sortBy f = let instance ordDict :: Ord.Dict a
>>>                                         ordDict = constructOrdDict f
>>>                    in sort :: Ord a => [a] -> [a]
>>>
>>> Local instances were already considered by Wadler when he proposed
>>> type classes, but they are problematic to combine with type inference.
>>>  However, it seems likely that this is not an issue if we require
>>> sufficiently informative type annotations.
>>>
>>> For the problem above, this would allow to construct, use and lift
>>> (together with newtype coercions) a MonadReader dictionary for the
>>> State monad without necessarily having it derived automatically if
>>> this is not desired.  Also, this would allow to write the undecidable
>>> instances as normal functions that need to be explicitly invoked
>>> instead of inferred by type inference, avoiding the
>>> UndecidableInstances problem.
>>>
>>> Regards
>>> Dominique
>>>
>>
>>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140213/4061f33f/attachment.html>

From jmacristovao at gmail.com  Thu Feb 13 17:05:46 2014
From: jmacristovao at gmail.com (=?ISO-8859-1?B?Sm/jbyBDcmlzdPN2428=?=)
Date: Thu, 13 Feb 2014 17:05:46 +0000
Subject: [Haskell-cafe] ANN: asynchronous-exceptions
In-Reply-To: <CAKA2JgKCkWr2YE_JtCHFGcdm4T+YLXpBmw+qHJp4HExEMb9OaA@mail.gmail.com>
References: <20140205112801.GA5306@sniper>
 <CAKA2JgKSWQ8An-KK4gCjcaRChyoXhzVg8k-S5XDDvQvLDWKD6Q@mail.gmail.com>
 <20140205151926.GA9254@sniper>
 <CAKA2JgKWdLHYgyMWpHPo8vZB8RBXVmvba5xXceH+iNyGPcX-Cg@mail.gmail.com>
 <20140205162849.GC10049@sniper>
 <CAKA2JgJyonmwpscN_=9kXPTL0w7DT4LgB2wvvPyOc5z7BiinDQ@mail.gmail.com>
 <20140205212308.GA12415@sniper>
 <CAAbu24o=zuOJQkEHxYyKgkjq=Au7QwBK0+h7BSu5X6WZnVZ-kw@mail.gmail.com>
 <20140205223353.GA17748@sniper>
 <CAAbu24p+G+GCmXtdt5brGUeNMCaBA0tJwCni_04TtVqoxpcBJQ@mail.gmail.com>
 <20140206061707.GA19197@sniper>
 <CAKA2JgL+N3_TzE-8vEVRTnfpi0SyK4fi7xFHjqmQwOOSxSeQPw@mail.gmail.com>
 <CAAbu24qZuZLJofbvL+g4w1e4cBT6+1bBnV6B8VtU0W4AeANvQg@mail.gmail.com>
 <CAKA2JgKCkWr2YE_JtCHFGcdm4T+YLXpBmw+qHJp4HExEMb9OaA@mail.gmail.com>
Message-ID: <CAAbu24rnStnWOhvyeH4XXmpbSn6-52GHdH5cGJi5V74DqNG33A@mail.gmail.com>

Just to let you know, the enclosed-exceptions is now at Hackage, allowing
you to use the functions previously discussed without adding the heavier
dependency on Classy Prelude.

http://hackage.haskell.org/package/enclosed-exceptions


Cheers,
Joao


2014-02-06 12:35 GMT+00:00 Michael Snoyman <michael at snoyman.com>:

> I like the idea of renaming the module to reflect this concept (I'm fine
> with either Inner or Enclosed), but leaving the function names themselves
> as-is.
>
>
> On Thu, Feb 6, 2014 at 2:12 PM, Jo?o Crist?v?o <jmacristovao at gmail.com>wrote:
>
>> Thanks Roman and Michael for the latest clarifications:
>>
>> I had indeed forgot the case where a thread runned in catchAny spawn
>> child threads that kill their parent.
>>
>> > But given how overloaded the term is, I'd be in favor of coming up with
>> a new term to represent what these catch functions are intended to do.
>>
>> The word currently in my head is 'inner', although Roman's suggestion
>> of 'enclosed' looks fine too. Internal is also correct, but as it is
>> regularly used to denote a package internal functions, it may lead to
>> confusion.
>>
>> What these functions (classy prelude/my library spin-off) do is run a
>> computation, isolating it from the calling thread (through async) and
>> catching all inner exceptions (of either synchronous or asynchronous
>> type, raised by either throwIO or throwTo instructions _present
>> somewhere inside that computation_, or by the RTS but once again
>> affecting only that computation, not the calling one.
>>
>> The calling one is thus 'free' to receive asynchronous exceptions in
>> the meantime (the execution of the inner computation).
>>
>> Thus, I propose either:
>>
>> Control.Exception.Inner / Control.Exception.Enclosed
>>
>> And/or, possibly also rename the functions to something like:
>>
>> catchAnyInner / catchAnyEnclosed
>>
>> Although I do not like this last option so much, the function name
>> gets too long, but that's a personal preference.
>>
>>
>> What do you think?
>> Jo?o
>>
>> 2014-02-06 Michael Snoyman <michael at snoyman.com>:
>> >
>> >
>> >
>> > On Thu, Feb 6, 2014 at 8:17 AM, Roman Cheplyaka <roma at ro-che.info>
>> wrote:
>> >>
>> >> > Am I getting this right?
>> >>
>> >> Not quite.
>> >>
>> >> The enclosed computation may get asynchronous exceptions whatever
>> >> definition of 'asynchronous' you use -- the exact one (by throw method)
>> >> or the approximate one (by type).
>> >>
>> >> Just a couple of examples:
>> >>
>> >> * The thread may catch an async exception from the RTS (such as
>> >>   BlockedIndefinitelyOnMVar or StackOverflow)
>> >> * The thread may spawn other threads, passing its pid to them, and one
>> >>   of its children may eventually kill it
>> >>
>> >> So I'd say this method allows to catch any exceptions "related" to
>> >> the computation, synchronous or asynchronous. It is this "relatedness"
>> >> that is enforced by running it in a separate thread.
>> >>
>> >> Roman
>> >>
>> >
>> > I definitely think this is important to get our terminology right. A
>> lot of
>> > the scariness of async exceptions likely spawns from the fact that we
>> use
>> > the same term to refer to a number of very different cases. Let me give
>> a
>> > crack at breaking down exceptions:
>> >
>> > * An exception with a synchronous type (e.g., IOException) thrown via
>> > throwIO. This is the most synchronous of synchronous exceptions.
>> > * An exception with an asynchronous type (e.g., UserInterrupt) thrown
>> via
>> > throwIO. There's legitimate room for debate as to what we should call
>> this.
>> > For my purposes, I'd want to call it a synchronous exception.
>> > * An exception with a synchronous type thrown via throwTo. Similar to
>> > previous bullet, but I'd consider this asynchronous.
>> > * An exception with an asynchronous type thrown via throwTo. This is
>> solidly
>> > an asynchronous exception.
>> >
>> > Then we have some more interesting questions:
>> >
>> > * What *is* an asynchronous type? By including
>> BlockedIndefinitelyOnMVar, it
>> > seems like you're defining it to include any exception generated by the
>> RTS.
>> > However, I'd consider it a synchronous exception: it is generated in
>> direct
>> > consequence of performing an IO action. It just happens to be generated
>> by
>> > the RTS instead of via some library talking to the filesystem.
>> > * What happens if an async exception is caught and then rethrown? Has it
>> > transformed itself into a synchronous exception? That's a tricky
>> question,
>> > and likely depends on the exact manner in which is was caught.
>> > * What happens if a function utilizes some form of asynchronous
>> exception
>> > mechanism to affect its behavior? The prime example of this is
>> `timeout`, or
>> > better, the `asyncTimeout` function I displayed above. Internally to
>> that
>> > function, I think that's an async exception. However, for a *caller* of
>> that
>> > function, the behavior is actually synchronous: there was no
>> notification
>> > from the outside world changing the behavior of this function, it
>> simply has
>> > the possibility to terminate by throwing a Timeout, the same way a
>> function
>> > may terminate by throwing an IOException.
>> >
>> > That last bullet is crucial to the question of whether classy-prelude's
>> and
>> > Jo?o's catching functions are asynchronous or not. But given how
>> overloaded
>> > the term is, I'd be in favor of coming up with a new term to represent
>> what
>> > these catch functions are intended to do.
>> >
>> > Michael
>>
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140213/a7244624/attachment.html>

From nick.rudnick at gmail.com  Thu Feb 13 20:04:34 2014
From: nick.rudnick at gmail.com (Nick Rudnick)
Date: Thu, 13 Feb 2014 21:04:34 +0100
Subject: [Haskell-cafe] C++ exception (from *.so) catchable by Haskell??
In-Reply-To: <CAHVSqQd+zuV8AvvSMtvZ=55F083UrK+N5Djv3T02gJYWkB5zGw@mail.gmail.com>
References: <CA+XUKchkD5pSigEBqp77JQe3xwq6PL=Q_ZVuLeS1c9V67yXxRA@mail.gmail.com>
 <CAHVSqQd+zuV8AvvSMtvZ=55F083UrK+N5Djv3T02gJYWkB5zGw@mail.gmail.com>
Message-ID: <CA+XUKcgcb0iRuG6KUi1T5yG9etFwhw=8EN=Bw7cwdq5a6PVf2Q@mail.gmail.com>

thank you :-) in regard of (1), I am still fiddling to get it running; as
Brandon did foresee, there seem difficulties here. Do have any piece of FFI
code in mind which makes use of this?

With respect to (2) ? if one has a rather fine grained interface to rather
atomic actions, remains the overhead still OK at lots of function calls? I
read overhead should be quite low, but does it apply for FFI usage?

Cheers, Nick


2014-02-13 13:11 GMT+01:00 Alexander Kjeldaas <alexander.kjeldaas at gmail.com>
:

>
> Two approaches:
>
> 1. Use set_unexpected.
> http://www.cplusplus.com/reference/exception/set_unexpected/
>
> 2. Wrap your FFI code in try/catch.
>
> Alexander
>
>
> On Thu, Feb 13, 2014 at 12:43 PM, Nick Rudnick <nick.rudnick at gmail.com>wrote:
>
>> Dear all,
>>
>> after trying around a while this seems to be a good question for
>> Haskell-cafe to me: Is somewhere a place (e.g. some Hackage package) where
>> intercepting exceptions from C++ library code is done, so one can look
>> *how* it is done?
>>
>> Generally, it is the following:
>> 1) Injecting code that throws a an exception in C++ library code, e.g.,
>>
>> throw runtime_error("OOOPS...");
>>
>>
>> 2) then, I tried out everything in reach (Haskell docs, Hackage
>> interfaces to C++ considered to be well-done) to get it caught (try, catch,
>> bracket, finally; various exception types; forkOS).
>>
>> 3) To my surprise, every time the output stays the same:
>>
>> terminate called after throwing an instance of 'std::runtime_error'
>>   what():  OOOPS...
>>
>> Is it possible at all to get a grip of this? Is there some place where it
>> is done? Does the terminate call already happen with the C++ execution?
>>
>> Any comment welcome, cheers, Nick
>>
>> _______________________________________________
>> Haskell-Cafe mailing list
>> Haskell-Cafe at haskell.org
>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>
>>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140213/475757e4/attachment.html>

From nick.rudnick at gmail.com  Thu Feb 13 20:57:31 2014
From: nick.rudnick at gmail.com (Nick Rudnick)
Date: Thu, 13 Feb 2014 21:57:31 +0100
Subject: [Haskell-cafe] C++ exception (from *.so) catchable by Haskell??
In-Reply-To: <CAKFCL4UJwDBZny9J2BSv40YWk263DJH_0yWsWVhXw_FhkuZbmw@mail.gmail.com>
References: <CA+XUKchkD5pSigEBqp77JQe3xwq6PL=Q_ZVuLeS1c9V67yXxRA@mail.gmail.com>
 <CAKFCL4UJwDBZny9J2BSv40YWk263DJH_0yWsWVhXw_FhkuZbmw@mail.gmail.com>
Message-ID: <CA+XUKciW_y8pF57f1mQYj+AQkX4iYik6_BMBa5TOLni68XSoPg@mail.gmail.com>

thank you :-)

Injecting the example pointed to by Alexander to my code, e.g.

void myUnexpected () {
  std::cerr << "unexpected called\n";
  throw 0;
}

...

std::set_unexpected (myUnexpected);
try {
  throw runtime_error("OOOPS...");
}
catch (int) { std::cerr << "caught int\n"; }
catch (...) { std::cerr << "caught some other exception type\n"; }

still is the problem that the STDERR message of myUnexpected doesn't appear
? is there anywhere code applying what you told about?

Cheers, Nick



2014-02-13 15:44 GMT+01:00 Brandon Allbery <allbery.b at gmail.com>:

>
> On Thu, Feb 13, 2014 at 6:43 AM, Nick Rudnick <nick.rudnick at gmail.com>wrote:
>
>> 3) To my surprise, every time the output stays the same:
>>
>> terminate called after throwing an instance of 'std::runtime_error'
>>   what():  OOOPS.
>>
>
> It's calling terminate which calls exit(), in the C++ runtime. You can't
> catch it at that level.
>
> set_unexpected() may or may not help you since it's not clear that you can
> make it pop back to the FFI call and no further. Maybe you can use
> setjmp()/longjmp() or setcontext() and friends, but I'm betting its
> interaction with C++ is undefined (and in particular C++
> finalizers/destructors don't get called).
>
> Your best bet is to catch the exception in C++, in whatever code you are
> invoking from the (C context) FFI call.
>
> Upshot: there is no global concept of exceptions that applies across all
> languages unless you're using something like JVM or CLR.
>
> --
> brandon s allbery kf8nh                               sine nomine
> associates
> allbery.b at gmail.com
> ballbery at sinenomine.net
> unix, openafs, kerberos, infrastructure, xmonad
> http://sinenomine.net
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140213/5fb6e001/attachment.html>

From omari at smileystation.com  Thu Feb 13 21:36:19 2014
From: omari at smileystation.com (Omari Norman)
Date: Thu, 13 Feb 2014 16:36:19 -0500
Subject: [Haskell-cafe] [ANN] anonymous-sums
Message-ID: <CA+aFgYA-QvDgLnK8CK2fbTJ8sYeAWi9oWgyFTDF2fY_75JTnrg@mail.gmail.com>

Someone once wondered why there are no anonymous sum types in Haskell:

https://groups.google.com/forum/#!topic/haskell-cafe/cIxfLdcJ7aI

Wonder no more:

http://hackage.haskell.org/package/anonymous-sums

Occasionally I have needed this so I split it off into a package.

If there is already something like this out there (or some elegant way
to do this that doesn't involve hairy extensions), please let me know
and I will be all too happy to deprecate this.

Omari

From allbery.b at gmail.com  Thu Feb 13 22:18:40 2014
From: allbery.b at gmail.com (Brandon Allbery)
Date: Thu, 13 Feb 2014 17:18:40 -0500
Subject: [Haskell-cafe] C++ exception (from *.so) catchable by Haskell??
In-Reply-To: <CA+XUKciW_y8pF57f1mQYj+AQkX4iYik6_BMBa5TOLni68XSoPg@mail.gmail.com>
References: <CA+XUKchkD5pSigEBqp77JQe3xwq6PL=Q_ZVuLeS1c9V67yXxRA@mail.gmail.com>
 <CAKFCL4UJwDBZny9J2BSv40YWk263DJH_0yWsWVhXw_FhkuZbmw@mail.gmail.com>
 <CA+XUKciW_y8pF57f1mQYj+AQkX4iYik6_BMBa5TOLni68XSoPg@mail.gmail.com>
Message-ID: <CAKFCL4VHT5fFXbyQuwsNnt1BB1Gmb+zXh+eLQ3QcNEQv2ebEMg@mail.gmail.com>

On Thu, Feb 13, 2014 at 3:57 PM, Nick Rudnick <nick.rudnick at gmail.com>wrote:

> std::set_unexpected (myUnexpected);
> try {
>   throw runtime_error("OOOPS...");
> }
> catch (int) { std::cerr << "caught int\n"; }
> catch (...) { std::cerr << "caught some other exception type\n"; }
>
> still is the problem that the STDERR message of myUnexpected doesn't
> appear ? is
>

You're catching all exceptions so there are no "unexpected" ones to invoke
myUnexpected on.


> there anywhere code applying what you told about?
>

I'm not sure what you're asking here. My suggestion was essentially to have
something like the try/catch you wrote for testing above wrapped around
whatever C++ code is throwing the exception, and invoke that try/catch via
the FFI.

-- 
brandon s allbery kf8nh                               sine nomine associates
allbery.b at gmail.com                                  ballbery at sinenomine.net
unix, openafs, kerberos, infrastructure, xmonad        http://sinenomine.net
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140213/49593a90/attachment.html>

From nick.rudnick at gmail.com  Thu Feb 13 23:07:47 2014
From: nick.rudnick at gmail.com (Nick Rudnick)
Date: Fri, 14 Feb 2014 00:07:47 +0100
Subject: [Haskell-cafe] C++ exception (from *.so) catchable by Haskell??
In-Reply-To: <CAKFCL4VHT5fFXbyQuwsNnt1BB1Gmb+zXh+eLQ3QcNEQv2ebEMg@mail.gmail.com>
References: <CA+XUKchkD5pSigEBqp77JQe3xwq6PL=Q_ZVuLeS1c9V67yXxRA@mail.gmail.com>
 <CAKFCL4UJwDBZny9J2BSv40YWk263DJH_0yWsWVhXw_FhkuZbmw@mail.gmail.com>
 <CA+XUKciW_y8pF57f1mQYj+AQkX4iYik6_BMBa5TOLni68XSoPg@mail.gmail.com>
 <CAKFCL4VHT5fFXbyQuwsNnt1BB1Gmb+zXh+eLQ3QcNEQv2ebEMg@mail.gmail.com>
Message-ID: <CA+XUKcjTC6mSVWGtz0pUacVOp9CQsYo8O9Y=ndJ88v8gPe94LA@mail.gmail.com>

2014-02-13 23:18 GMT+01:00 Brandon Allbery <allbery.b at gmail.com>:

> On Thu, Feb 13, 2014 at 3:57 PM, Nick Rudnick <nick.rudnick at gmail.com>wrote:
>
>> std::set_unexpected (myUnexpected);
>> try {
>>   throw runtime_error("OOOPS...");
>> }
>> catch (int) { std::cerr << "caught int\n"; }
>> catch (...) { std::cerr << "caught some other exception type\n"; }
>>
>> still is the problem that the STDERR message of myUnexpected doesn't
>> appear ? is
>>
>
> You're catching all exceptions so there are no "unexpected" ones to invoke
> myUnexpected on.
>

I experimented with commenting out the try/catch wrapping (I am afraid I
did not make it clear; btw. the latter doesn't need set_unexpected). So my
report refers to (only)

std::set_unexpected (myUnexpected);
throw runtime_error("OOOPS...");



> there anywhere code applying what you told about?
>>
>
> I'm not sure what you're asking here. My suggestion was essentially to
> have something like the try/catch you wrote for testing above wrapped
> around whatever C++ code is throwing the exception, and invoke that
> try/catch via the FFI.
>

Oh, I am reworking an FFI interface to C++, and thought it would be neat to
give it a nice exception handling, too. As you appeared quite experienced
and I consider this to be a practical issue occurring not too seldom, I
hoped you might refer to some project, where C++ exception handling is
realized.

Thanks, Nick






>
> --
> brandon s allbery kf8nh                               sine nomine
> associates
> allbery.b at gmail.com
> ballbery at sinenomine.net
> unix, openafs, kerberos, infrastructure, xmonad
> http://sinenomine.net
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140214/96db5433/attachment.html>

From allbery.b at gmail.com  Thu Feb 13 23:14:12 2014
From: allbery.b at gmail.com (Brandon Allbery)
Date: Thu, 13 Feb 2014 18:14:12 -0500
Subject: [Haskell-cafe] C++ exception (from *.so) catchable by Haskell??
In-Reply-To: <CA+XUKcjTC6mSVWGtz0pUacVOp9CQsYo8O9Y=ndJ88v8gPe94LA@mail.gmail.com>
References: <CA+XUKchkD5pSigEBqp77JQe3xwq6PL=Q_ZVuLeS1c9V67yXxRA@mail.gmail.com>
 <CAKFCL4UJwDBZny9J2BSv40YWk263DJH_0yWsWVhXw_FhkuZbmw@mail.gmail.com>
 <CA+XUKciW_y8pF57f1mQYj+AQkX4iYik6_BMBa5TOLni68XSoPg@mail.gmail.com>
 <CAKFCL4VHT5fFXbyQuwsNnt1BB1Gmb+zXh+eLQ3QcNEQv2ebEMg@mail.gmail.com>
 <CA+XUKcjTC6mSVWGtz0pUacVOp9CQsYo8O9Y=ndJ88v8gPe94LA@mail.gmail.com>
Message-ID: <CAKFCL4W1Mxz3m=4Cv-6PQoiUr4k59UjoEd+oNwDa-ur20CznLg@mail.gmail.com>

On Thu, Feb 13, 2014 at 6:07 PM, Nick Rudnick <nick.rudnick at gmail.com>wrote:

> Oh, I am reworking an FFI interface to C++, and thought it would be neat
> to give it a nice exception handling, too. As you appeared quite
> experienced and I consider this to be a practical issue occurring not too
> seldom, I hoped you might refer to some project, where C++ exception
> handling is realized.
>

Then I was apparently insufficiently clear before, so let me try to be
clearer here: The ONLY way to handle C++ exceptions is from C++. You can't
handle them from Haskell, or even from C.

-- 
brandon s allbery kf8nh                               sine nomine associates
allbery.b at gmail.com                                  ballbery at sinenomine.net
unix, openafs, kerberos, infrastructure, xmonad        http://sinenomine.net
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140213/0090c390/attachment.html>

From simons at cryp.to  Thu Feb 13 23:38:02 2014
From: simons at cryp.to (Peter Simons)
Date: Fri, 14 Feb 2014 00:38:02 +0100
Subject: [Haskell-cafe] C++ exception (from *.so) catchable by Haskell??
References: <CA+XUKchkD5pSigEBqp77JQe3xwq6PL=Q_ZVuLeS1c9V67yXxRA@mail.gmail.com>
 <CAKFCL4UJwDBZny9J2BSv40YWk263DJH_0yWsWVhXw_FhkuZbmw@mail.gmail.com>
 <CA+XUKciW_y8pF57f1mQYj+AQkX4iYik6_BMBa5TOLni68XSoPg@mail.gmail.com>
Message-ID: <87r476h9d1.fsf@write-only.cryp.to>

Hi Nick,

please note that the handler set by std::unexpected() fires only if a
function violates its exception specification, i.e. the function

  void foobar() throw() { throw 0; }

would trigger std::unexpected_handler(), but

  void foobar() { throw 0; }

does not, because there is no "unexpected" exception. Uncaught exceptions,
on the other hand, trigger the function std::terminate(), which by default
translates to std::abort().

Brandon Allbery pointed this out before, but it's probably worth
repeating: there is no way to catch (or throw) a C++ exception in Haskell.
The internal details of C++ exception handling are "implementation
defined". There is no standard that defines how to implement exceptions,
which means that you cannot even mix code from different C++ compilers if
you want to handle exceptions. Mixing in Haskell code is probably next to
impossible.

Take care,
Peter


From vogt.adam at gmail.com  Fri Feb 14 00:51:34 2014
From: vogt.adam at gmail.com (adam vogt)
Date: Thu, 13 Feb 2014 19:51:34 -0500
Subject: [Haskell-cafe] [ANN] anonymous-sums
In-Reply-To: <CA+aFgYA-QvDgLnK8CK2fbTJ8sYeAWi9oWgyFTDF2fY_75JTnrg@mail.gmail.com>
References: <CA+aFgYA-QvDgLnK8CK2fbTJ8sYeAWi9oWgyFTDF2fY_75JTnrg@mail.gmail.com>
Message-ID: <CAHfjoWkrkCQdHGF77TXn4h1DhWB00ZsFp_ibYDHtzpKsm19NMg@mail.gmail.com>

On Thu, Feb 13, 2014 at 4:36 PM, Omari Norman <omari at smileystation.com>
wrote:
>
> If there is already something like this out there (or some elegant way
> to do this that doesn't involve hairy extensions), please let me know
> and I will be all too happy to deprecate this.
>
> Omari

Hi Omari,

You could use:

type S3 a b c = (Maybe a, Maybe b, Maybe c)

And then prove to yourself that only one entry is Just. This lets you use
of classes that work with tuples such as Field1 through Field9 from lens or
things from http://hackage.haskell.org/package/tuple.

At least that's the strategy in <
http://hackage.haskell.org/package/HList-0.3.2.0/docs/Data-HList-Variant.html
>.

Regards,
Adam
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140213/4364bc1c/attachment.html>

From roma at ro-che.info  Fri Feb 14 07:01:24 2014
From: roma at ro-che.info (Roman Cheplyaka)
Date: Fri, 14 Feb 2014 09:01:24 +0200
Subject: [Haskell-cafe] [ANN] anonymous-sums
In-Reply-To: <CAHfjoWkrkCQdHGF77TXn4h1DhWB00ZsFp_ibYDHtzpKsm19NMg@mail.gmail.com>
References: <CA+aFgYA-QvDgLnK8CK2fbTJ8sYeAWi9oWgyFTDF2fY_75JTnrg@mail.gmail.com>
 <CAHfjoWkrkCQdHGF77TXn4h1DhWB00ZsFp_ibYDHtzpKsm19NMg@mail.gmail.com>
Message-ID: <20140214070124.GA29474@sniper>

* adam vogt <vogt.adam at gmail.com> [2014-02-13 19:51:34-0500]
> On Thu, Feb 13, 2014 at 4:36 PM, Omari Norman <omari at smileystation.com>
> wrote:
> >
> > If there is already something like this out there (or some elegant way
> > to do this that doesn't involve hairy extensions), please let me know
> > and I will be all too happy to deprecate this.
> >
> > Omari
> 
> Hi Omari,
> 
> You could use:
> 
> type S3 a b c = (Maybe a, Maybe b, Maybe c)
> 
> And then prove to yourself that only one entry is Just. This lets you use
> of classes that work with tuples such as Field1 through Field9 from lens or
> things from http://hackage.haskell.org/package/tuple.
> 
> At least that's the strategy in <
> http://hackage.haskell.org/package/HList-0.3.2.0/docs/Data-HList-Variant.html
> >.

Yes, this solution is highly recommended... by @EvilHaskellTips :-)
https://twitter.com/EvilHaskellTips/status/433403451054096384

Roman
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140214/3669360d/attachment-0001.sig>

From miguelimo38 at yandex.ru  Fri Feb 14 07:37:25 2014
From: miguelimo38 at yandex.ru (Miguel Mitrofanov)
Date: Fri, 14 Feb 2014 11:37:25 +0400
Subject: [Haskell-cafe] [ANN] anonymous-sums
In-Reply-To: <CA+aFgYA-QvDgLnK8CK2fbTJ8sYeAWi9oWgyFTDF2fY_75JTnrg@mail.gmail.com>
References: <CA+aFgYA-QvDgLnK8CK2fbTJ8sYeAWi9oWgyFTDF2fY_75JTnrg@mail.gmail.com>
Message-ID: <166991392363445@web26g.yandex.ru>

NOOOO! Why would you stop at S15, I really really need S17!

14.02.2014, 01:36, "Omari Norman" <omari at smileystation.com>:
> Someone once wondered why there are no anonymous sum types in Haskell:
>
> https://groups.google.com/forum/#!topic/haskell-cafe/cIxfLdcJ7aI
>
> Wonder no more:
>
> http://hackage.haskell.org/package/anonymous-sums
>
> Occasionally I have needed this so I split it off into a package.
>
> If there is already something like this out there (or some elegant way
> to do this that doesn't involve hairy extensions), please let me know
> and I will be all too happy to deprecate this.
>
> Omari
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe

From alexander.kjeldaas at gmail.com  Fri Feb 14 08:11:33 2014
From: alexander.kjeldaas at gmail.com (Alexander Kjeldaas)
Date: Fri, 14 Feb 2014 09:11:33 +0100
Subject: [Haskell-cafe] C++ exception (from *.so) catchable by Haskell??
In-Reply-To: <87r476h9d1.fsf@write-only.cryp.to>
References: <CA+XUKchkD5pSigEBqp77JQe3xwq6PL=Q_ZVuLeS1c9V67yXxRA@mail.gmail.com>
 <CAKFCL4UJwDBZny9J2BSv40YWk263DJH_0yWsWVhXw_FhkuZbmw@mail.gmail.com>
 <CA+XUKciW_y8pF57f1mQYj+AQkX4iYik6_BMBa5TOLni68XSoPg@mail.gmail.com>
 <87r476h9d1.fsf@write-only.cryp.to>
Message-ID: <CAHVSqQfeB3s0QQuXhWm78PSKHccK97ZNSu-CX9eFYviAN0MzCQ@mail.gmail.com>

Thanks Peter for that informative answer.

One unmentioned fact is that the exception mechanism in C++ is designed to
allow for implementations to have zero runtime cost.  Basically exception
handlers can be found by matching the stack frames with tables, and
registers can be populated using basically debug info.

How this is done is at the ABI level, but the Itanium C++ ABI, which is the
one used for x86-* does this.

http://mentorembedded.github.io/cxx-abi/abi-eh.html

An interesting nugget I learned today reading up on the ABI is that the ABI
actually supports common lisp conditions, that is, restarting or continuing
a computation that is in an exceptional state is supported by the ABI, but
not by C++.  I don't know of any language that supports zero-overhead
exceptions and conditions, but the support is already standardized.  It
isn't unthinkable that some C++ implementation would have extensions to
hook into the exception handling mechanism before stack-unwinding happens.

Alexander


On Fri, Feb 14, 2014 at 12:38 AM, Peter Simons <simons at cryp.to> wrote:

> Hi Nick,
>
> please note that the handler set by std::unexpected() fires only if a
> function violates its exception specification, i.e. the function
>
>   void foobar() throw() { throw 0; }
>
> would trigger std::unexpected_handler(), but
>
>   void foobar() { throw 0; }
>
> does not, because there is no "unexpected" exception. Uncaught exceptions,
> on the other hand, trigger the function std::terminate(), which by default
> translates to std::abort().
>
> Brandon Allbery pointed this out before, but it's probably worth
> repeating: there is no way to catch (or throw) a C++ exception in Haskell.
> The internal details of C++ exception handling are "implementation
> defined". There is no standard that defines how to implement exceptions,
> which means that you cannot even mix code from different C++ compilers if
> you want to handle exceptions. Mixing in Haskell code is probably next to
> impossible.
>
> Take care,
> Peter
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140214/8ceda145/attachment.html>

From nick.rudnick at gmail.com  Fri Feb 14 10:22:28 2014
From: nick.rudnick at gmail.com (Nick Rudnick)
Date: Fri, 14 Feb 2014 11:22:28 +0100
Subject: [Haskell-cafe] C++ exception (from *.so) catchable by Haskell??
In-Reply-To: <87r476h9d1.fsf@write-only.cryp.to>
References: <CA+XUKchkD5pSigEBqp77JQe3xwq6PL=Q_ZVuLeS1c9V67yXxRA@mail.gmail.com>
 <CAKFCL4UJwDBZny9J2BSv40YWk263DJH_0yWsWVhXw_FhkuZbmw@mail.gmail.com>
 <CA+XUKciW_y8pF57f1mQYj+AQkX4iYik6_BMBa5TOLni68XSoPg@mail.gmail.com>
 <87r476h9d1.fsf@write-only.cryp.to>
Message-ID: <CA+XUKciFVvDY0-UM0h07gsBtt8cux44_XY9H8xoj12m7JgY3DA@mail.gmail.com>

Thank you, Peter :-)

The exception specification hint is helpful ? now I got it :-) Here,
the exception specification stuff is useful...

OK, I can intercept now, but I see the solution isn't as easy as just
replacing e.g.

void myUnexpected () {
  std::cerr << "unexpected called\n";
  throw 0;
}

by

void myUnexpected () {
  std::cerr << "unexpected called\n";
}

... is it here where Brandon comes in, as the message gets out, but the
whole still carries the original Exception thrown with it ? like you can
shoot yourself by your own bullet before the adversary's one arrives you?!?

The test code I have chosen for learning about the problem is hsqml by
Robin Kay, which I consider to be very well done, usually injecting into
HsQMLManager.{cpp|h}.hsqml_init(...),

extern "C" void hsqml_init(void (*freeFun)(HsFunPtr),
                                 void (*freeStable)(HsStablePtr)
  ) throw() {
  std::set_unexpected (myunexpected);
  throw runtime_error("OOOPS...");
  ...
}

hsqml_init(...), again, is directly called from
Graphics/QML/Internal/BindCore.chs ? solely (grep ascertained there is no
other call from the C/C++ code):

{#fun unsafe hsqml_init as hsqmlInit_
    {id `HsFreeFunPtr',
     id `HsFreeStablePtr'} ->
    `()' #}

What puzzles me currently is that, by the descriptions, I would expect that
terminate() actually is replaced by std::cerr, so that the termination
displayed in the result happens afterwards ? but where??

In regard of what's my question, there should be something like a
common/best practice,shouldn't it? As I see, catching inside C++ isn't an
issue at all with coarse-grained interfaces, as the overhead doesn't
matter. But I expect there are also some experiences for the case of lots
of calls to do from Haskell to very small C++ jobs ? how then? As Alexander
states (just incoming... ;-) there is a pleasing zero runtime approach with
C++ exceptions ? great if it that be done via pointer addresses only (i.e.
'virtual Either', addresses that will either point to a 'Left' or 'Right'
instance, but without tag), so there might be no additional overhead...
(though things would go somewhat opaque for the Haskell side)

But is there a practice to do this? If not, would it not mean a certain
overhead to construct/destruct, e.g. Either, lots of time, together with
doing the appropriate conditionals?

If not, there is no issue to worry about. :-)

So my interest is a very practical one ? so insn't there hope even in case
there is no standard covering it, as concrete FFI interfacing goes to a
fixed project, let's say Qt4? So experiences might have gathered...

Cheers, Nick




2014-02-14 0:38 GMT+01:00 Peter Simons <simons at cryp.to>:

> Hi Nick,
>
> please note that the handler set by std::unexpected() fires only if a
> function violates its exception specification, i.e. the function
>
>   void foobar() throw() { throw 0; }
>
> would trigger std::unexpected_handler(), but
>
>   void foobar() { throw 0; }
>
> does not, because there is no "unexpected" exception. Uncaught exceptions,
> on the other hand, trigger the function std::terminate(), which by default
> translates to std::abort().
>
> Brandon Allbery pointed this out before, but it's probably worth
> repeating: there is no way to catch (or throw) a C++ exception in Haskell.
> The internal details of C++ exception handling are "implementation
> defined". There is no standard that defines how to implement exceptions,
> which means that you cannot even mix code from different C++ compilers if
> you want to handle exceptions. Mixing in Haskell code is probably next to
> impossible.
>
> Take care,
> Peter
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140214/511409b9/attachment.html>

From jan.stolarek at p.lodz.pl  Fri Feb 14 13:59:31 2014
From: jan.stolarek at p.lodz.pl (Jan Stolarek)
Date: Fri, 14 Feb 2014 14:59:31 +0100
Subject: [Haskell-cafe] Problems using tasty-golden
Message-ID: <201402141459.31873.jan.stolarek@p.lodz.pl>

Hi *,

I've been trying to write a testsuite using tasty-golden and I've run into two technical problems. 

I'll start with some background. I'm working on singletons library that provides Template Haskell 
functionality. I would like to tests whether some particular TH splices compile at all and if 
they compile whether they produce expected output. My plan is to attempt compilation of a file 
with GHC. If compilation fails then the test fails. If it succeedes then output is compared with 
a golden file. I am directly calling goldenTest function from Test.Tasty.Golden.Internal. I wrote 
this function to produce the test output:

compileWithGHC :: IO (Either BSL.ByteString BSL.ByteString)

It runs GHC with some specified options and returns Left stderr (if compilation fails) or Right 
stdout (if it succeedes). This function is passed as third parameter to goldenTest (using 
liftIO). Then I have a comparing function:

cmp :: Either BSL.ByteString BSL.ByteString 
     -> Either BSL.ByteString BSL.ByteString 
     -> IO (Maybe String)

If it gets two Rights then it compares them. If the second param is left then the function returns 
Just stderr.

I've run into following problems:

1. When I try to run my test I get:

message threw an exception: MY_GOLDEN_FILE: hGetBufSome: illegal operation (handle is closed)

I suspect that lazy IO is getting in the way but I have no idea why exactly things go wrong.

2. I had to hardcode the path to my golden file. Otherwise the file could not be found. I suspect 
the reason is that test are run somewhere in dist/ subdirectory whereas my golden files are 
located alongside my test files. What can I do to have the golden files located without giving 
specific subdirectories in the source code?

A bonus question. I redefined vgReadFile from Test.Tasty.Golden.Internal to return Either:

vgReadFileE :: FilePath -> ValueGetter r (Either BSL.ByteString BSL.ByteString)
vgReadFileE path =
  (fmap Right . liftIO . BSL.hGetContents =<<) $
  ValueGetter $
  ContT $ \k ->
  bracket
    (openBinaryFile path ReadMode)
    hClose
    k

The only modification is the "fmap Right .". How can I return Left if opening the file fails?

Janek

From althainz at gmail.com  Fri Feb 14 14:39:07 2014
From: althainz at gmail.com (Peter Althainz)
Date: Fri, 14 Feb 2014 15:39:07 +0100
Subject: [Haskell-cafe] HGamer3D 0.3.0 on Github
Message-ID: <CAKS-SOmgKi5ME+ubbdZeqj+sZmuWRCn2mW-ne4_q=oMkWQyEOg@mail.gmail.com>

Dear All,

HGamer3D version 0.3.0 is finalized and on Github.
www.hgamer3d.org
www.github.com/urs-of-the-backwoods/HGamer3D
News: runs on Linux and Windows, example Games/Cuboid2.hs with FRP

regards
Peter Althainz
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140214/7a0d504a/attachment.html>

From v.dijk.bas at gmail.com  Fri Feb 14 15:52:18 2014
From: v.dijk.bas at gmail.com (Bas van Dijk)
Date: Fri, 14 Feb 2014 16:52:18 +0100
Subject: [Haskell-cafe] ANN: Simon Marlow & Edward Kmett @ ZuriHac 2014
Message-ID: <CADLz5wUJbn64fenyxynqDY2bh7BbUKJNnbu0qhnHxKsyKTGHxQ@mail.gmail.com>

Dear Haskellers and ZuriHac 2014 attendees,

On this lovely day (pun intended), I'm excited to announce that Simon
Marlow and Edward Kmett will be giving talks at ZuriHac 2014.

When: Friday 6 June 2014 - Sunday 8 June 2014
Where: Erudify offices, Zurich, Switzerland

ZuriHac is an international Haskell hackathon: a grassroots,
collaborative coding festival with a simple focus, to build and
improve Haskell libraries, tools, and infrastructure.

This is a great opportunity to meet your fellow Haskellers in real
life, find new contributors for your project, improve existing
libraries and tools, or even start new ones!

30 people already signed up for ZuriHac 2014 but there's still room
for more. If you wish to attend, please register by filling in this
form:

http://bit.ly/ZuriHac2014

Full details can be found on the wiki page:

http://www.haskell.org/haskellwiki/ZuriHac2014

We look forward to seeing you there!

-- The organisers of ZuriHac 2014

ZuriHac 2014 is sponsored by Erudify & Google

From fuuzetsu at fuuzetsu.co.uk  Fri Feb 14 16:06:22 2014
From: fuuzetsu at fuuzetsu.co.uk (Mateusz Kowalczyk)
Date: Fri, 14 Feb 2014 16:06:22 +0000
Subject: [Haskell-cafe] ANN: Simon Marlow & Edward Kmett @ ZuriHac 2014
In-Reply-To: <CADLz5wUJbn64fenyxynqDY2bh7BbUKJNnbu0qhnHxKsyKTGHxQ@mail.gmail.com>
References: <CADLz5wUJbn64fenyxynqDY2bh7BbUKJNnbu0qhnHxKsyKTGHxQ@mail.gmail.com>
Message-ID: <52FE3EFE.6010804@fuuzetsu.co.uk>

On 14/02/14 15:52, Bas van Dijk wrote:
> Dear Haskellers and ZuriHac 2014 attendees,
> 
> On this lovely day (pun intended), I'm excited to announce that Simon
> Marlow and Edward Kmett will be giving talks at ZuriHac 2014.
> 
> When: Friday 6 June 2014 - Sunday 8 June 2014
> Where: Erudify offices, Zurich, Switzerland
> 
> ZuriHac is an international Haskell hackathon: a grassroots,
> collaborative coding festival with a simple focus, to build and
> improve Haskell libraries, tools, and infrastructure.
> 
> This is a great opportunity to meet your fellow Haskellers in real
> life, find new contributors for your project, improve existing
> libraries and tools, or even start new ones!
> 
> 30 people already signed up for ZuriHac 2014 but there's still room
> for more. If you wish to attend, please register by filling in this
> form:
> 
> http://bit.ly/ZuriHac2014
> 
> Full details can be found on the wiki page:
> 
> http://www.haskell.org/haskellwiki/ZuriHac2014
> 
> We look forward to seeing you there!
> 
> -- The organisers of ZuriHac 2014
> 
> ZuriHac 2014 is sponsored by Erudify & Google
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
> 

Hi

I see the linked Wiki page with some brief directions to Zurich Youth
Hostel but no mention why they are there. Is that where attendees are
meant to stay? Is there a reason for that particular place?

I'm just a bit confused about its mention out of nowhere. It'd be great
if the page could be updated to outline some accommodation advice for
those traveling from over-seas.

-- 
Mateusz K.

From roma at ro-che.info  Fri Feb 14 16:37:07 2014
From: roma at ro-che.info (Roman Cheplyaka)
Date: Fri, 14 Feb 2014 18:37:07 +0200
Subject: [Haskell-cafe] Problems using tasty-golden
In-Reply-To: <201402141459.31873.jan.stolarek@p.lodz.pl>
References: <201402141459.31873.jan.stolarek@p.lodz.pl>
Message-ID: <20140214163707.GA9743@sniper>

* Jan Stolarek <jan.stolarek at p.lodz.pl> [2014-02-14 14:59:31+0100]
> Hi *,
> 
> I've been trying to write a testsuite using tasty-golden and I've run into two technical problems. 
> 
> I'll start with some background. I'm working on singletons library that provides Template Haskell 
> functionality. I would like to tests whether some particular TH splices compile at all and if 
> they compile whether they produce expected output. My plan is to attempt compilation of a file 
> with GHC. If compilation fails then the test fails. If it succeedes then output is compared with 
> a golden file. I am directly calling goldenTest function from Test.Tasty.Golden.Internal. I wrote 
> this function to produce the test output:
> 
> compileWithGHC :: IO (Either BSL.ByteString BSL.ByteString)
> 
> It runs GHC with some specified options and returns Left stderr (if compilation fails) or Right 
> stdout (if it succeedes). This function is passed as third parameter to goldenTest (using 
> liftIO). Then I have a comparing function:
> 
> cmp :: Either BSL.ByteString BSL.ByteString 
>      -> Either BSL.ByteString BSL.ByteString 
>      -> IO (Maybe String)
> 
> If it gets two Rights then it compares them. If the second param is left then the function returns 
> Just stderr.
> 
> I've run into following problems:
> 
> 1. When I try to run my test I get:
> 
> message threw an exception: MY_GOLDEN_FILE: hGetBufSome: illegal operation (handle is closed)
> 
> I suspect that lazy IO is getting in the way but I have no idea why exactly things go wrong.

That's a plausible explanations. File handles are closed when the
ValueGetter monad is run. Try to add something like

  Control.Exception.evaluate $ Control.DeepSeq.force cmpResult

to your comparison function. (I think I should build this forcing
behaviour right into tasty-golden itself.)

(Filed as https://github.com/feuerbach/tasty-golden/issues/7)

> 2. I had to hardcode the path to my golden file. Otherwise the file could not be found. I suspect 
> the reason is that test are run somewhere in dist/ subdirectory whereas my golden files are 
> located alongside my test files. What can I do to have the golden files located without giving 
> specific subdirectories in the source code?

Golden files are looked up in an ordinary way ? i.e. relative paths are
interpreted relative to the test program's CWD. So, for example, if your
test files are under 'test/' subdirectory of your project's main directory,
and you want to run the test suite from your project's main directory,
then your paths must look like "test/...".

(Filed as https://github.com/feuerbach/tasty-golden/issues/8)

> A bonus question. I redefined vgReadFile from Test.Tasty.Golden.Internal to return Either:
> 
> vgReadFileE :: FilePath -> ValueGetter r (Either BSL.ByteString BSL.ByteString)
> vgReadFileE path =
>   (fmap Right . liftIO . BSL.hGetContents =<<) $
>   ValueGetter $
>   ContT $ \k ->
>   bracket
>     (openBinaryFile path ReadMode)
>     hClose
>     k
> 
> The only modification is the "fmap Right .". How can I return Left if opening the file fails?

First off, you don't have to do that (unless you have some special needs
? if so, what are they?). If the file doesn't exist, tasty will catch
the exception and handle it gracefully.

If you really want to do it (or are just curious), the easiest way is to
revert your addition of 'fmap Right' and replace the 'bracket' code with
'try' code.

Roman
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140214/3d708363/attachment.sig>

From v.dijk.bas at gmail.com  Fri Feb 14 16:47:41 2014
From: v.dijk.bas at gmail.com (Bas van Dijk)
Date: Fri, 14 Feb 2014 17:47:41 +0100
Subject: [Haskell-cafe] ANN: Simon Marlow & Edward Kmett @ ZuriHac 2014
In-Reply-To: <52FE3EFE.6010804@fuuzetsu.co.uk>
References: <CADLz5wUJbn64fenyxynqDY2bh7BbUKJNnbu0qhnHxKsyKTGHxQ@mail.gmail.com>
 <52FE3EFE.6010804@fuuzetsu.co.uk>
Message-ID: <CADLz5wVv4SrbzK5-UhxkmDmmyGFNKXPK3Wurw6pqbU-RXO2UYA@mail.gmail.com>

On 14 February 2014 17:06, Mateusz Kowalczyk <fuuzetsu at fuuzetsu.co.uk> wrote:
> I see the linked Wiki page with some brief directions to Zurich Youth
> Hostel but no mention why they are there. Is that where attendees are
> meant to stay? Is there a reason for that particular place?

Hi Mateusz,

Good point. I should probably remove the link to the Zurich Youth
Hostel. We had an arrangement with them for ZuriHac 2013 which allowed
Haskellers to stay in one big room together. In the end, hardly
anybody made use of the hostel and instead stayed in hotels in/near
the center of Zurich.

> I'm just a bit confused about its mention out of nowhere. It'd be great
> if the page could be updated to outline some accommodation advice for
> those traveling from over-seas.

I think it's not hard finding accommodation in Zurich but I'll put up
some advice on the wiki.

See you in Zurich :-)

Bas

From roma at ro-che.info  Fri Feb 14 16:51:33 2014
From: roma at ro-che.info (Roman Cheplyaka)
Date: Fri, 14 Feb 2014 18:51:33 +0200
Subject: [Haskell-cafe] Problems using tasty-golden
In-Reply-To: <20140214163707.GA9743@sniper>
References: <201402141459.31873.jan.stolarek@p.lodz.pl>
 <20140214163707.GA9743@sniper>
Message-ID: <20140214165133.GA10148@sniper>

* Roman Cheplyaka <roma at ro-che.info> [2014-02-14 18:37:07+0200]
> > A bonus question. I redefined vgReadFile from Test.Tasty.Golden.Internal to return Either:
> > 
> > vgReadFileE :: FilePath -> ValueGetter r (Either BSL.ByteString BSL.ByteString)
> > vgReadFileE path =
> >   (fmap Right . liftIO . BSL.hGetContents =<<) $
> >   ValueGetter $
> >   ContT $ \k ->
> >   bracket
> >     (openBinaryFile path ReadMode)
> >     hClose
> >     k
> > 
> > The only modification is the "fmap Right .". How can I return Left if opening the file fails?
> 
> First off, you don't have to do that (unless you have some special needs
> ? if so, what are they?). If the file doesn't exist, tasty will catch
> the exception and handle it gracefully.
> 
> If you really want to do it (or are just curious), the easiest way is to
> revert your addition of 'fmap Right' and replace the 'bracket' code with
> 'try' code.

On a second thought, you can't *replace* 'bracket' with 'try', because of
possible exceptions arising from 'k' (also, because of possible async
exceptions). Instead, you need to use both. Something like (untested)

  bracket
    (try $ openBinaryFile path ReadMode :: IO (Either IOException Handle))
    (either (const $ pure ()) hClose)
    k

Roman
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140214/de4a4942/attachment.sig>

From rendel at informatik.uni-marburg.de  Fri Feb 14 23:00:19 2014
From: rendel at informatik.uni-marburg.de (Tillmann Rendel)
Date: Sat, 15 Feb 2014 00:00:19 +0100
Subject: [Haskell-cafe] ANN: Simon Marlow & Edward Kmett @ ZuriHac 2014
In-Reply-To: <CADLz5wVv4SrbzK5-UhxkmDmmyGFNKXPK3Wurw6pqbU-RXO2UYA@mail.gmail.com>
References: <CADLz5wUJbn64fenyxynqDY2bh7BbUKJNnbu0qhnHxKsyKTGHxQ@mail.gmail.com>
 <52FE3EFE.6010804@fuuzetsu.co.uk>
 <CADLz5wVv4SrbzK5-UhxkmDmmyGFNKXPK3Wurw6pqbU-RXO2UYA@mail.gmail.com>
Message-ID: <52FEA003.2050407@informatik.uni-marburg.de>

Hi,

Bas van Dijk wrote:
>> I see the linked Wiki page with some brief directions to Zurich Youth
>> Hostel but no mention why they are there. Is that where attendees are
>> meant to stay? Is there a reason for that particular place?
>
> Good point. I should probably remove the link to the Zurich Youth
> Hostel. We had an arrangement with them for ZuriHac 2013 which allowed
> Haskellers to stay in one big room together. In the end, hardly
> anybody made use of the hostel and instead stayed in hotels in/near
> the center of Zurich.

I was one of the few people that stayed in the hostel. We mentioned 
ZuriHac on our reservation for two people, but that didn't make any 
difference. When we arrived, we mentioned at the front desk that we 
attend ZuriHac, and they agreed to try to fill up our four bed room with 
other ZuriHac attendants. And indeed, we ended up with one additional 
Haskeller but also one unrelated person. That was fun, but an 
all-Haskeller room would have been even more fun, I guess. If I would go 
again, I would only consider the youth hostel if I manage to find enough 
Haskellers via the mailing list or IRC or whatever to book all of the 
beds in a room together.

There was free Wifi, but only in the common room, not in the bed room. 
The common room was very nice, and it was fun to meet the other 
travelers, as you would expect at a youth hostel. The hostel is not down 
town, but there is good public transport to the downtown locations, or a 
30min walk along the lake.

   Tillmann

From rendel at informatik.uni-marburg.de  Fri Feb 14 23:38:11 2014
From: rendel at informatik.uni-marburg.de (Tillmann Rendel)
Date: Sat, 15 Feb 2014 00:38:11 +0100
Subject: [Haskell-cafe] [ANN] anonymous-sums
In-Reply-To: <CA+aFgYA-QvDgLnK8CK2fbTJ8sYeAWi9oWgyFTDF2fY_75JTnrg@mail.gmail.com>
References: <CA+aFgYA-QvDgLnK8CK2fbTJ8sYeAWi9oWgyFTDF2fY_75JTnrg@mail.gmail.com>
Message-ID: <52FEA8E3.2010601@informatik.uni-marburg.de>

Hi,

Omari Norman wrote:
> http://hackage.haskell.org/package/anonymous-sums

What about S0 and S1?

   Tillmann

From tikhon at jelv.is  Sat Feb 15 04:02:08 2014
From: tikhon at jelv.is (Tikhon Jelvis)
Date: Fri, 14 Feb 2014 20:02:08 -0800
Subject: [Haskell-cafe] [ANN] anonymous-sums
In-Reply-To: <52FEA8E3.2010601@informatik.uni-marburg.de>
References: <CA+aFgYA-QvDgLnK8CK2fbTJ8sYeAWi9oWgyFTDF2fY_75JTnrg@mail.gmail.com>
 <52FEA8E3.2010601@informatik.uni-marburg.de>
Message-ID: <CAJN5CVJsLm2N1-xWUGywjY95ROLJ8SMHppXKk-NzuzQCECBeDw@mail.gmail.com>

Yeah, S0 and S1 are probably worth including for the sake of completion. We
don't have a 1-tuple, and I believe that's caused a bit of trouble for
people writing generic libraries. Enough trouble so that somebody wrote a
OneTuple package[1] anyhow.

Of course, S0 is isomorphic to Void and S1 is isomorphic to Identity, but I
don't think that's a big deal especially given that S2 is isomorphic to
Either.

[1]:
http://hackage.haskell.org/package/OneTuple-0.2.1/docs/Data-Tuple-OneTuple.html


On Fri, Feb 14, 2014 at 3:38 PM, Tillmann Rendel <
rendel at informatik.uni-marburg.de> wrote:

> Hi,
>
> Omari Norman wrote:
>
>> http://hackage.haskell.org/package/anonymous-sums
>>
>
> What about S0 and S1?
>
>   Tillmann
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140214/2ccd2d47/attachment.html>

From alex.solla at gmail.com  Sat Feb 15 05:11:31 2014
From: alex.solla at gmail.com (Alexander Solla)
Date: Fri, 14 Feb 2014 21:11:31 -0800
Subject: [Haskell-cafe] GHC 7.6.3 (and others) hashes
Message-ID: <CAO0Ooq1RaFziTa1NU23sy0rfW2=d8_GAtU8iLp+-SpAO1eV7yg@mail.gmail.com>

Hi everybody,

I'm building up a body of SaltStack "states" for developing with and
running Haskell web-apps.  Since I am hoping my project will go big (don't
we all?) I'm hoping to do things right, the first time (up to the
constraints of marginal costs...)

So, to that end, I'm trying to go a little overboard on the systems
security front, since the costs are so low.

Is there any where I can find SHA hashes for the official GHC builds?  In
particular, I'm looking for a hash for the file located at:

https://www.haskell.org/ghc/dist/7.6.3/ghc-7.6.3-x86_64-unknown-linux.tar.bz2

I suppose downloading via an encrypted http connection goes a long way to
mitigate MITM, etc.  And I realize that long term, I'll want to host my own
copy (and I will).  But that is quickly sliding up the cost curve.  Plus, I
won't know if the copy I host will be okay unless I get the hash from a
trusted source.

Is there some place to get that hash?

Thanks!
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140214/37161a31/attachment.html>

From carter.schonwald at gmail.com  Sat Feb 15 06:11:53 2014
From: carter.schonwald at gmail.com (Carter Schonwald)
Date: Sat, 15 Feb 2014 01:11:53 -0500
Subject: [Haskell-cafe] GHC 7.6.3 (and others) hashes
In-Reply-To: <CAO0Ooq1RaFziTa1NU23sy0rfW2=d8_GAtU8iLp+-SpAO1eV7yg@mail.gmail.com>
References: <CAO0Ooq1RaFziTa1NU23sy0rfW2=d8_GAtU8iLp+-SpAO1eV7yg@mail.gmail.com>
Message-ID: <CAHYVw0xeU1udB_BM4sETP2NiT=1T+B0J6Q1-OPZ0_TFxCs08Rw@mail.gmail.com>

just dl and hash it.


On Sat, Feb 15, 2014 at 12:11 AM, Alexander Solla <alex.solla at gmail.com>wrote:

> Hi everybody,
>
> I'm building up a body of SaltStack "states" for developing with and
> running Haskell web-apps.  Since I am hoping my project will go big (don't
> we all?) I'm hoping to do things right, the first time (up to the
> constraints of marginal costs...)
>
> So, to that end, I'm trying to go a little overboard on the systems
> security front, since the costs are so low.
>
> Is there any where I can find SHA hashes for the official GHC builds?  In
> particular, I'm looking for a hash for the file located at:
>
>
> https://www.haskell.org/ghc/dist/7.6.3/ghc-7.6.3-x86_64-unknown-linux.tar.bz2
>
> I suppose downloading via an encrypted http connection goes a long way to
> mitigate MITM, etc.  And I realize that long term, I'll want to host my own
> copy (and I will).  But that is quickly sliding up the cost curve.  Plus, I
> won't know if the copy I host will be okay unless I get the hash from a
> trusted source.
>
> Is there some place to get that hash?
>
> Thanks!
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140215/0e3dea7e/attachment.html>

From magnus at therning.org  Sat Feb 15 06:40:03 2014
From: magnus at therning.org (Magnus Therning)
Date: Sat, 15 Feb 2014 07:40:03 +0100
Subject: [Haskell-cafe] GHC 7.6.3 (and others) hashes
In-Reply-To: <CAHYVw0xeU1udB_BM4sETP2NiT=1T+B0J6Q1-OPZ0_TFxCs08Rw@mail.gmail.com>
References: <CAO0Ooq1RaFziTa1NU23sy0rfW2=d8_GAtU8iLp+-SpAO1eV7yg@mail.gmail.com>
 <CAHYVw0xeU1udB_BM4sETP2NiT=1T+B0J6Q1-OPZ0_TFxCs08Rw@mail.gmail.com>
Message-ID: <20140215064003.GB1033@tatooine.lan>

On Sat, Feb 15, 2014 at 01:11:53AM -0500, Carter Schonwald wrote:
> just dl and hash it.

Yes, to ensure it's the exact same trojan you install on all your
machines ;)

/M

-- 
Magnus Therning                      OpenPGP: 0xAB4DFBA4 
email: magnus at therning.org   jabber: magnus at therning.org
twitter: magthe               http://therning.org/magnus

The results point out the fragility of programmer expertise: advanced
programmers have strong expectations about what programs should look like,
and when those expectations are violated--in seemingly innocuous
ways--their performance drops drastically.
     -- Elliot Soloway and Kate Ehrlich
-------------- next part --------------
A non-text attachment was scrubbed...
Name: not available
Type: application/pgp-signature
Size: 198 bytes
Desc: not available
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140215/aa9c9def/attachment.sig>

From carter.schonwald at gmail.com  Sat Feb 15 06:48:18 2014
From: carter.schonwald at gmail.com (Carter Schonwald)
Date: Sat, 15 Feb 2014 01:48:18 -0500
Subject: [Haskell-cafe] GHC 7.6.3 (and others) hashes
In-Reply-To: <20140215064003.GB1033@tatooine.lan>
References: <CAO0Ooq1RaFziTa1NU23sy0rfW2=d8_GAtU8iLp+-SpAO1eV7yg@mail.gmail.com>
 <CAHYVw0xeU1udB_BM4sETP2NiT=1T+B0J6Q1-OPZ0_TFxCs08Rw@mail.gmail.com>
 <20140215064003.GB1033@tatooine.lan>
Message-ID: <CAHYVw0ztbdPxXVF+=UGJUxdHkV9dNeTa8uz7Hib3b-jgN60s3A@mail.gmail.com>

the day that ghc binaries are MITM'd is the day we've failed to avoid
success :)


On Sat, Feb 15, 2014 at 1:40 AM, Magnus Therning <magnus at therning.org>wrote:

> On Sat, Feb 15, 2014 at 01:11:53AM -0500, Carter Schonwald wrote:
> > just dl and hash it.
>
> Yes, to ensure it's the exact same trojan you install on all your
> machines ;)
>
> /M
>
> --
> Magnus Therning                      OpenPGP: 0xAB4DFBA4
> email: magnus at therning.org   jabber: magnus at therning.org
> twitter: magthe               http://therning.org/magnus
>
> The results point out the fragility of programmer expertise: advanced
> programmers have strong expectations about what programs should look like,
> and when those expectations are violated--in seemingly innocuous
> ways--their performance drops drastically.
>      -- Elliot Soloway and Kate Ehrlich
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140215/23543fdc/attachment.html>

From carter.schonwald at gmail.com  Sat Feb 15 06:48:55 2014
From: carter.schonwald at gmail.com (Carter Schonwald)
Date: Sat, 15 Feb 2014 01:48:55 -0500
Subject: [Haskell-cafe] GHC 7.6.3 (and others) hashes
In-Reply-To: <CAHYVw0ztbdPxXVF+=UGJUxdHkV9dNeTa8uz7Hib3b-jgN60s3A@mail.gmail.com>
References: <CAO0Ooq1RaFziTa1NU23sy0rfW2=d8_GAtU8iLp+-SpAO1eV7yg@mail.gmail.com>
 <CAHYVw0xeU1udB_BM4sETP2NiT=1T+B0J6Q1-OPZ0_TFxCs08Rw@mail.gmail.com>
 <20140215064003.GB1033@tatooine.lan>
 <CAHYVw0ztbdPxXVF+=UGJUxdHkV9dNeTa8uz7Hib3b-jgN60s3A@mail.gmail.com>
Message-ID: <CAHYVw0xN-EWuNNeki1Xc3PN2e5opTC+pgmPCgS7jzcYG3n6-KQ@mail.gmail.com>

mind you, even if haskell industrial usage grows, I hope we continue to
grow our security in infrastructure to ensure that such attacks are never
viable! :)


On Sat, Feb 15, 2014 at 1:48 AM, Carter Schonwald <
carter.schonwald at gmail.com> wrote:

> the day that ghc binaries are MITM'd is the day we've failed to avoid
> success :)
>
>
> On Sat, Feb 15, 2014 at 1:40 AM, Magnus Therning <magnus at therning.org>wrote:
>
>> On Sat, Feb 15, 2014 at 01:11:53AM -0500, Carter Schonwald wrote:
>> > just dl and hash it.
>>
>> Yes, to ensure it's the exact same trojan you install on all your
>> machines ;)
>>
>> /M
>>
>> --
>> Magnus Therning                      OpenPGP: 0xAB4DFBA4
>> email: magnus at therning.org   jabber: magnus at therning.org
>> twitter: magthe               http://therning.org/magnus
>>
>> The results point out the fragility of programmer expertise: advanced
>> programmers have strong expectations about what programs should look like,
>> and when those expectations are violated--in seemingly innocuous
>> ways--their performance drops drastically.
>>      -- Elliot Soloway and Kate Ehrlich
>>
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140215/5e5393ef/attachment.html>

From mwm at mired.org  Sat Feb 15 09:45:32 2014
From: mwm at mired.org (Mike Meyer)
Date: Sat, 15 Feb 2014 03:45:32 -0600
Subject: [Haskell-cafe] GHC 7.6.3 (and others) hashes
In-Reply-To: <CAHYVw0xeU1udB_BM4sETP2NiT=1T+B0J6Q1-OPZ0_TFxCs08Rw@mail.gmail.com>
References: <CAO0Ooq1RaFziTa1NU23sy0rfW2=d8_GAtU8iLp+-SpAO1eV7yg@mail.gmail.com>
 <CAHYVw0xeU1udB_BM4sETP2NiT=1T+B0J6Q1-OPZ0_TFxCs08Rw@mail.gmail.com>
Message-ID: <CAD=7U2CztYPWpaRwYG7Q5PcP5f5st45vRctVuV_SXuaqOC7z7Q@mail.gmail.com>

Hosting your own copy doesn't mean you can trust it. Read
http://cm.bell-labs.com/who/ken/trust.html
just dl and hash it.


On Sat, Feb 15, 2014 at 12:11 AM, Alexander Solla <alex.solla at gmail.com>wrote:

> Hi everybody,
>
> I'm building up a body of SaltStack "states" for developing with and
> running Haskell web-apps.  Since I am hoping my project will go big (don't
> we all?) I'm hoping to do things right, the first time (up to the
> constraints of marginal costs...)
>
> So, to that end, I'm trying to go a little overboard on the systems
> security front, since the costs are so low.
>
> Is there any where I can find SHA hashes for the official GHC builds?  In
> particular, I'm looking for a hash for the file located at:
>
>
> https://www.haskell.org/ghc/dist/7.6.3/ghc-7.6.3-x86_64-unknown-linux.tar.bz2
>
> I suppose downloading via an encrypted http connection goes a long way to
> mitigate MITM, etc.  And I realize that long term, I'll want to host my own
> copy (and I will).  But that is quickly sliding up the cost curve.  Plus, I
> won't know if the copy I host will be okay unless I get the hash from a
> trusted source.
>
> Is there some place to get that hash?
>
> Thanks!
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
>

_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe at haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140215/19954fb9/attachment.html>

From simons at cryp.to  Sat Feb 15 12:45:44 2014
From: simons at cryp.to (Peter Simons)
Date: Sat, 15 Feb 2014 13:45:44 +0100
Subject: [Haskell-cafe] C++ exception (from *.so) catchable by Haskell??
References: <CA+XUKchkD5pSigEBqp77JQe3xwq6PL=Q_ZVuLeS1c9V67yXxRA@mail.gmail.com>
 <CAKFCL4UJwDBZny9J2BSv40YWk263DJH_0yWsWVhXw_FhkuZbmw@mail.gmail.com>
 <CA+XUKciW_y8pF57f1mQYj+AQkX4iYik6_BMBa5TOLni68XSoPg@mail.gmail.com>
 <87r476h9d1.fsf@write-only.cryp.to>
 <CA+XUKciFVvDY0-UM0h07gsBtt8cux44_XY9H8xoj12m7JgY3DA@mail.gmail.com>
Message-ID: <87fvnkzgqv.fsf@write-only.cryp.to>

Hi Nick,

I have to admit that reading your messages has left me wondering what exactly
it is that you are trying to do? What exactly is the problem that you are
trying to solve?

 > I see the solution isn't as easy as just replacing e.g.
 >
 > void myUnexpected () {
 >   std::cerr << "unexpected called\n";
 >   throw 0;
 > }
 >
 > by
 >
 > void myUnexpected () {
 >   std::cerr << "unexpected called\n";
 > }

I'm not sure whether the purpose of std::unexpected_handler() has become clear.
That function is not supposed to handle exceptions in the sense that it makes
the exception "go away" so that normal program flow can continue. Its purpose
is to translate an unexpected exception -- which the program cannot handle --
into a different one that the program can handle. Maybe this quote from [1]
clarifies the matter:

 | A user-defined std::unexpected_handler is expected to either terminate the
 | program or throw an exception. If it throws an exception, one of the
 | following three situations may be encountered:
 |
 |   1) the exception thrown by std::unexpected_handler satisfies the dynamic
 |      exception specification that was violated earlier. The new exception is
 |      allowed to escape the function and stack unwinding continues.
 |
 |   2) the exception thrown by std::unexpected_handler still violates the
 |      exception specification:
 |
 |       a) however, the exception specification allows std::bad_exception: the
 |          thrown exception object is destroyed, and std::bad_exception is
 |          constructed by the C++ runtime and thrown instead.
 |
 |       b) the exception specification does not allow std::bad_exception:
 |          std::terminate() is called.

This means that the second myUnexpected() function from above is actually
illegal in this context, because it neither throws an exception nor does it
terminate the program.


 > The test code I have chosen for learning about the problem is hsqml by Robin
 > Kay, which I consider to be very well done, usually injecting into
 > HsQMLManager.{cpp|h}.hsqml_init(...),
 >
 > extern "C"
 > void hsqml_init(void (*freeFun)(HsFunPtr), void (*freeStable)(HsStablePtr) ) throw() {
 >   std::set_unexpected (myunexpected);
 >   throw runtime_error("OOOPS...");
 >   ...
 > }

I am not sure what exactly the intention behind that code snippet is. I've
looked into the hsqml source at [2], and the hsqml_init() function there
doesn't look like that.


 > What puzzles me currently is that, by the descriptions, I would expect
 > that terminate() actually is replaced by std::cerr, so that the
 > termination displayed in the result happens afterwards ? but where??

I am not sure what you mean by that statement. std:cerr is an object, so it
cannot replace std::terminate(), which is a function.


 > In regard of what's my question, there should be something like a
 > common/best practice, shouldn't it?

Your question is how to integrate C++ code that might throw exceptions into
Haskell via FFI, right? Please correct me if that's not the case.

There is no one true way to accomplish that. Since you cannot catch or throw
C++ exceptions in Haskell, you'll probably have to pass them from C++ to
Haskell manually as a value. For example, the C++ function

  int do_stuff() { ... }

would need a wrapper like this one:

  enum exception_type { none = 0, runtime_error, logic_error, unknown };

  struct either_exception_or_int
  {
    exception_type err;
    int val;
  };

  void do_stuff_(either_exception_or_int * result) throw()
  {
    try
    {
      result->err = none;
      result->val = do_stuff();
    }
    catch(std::runtime_error const &)   { result->err = runtime_error; }
    catch(std::logic_error const &)     { result->err = logic_error; }
    catch(...)                          { result->err = unknown; }
  }

Now, on the Haskell side, you'd import do_stuff_() via FFI, and then write
another wrapper

  do_stuff :: IO Int
  do_stuff = alloca $ \result -> do
    do_stuff_ result
    val <- peek result
    either throwCxxError return val

  throwCxxError :: CxxExceptionType -> IO a
  throwCxxError Runtime_error = throwIO ...
  throwCxxError ...

to throw an appropriate Haskell exception that corresponds to the C++ exception
type.

I'm not sure whether anybody has done something like that before, i.e. I cannot
refer you to a concrete Haskell project that demonstrates this technique with
real-world code.


 > As Alexander states, there is a pleasing zero runtime approach with C++
 > exceptions.

I thought Alexander said the exact opposite, i.e. that C++ does *not* have zero
overhead exceptions?

Best regards,
Peter


[1] http://en.cppreference.com/w/cpp/error/unexpected_handler
[2] http://hackage.haskell.org/package/hsqml-0.2.0.3/src/cbits/HsQMLManager.cpp


From omari at smileystation.com  Sat Feb 15 13:46:06 2014
From: omari at smileystation.com (Omari Norman)
Date: Sat, 15 Feb 2014 08:46:06 -0500
Subject: [Haskell-cafe] [ANN] anonymous-sums
In-Reply-To: <CAJN5CVJsLm2N1-xWUGywjY95ROLJ8SMHppXKk-NzuzQCECBeDw@mail.gmail.com>
References: <CA+aFgYA-QvDgLnK8CK2fbTJ8sYeAWi9oWgyFTDF2fY_75JTnrg@mail.gmail.com>
 <52FEA8E3.2010601@informatik.uni-marburg.de>
 <CAJN5CVJsLm2N1-xWUGywjY95ROLJ8SMHppXKk-NzuzQCECBeDw@mail.gmail.com>
Message-ID: <CA+aFgYBUH7ZbiqA7gpMuwyOd4mfW73q=kFGwe_VZPkm6Rz+dxg@mail.gmail.com>

On Fri, Feb 14, 2014 at 11:02 PM, Tikhon Jelvis <tikhon at jelv.is> wrote:
> Yeah, S0 and S1 are probably worth including for the sake of completion. We
> don't have a 1-tuple, and I believe that's caused a bit of trouble for
> people writing generic libraries. Enough trouble so that somebody wrote a
> OneTuple package[1] anyhow.

S1 is easy enough; I added that in.

http://hackage.haskell.org/package/anonymous-sums-0.2.2.0

S0 takes some more thought as there's more than one way to do that. I
could use EmptyDataDecls or do it more like ekmett's Data.Void.  Then
what do you get for, e.g., partitionS0?

partitionS0 :: [S0] -> ()

I suppose that makes sense if you look at partition as returning the
same number of lists as there are type variables.  No type variables,
no lists.  Or should it be

partitionS0 :: [S0] -> Void

which also makes me wonder if this is a special case better left to Data.Void.

Thoughts?

From roma at ro-che.info  Sat Feb 15 14:08:01 2014
From: roma at ro-che.info (Roman Cheplyaka)
Date: Sat, 15 Feb 2014 16:08:01 +0200
Subject: [Haskell-cafe] [ANN] anonymous-sums
In-Reply-To: <CA+aFgYBUH7ZbiqA7gpMuwyOd4mfW73q=kFGwe_VZPkm6Rz+dxg@mail.gmail.com>
References: <CA+aFgYA-QvDgLnK8CK2fbTJ8sYeAWi9oWgyFTDF2fY_75JTnrg@mail.gmail.com>
 <52FEA8E3.2010601@informatik.uni-marburg.de>
 <CAJN5CVJsLm2N1-xWUGywjY95ROLJ8SMHppXKk-NzuzQCECBeDw@mail.gmail.com>
 <CA+aFgYBUH7ZbiqA7gpMuwyOd4mfW73q=kFGwe_VZPkm6Rz+dxg@mail.gmail.com>
Message-ID: <20140215140801.GA22784@sniper>

* Omari Norman <omari at smileystation.com> [2014-02-15 08:46:06-0500]
> On Fri, Feb 14, 2014 at 11:02 PM, Tikhon Jelvis <tikhon at jelv.is> wrote:
> > Yeah, S0 and S1 are probably worth including for the sake of completion. We
> > don't have a 1-tuple, and I believe that's caused a bit of trouble for
> > people writing generic libraries. Enough trouble so that somebody wrote a
> > OneTuple package[1] anyhow.
> 
> S1 is easy enough; I added that in.
> 
> http://hackage.haskell.org/package/anonymous-sums-0.2.2.0
> 
> S0 takes some more thought as there's more than one way to do that. I
> could use EmptyDataDecls or do it more like ekmett's Data.Void.  Then
> what do you get for, e.g., partitionS0?
> 
> partitionS0 :: [S0] -> ()
> 
> I suppose that makes sense if you look at partition as returning the
> same number of lists as there are type variables.  No type variables,
> no lists.  Or should it be
> 
> partitionS0 :: [S0] -> Void
> 
> which also makes me wonder if this is a special case better left to Data.Void.

The result should be a 0-tuple, i.e. (), of course. 

Otherwise, what would paritionS0 [] return?

Roman
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140215/dc71ac08/attachment.sig>

From simons at cryp.to  Sat Feb 15 14:54:57 2014
From: simons at cryp.to (Peter Simons)
Date: Sat, 15 Feb 2014 15:54:57 +0100
Subject: [Haskell-cafe] GHC 7.6.3 (and others) hashes
References: <CAO0Ooq1RaFziTa1NU23sy0rfW2=d8_GAtU8iLp+-SpAO1eV7yg@mail.gmail.com>
Message-ID: <874n408lz2.fsf@write-only.cryp.to>

Hi Alexander,

 > Is there any where I can find SHA hashes for the official GHC builds?

I don't think the GHC folks publish such hashes anywhere. You might want to
create a Trac ticket to that extend, because they really should, IMHO.

At the time being, there is no way for you to authenticate those binaries.

Take care,
Peter


From roma at ro-che.info  Sat Feb 15 15:04:29 2014
From: roma at ro-che.info (Roman Cheplyaka)
Date: Sat, 15 Feb 2014 17:04:29 +0200
Subject: [Haskell-cafe] GHC 7.6.3 (and others) hashes
In-Reply-To: <874n408lz2.fsf@write-only.cryp.to>
References: <CAO0Ooq1RaFziTa1NU23sy0rfW2=d8_GAtU8iLp+-SpAO1eV7yg@mail.gmail.com>
 <874n408lz2.fsf@write-only.cryp.to>
Message-ID: <20140215150429.GA27506@sniper>

* Peter Simons <simons at cryp.to> [2014-02-15 15:54:57+0100]
> Hi Alexander,
> 
>  > Is there any where I can find SHA hashes for the official GHC builds?
> 
> I don't think the GHC folks publish such hashes anywhere. You might want to
> create a Trac ticket to that extend, because they really should, IMHO.
> 
> At the time being, there is no way for you to authenticate those binaries.

This is one thing I never really understood. Can someone explain it
to me? I suppose that SHA hashes are meaningless unless they are
PGP-signed by, say, Austin? So what's the advantage over distributing a
PGP signature for the tarball itself?

Roman
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140215/698532b1/attachment.sig>

From simons at cryp.to  Sat Feb 15 15:10:55 2014
From: simons at cryp.to (Peter Simons)
Date: Sat, 15 Feb 2014 16:10:55 +0100
Subject: [Haskell-cafe] GHC 7.6.3 (and others) hashes
References: <CAO0Ooq1RaFziTa1NU23sy0rfW2=d8_GAtU8iLp+-SpAO1eV7yg@mail.gmail.com>
 <874n408lz2.fsf@write-only.cryp.to> <20140215150429.GA27506@sniper>
Message-ID: <87eh3476o0.fsf@write-only.cryp.to>

Hi Roman,

 > I suppose that SHA hashes are meaningless unless they are PGP-signed
 > by, say, Austin?

well, there are shades of gray. Technically speaking, even PGP-signatures
are meaningless unless you've personally verified the fingerprint of the
PGP-key that signed the release with the owner of the key. If you didn't do
that, you cannot trust the key, and hence its signature doesn't mean
anything.

In practice, however, a valid PGP-signature *does* add some security. It's
not 100% secure, but it's certainly better than no signature at all.

The same applies to publishing hashes. A published hash is no guarantee that
the binary is authentic, but having one is certainly better than *not*
having one. Right?

Take care,
Peter


From aslatter at gmail.com  Sat Feb 15 15:40:21 2014
From: aslatter at gmail.com (Antoine Latter)
Date: Sat, 15 Feb 2014 09:40:21 -0600
Subject: [Haskell-cafe] Naming scheme for partial functions
In-Reply-To: <CAKA2Jg+utH5gprJ_x10YVhQ_-xNfQRP5A7Lqdyq9-A9E5F=+5w@mail.gmail.com>
References: <CAKA2JgKUDSpS3Etmm4gdepd5UuiLnF1RTVbx62eTs2yEdMzUcg@mail.gmail.com>
 <CAGigdoeH495PqqCa+sfkNfCpqB7HwbGTReMg_JDg1SD30A24hg@mail.gmail.com>
 <CAJN5CVKhTjAY7Njzv9FZChzxEbRY8dyj6g9Q3cE8bpcx+AL=Kw@mail.gmail.com>
 <CAKA2JgJzRMOQO6vqobC86ZN=adHqYn-wR92akOPWqGfH=Pptxg@mail.gmail.com>
 <CAKjSnQGj5UXWEtQDCAtB6f4ETMho25-=HN7BqKYDbETa+SF9_w@mail.gmail.com>
 <CAKA2JgJURJEo5-01yOtN1KOdA5HPzBT_BrmcKTCQ1b=rA6a0Dg@mail.gmail.com>
 <CAKjSnQFa_yza4hz+hM4Zk2EKTnF=msNVA3mz4+R+tYrq8Kywug@mail.gmail.com>
 <CAKA2Jg+utH5gprJ_x10YVhQ_-xNfQRP5A7Lqdyq9-A9E5F=+5w@mail.gmail.com>
Message-ID: <CAKjSnQEYcnk95m0hC6yTZafK-fM_-jhp-aixbmL7tvZLoWOZ4Q@mail.gmail.com>

Yeah, that's a good point.Text and Bytestring (and other similar packages)
have been pushing the boundaries of 'unsafe' and are in wide use.


On Sun, Feb 9, 2014 at 11:38 PM, Michael Snoyman <michael at snoyman.com>wrote:

> I don't want to drag out bikeshedding either. But I *do* want to point out
> that mono-traversable also includes a function unsafeHead, separate from
> headEx. While headEx guarantees that it will throw an exception in the case
> of an empty Foldable, unsafeHead may crash your program. This is the same
> kind of distinction as vector and bytestring make between head and
> unsafeHead.
>
>
> On Sun, Feb 9, 2014 at 6:41 PM, Antoine Latter <aslatter at gmail.com> wrote:
>
>> Not that it matters, but I think I prefer the "Unsafe" suffix. I'm not
>> calling this version of "head" because I *want* an exception - I'm calling
>> it because I want "Unsafe" (non-typechecked) behavior - I'm asserting that
>> I've already validated some preconditions that aren't reflected in the type.
>>
>> But on the other hand I've always found functions like "fromMaybe" easier
>> to work with than functions like "fromJust".
>>
>> Enough bikeshedding! If it works in your packages that's fine, and these
>> are the sort of functions I have no complaints about reimplementing on my
>> own.
>>
>>
>> On Sat, Feb 8, 2014 at 11:25 PM, Michael Snoyman <michael at snoyman.com>wrote:
>>
>>> It means "throws an *ex*ception."
>>>
>>>
>>> On Sun, Feb 9, 2014 at 5:04 AM, Antoine Latter <aslatter at gmail.com>wrote:
>>>
>>>> What does "Ex" mean?
>>>>
>>>>
>>>> On Thu, Feb 6, 2014 at 8:59 PM, Michael Snoyman <michael at snoyman.com>wrote:
>>>>
>>>>> Thanks for the input. We ended up going with an `Ex` suffix, e.g.
>>>>> headEx, lastEx.
>>>>>
>>>>>
>>>>> On Fri, Feb 7, 2014 at 4:53 AM, Tikhon Jelvis <tikhon at jelv.is> wrote:
>>>>>
>>>>>> For what it's worth, OCaml's Core library does this with _exn, so
>>>>>> they would call a partial last "last_exn". I would actually prefer an
>>>>>> abbreviation of some sort (like exn) as long as it's a consistent
>>>>>> convention. Using a full word like "exception" or "partial" adds to much
>>>>>> noise in my opinion, especially if the base name (like "last") is shorter
>>>>>> than the suffix!
>>>>>>
>>>>>> Also, I think a suffix would be better than a prefix, if only to
>>>>>> group things conveniently when sorted alphabetically.
>>>>>>
>>>>>>
>>>>>> On Thu, Jan 30, 2014 at 9:36 AM, Atze van der Ploeg <atzeus at gmail.com
>>>>>> > wrote:
>>>>>>
>>>>>>> unprovenLast ?
>>>>>>> On Jan 30, 2014 6:33 PM, "Michael Snoyman" <michael at snoyman.com>
>>>>>>> wrote:
>>>>>>>
>>>>>>>> Greg Weber and I have been discussing some changes to
>>>>>>>> mono-traversable[1]. One of the modules we provide is Data.NonNull, which
>>>>>>>> provides total versions of functions like `last`. A change we're looking at
>>>>>>>> would require having a partial version of `last` defined in a separate
>>>>>>>> typeclass (IsSequence), which would allowing for more optimized
>>>>>>>> implementations of the total `last` function for datatypes which support it
>>>>>>>> (e.g., strict ByteStrings).
>>>>>>>>
>>>>>>>> But what should we name it? I'm sure everyone's familiar with the
>>>>>>>> `unsafe` naming convention, but that's not appropriate here: standard usage
>>>>>>>> shows `unsafe` meaning a function which can cause a segfault.
>>>>>>>>
>>>>>>>> I initially named it `partialLast`, but partial can also imply
>>>>>>>> partial function application. Greg brought up the idea of suffixing the
>>>>>>>> function with something like `Throws` or `Errors`, which I think I'm a bit
>>>>>>>> partial to myself[2].
>>>>>>>>
>>>>>>>> So my questions are:
>>>>>>>>
>>>>>>>> * Is there some already used naming scheme out there for partial
>>>>>>>> functions which I've missed?
>>>>>>>> * Do people have any ideas to throw into the mix?
>>>>>>>>
>>>>>>>> Michael
>>>>>>>>
>>>>>>>> [1] https://github.com/snoyberg/mono-traversable/pull/21
>>>>>>>> [2] Pardon the pun.
>>>>>>>>
>>>>>>>> _______________________________________________
>>>>>>>> Haskell-Cafe mailing list
>>>>>>>> Haskell-Cafe at haskell.org
>>>>>>>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>>>>>>>
>>>>>>>>
>>>>>>> _______________________________________________
>>>>>>> Haskell-Cafe mailing list
>>>>>>> Haskell-Cafe at haskell.org
>>>>>>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>>>>>>
>>>>>>>
>>>>>>
>>>>>
>>>>> _______________________________________________
>>>>> Haskell-Cafe mailing list
>>>>> Haskell-Cafe at haskell.org
>>>>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>>>>
>>>>>
>>>>
>>>
>>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140215/32a9f4e9/attachment.html>

From roma at ro-che.info  Sat Feb 15 15:41:38 2014
From: roma at ro-che.info (Roman Cheplyaka)
Date: Sat, 15 Feb 2014 17:41:38 +0200
Subject: [Haskell-cafe] GHC 7.6.3 (and others) hashes
In-Reply-To: <87eh3476o0.fsf@write-only.cryp.to>
References: <CAO0Ooq1RaFziTa1NU23sy0rfW2=d8_GAtU8iLp+-SpAO1eV7yg@mail.gmail.com>
 <874n408lz2.fsf@write-only.cryp.to> <20140215150429.GA27506@sniper>
 <87eh3476o0.fsf@write-only.cryp.to>
Message-ID: <20140215154138.GA28839@sniper>

* Peter Simons <simons at cryp.to> [2014-02-15 16:10:55+0100]
> Hi Roman,
> 
>  > I suppose that SHA hashes are meaningless unless they are PGP-signed
>  > by, say, Austin?
> 
> well, there are shades of gray. Technically speaking, even PGP-signatures
> are meaningless unless you've personally verified the fingerprint of the
> PGP-key that signed the release with the owner of the key. If you didn't do
> that, you cannot trust the key, and hence its signature doesn't mean
> anything.

Obviously. But PGP has at least some value (it's useful for those who
trust the key), while just an SHA sum... I don't know.

Also, a PGP signature is itself a signed hash, so there's hardly any
"security" reason to prefer plain SHA to PGP.

> In practice, however, a valid PGP-signature *does* add some security. It's
> not 100% secure, but it's certainly better than no signature at all.
> 
> The same applies to publishing hashes. A published hash is no guarantee that
> the binary is authentic, but having one is certainly better than *not*
> having one. Right?

In that case, SHA256 of https://www.haskell.org/ghc/dist/7.6.3/ghc-7.6.3-i386-unknown-linux.tar.bz2
is eb9bd2ca86c72c7f2ba9f2301e2ae04c44aa4828cf1180548619aa4c040a7ff0. HTH.

Roman
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140215/4d2c5603/attachment.sig>

From kyle.marek.spartz at gmail.com  Sat Feb 15 16:20:45 2014
From: kyle.marek.spartz at gmail.com (Kyle Marek-Spartz)
Date: Sat, 15 Feb 2014 10:20:45 -0600
Subject: [Haskell-cafe] GHC 7.6.3 (and others) hashes
In-Reply-To: <20140215154138.GA28839@sniper>
References: <CAO0Ooq1RaFziTa1NU23sy0rfW2=d8_GAtU8iLp+-SpAO1eV7yg@mail.gmail.com>
 <874n408lz2.fsf@write-only.cryp.to> <20140215150429.GA27506@sniper>
 <87eh3476o0.fsf@write-only.cryp.to> <20140215154138.GA28839@sniper>
Message-ID: <etPan.52ff93dd.643c9869.f8d8@highlander>

It is also useful for non-security reasons, e.g. data corruption due to a poor network connection or bad file system.

-- 
Kyle Marek-Spartz

On February 15, 2014 at 9:41:55 AM, Roman Cheplyaka (roma at ro-che.info) wrote:
> 
> * Peter Simons [2014-02-15 16:10:55+0100] 
> > Hi Roman,
> >
> > > I suppose that SHA hashes are meaningless unless they are PGP-signed 
> > > by, say, Austin?
> >
> > well, there are shades of gray. Technically speaking, even 
> PGP-signatures
> > are meaningless unless you've personally verified the fingerprint 
> of the
> > PGP-key that signed the release with the owner of the key. If 
> you didn't do
> > that, you cannot trust the key, and hence its signature doesn't 
> mean
> > anything.
> 
> Obviously. But PGP has at least some value (it's useful for those 
> who
> trust the key), while just an SHA sum... I don't know.
> 
> Also, a PGP signature is itself a signed hash, so there's hardly 
> any
> "security" reason to prefer plain SHA to PGP.
> 
> > In practice, however, a valid PGP-signature *does* add some 
> security. It's
> > not 100% secure, but it's certainly better than no signature 
> at all.
> >
> > The same applies to publishing hashes. A published hash is no 
> guarantee that
> > the binary is authentic, but having one is certainly better 
> than *not*
> > having one. Right?
> 
> In that case, SHA256 of https://www.haskell.org/ghc/dist/7.6.3/ghc-7.6.3-i386-unknown-linux.tar.bz2 
> is eb9bd2ca86c72c7f2ba9f2301e2ae04c44aa4828cf1180548619aa4c040a7ff0. 
> HTH.
> 
> Roman
> - signature.asc, 836 bytes _______________________________________________ 
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe 
> 


From omari at smileystation.com  Sat Feb 15 17:32:58 2014
From: omari at smileystation.com (Omari Norman)
Date: Sat, 15 Feb 2014 12:32:58 -0500
Subject: [Haskell-cafe] [ANN] anonymous-sums
In-Reply-To: <20140215140801.GA22784@sniper>
References: <CA+aFgYA-QvDgLnK8CK2fbTJ8sYeAWi9oWgyFTDF2fY_75JTnrg@mail.gmail.com>
 <52FEA8E3.2010601@informatik.uni-marburg.de>
 <CAJN5CVJsLm2N1-xWUGywjY95ROLJ8SMHppXKk-NzuzQCECBeDw@mail.gmail.com>
 <CA+aFgYBUH7ZbiqA7gpMuwyOd4mfW73q=kFGwe_VZPkm6Rz+dxg@mail.gmail.com>
 <20140215140801.GA22784@sniper>
Message-ID: <CA+aFgYAf=+iKu8LR57qAVC1c0mardYxJk+7uYg1OCyX+43LPNg@mail.gmail.com>

On Sat, Feb 15, 2014 at 9:08 AM, Roman Cheplyaka <roma at ro-che.info> wrote:
>> partitionS0 :: [S0] -> ()
>>
>> I suppose that makes sense if you look at partition as returning the
>> same number of lists as there are type variables.  No type variables,
>> no lists.  Or should it be
>>
>> partitionS0 :: [S0] -> Void
>>
>> which also makes me wonder if this is a special case better left to Data.Void.
>
> The result should be a 0-tuple, i.e. (), of course.
>
> Otherwise, what would paritionS0 [] return?

OK, so with EmptyDataDecls this yields:

data S0 deriving (Generic, Typeable)

instance Eq S0 where _ == _ = undefined
instance Ord S0 where compare _ _ = undefined
instance Read S0 where readsPrec _ = undefined
instance Show S0 where show _ = undefined

partitionS0 :: [S0] -> ()
partitionS0 _ = ()

caseS0 :: S0 -> z
caseS0 = undefined

mapS0 :: S0 -> S0
mapS0 = id

mapS0f :: Functor ftr => S0 -> ftr S0
mapS0f = undefined

From roma at ro-che.info  Sat Feb 15 19:27:56 2014
From: roma at ro-che.info (Roman Cheplyaka)
Date: Sat, 15 Feb 2014 21:27:56 +0200
Subject: [Haskell-cafe] GHC 7.6.3 (and others) hashes
In-Reply-To: <etPan.52ff93dd.643c9869.f8d8@highlander>
References: <CAO0Ooq1RaFziTa1NU23sy0rfW2=d8_GAtU8iLp+-SpAO1eV7yg@mail.gmail.com>
 <874n408lz2.fsf@write-only.cryp.to> <20140215150429.GA27506@sniper>
 <87eh3476o0.fsf@write-only.cryp.to> <20140215154138.GA28839@sniper>
 <etPan.52ff93dd.643c9869.f8d8@highlander>
Message-ID: <20140215192756.GA29983@sniper>

bzip2 already includes a CRC-32 checksum that should suffice for
non-security purposes.

* Kyle Marek-Spartz <kyle.marek.spartz at gmail.com> [2014-02-15 10:20:45-0600]
> It is also useful for non-security reasons, e.g. data corruption due to a poor network connection or bad file system.
> 
> -- 
> Kyle Marek-Spartz
> 
> On February 15, 2014 at 9:41:55 AM, Roman Cheplyaka (roma at ro-che.info) wrote:
> > 
> > * Peter Simons [2014-02-15 16:10:55+0100] 
> > > Hi Roman,
> > >
> > > > I suppose that SHA hashes are meaningless unless they are PGP-signed 
> > > > by, say, Austin?
> > >
> > > well, there are shades of gray. Technically speaking, even 
> > PGP-signatures
> > > are meaningless unless you've personally verified the fingerprint 
> > of the
> > > PGP-key that signed the release with the owner of the key. If 
> > you didn't do
> > > that, you cannot trust the key, and hence its signature doesn't 
> > mean
> > > anything.
> > 
> > Obviously. But PGP has at least some value (it's useful for those 
> > who
> > trust the key), while just an SHA sum... I don't know.
> > 
> > Also, a PGP signature is itself a signed hash, so there's hardly 
> > any
> > "security" reason to prefer plain SHA to PGP.
> > 
> > > In practice, however, a valid PGP-signature *does* add some 
> > security. It's
> > > not 100% secure, but it's certainly better than no signature 
> > at all.
> > >
> > > The same applies to publishing hashes. A published hash is no 
> > guarantee that
> > > the binary is authentic, but having one is certainly better 
> > than *not*
> > > having one. Right?
> > 
> > In that case, SHA256 of https://www.haskell.org/ghc/dist/7.6.3/ghc-7.6.3-i386-unknown-linux.tar.bz2 
> > is eb9bd2ca86c72c7f2ba9f2301e2ae04c44aa4828cf1180548619aa4c040a7ff0. 
> > HTH.
> > 
> > Roman
> > - signature.asc, 836 bytes _______________________________________________ 
> > Haskell-Cafe mailing list
> > Haskell-Cafe at haskell.org
> > http://www.haskell.org/mailman/listinfo/haskell-cafe 
> > 
> 
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140215/80816feb/attachment.sig>

From roma at ro-che.info  Sat Feb 15 21:53:33 2014
From: roma at ro-che.info (Roman Cheplyaka)
Date: Sat, 15 Feb 2014 23:53:33 +0200
Subject: [Haskell-cafe] Protecting against main thread exit
Message-ID: <20140215215333.GA6971@sniper>

When using forkFinally or bracket, I like to have the guarantee that the
cleanup action will be executed regardless of how the action or thread
is terminated ? normally or via an exception.

Of course, all guarantees are off when dealing with SIGKILL or power
reset, but there's one other annoying exception (no pun intended) ? when
the main thread terminates, all other threads are silently shut down,
without any chance to clean up.

Why is it done that way? Why not kill them with an async exception
instead? That would be a more uniform behavior.

Are there any good ways to protect again the main thread exit?

(Note that I'm talking about a library, so I can't have direct
control over what's going on in the main thread.)

Roman
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140215/fa2713ed/attachment.sig>

From nick.rudnick at gmail.com  Sun Feb 16 03:39:24 2014
From: nick.rudnick at gmail.com (Nick Rudnick)
Date: Sun, 16 Feb 2014 04:39:24 +0100
Subject: [Haskell-cafe] C++ exception (from *.so) catchable by Haskell??
In-Reply-To: <87fvnkzgqv.fsf@write-only.cryp.to>
References: <CA+XUKchkD5pSigEBqp77JQe3xwq6PL=Q_ZVuLeS1c9V67yXxRA@mail.gmail.com>
 <CAKFCL4UJwDBZny9J2BSv40YWk263DJH_0yWsWVhXw_FhkuZbmw@mail.gmail.com>
 <CA+XUKciW_y8pF57f1mQYj+AQkX4iYik6_BMBa5TOLni68XSoPg@mail.gmail.com>
 <87r476h9d1.fsf@write-only.cryp.to>
 <CA+XUKciFVvDY0-UM0h07gsBtt8cux44_XY9H8xoj12m7JgY3DA@mail.gmail.com>
 <87fvnkzgqv.fsf@write-only.cryp.to>
Message-ID: <CA+XUKcijrcvt1TEDXCMWFMbLbRhHx6Vf0sWKaPhJo3vrPqntWg@mail.gmail.com>

>
>
>
> I have to admit that reading your messages has left me wondering what
> exactly
> it is that you are trying to do? What exactly is the problem that you are
> trying to solve?
>
You exactly got the point (below)  with "Your question is how to integrate
C++ code that might throw exceptions into Haskell via FFI, right?".

The only thing I am worried about is that, due to lacking experience, I
might introduce unnecessary runtime overhead, as performance is critical. I
don't want to disimprove.


>  > I see the solution isn't as easy as just replacing e.g.
>  >
>  > void myUnexpected () {
>  >   std::cerr << "unexpected called\n";
>  >   throw 0;
>  > }
>  >
>  > by
>  >
>  > void myUnexpected () {
>  >   std::cerr << "unexpected called\n";
>  > }
>
> I'm not sure whether the purpose of std::unexpected_handler() has become
> clear.
> That function is not supposed to handle exceptions in the sense that it
> makes
> the exception "go away" so that normal program flow can continue. Its
> purpose
> is to translate an unexpected exception -- which the program cannot handle
> --
> into a different one that the program can handle. Maybe this quote from [1]
> clarifies the matter:
>
>  | A user-defined std::unexpected_handler is expected to either terminate
> the
>  | program or throw an exception. If it throws an exception, one of the
>  | following three situations may be encountered:
>  |
>  |   1) the exception thrown by std::unexpected_handler satisfies the
> dynamic
>  |      exception specification that was violated earlier. The new
> exception is
>  |      allowed to escape the function and stack unwinding continues.
>  |
>  |   2) the exception thrown by std::unexpected_handler still violates the
>  |      exception specification:
>  |
>  |       a) however, the exception specification allows
> std::bad_exception: the
>  |          thrown exception object is destroyed, and std::bad_exception is
>  |          constructed by the C++ runtime and thrown instead.
>  |
>  |       b) the exception specification does not allow std::bad_exception:
>  |          std::terminate() is called.
>
> This means that the second myUnexpected() function from above is actually
> illegal in this context, because it neither throws an exception nor does it
> terminate the program.

What a delicate question... :-)) :-)) :-)) Better I choose my words
careful... Hmmm... certainly... In my case, it's failed DB queries that may
be caused by failed SQL queries in a backend behind the C++ code; and as
far as I can judge, everything is already handled neatly with no collateral
damage to be feared for ? roughly, these C++ exceptions say that the SQL
code wasn't executed ? in (a possible) interactive mode meaning merely
"please repeat that query correctly...".

But currently, this appears somewhat complicated by
(1) termination of the code
(2) quite terse messages (i.e., I am interested in better debug
capabilities, too)

By reading Alexander's link to
http://www.cplusplus.com/reference/exception/set_unexpected/, I got the
impression that there is reasonable chance there is a simple mechanism
behind set_unexpected(...) allows replacing some default code leading to
termination by arbitrary code ? very attractive under these circumstances
?, and facing the question what's the meaning of 'illegal' was second to
this...

Anyway, this round went to Murphy ? or at least I do not see a way to get
the termination avalanche stopped yet.

>
>  > The test code I have chosen for learning about the problem is hsqml by
> Robin
>  > Kay, which I consider to be very well done, usually injecting into
>  > HsQMLManager.{cpp|h}.hsqml_init(...),
>  >
>  > extern "C"
>  > void hsqml_init(void (*freeFun)(HsFunPtr), void
> (*freeStable)(HsStablePtr) ) throw() {
>  >   std::set_unexpected (myunexpected);
>  >   throw runtime_error("OOOPS...");
>  >   ...
>  > }
>
> I am not sure what exactly the intention behind that code snippet is. I've
> looked into the hsqml source at [2], and the hsqml_init() function there
> doesn't look like that.
>
Certainly, as lines were injected by me (I guess I mentioned at 1st mail)
for learning about the problem ? with hsqml being needed as a scaffold for
this.


>
>  > What puzzles me currently is that, by the descriptions, I would expect
>  > that terminate() actually is replaced by std::cerr, so that the
>  > termination displayed in the result happens afterwards ? but where??
>
> I am not sure what you mean by that statement. std:cerr is an object, so it
> cannot replace std::terminate(), which is a function.
>
 Please excuse: s/std:cerr/std:cerr.../

>
>  > In regard of what's my question, there should be something like a
>  > common/best practice, shouldn't it?
>
> Your question is how to integrate C++ code that might throw exceptions into
> Haskell via FFI, right? Please correct me if that's not the case.
>
Definitely, modulo performance/overhead.

>
> There is no one true way to accomplish that. Since you cannot catch or
> throw
> C++ exceptions in Haskell, you'll probably have to pass them from C++ to
> Haskell manually as a value. For example, the C++ function
>
>   int do_stuff() { ... }
>
> would need a wrapper like this one:
>
>   enum exception_type { none = 0, runtime_error, logic_error, unknown };
>
>   struct either_exception_or_int
>   {
>     exception_type err;
>     int val;
>   };
>
>   void do_stuff_(either_exception_or_int * result) throw()
>   {
>     try
>     {
>       result->err = none;
>       result->val = do_stuff();
>     }
>     catch(std::runtime_error const &)   { result->err = runtime_error; }
>     catch(std::logic_error const &)     { result->err = logic_error; }
>     catch(...)                          { result->err = unknown; }
>   }
>
> Now, on the Haskell side, you'd import do_stuff_() via FFI, and then write
> another wrapper
>
>   do_stuff :: IO Int
>   do_stuff = alloca $ \result -> do
>     do_stuff_ result
>     val <- peek result
>     either throwCxxError return val
>
>   throwCxxError :: CxxExceptionType -> IO a
>   throwCxxError Runtime_error = throwIO ...
>   throwCxxError ...
>
> to throw an appropriate Haskell exception that corresponds to the C++
> exception
> type.
>
You exactly concretized the 'Either' approach sketched in my mail, though I
would have tried to
(1) get a union instead of a struct for `either_exception_or_int'
(2) use pointers for err/val.
What I am worried about is that exactly this might result in inappropriate
overhead.

This directly leads to the other suggestion of my mail; to, instead of a
union of 2 pointers, let `either_exception_or_int' be just a pointer ?
somewhat opaque for the Haskell side, which still might pipeline it very
efficiently from here to there, while it would be possible to C++ to
resolve the pointer addresses.

So with my 'illegal' one, I see 3 approaches yet.

I'm not sure whether anybody has done something like that before, i.e. I
> cannot
> refer you to a concrete Haskell project that demonstrates this technique
> with
> real-world code.
>
[?]

 > As Alexander states, there is a pleasing zero runtime approach with C++
>  > exceptions.
>
> I thought Alexander said the exact opposite, i.e. that C++ does *not* have
> zero
> overhead exceptions?
>
I referred to his mail just incoming when I answered to you (2014-2-14
9:11, "One unmentioned fact is that the exception mechanism in C++ is
designed to allow for implementations to have zero runtime cost. ...") ?
what he addresses makes me quite less worried that catching C++ exceptions
themselves in the FFI would introduce performance issues, than
wrapping/unwrapping with Either & Co.

Cheers, Nick
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140216/c28c32cf/attachment.html>
-------------- next part --------------
A non-text attachment was scrubbed...
Name: 33A.gif
Type: image/gif
Size: 581 bytes
Desc: not available
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140216/c28c32cf/attachment.gif>

From alex.solla at gmail.com  Sun Feb 16 06:19:57 2014
From: alex.solla at gmail.com (Alexander Solla)
Date: Sat, 15 Feb 2014 22:19:57 -0800
Subject: [Haskell-cafe] GHC 7.6.3 (and others) hashes
In-Reply-To: <20140215150429.GA27506@sniper>
References: <CAO0Ooq1RaFziTa1NU23sy0rfW2=d8_GAtU8iLp+-SpAO1eV7yg@mail.gmail.com>
 <874n408lz2.fsf@write-only.cryp.to> <20140215150429.GA27506@sniper>
Message-ID: <CAO0Ooq2LwjO3xOrobceQMTk5x3y9A8gYbJbwrWNip-UjqpgdFA@mail.gmail.com>

On Sat, Feb 15, 2014 at 7:04 AM, Roman Cheplyaka <roma at ro-che.info> wrote:

> * Peter Simons <simons at cryp.to> [2014-02-15 15:54:57+0100]
> > Hi Alexander,
> >
> >  > Is there any where I can find SHA hashes for the official GHC builds?
> >
> > I don't think the GHC folks publish such hashes anywhere. You might want
> to
> > create a Trac ticket to that extend, because they really should, IMHO.
> >
> > At the time being, there is no way for you to authenticate those
> binaries.
>
> This is one thing I never really understood. Can someone explain it
> to me? I suppose that SHA hashes are meaningless unless they are
> PGP-signed by, say, Austin? So what's the advantage over distributing a
> PGP signature for the tarball itself?


For my part, my question was mostly motivated by the tools I'm using, which
use SHA hashes.  You are right that signing would provide more security,
but the tools I'm evaluating use hashes.  And I can foresee circumstances
in which they provide protection against attack.  For example, some large
projects mirror the keys.  An unannounced change of the hash would get
noticed.  This is especially true if I keep a copy of the hash.  Making
hashes is pretty cheap.  So is signing.  I am not against signing as well,
by any means.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140215/1a057abe/attachment.html>

From carter.schonwald at gmail.com  Sun Feb 16 06:59:21 2014
From: carter.schonwald at gmail.com (Carter Schonwald)
Date: Sun, 16 Feb 2014 01:59:21 -0500
Subject: [Haskell-cafe] C++ exception (from *.so) catchable by Haskell??
In-Reply-To: <CA+XUKcijrcvt1TEDXCMWFMbLbRhHx6Vf0sWKaPhJo3vrPqntWg@mail.gmail.com>
References: <CA+XUKchkD5pSigEBqp77JQe3xwq6PL=Q_ZVuLeS1c9V67yXxRA@mail.gmail.com>
 <CAKFCL4UJwDBZny9J2BSv40YWk263DJH_0yWsWVhXw_FhkuZbmw@mail.gmail.com>
 <CA+XUKciW_y8pF57f1mQYj+AQkX4iYik6_BMBa5TOLni68XSoPg@mail.gmail.com>
 <87r476h9d1.fsf@write-only.cryp.to>
 <CA+XUKciFVvDY0-UM0h07gsBtt8cux44_XY9H8xoj12m7JgY3DA@mail.gmail.com>
 <87fvnkzgqv.fsf@write-only.cryp.to>
 <CA+XUKcijrcvt1TEDXCMWFMbLbRhHx6Vf0sWKaPhJo3vrPqntWg@mail.gmail.com>
Message-ID: <CAHYVw0z+1fOw7kf-QhcN-KzHKB_AoS_zPG2G0Hya9-spu08_Aw@mail.gmail.com>

Don't speculate.  Write benchmarks for the safe and unsafe benchmark
approaches using criterion and find out.  Honestly any db query will take
at least 100 microseconds and any exceptions overhead plus safe ffi
overhead is going to be negligible.

Point being : write benchmarks. And for ANY computation that ever takes
more than 1 microsecond, please use the safe ffi.

On Saturday, February 15, 2014, Nick Rudnick <nick.rudnick at gmail.com> wrote:

>
>>
>> I have to admit that reading your messages has left me wondering what
>> exactly
>> it is that you are trying to do? What exactly is the problem that you are
>> trying to solve?
>>
> You exactly got the point (below)  with "Your question is how to integrate
> C++ code that might throw exceptions into Haskell via FFI, right?".
>
> The only thing I am worried about is that, due to lacking experience, I
> might introduce unnecessary runtime overhead, as performance is critical. I
> don't want to disimprove.
>
>
>>  > I see the solution isn't as easy as just replacing e.g.
>>  >
>>  > void myUnexpected () {
>>  >   std::cerr << "unexpected called\n";
>>  >   throw 0;
>>  > }
>>  >
>>  > by
>>  >
>>  > void myUnexpected () {
>>  >   std::cerr << "unexpected called\n";
>>  > }
>>
>> I'm not sure whether the purpose of std::unexpected_handler() has become
>> clear.
>> That function is not supposed to handle exceptions in the sense that it
>> makes
>> the exception "go away" so that normal program flow can continue. Its
>> purpose
>> is to translate an unexpected exception -- which the program cannot
>> handle --
>> into a different one that the program can handle. Maybe this quote from
>> [1]
>> clarifies the matter:
>>
>>  | A user-defined std::unexpected_handler is expected to either terminate
>> the
>>  | program or throw an exception. If it throws an exception, one of the
>>  | following three situations may be encountered:
>>  |
>>  |   1) the exception thrown by std::unexpected_handler satisfies the
>> dynamic
>>  |      exception specification that was violated earlier. The new
>> exception is
>>  |      allowed to escape the function and stack unwinding continues.
>>  |
>>  |   2) the exception thrown by std::unexpected_handler still violates the
>>  |      exception specification:
>>  |
>>  |       a) however, the exception specification allows
>> std::bad_exception: the
>>  |          thrown exception object is destroyed, and std::bad_exception
>> is
>>  |          constructed by the C++ runtime and thrown instead.
>>  |
>>  |       b) the exception specification does not allow std::bad_exception:
>>  |          std::terminate() is called.
>>
>> This means that the second myUnexpected() function from above is actually
>> illegal in this context, because it neither throws an exception nor does
>> it
>> terminate the program.
>
> What a delicate question... :-)) :-)) :-)) Better I choose my words
> careful... Hmmm... certainly... In my case, it's failed DB queries that may
> be caused by failed SQL queries in a backend behind the C++ code; and as
> far as I can judge, everything is already handled neatly with no collateral
> damage to be feared for ? roughly, these C++ exceptions say that the SQL
> code wasn't executed ? in (a possible) interactive mode meaning merely
> "please repeat that query correctly...".
>
> But currently, this appears somewhat complicated by
> (1) termination of the code
> (2) quite terse messages (i.e., I am interested in better debug
> capabilities, too)
>
> By reading Alexander's link to
> http://www.cplusplus.com/reference/exception/set_unexpected/, I got the
> impression that there is reasonable chance there is a simple mechanism
> behind set_unexpected(...) allows replacing some default code leading to
> termination by arbitrary code ? very attractive under these circumstances
> ?, and facing the question what's the meaning of 'illegal' was second to
> this...
>
> Anyway, this round went to Murphy ? or at least I do not see a way to get
> the termination avalanche stopped yet.
>
>>
>>  > The test code I have chosen for learning about the problem is hsqml by
>> Robin
>>  > Kay, which I consider to be very well done, usually injecting into
>>  > HsQMLManager.{cpp|h}.hsqml_init(...),
>>  >
>>  > extern "C"
>>  > void hsqml_init(void (*freeFun)(HsFunPtr), void
>> (*freeStable)(HsStablePtr) ) throw() {
>>  >   std::set_unexpected (myunexpected);
>>  >   throw runtime_error("OOOPS...");
>>  >   ...
>>  > }
>>
>> I am not sure what exactly the intention behind that code snippet is. I've
>> looked into the hsqml source at [2], and the hsqml_init() function there
>> doesn't look like that.
>>
> Certainly, as lines were injected by me (I guess I mentioned at 1st mail)
> for learning about the problem ? with hsqml being needed as a scaffold for
> this.
>
>
>>
>>  > What puzzles me currently is that, by the descriptions, I would expect
>>  > that terminate() actually is replaced by std::cerr, so that the
>>  > termination displayed in the result happens afterwards ? but where??
>>
>> I am not sure what you mean by that statement. std:cerr is an object, so
>> it
>> cannot replace std::terminate(), which is a function.
>>
>  Please excuse: s/std:cerr/std:cerr.../
>
>>
>>  > In regard of what's my question, there should be something like a
>>  > common/best practice, shouldn't it?
>>
>> Your question is how to integrate C++ code that might throw exceptions
>> into
>> Haskell via FFI, right? Please correct me if that's not the case.
>>
> Definitely, modulo performance/overhead.
>
>>
>> There is no one true way to accomplish that. Since you cannot catch or
>> throw
>> C++ exceptions in Haskell, you'll probably have to pass them from C++ to
>> Haskell manually as a value. For example, the C++ function
>>
>>   int do_stuff() { ... }
>>
>> would need a wrapper like this one:
>>
>>   enum exception_type { none = 0, runtime_error, logic_error, unknown };
>>
>>   struct either_exception_or_int
>>   {
>>     exception_type err;
>>     int val;
>>   };
>>
>>   void do_stuff_(either_exception_or_int * result) throw()
>>   {
>>     try
>>     {
>>       result->err = none;
>>       result->val = do_stuff();
>>     }
>>     catch(std::runtime_error const &)   { result->err = runtime_error; }
>>     catch(std::logic_error const &)     { result->err = logic_error; }
>>     catch(...)                          { result->err = unknown; }
>>   }
>>
>> Now, on the Haskell side, you'd import do_stuff_() via FFI, and then write
>> another wrapper
>>
>>   do_stuff :: IO Int
>>   do_stuff = alloca $ \result -> do
>>     do_stuff_ result
>>     val <- peek result
>>     either throwCxxError return val
>>
>>   throwCxxError :: CxxExceptionType -> IO a
>>   throwCxxError Runtime_error = throwIO ...
>>   throwCxxError ...
>>
>> to throw an appropriate Haskell exception that corresponds to the C++
>> exception
>> type.
>>
> You exactly concretized the 'Either' approach sketched in my mail, though
> I would have tried to
> (1) get a union instead of a struct for `either_exception_or_int'
> (2) use pointers for err/val.
> What I am worried about is that exactly this might result in inappropriate
> overhead.
>
> This directly leads to the other suggestion of my mail; to, instead of a
> union of 2 pointers, let `either_exception_or_int' be just a pointer ?
> somewhat opaque for the Haskell side, which still might pipeline it very
> efficiently from here to there, while it would be possible to C++ to
> resolve the pointer addresses.
>
> So with my 'illegal' one, I see 3 approaches yet.
>
> I'm not sure whether anybody has done something like that before, i.e. I
>> cannot
>> refer you to a concrete Haskell project that demonstrates this technique
>> with
>> real-world code.
>>
> [?]
>
>  > As Alexander states, there is a pleasing zero runtime approach with C++
>>  > exceptions.
>>
>> I thought Alexander said the exact opposite, i.e. that C++ does *not*
>> have zero
>> overhead exceptions?
>>
> I referred to his mail just incoming when I answered to you (2014-2-14
> 9:11, "One unmentioned fact is that the exception mechanism in C++ is
> designed to allow for implementations to have zero runtime cost. ...") ?
> what he addresses makes me quite less worried that catching C++ exceptions
> themselves in the FFI would introduce performance issues, than
> wrapping/unwrapping with Either & Co.
>
> Cheers, Nick
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140216/091f55b5/attachment-0001.html>
-------------- next part --------------
A non-text attachment was scrubbed...
Name: 33A.gif
Type: image/gif
Size: 581 bytes
Desc: not available
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140216/091f55b5/attachment-0001.gif>

From david.sorokin at gmail.com  Sun Feb 16 16:55:45 2014
From: david.sorokin at gmail.com (David Sorokin)
Date: Sun, 16 Feb 2014 20:55:45 +0400
Subject: [Haskell-cafe] ANN: aivika-1.1 (the simulation library for DES and
	SD)
Message-ID: <9DE15FA3-BC47-45B4-AB55-B388075BF872@gmail.com>

Hi Cafe,

Aivika is a multi-paradigm simulation library with a strong emphasis on the Discrete Event Simulation (DES) in the first order and System Dynamics (SD) in the second one.

A new version introduces an infinite stream of simulation data. This stream is based on the process-oriented computation of DES (this computation in its turn works on top of the event queue and uses the continuations). So, a random input of arrivals distributed exponentially can be described as such a stream in just one line of code!

There is also a processor that just a function that takes an input stream and then returns a resulting stream after the processing. The processor is a Haskell arrow, which means that we can use the proc-notation in case of need, although there is a lot of predefined combinators such as that one which unites parallel processors into one processor.

There are finite and infinite queues. The library collects the statistics for theses queues. We can either work with the queue directly, or create a buffer processor for the queue (with loop-back or not).

There is also so called the server that provides its own processor. It suits for modeling working places. As before, the library collects the statistics too.

In my personal opinion the library was powerful enough already earlier but now it can also allow the modeler to define some models using the mentioned above streams and processors directly in a very high-level Haskell code in such a way as he/she would draw the model on the diagram like those ones which are used by some visual simulation software tools.

At the same time, all parts of the library are very well integrated. Actually, all them are inter-connected, where more high-level monads are just based on more low-level ones. Now the top is the mentioned above processor (the Haskell arrow).

Unfortunately, the PDF document included in the package is outdated. Moreover, it doesn't cover even 10% of the features of my simulation library. But there are example models that illustrate the most important features. Also I use them for my tests.

Best regards,
David Sorokin

[1] http://hackage.haskell.org/package/aivika
[2] http://hackage.haskell.org/package/aivika-experiment
[3] http://hackage.haskell.org/package/aivika-experiment-chart


From hanooter at gmail.com  Sun Feb 16 19:21:51 2014
From: hanooter at gmail.com (Kyle Hanson)
Date: Sun, 16 Feb 2014 11:21:51 -0800
Subject: [Haskell-cafe] Wheb 0.1 released -- Graceful shutdown, Mongo plugin,
 blaze example and more.
Message-ID: <CA+RnCFbg0XOeFgLMGnocOnMSC7Uxc2BZwVnZNR2188Szs2vN7w@mail.gmail.com>

Hello all,

This is a small release, but I thought I would tell you about it. I have
added some new stuff to my Haskell server framework, Wheb.

For those of you (most) who don't know about Wheb, here is Wheb's
description from github:

> Wheb's a framework for building robust, high-concurrency web applications
> simply and effectively. Its primary goal is to extend the functionality of
> the base WAI library as well as provide an easy entry point into Haskell
> web servers. The only prerequisite is "Learn you a Haskell" or another
> introductory Haskell course.

I fleshed out some more examples, rewrote some of the documentation and
made some feature improvements to make it easier to build plugins. The
github repo's readme now contains a small tutorial.

Probably the biggest change this release is the addCleanupHook which you
can use to hook in and run IO actions after server shutdown to cleanup any
open resources. Wheb handles the SIGINT signal and waits for all requests
to complete before shutting down.

Here is the complete changelog:

   - Ability to read settings from a file
   - Add graceful shutdown and cleanup hooks.
   - Ability to monitor number of active connections.
   - Remove Data.Default
   - Add builder helper function
   - URL encoding

You can find Wheb on hackage or github:

   - http://hackage.haskell.org/package/Wheb
   - https://github.com/hansonkd/Wheb-Framework

In addition to these changes, I have released Wheb-Mongo which provides
Auth, Sessions and document manipulation/querying for mongoDB.

   - http://hackage.haskell.org/package/wheb-mongo

If you have any recommendations please feel free to let me know!


--

Kyle Hanson
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140216/f4a77fb5/attachment.html>

From s.j.thompson at kent.ac.uk  Sun Feb 16 19:30:55 2014
From: s.j.thompson at kent.ac.uk (Simon Thompson)
Date: Sun, 16 Feb 2014 19:30:55 +0000
Subject: [Haskell-cafe] Announce: Software Engineering for Systems Developed
	in Functional Languages
Message-ID: <A18697A9-4130-4DD9-8957-1F20F7B47F7F@kent.ac.uk>



The 32nd CREST Open Workshop: Software Engineering for Systems Developed in Functional Languages

Date:  24th - 25th March 2014

Venue: University College London, UK

Through the kind support of the EPSRC in the form of a platform grant, we have funding to support the workshops, so registration is free (but there is a charge for registering and then *not* attending, since places are limited). Registration includes lunch on both days and light refreshments. 


Overview:
Functional programming has become a mature practical tool for software development. Large complex functional programs require many of the software engineering techniques developed for other languages and paradigms, such as testing, slicing and refactoring. Some of these techniques, originally designed for imperative languages, such as amorphous slicing and refactoring may prove highly amendable to functional styles of programming. This workshop will bring together software engineers and functional programmers to concentrate on aspects of software engineering that can be extended, adapted and augmented for application to functional programs.   


Confirmed Speakers
David Binkley, Computer Science Department, Loyola University Maryland, USA
Sebastian Danicic, Department of Computing - Goldsmiths College London, UK
Kevin Hammond, School of Computer Science, at the University of St. Andrews, UK
Torben Hoffmann, Erlang Solutions, Denmark
Yue Jia, CREST Centre, SSE Group, Department of Computer Science, UCL, UK
Raghavan Komondoor, Indian Institute of Science, India
Alan Mycroft, Computer Laboratory, University of Cambridge, UK
Jerry Swan, Computing Science and Mathematics, University of Stirling, UK
Don Syme, Microsoft Research, Cambridge, UK
Simon Thompson, School of Computing, University of Kent, UK
Dimitrios Vytiniotis, MSRC PPT group, Microsoft Research, Cambridge, UK 


More details and registration at: http://crest.cs.ucl.ac.uk/cow/32/ 


Simon Thompson | Professor of Logic and Computation 
School of Computing | University of Kent | Canterbury, CT2 7NF, UK
s.j.thompson at kent.ac.uk | M +44 7986 085754 | W www.cs.kent.ac.uk/~sjt



From lemming at henning-thielemann.de  Sun Feb 16 20:05:16 2014
From: lemming at henning-thielemann.de (Henning Thielemann)
Date: Sun, 16 Feb 2014 21:05:16 +0100
Subject: [Haskell-cafe] create a record with all record accessors
Message-ID: <530119FC.6040406@henning-thielemann.de>

I have records of type (f a) where all fields are of type "a". I want to 
create records that contain all field getters as elements. I can do this 
generically:

getters ::
    (Traversable f, Applicative f) =>
    f (f a -> a)
getters =
    fmap (\n x -> Fold.toList x !! n) $
    MS.evalState (Trav.sequenceA (pure (MS.state $ \n -> (n, succ n)))) 0

Applicative is only needed for "pure". That is, "Pointed f" would be enough.

However, (!!) is not total and not very efficient. Is there already a 
type class in a package with "getters" as method or something I can 
build an efficient "getters" from? I suspect the answer lies in one of 
the "lens" modules. :-)

From cobbe at ccs.neu.edu  Sun Feb 16 22:15:25 2014
From: cobbe at ccs.neu.edu (Richard Cobbe)
Date: Sun, 16 Feb 2014 17:15:25 -0500
Subject: [Haskell-cafe] how to write cabal package file for executable with
	unit tests?
Message-ID: <20140216221525.GA238@ridcully.home>

What's the preferred way to write a cabal configuration file for a package
that contains an executable and a test suite?  The only thing I've found
that seems to work is to put a thin wrapper Main.hs into the executable,
put all of the actual code into the library, and then have the test-suite
include the library in its build-depends list.

This works, but I find it mildly annoying that I have to separate the code
out in this fashion -- especially since the unit tests require me to expose
modules in my library that aren't really part of the library's public
interface.

In more detail:

This is a follow-up to a thread I posted back on Feb 2; you can see it on
GMane at <http://thread.gmane.org/gmane.comp.lang.haskell.cafe/109374>.
The original example (tarball attached to the first message in that thread)
was a package structured as a library with unit tests.  After acting on
Erik's suggestion to put the library and test-suite source in different
directories, I was able to compile the library without the type error I
originally mentioned.

However, this isn't really the package structure I want.  The package is
actually intended to produce a standalone executable, not a library.  My
original example used a library for reasons that I don't honestly remember
-- I think I more or less stumbled upon that structure as something that
more or less worked, given the difficulty of getting Cabal, test suites,
Happy, and Alex to all work together well.

So I tried replacing the "Library" section of the cabal file with an
"Executable" section (sample tarball attached), but then I can't get the
tests to compile.  If I leave sample as a build-depends for the test-suite,
then "cabal configure --enable-tests" fails with

    Preprocessing test suite 'sample-tests' for sample-0.4...
    <command line>: cannot satisfy -package-id sample-0.4-inplace
        (use -v for more information)

If I take sample out of the build-depends list for the test-suite, then
"cabal configure --enable-tests" works, but "cabal build" fails:

    test-src/RunTests.hs:8:8:
        Could not find module `Parser'
        It is a member of the hidden package `ghc-7.6.3'.
        Perhaps you need to add `ghc' to the build-depends in your .cabal file.
        Use -v to see a list of the files searched for.

Either way, "cabal configure && cabal build" works fine; it's only when I
try to build the test suite that things break down.

Thanks,

Richard
-------------- next part --------------
A non-text attachment was scrubbed...
Name: sample.tgz
Type: application/x-tar-gz
Size: 1262 bytes
Desc: not available
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140216/8f3e91bd/attachment.bin>

From roma at ro-che.info  Sun Feb 16 22:52:41 2014
From: roma at ro-che.info (Roman Cheplyaka)
Date: Mon, 17 Feb 2014 00:52:41 +0200
Subject: [Haskell-cafe] how to write cabal package file for executable
 with unit tests?
In-Reply-To: <20140216221525.GA238@ridcully.home>
References: <20140216221525.GA238@ridcully.home>
Message-ID: <20140216225241.GA18934@sniper>

If you don't want a separate library, use the second Erik's suggestion
from that thread.

* Richard Cobbe <cobbe at ccs.neu.edu> [2014-02-16 17:15:25-0500]
> What's the preferred way to write a cabal configuration file for a package
> that contains an executable and a test suite?  The only thing I've found
> that seems to work is to put a thin wrapper Main.hs into the executable,
> put all of the actual code into the library, and then have the test-suite
> include the library in its build-depends list.
> 
> This works, but I find it mildly annoying that I have to separate the code
> out in this fashion -- especially since the unit tests require me to expose
> modules in my library that aren't really part of the library's public
> interface.
> 
> In more detail:
> 
> This is a follow-up to a thread I posted back on Feb 2; you can see it on
> GMane at <http://thread.gmane.org/gmane.comp.lang.haskell.cafe/109374>.
> The original example (tarball attached to the first message in that thread)
> was a package structured as a library with unit tests.  After acting on
> Erik's suggestion to put the library and test-suite source in different
> directories, I was able to compile the library without the type error I
> originally mentioned.
> 
> However, this isn't really the package structure I want.  The package is
> actually intended to produce a standalone executable, not a library.  My
> original example used a library for reasons that I don't honestly remember
> -- I think I more or less stumbled upon that structure as something that
> more or less worked, given the difficulty of getting Cabal, test suites,
> Happy, and Alex to all work together well.
> 
> So I tried replacing the "Library" section of the cabal file with an
> "Executable" section (sample tarball attached), but then I can't get the
> tests to compile.  If I leave sample as a build-depends for the test-suite,
> then "cabal configure --enable-tests" fails with
> 
>     Preprocessing test suite 'sample-tests' for sample-0.4...
>     <command line>: cannot satisfy -package-id sample-0.4-inplace
>         (use -v for more information)
> 
> If I take sample out of the build-depends list for the test-suite, then
> "cabal configure --enable-tests" works, but "cabal build" fails:
> 
>     test-src/RunTests.hs:8:8:
>         Could not find module `Parser'
>         It is a member of the hidden package `ghc-7.6.3'.
>         Perhaps you need to add `ghc' to the build-depends in your .cabal file.
>         Use -v to see a list of the files searched for.
> 
> Either way, "cabal configure && cabal build" works fine; it's only when I
> try to build the test suite that things break down.
> 
> Thanks,
> 
> Richard


> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe

-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140217/f36809c4/attachment.sig>

From erkokl at gmail.com  Sun Feb 16 23:50:35 2014
From: erkokl at gmail.com (Levent Erkok)
Date: Sun, 16 Feb 2014 15:50:35 -0800
Subject: [Haskell-cafe] [Announcement] New release of SBV: SMT Based
	Verification, v3.0
Message-ID: <CACOpX0c2Sq3ynD1h2ZPF=Nra_g0RsQT+SCe4Fc_zws8Kdp0bnQ@mail.gmail.com>

Home page: http://leventerkok.github.io/sbv/
ChangeLog: http://github.com/LeventErkok/sbv/blob/master/CHANGES.md

I'm happy to announce a new release of SBV, v3.0.

The most important addition is support for reasoning about IEEE-74 floating
point numbers, i.e., programs using the Float and Double types. See the
change-log for full details.

Reasoning with floating-point is a tricky task, and SMT solvers are slowly
starting to provide support for true machine arithmetic as prescribed by
the IEEE-754 standard. In particular, the semantics of NaN and Infinity are
both properly captured, along with proper rounding. Also supported is
fused-multiply-add, and square-root functions at the logic level.

Currently, only Z3 (the developer version release) has official support for
this logic, and the implementation in SBV builds on top of Z3's
implementation. It's likely that both Z3's and SBV might have some rough
edges, so any bug reports are most welcome.

There's also a new example file demonstrating the floating-point
arithmetic: Formally establishing that floating point addition is not
associative (finding a concrete counter-example),  multiplicative inverses
do not necessarily exist, etc. See:
http://hackage.haskell.org/package/sbv-3.0/docs/Data-SBV-Examples-Misc-Floating.html

Happy theorem proving!

-Levent.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140216/9ed97ef5/attachment.html>

From cobbe at ccs.neu.edu  Mon Feb 17 01:26:18 2014
From: cobbe at ccs.neu.edu (Richard Cobbe)
Date: Sun, 16 Feb 2014 20:26:18 -0500
Subject: [Haskell-cafe] how to write cabal package file for executable
 with unit tests?
In-Reply-To: <20140216225241.GA18934@sniper>
References: <20140216221525.GA238@ridcully.home>
 <20140216225241.GA18934@sniper>
Message-ID: <20140217012618.GB238@ridcully.home>

On Mon, Feb 17, 2014 at 12:52:41AM +0200, Roman Cheplyaka wrote:
> If you don't want a separate library, use the second Erik's suggestion
> from that thread.

I tried that, and I seem to still be missing something.

With

    Test-Suite sample-tests
      main-is: RunTests.hs
      hs-source-dirs: test-src, src
      other-modules: Ast, Parser, Scanner
      type: exitcode-stdio-1.0
      default-language: Haskell2010
      build-depends: base, array, containers, HUnit

then "cabal configure --enable-tests && cabal build" results in the
following error:

    test-src/RunTests.hs:8:8:
        Could not find module `Parser'
        It is a member of the hidden package `ghc-7.6.3'.
        Perhaps you need to add `ghc' to the build-depends in your .cabal file.
        Use -v to see a list of the files searched for.

If I remove "src" from the hs-source-dirs line, then cabal complains that
it can't find source for Ast.

If I put "src" back and remove the other-modules line, I get the same
"Could not find module 'Parser'" error message from above.

                                 * * * * *

These seem to be pretty basic questions to me, but they also don't seem to
be in the Cabal manual anywhere.  Is there somewhere else I should be
looking?

Richard

> * Richard Cobbe <cobbe at ccs.neu.edu> [2014-02-16 17:15:25-0500]
> > What's the preferred way to write a cabal configuration file for a package
> > that contains an executable and a test suite?  The only thing I've found
> > that seems to work is to put a thin wrapper Main.hs into the executable,
> > put all of the actual code into the library, and then have the test-suite
> > include the library in its build-depends list.
> >
> > This works, but I find it mildly annoying that I have to separate the code
> > out in this fashion -- especially since the unit tests require me to expose
> > modules in my library that aren't really part of the library's public
> > interface.


From mail at nh2.me  Mon Feb 17 02:04:49 2014
From: mail at nh2.me (=?ISO-8859-1?Q?Niklas_Hamb=FCchen?=)
Date: Mon, 17 Feb 2014 02:04:49 +0000
Subject: [Haskell-cafe] [Announcement] New release of SBV: SMT Based
 Verification, v3.0
In-Reply-To: <CACOpX0c2Sq3ynD1h2ZPF=Nra_g0RsQT+SCe4Fc_zws8Kdp0bnQ@mail.gmail.com>
References: <CACOpX0c2Sq3ynD1h2ZPF=Nra_g0RsQT+SCe4Fc_zws8Kdp0bnQ@mail.gmail.com>
Message-ID: <53016E41.8020709@nh2.me>

Hi,

this is pretty darn cool.

Short technical question: Why functions on SInteger so much faster to
check than functions on SWord32? Is it because they don't overflow?

Also I think RebindableSyntax would be really useful for this.
I have seen your counter arguments in
https://github.com/LeventErkok/sbv/issues/79, but RebindableSyntax would
make checking many functions really easy. I think your idea with making
it a separate module is the right way, e.g. Data.SBV.RebindableSyntax.

Niklas

On 16/02/14 23:50, Levent Erkok wrote:
> Home page: http://leventerkok.github.io/sbv/
> ChangeLog: http://github.com/LeventErkok/sbv/blob/master/CHANGES.md
> 
> I'm happy to announce a new release of SBV, v3.0.
> 
> The most important addition is support for reasoning about IEEE-74
> floating point numbers, i.e., programs using the Float and Double types.
> See the change-log for full details.
> 
> Reasoning with floating-point is a tricky task, and SMT solvers are
> slowly starting to provide support for true machine arithmetic as
> prescribed by the IEEE-754 standard. In particular, the semantics of NaN
> and Infinity are both properly captured, along with proper rounding.
> Also supported is fused-multiply-add, and square-root functions at the
> logic level.
> 
> Currently, only Z3 (the developer version release) has official support
> for this logic, and the implementation in SBV builds on top of Z3's
> implementation. It's likely that both Z3's and SBV might have some rough
> edges, so any bug reports are most welcome. 
> 
> There's also a new example file demonstrating the floating-point
> arithmetic: Formally establishing that floating point addition is not
> associative (finding a concrete counter-example),  multiplicative
> inverses do not necessarily exist, etc.
> See: http://hackage.haskell.org/package/sbv-3.0/docs/Data-SBV-Examples-Misc-Floating.html
> 
> Happy theorem proving!
> 
> -Levent.
> 
> 
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
> 

From tikhon at jelv.is  Mon Feb 17 02:33:27 2014
From: tikhon at jelv.is (Tikhon Jelvis)
Date: Sun, 16 Feb 2014 18:33:27 -0800
Subject: [Haskell-cafe] [Announcement] New release of SBV: SMT Based
 Verification, v3.0
In-Reply-To: <53016E41.8020709@nh2.me>
References: <CACOpX0c2Sq3ynD1h2ZPF=Nra_g0RsQT+SCe4Fc_zws8Kdp0bnQ@mail.gmail.com>
 <53016E41.8020709@nh2.me>
Message-ID: <CAJN5CVKufKL3PzsrQrP4B4qOkZn4x3+GoxZTBjPUgX6H0Q3_Xw@mail.gmail.com>

It's a difference in the Z3 theorem prover rather than the library.
SInteger maps to the theory of integers while SWord32 maps to theory of
bitvectors. The two are implemented completely differently.

Of course, this just punts the question to why Z3 can be faster for
Integers than for BitVectors. BitVectors are just fixed-length patterns of
bits--32 bits in this case. Integers, on the other hand, cannot be reasoned
about as bits because Z3 has to prove things about *all* integers in the
mathematical sense. I *think* the difference comes up because the theory of
bitvectors is optimized for exhaustively searching over all possible bit
patterns given a wide range of constraints while integers, by their very
nature, have to be dealt with symbolically.

In fact, working with bitvectors is pretty much the same as doing normal
SAT solving. I don't know about Z3 in particular, but this is actually how
some solvers implement bitvectors: they just compile the bitvector
constraints to normal SAT constraints (called "bit blasting").

For simpler queries, symbolically working with integers can prove faster,
but for complex ones it might just not return an answer at all. (In SBV, it
would just return `Unknown'.) Since the domain of bitvectors of a given
size is finite we can, in principle, check everything which means that any
set of constraints is solvable although it might take a really long time.

Also, the solver uses different strategies for the same types depending on
the actual constraints you have. I've noticed slow-downs in a very similar
vein just using SInteger. I had a problem that would quickly return
`Unknown' with unbounded integers; when I added some bounds (ie x .> 0 &&&
x .< 10000000000) the process started eating up a lot more CPU and not
returning in a reasonable time-frame.

I should add that while I've worked *with* a few SMT solvers, I still only
have a vague idea of how they are implemented. If you really want to
understand what's going on, you'll have to ask somebody knowledgeable or
just read their publications :).


On Sun, Feb 16, 2014 at 6:04 PM, Niklas Hamb?chen <mail at nh2.me> wrote:

> Hi,
>
> this is pretty darn cool.
>
> Short technical question: Why functions on SInteger so much faster to
> check than functions on SWord32? Is it because they don't overflow?
>
> Also I think RebindableSyntax would be really useful for this.
> I have seen your counter arguments in
> https://github.com/LeventErkok/sbv/issues/79, but RebindableSyntax would
> make checking many functions really easy. I think your idea with making
> it a separate module is the right way, e.g. Data.SBV.RebindableSyntax.
>
> Niklas
>
> On 16/02/14 23:50, Levent Erkok wrote:
> > Home page: http://leventerkok.github.io/sbv/
> > ChangeLog: http://github.com/LeventErkok/sbv/blob/master/CHANGES.md
> >
> > I'm happy to announce a new release of SBV, v3.0.
> >
> > The most important addition is support for reasoning about IEEE-74
> > floating point numbers, i.e., programs using the Float and Double types.
> > See the change-log for full details.
> >
> > Reasoning with floating-point is a tricky task, and SMT solvers are
> > slowly starting to provide support for true machine arithmetic as
> > prescribed by the IEEE-754 standard. In particular, the semantics of NaN
> > and Infinity are both properly captured, along with proper rounding.
> > Also supported is fused-multiply-add, and square-root functions at the
> > logic level.
> >
> > Currently, only Z3 (the developer version release) has official support
> > for this logic, and the implementation in SBV builds on top of Z3's
> > implementation. It's likely that both Z3's and SBV might have some rough
> > edges, so any bug reports are most welcome.
> >
> > There's also a new example file demonstrating the floating-point
> > arithmetic: Formally establishing that floating point addition is not
> > associative (finding a concrete counter-example),  multiplicative
> > inverses do not necessarily exist, etc.
> > See:
> http://hackage.haskell.org/package/sbv-3.0/docs/Data-SBV-Examples-Misc-Floating.html
> >
> > Happy theorem proving!
> >
> > -Levent.
> >
> >
> > _______________________________________________
> > Haskell-Cafe mailing list
> > Haskell-Cafe at haskell.org
> > http://www.haskell.org/mailman/listinfo/haskell-cafe
> >
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140216/354e735a/attachment.html>

From erkokl at gmail.com  Mon Feb 17 03:08:39 2014
From: erkokl at gmail.com (Levent Erkok)
Date: Sun, 16 Feb 2014 19:08:39 -0800
Subject: [Haskell-cafe] [Announcement] New release of SBV: SMT Based
 Verification, v3.0
In-Reply-To: <CAJN5CVKufKL3PzsrQrP4B4qOkZn4x3+GoxZTBjPUgX6H0Q3_Xw@mail.gmail.com>
References: <CACOpX0c2Sq3ynD1h2ZPF=Nra_g0RsQT+SCe4Fc_zws8Kdp0bnQ@mail.gmail.com>
 <53016E41.8020709@nh2.me>
 <CAJN5CVKufKL3PzsrQrP4B4qOkZn4x3+GoxZTBjPUgX6H0Q3_Xw@mail.gmail.com>
Message-ID: <CACOpX0fmt4GSYUfHsb-1RMON9-8XSe30-=oGs-LKuvCm-GnSHA@mail.gmail.com>

To add to what Tikhon mentioned; most SMT solvers deploy a number of
heuristics in the theories they support, and a slight modification of the
problem ("benchmark" in SMTLib terminology) can exhibit itself as a
performance degradation. I don't think it's possible to generalize and say
that bit-vectors are faster than unbounded integers. It is entirely problem
specific, and whatever optimizations/tricks might be available in the
underlying solver; which will also depend of the version of the solver you
have, options, the random seed they use, etc. One thing is for sure though:
SMT solvers have improved significantly in the last decade, and they'll
only get better in time. It's quite an active research area with many very
highly-skilled people working on them.

Re: Rebindable syntax: I'm not a big fan of it; but patches are always
welcome! SBV is hosted on github, so it should be easy to branch if anybody
is interested in exploring: http://github.com/LeventErkok/sbv

-Levent.


On Sun, Feb 16, 2014 at 6:33 PM, Tikhon Jelvis <tikhon at jelv.is> wrote:

> It's a difference in the Z3 theorem prover rather than the library.
> SInteger maps to the theory of integers while SWord32 maps to theory of
> bitvectors. The two are implemented completely differently.
>
> Of course, this just punts the question to why Z3 can be faster for
> Integers than for BitVectors. BitVectors are just fixed-length patterns of
> bits--32 bits in this case. Integers, on the other hand, cannot be reasoned
> about as bits because Z3 has to prove things about *all* integers in the
> mathematical sense. I *think* the difference comes up because the theory of
> bitvectors is optimized for exhaustively searching over all possible bit
> patterns given a wide range of constraints while integers, by their very
> nature, have to be dealt with symbolically.
>
> In fact, working with bitvectors is pretty much the same as doing normal
> SAT solving. I don't know about Z3 in particular, but this is actually how
> some solvers implement bitvectors: they just compile the bitvector
> constraints to normal SAT constraints (called "bit blasting").
>
> For simpler queries, symbolically working with integers can prove faster,
> but for complex ones it might just not return an answer at all. (In SBV, it
> would just return `Unknown'.) Since the domain of bitvectors of a given
> size is finite we can, in principle, check everything which means that any
> set of constraints is solvable although it might take a really long time.
>
> Also, the solver uses different strategies for the same types depending on
> the actual constraints you have. I've noticed slow-downs in a very similar
> vein just using SInteger. I had a problem that would quickly return
> `Unknown' with unbounded integers; when I added some bounds (ie x .> 0 &&&
> x .< 10000000000) the process started eating up a lot more CPU and not
> returning in a reasonable time-frame.
>
> I should add that while I've worked *with* a few SMT solvers, I still only
> have a vague idea of how they are implemented. If you really want to
> understand what's going on, you'll have to ask somebody knowledgeable or
> just read their publications :).
>
>
> On Sun, Feb 16, 2014 at 6:04 PM, Niklas Hamb?chen <mail at nh2.me> wrote:
>
>> Hi,
>>
>> this is pretty darn cool.
>>
>> Short technical question: Why functions on SInteger so much faster to
>> check than functions on SWord32? Is it because they don't overflow?
>>
>> Also I think RebindableSyntax would be really useful for this.
>> I have seen your counter arguments in
>> https://github.com/LeventErkok/sbv/issues/79, but RebindableSyntax would
>> make checking many functions really easy. I think your idea with making
>> it a separate module is the right way, e.g. Data.SBV.RebindableSyntax.
>>
>> Niklas
>>
>> On 16/02/14 23:50, Levent Erkok wrote:
>> > Home page: http://leventerkok.github.io/sbv/
>> > ChangeLog: http://github.com/LeventErkok/sbv/blob/master/CHANGES.md
>> >
>> > I'm happy to announce a new release of SBV, v3.0.
>> >
>> > The most important addition is support for reasoning about IEEE-74
>> > floating point numbers, i.e., programs using the Float and Double types.
>> > See the change-log for full details.
>> >
>> > Reasoning with floating-point is a tricky task, and SMT solvers are
>> > slowly starting to provide support for true machine arithmetic as
>> > prescribed by the IEEE-754 standard. In particular, the semantics of NaN
>> > and Infinity are both properly captured, along with proper rounding.
>> > Also supported is fused-multiply-add, and square-root functions at the
>> > logic level.
>> >
>> > Currently, only Z3 (the developer version release) has official support
>> > for this logic, and the implementation in SBV builds on top of Z3's
>> > implementation. It's likely that both Z3's and SBV might have some rough
>> > edges, so any bug reports are most welcome.
>> >
>> > There's also a new example file demonstrating the floating-point
>> > arithmetic: Formally establishing that floating point addition is not
>> > associative (finding a concrete counter-example),  multiplicative
>> > inverses do not necessarily exist, etc.
>> > See:
>> http://hackage.haskell.org/package/sbv-3.0/docs/Data-SBV-Examples-Misc-Floating.html
>> >
>> > Happy theorem proving!
>> >
>> > -Levent.
>> >
>> >
>> > _______________________________________________
>> > Haskell-Cafe mailing list
>> > Haskell-Cafe at haskell.org
>> > http://www.haskell.org/mailman/listinfo/haskell-cafe
>> >
>> _______________________________________________
>> Haskell-Cafe mailing list
>> Haskell-Cafe at haskell.org
>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140216/09f87327/attachment.html>

From fuuzetsu at fuuzetsu.co.uk  Mon Feb 17 04:35:16 2014
From: fuuzetsu at fuuzetsu.co.uk (Mateusz Kowalczyk)
Date: Mon, 17 Feb 2014 04:35:16 +0000
Subject: [Haskell-cafe] Yi documentation
Message-ID: <53019184.5010702@fuuzetsu.co.uk>

Hi all,

In #yi (and other Haskell-related outlets), we ofter have people who
want to try Yi but struggle one way or another. It seems that a big
barrier is lack of documentation.

If you had tried Yi or wanted to try it and you met with difficulties
due to lacking documentation, I'd like to hear about it. Perhaps you
tried to get going but just couldn't figure out how to do something in
your config, or perhaps you tried hacking on the source but didn't know
where to get started.

If you're looking for any specific guides, I'd also like to hear about
it. I (and perhaps some others) can write documentation but it helps if
we have specific topics to talk about rather than taking guesses in the
dark.

If you want to try it out, we recommend that you read the README at [1].
If you have problems that aren't related to the documentation, you
should use the issue tracker[2] to report them.

Thanks!

[1]: https://github.com/yi-editor/yi
[2]: https://github.com/yi-editor/yi/issues?state=open
-- 
Mateusz K.

From roma at ro-che.info  Mon Feb 17 07:23:51 2014
From: roma at ro-che.info (Roman Cheplyaka)
Date: Mon, 17 Feb 2014 09:23:51 +0200
Subject: [Haskell-cafe] how to write cabal package file for executable
 with unit tests?
In-Reply-To: <20140217012618.GB238@ridcully.home>
References: <20140216221525.GA238@ridcully.home>
 <20140216225241.GA18934@sniper>
 <20140217012618.GB238@ridcully.home>
Message-ID: <20140217072351.GA20768@sniper>

Can you upload your code somewhere (e.g. github)? It would be much
easier for us to troubleshoot.

But please don't attach archives to mailing list messages.

* Richard Cobbe <cobbe at ccs.neu.edu> [2014-02-16 20:26:18-0500]
> On Mon, Feb 17, 2014 at 12:52:41AM +0200, Roman Cheplyaka wrote:
> > If you don't want a separate library, use the second Erik's suggestion
> > from that thread.
> 
> I tried that, and I seem to still be missing something.
> 
> With
> 
>     Test-Suite sample-tests
>       main-is: RunTests.hs
>       hs-source-dirs: test-src, src
>       other-modules: Ast, Parser, Scanner
>       type: exitcode-stdio-1.0
>       default-language: Haskell2010
>       build-depends: base, array, containers, HUnit
> 
> then "cabal configure --enable-tests && cabal build" results in the
> following error:
> 
>     test-src/RunTests.hs:8:8:
>         Could not find module `Parser'
>         It is a member of the hidden package `ghc-7.6.3'.
>         Perhaps you need to add `ghc' to the build-depends in your .cabal file.
>         Use -v to see a list of the files searched for.
> 
> If I remove "src" from the hs-source-dirs line, then cabal complains that
> it can't find source for Ast.
> 
> If I put "src" back and remove the other-modules line, I get the same
> "Could not find module 'Parser'" error message from above.
> 
>                                  * * * * *
> 
> These seem to be pretty basic questions to me, but they also don't seem to
> be in the Cabal manual anywhere.  Is there somewhere else I should be
> looking?
> 
> Richard
> 
> > * Richard Cobbe <cobbe at ccs.neu.edu> [2014-02-16 17:15:25-0500]
> > > What's the preferred way to write a cabal configuration file for a package
> > > that contains an executable and a test suite?  The only thing I've found
> > > that seems to work is to put a thin wrapper Main.hs into the executable,
> > > put all of the actual code into the library, and then have the test-suite
> > > include the library in its build-depends list.
> > >
> > > This works, but I find it mildly annoying that I have to separate the code
> > > out in this fashion -- especially since the unit tests require me to expose
> > > modules in my library that aren't really part of the library's public
> > > interface.
> 
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140217/583e1064/attachment.sig>

From hesselink at gmail.com  Mon Feb 17 10:07:07 2014
From: hesselink at gmail.com (Erik Hesselink)
Date: Mon, 17 Feb 2014 11:07:07 +0100
Subject: [Haskell-cafe] how to write cabal package file for executable
 with unit tests?
In-Reply-To: <20140217012618.GB238@ridcully.home>
References: <20140216221525.GA238@ridcully.home>
 <20140216225241.GA18934@sniper>
 <20140217012618.GB238@ridcully.home>
Message-ID: <CAPeieQHa5-FZBC2N-Bjk8Tmw=epMWjkJhr591zo4rQ0dnBzmNg@mail.gmail.com>

Hi Richard,

Where is your Parser module located?

Remember that your code will be compiled twice this way. What is, in
my opinion, a better setup, is put the shared code in a library (like
you had), and then have a shallow executable in the same package that
depends on the library. The test-suite can then also depend on the
library. All three should have distinct source dirs.

Having most functionality in a library is a good design principle
anyway: it makes it easier to re-use it in a different way later, and
makes sure you think about API boundaries and such.

Regards,

Erik

On Mon, Feb 17, 2014 at 2:26 AM, Richard Cobbe <cobbe at ccs.neu.edu> wrote:
> On Mon, Feb 17, 2014 at 12:52:41AM +0200, Roman Cheplyaka wrote:
>> If you don't want a separate library, use the second Erik's suggestion
>> from that thread.
>
> I tried that, and I seem to still be missing something.
>
> With
>
>     Test-Suite sample-tests
>       main-is: RunTests.hs
>       hs-source-dirs: test-src, src
>       other-modules: Ast, Parser, Scanner
>       type: exitcode-stdio-1.0
>       default-language: Haskell2010
>       build-depends: base, array, containers, HUnit
>
> then "cabal configure --enable-tests && cabal build" results in the
> following error:
>
>     test-src/RunTests.hs:8:8:
>         Could not find module `Parser'
>         It is a member of the hidden package `ghc-7.6.3'.
>         Perhaps you need to add `ghc' to the build-depends in your .cabal file.
>         Use -v to see a list of the files searched for.
>
> If I remove "src" from the hs-source-dirs line, then cabal complains that
> it can't find source for Ast.
>
> If I put "src" back and remove the other-modules line, I get the same
> "Could not find module 'Parser'" error message from above.
>
>                                  * * * * *
>
> These seem to be pretty basic questions to me, but they also don't seem to
> be in the Cabal manual anywhere.  Is there somewhere else I should be
> looking?
>
> Richard
>
>> * Richard Cobbe <cobbe at ccs.neu.edu> [2014-02-16 17:15:25-0500]
>> > What's the preferred way to write a cabal configuration file for a package
>> > that contains an executable and a test suite?  The only thing I've found
>> > that seems to work is to put a thin wrapper Main.hs into the executable,
>> > put all of the actual code into the library, and then have the test-suite
>> > include the library in its build-depends list.
>> >
>> > This works, but I find it mildly annoying that I have to separate the code
>> > out in this fashion -- especially since the unit tests require me to expose
>> > modules in my library that aren't really part of the library's public
>> > interface.
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe

From rendel at informatik.uni-marburg.de  Mon Feb 17 10:16:27 2014
From: rendel at informatik.uni-marburg.de (Tillmann Rendel)
Date: Mon, 17 Feb 2014 11:16:27 +0100
Subject: [Haskell-cafe] how to write cabal package file for executable
 with unit tests?
In-Reply-To: <20140217012618.GB238@ridcully.home>
References: <20140216221525.GA238@ridcully.home>
 <20140216225241.GA18934@sniper> <20140217012618.GB238@ridcully.home>
Message-ID: <5301E17B.2060501@informatik.uni-marburg.de>

Hi,

Richard Cobbe wrote:
>      test-src/RunTests.hs:8:8:
>          Could not find module `Parser'

Is the Parser module generated by happy? In this case, maybe you have to 
add the

   build-tools: happy

line to your test-suite description in the cabal file.

   Tillmann

From jan.stolarek at p.lodz.pl  Mon Feb 17 10:20:20 2014
From: jan.stolarek at p.lodz.pl (Jan Stolarek)
Date: Mon, 17 Feb 2014 11:20:20 +0100
Subject: [Haskell-cafe] Problems using tasty-golden
In-Reply-To: <20140214163707.GA9743@sniper>
References: <201402141459.31873.jan.stolarek@p.lodz.pl>
 <20140214163707.GA9743@sniper>
Message-ID: <201402171120.20901.jan.stolarek@p.lodz.pl>

Thanks for quick reply Roman (and sorry for my slow reply - I was AFK for the weekend).

> That's a plausible explanations. File handles are closed when the
> ValueGetter monad is run. Try to add something like
>
>   Control.Exception.evaluate $ Control.DeepSeq.force cmpResult
>
> to your comparison function. 
Yes, that works. I wonder why no one stumbled upon this problem before.

> if your test files are under 'test/' subdirectory of your project's main directory,
> and you want to run the test suite from your project's main directory,
> then your paths must look like "test/...".
Oh, right. I couldn't get this right because I set wrong CWD for the GHC process.

> First off, you don't have to do that (unless you have some special needs
> ? if so, what are they?).
No, I don't have any special needs. It's just that my cmp function has to cover all possible 
cases - including when the file loading function returns Left - so I figured out I can handle the 
potential error there and have my own error message. But that's not really necessary, which means 
I can get rid of my custom cgReadFile altogether and use (fmap Right $ vgReadFile path).

Once again thank you.

Janek

From davidleothomas at gmail.com  Mon Feb 17 17:47:04 2014
From: davidleothomas at gmail.com (David Thomas)
Date: Mon, 17 Feb 2014 09:47:04 -0800
Subject: [Haskell-cafe] Yi documentation
In-Reply-To: <53019184.5010702@fuuzetsu.co.uk>
References: <53019184.5010702@fuuzetsu.co.uk>
Message-ID: <CAJUDvciyp+fppxWsD19=eFjQNt=E9PRYEYPher9De5joZrMYzw@mail.gmail.com>

How good a job does Yi do at being vim?


On Sun, Feb 16, 2014 at 8:35 PM, Mateusz Kowalczyk
<fuuzetsu at fuuzetsu.co.uk>wrote:

> Hi all,
>
> In #yi (and other Haskell-related outlets), we ofter have people who
> want to try Yi but struggle one way or another. It seems that a big
> barrier is lack of documentation.
>
> If you had tried Yi or wanted to try it and you met with difficulties
> due to lacking documentation, I'd like to hear about it. Perhaps you
> tried to get going but just couldn't figure out how to do something in
> your config, or perhaps you tried hacking on the source but didn't know
> where to get started.
>
> If you're looking for any specific guides, I'd also like to hear about
> it. I (and perhaps some others) can write documentation but it helps if
> we have specific topics to talk about rather than taking guesses in the
> dark.
>
> If you want to try it out, we recommend that you read the README at [1].
> If you have problems that aren't related to the documentation, you
> should use the issue tracker[2] to report them.
>
> Thanks!
>
> [1]: https://github.com/yi-editor/yi
> [2]: https://github.com/yi-editor/yi/issues?state=open
> --
> Mateusz K.
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140217/64da07f2/attachment.html>

From fuuzetsu at fuuzetsu.co.uk  Mon Feb 17 19:20:18 2014
From: fuuzetsu at fuuzetsu.co.uk (Mateusz Kowalczyk)
Date: Mon, 17 Feb 2014 19:20:18 +0000
Subject: [Haskell-cafe] Yi documentation
In-Reply-To: <CAJUDvciyp+fppxWsD19=eFjQNt=E9PRYEYPher9De5joZrMYzw@mail.gmail.com>
References: <53019184.5010702@fuuzetsu.co.uk>
 <CAJUDvciyp+fppxWsD19=eFjQNt=E9PRYEYPher9De5joZrMYzw@mail.gmail.com>
Message-ID: <530260F2.6050704@fuuzetsu.co.uk>

On 17/02/14 17:47, David Thomas wrote:
> How good a job does Yi do at being vim?
> 
> 

Personally I'm an emacs person so I can't answer with 100% confidence
but from what I can hear from people who do come to #yi and use the vim
emulation, they are very impressed with what Yi does with the keymap.
Having said that, this only covers the keymap. I'm unsure what you
expect when you ask how good it is at being vim. Unfortunately we don't
have a list of implemented vim keybindings but it's certainly on the
list of things to write up.


-- 
Mateusz K.

From davidleothomas at gmail.com  Mon Feb 17 19:43:02 2014
From: davidleothomas at gmail.com (David Thomas)
Date: Mon, 17 Feb 2014 11:43:02 -0800
Subject: [Haskell-cafe] Yi documentation
In-Reply-To: <530260F2.6050704@fuuzetsu.co.uk>
References: <53019184.5010702@fuuzetsu.co.uk>
 <CAJUDvciyp+fppxWsD19=eFjQNt=E9PRYEYPher9De5joZrMYzw@mail.gmail.com>
 <530260F2.6050704@fuuzetsu.co.uk>
Message-ID: <CAJUDvcgSi9jKZ5VgkKUavg=bxvyCbRNC3qissEVgOEMUD_1SOA@mail.gmail.com>

I guess I'm mostly asking after subjective experience, but I think the
things I would rate most important would be (in no particular order): 1)
key bindings I use match vim, 2) easy to create new key bindings, and 3)
quickfix buffer.  I would be most surprised if 2 was missing.  1 is
typically underpopulated but could be grown... anyone know about 3?


On Mon, Feb 17, 2014 at 11:20 AM, Mateusz Kowalczyk <fuuzetsu at fuuzetsu.co.uk
> wrote:

> On 17/02/14 17:47, David Thomas wrote:
> > How good a job does Yi do at being vim?
> >
> >
>
> Personally I'm an emacs person so I can't answer with 100% confidence
> but from what I can hear from people who do come to #yi and use the vim
> emulation, they are very impressed with what Yi does with the keymap.
> Having said that, this only covers the keymap. I'm unsure what you
> expect when you ask how good it is at being vim. Unfortunately we don't
> have a list of implemented vim keybindings but it's certainly on the
> list of things to write up.
>
>
> --
> Mateusz K.
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140217/3860e1ca/attachment.html>

From kyle.marek.spartz at gmail.com  Mon Feb 17 19:50:04 2014
From: kyle.marek.spartz at gmail.com (Kyle Marek-Spartz)
Date: Mon, 17 Feb 2014 13:50:04 -0600
Subject: [Haskell-cafe] ANN: Implementations of TaPL
Message-ID: <etPan.530267ec.19495cff.20f@highlander>

Hello,

I?ve been working through Types and Programming Languages, implementing each language with a figure in the book. So far I?ve done Boolean, Arith, TypedBoolean, and TypedArith. Before I get too far, I?d like some feedback on my approach, project structure, and how idiomatic the code is.

Here?s the GitHub repo:

https://github.com/zeckalpha/TaPL

Thanks in advance!

I?m aware of the OCaML implementation, and a few previous Haskell implementations, but learning by doing is important, plus there were things I didn?t like about the other implementations.

--  
Kyle Marek-Spartz

From roma at ro-che.info  Mon Feb 17 20:07:58 2014
From: roma at ro-che.info (Roman Cheplyaka)
Date: Mon, 17 Feb 2014 22:07:58 +0200
Subject: [Haskell-cafe] Protecting against main thread exit
In-Reply-To: <53025EAB.7020608@vex.net>
References: <20140215215333.GA6971@sniper>
 <53025EAB.7020608@vex.net>
Message-ID: <20140217200758.GA1334@sniper>

* Albert Y. C. Lai <trebla at vex.net> [2014-02-17 14:10:35-0500]
> On 14-02-15 04:53 PM, Roman Cheplyaka wrote:
> >Of course, all guarantees are off when dealing with SIGKILL or power
> >reset, but there's one other annoying exception (no pun intended) ? when
> >the main thread terminates, all other threads are silently shut down,
> >without any chance to clean up.
> >
> >Why is it done that way? Why not kill them with an async exception
> >instead? That would be a more uniform behavior.
> >
> >Are there any good ways to protect again the main thread exit?
> >
> >(Note that I'm talking about a library, so I can't have direct
> >control over what's going on in the main thread.)
> 
> I guess it is a rabbit hole to have GHC RTS courteously send
> exceptions to all threads, and still expect certain and timely death.
> 
> Nothing says that a thread voluntarily dies after receiving that
> exception, much less when it dies.

Sure. But is it a responsibility of the RTS to ensure timely death?

My main use case is when the user interrupts the program with Ctrl-C.
The main thread can already ignore it, and the RTS is fine with it.
I'm just proposing that all threads get a chance to clean up.

If timely shutdown is important, there are plenty of external tools with
customizable logic that can take care of that.

> It seems to me that the cleanest way is still to have the author of
> main decide and implement whichever exit strategy is correct for
> his/her main and for the library he/she uses. And there are enough
> tools to do it tidily, too: main can get a "finally" clause, just
> like everybody else.

I wouldn't call that tidy. The action for which cleanup is needed
can be buried deep in the call hierarchy. For example, let's say 'a'
needs to cleanup after doing its job (but no-one needs to wait for a's
result). 'b' spawns 'a' in a new thread, 'c' calls 'b', 'd' calls 'c'
and so on. We cannot cleanup in the "finally" clause of 'b' even if 'b'
is executed in the main thread, because it's okay for 'a' to run longer
than 'b'.

We cannot simply pass the cleanup action up the chain of calls as a
return value (although even that would be rather invasive), because when
SIGINT strikes ? say, before 'b' returns, the cleanup handler won't be
installed yet ? it will only be on its way to 'main'.

The simplest option seems to be to convert the chain of calls from 'b'
up to 'main' to CPS (directly or by using a monad). I hope you agree
that it is too much for such a simple thing as (more or less) robust
cleanup.

Also, this violates DRY: I have to install the handler both
for the worker thread itself (in case it gets killed by an async
exception), and for the main thread (in case it decides to exit for
whatever reason). Moreover, I have to ensure that the cleanup doesn't
happen twice because of that.

Roman

From aemulcahy at gmail.com  Mon Feb 17 21:00:31 2014
From: aemulcahy at gmail.com (Anthony Mulcahy)
Date: Tue, 18 Feb 2014 06:00:31 +0900
Subject: [Haskell-cafe] ANN: LambdaMC: demo Haskell Android app built with
	the ghc-android tool.
Message-ID: <CADgw9YbL1+VCakj1sVLv5=ovsS34ussNt-Kf=kGQhy+gkP2bkQ@mail.gmail.com>

Announcing LambdaMC: a demo Haskell Android app to calculate option
prices by Monte Carlo simulation built with the ghc-android tool.

Based on the example app at
https://github.com/neurocyte/android-haskell-activity

Functionality is limited, but it may be a useful reference for anybody
developing a Haskell Android app:
- Android Pause / Resume functionality.
- Screen Rotation support.
- Background worker thread updates the UI when the calculation is complete.
- Interaction between various Android UI elements and Haskell code.

Google Play listing:
https://play.google.com/store/apps/details?id=org.dragongate_technologies

Files
LambdaMC.hs : Haskell app code
DgAndr.hs : Haskell wrapper for various Android library functions
DgMath.hs : Haskell option pricing code
LambdaMC.java : Minimal Java code to support the main Activity
LicenseActivity.java : Java Activity to display license information
(need to move more code to Haskell-land)

Prerequisites
- An Android cross-compiler built with the ghc-android tool at
https://github.com/neurocyte/ghc-android
- The foreign-jni package from https://github.com/neurocyte/foreign-jni
- The Haskell packages base, deepseq, transformers, mtl, text, time

Building
./build_workaround.sh ( to work around the -shared and -r issue
described at https://github.com/neurocyte/android-haskell-activity/issues/3
)

Install
sudo adb install -r bin/LambdaMC-debug.apk

best regards,
Anthony Mulcahy

From fuuzetsu at fuuzetsu.co.uk  Mon Feb 17 21:27:56 2014
From: fuuzetsu at fuuzetsu.co.uk (Mateusz Kowalczyk)
Date: Mon, 17 Feb 2014 21:27:56 +0000
Subject: [Haskell-cafe] Yi documentation
In-Reply-To: <CAJUDvcgSi9jKZ5VgkKUavg=bxvyCbRNC3qissEVgOEMUD_1SOA@mail.gmail.com>
References: <53019184.5010702@fuuzetsu.co.uk>	<CAJUDvciyp+fppxWsD19=eFjQNt=E9PRYEYPher9De5joZrMYzw@mail.gmail.com>	<530260F2.6050704@fuuzetsu.co.uk>
 <CAJUDvcgSi9jKZ5VgkKUavg=bxvyCbRNC3qissEVgOEMUD_1SOA@mail.gmail.com>
Message-ID: <53027EDC.2000306@fuuzetsu.co.uk>

On 17/02/14 19:43, David Thomas wrote:
> I guess I'm mostly asking after subjective experience, but I think the
> things I would rate most important would be (in no particular order): 1)
> key bindings I use match vim, 2) easy to create new key bindings, and 3)
> quickfix buffer.  I would be most surprised if 2 was missing.  1 is
> typically underpopulated but could be grown... anyone know about 3?
> 
> 

For 1 you'd probably have to try-and-see but I think we have a pretty
good coverage. For 2, I think the biggest hurdle is lack of
documentation on how to create the keybindings. AFAIK at the moment
everyone gets by through looking at other people's configs but I think
we should properly document what the different combinators do. I might
attempt this tonight.

Regarding quickfix, I have only learned about it recently. I believe
it's like a compilation buffer in emacs. I do see Compilation mode in
the source but I admit have never tried it out. I think none of the
commands that quickfix provides are offered either.

A big problem with implementing such modes properly is that currently we
have no way to run actions affecting Yi concurrently which means that Yi
would ?lock up? during compilation. Hopefully we can solve this in near
future but until then, I don't think it's very viable to start
implementing it.


-- 
Mateusz K.

From davidleothomas at gmail.com  Mon Feb 17 22:25:37 2014
From: davidleothomas at gmail.com (David Thomas)
Date: Mon, 17 Feb 2014 14:25:37 -0800
Subject: [Haskell-cafe] Yi documentation
In-Reply-To: <53027EDC.2000306@fuuzetsu.co.uk>
References: <53019184.5010702@fuuzetsu.co.uk>
 <CAJUDvciyp+fppxWsD19=eFjQNt=E9PRYEYPher9De5joZrMYzw@mail.gmail.com>
 <530260F2.6050704@fuuzetsu.co.uk>
 <CAJUDvcgSi9jKZ5VgkKUavg=bxvyCbRNC3qissEVgOEMUD_1SOA@mail.gmail.com>
 <53027EDC.2000306@fuuzetsu.co.uk>
Message-ID: <CAJUDvcjmuWUCHSNF_zmdHL=_fPcH1rtM=CbvzewgxAK-2PDtKw@mail.gmail.com>

Vim doesn't do concurrency either, so that wouldn't be a regression.


On Mon, Feb 17, 2014 at 1:27 PM, Mateusz Kowalczyk
<fuuzetsu at fuuzetsu.co.uk>wrote:

> On 17/02/14 19:43, David Thomas wrote:
> > I guess I'm mostly asking after subjective experience, but I think the
> > things I would rate most important would be (in no particular order): 1)
> > key bindings I use match vim, 2) easy to create new key bindings, and 3)
> > quickfix buffer.  I would be most surprised if 2 was missing.  1 is
> > typically underpopulated but could be grown... anyone know about 3?
> >
> >
>
> For 1 you'd probably have to try-and-see but I think we have a pretty
> good coverage. For 2, I think the biggest hurdle is lack of
> documentation on how to create the keybindings. AFAIK at the moment
> everyone gets by through looking at other people's configs but I think
> we should properly document what the different combinators do. I might
> attempt this tonight.
>
> Regarding quickfix, I have only learned about it recently. I believe
> it's like a compilation buffer in emacs. I do see Compilation mode in
> the source but I admit have never tried it out. I think none of the
> commands that quickfix provides are offered either.
>
> A big problem with implementing such modes properly is that currently we
> have no way to run actions affecting Yi concurrently which means that Yi
> would 'lock up' during compilation. Hopefully we can solve this in near
> future but until then, I don't think it's very viable to start
> implementing it.
>
>
> --
> Mateusz K.
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140217/1965af49/attachment.html>

From omari at smileystation.com  Mon Feb 17 22:27:04 2014
From: omari at smileystation.com (Omari Norman)
Date: Mon, 17 Feb 2014 17:27:04 -0500
Subject: [Haskell-cafe] Haskell Platform website error
Message-ID: <CA+aFgYB5oyqo4UnQOxgPuvSysg31W5nWfzL03MqAKYe=TA-86Q@mail.gmail.com>

Inaccuracy in Haskell Platform website: it says version 2013.2.0.0
includes containers-0.4.2.1:

http://www.haskell.org/platform/changelog.html

However the containers included in GHC 7.6.3 and, therefore, with this
version of Haskell Platform is in fact version 0.5.0.0.

There's no apparent contact link on the website; who should I report
this to? Thanks. --Omari

From fuuzetsu at fuuzetsu.co.uk  Mon Feb 17 22:50:31 2014
From: fuuzetsu at fuuzetsu.co.uk (Mateusz Kowalczyk)
Date: Mon, 17 Feb 2014 22:50:31 +0000
Subject: [Haskell-cafe] Yi documentation
In-Reply-To: <CAJUDvcjmuWUCHSNF_zmdHL=_fPcH1rtM=CbvzewgxAK-2PDtKw@mail.gmail.com>
References: <53019184.5010702@fuuzetsu.co.uk>	<CAJUDvciyp+fppxWsD19=eFjQNt=E9PRYEYPher9De5joZrMYzw@mail.gmail.com>	<530260F2.6050704@fuuzetsu.co.uk>	<CAJUDvcgSi9jKZ5VgkKUavg=bxvyCbRNC3qissEVgOEMUD_1SOA@mail.gmail.com>	<53027EDC.2000306@fuuzetsu.co.uk>
 <CAJUDvcjmuWUCHSNF_zmdHL=_fPcH1rtM=CbvzewgxAK-2PDtKw@mail.gmail.com>
Message-ID: <53029237.4070508@fuuzetsu.co.uk>

On 17/02/14 22:25, David Thomas wrote:
> Vim doesn't do concurrency either, so that wouldn't be a regression.
> 
> 

Yes, but it does single thread scheduling to compensate (as does emacs)
while Yi doesn't which means implementing quickfix (and other modes)
isn't too viable without halting the whole editor.

-- 
Mateusz K.

From roma at ro-che.info  Mon Feb 17 23:02:30 2014
From: roma at ro-che.info (Roman Cheplyaka)
Date: Tue, 18 Feb 2014 01:02:30 +0200
Subject: [Haskell-cafe] Yi documentation
In-Reply-To: <53029237.4070508@fuuzetsu.co.uk>
References: <53019184.5010702@fuuzetsu.co.uk>
 <CAJUDvciyp+fppxWsD19=eFjQNt=E9PRYEYPher9De5joZrMYzw@mail.gmail.com>
 <530260F2.6050704@fuuzetsu.co.uk>
 <CAJUDvcgSi9jKZ5VgkKUavg=bxvyCbRNC3qissEVgOEMUD_1SOA@mail.gmail.com>
 <53027EDC.2000306@fuuzetsu.co.uk>
 <CAJUDvcjmuWUCHSNF_zmdHL=_fPcH1rtM=CbvzewgxAK-2PDtKw@mail.gmail.com>
 <53029237.4070508@fuuzetsu.co.uk>
Message-ID: <20140217230230.GA4494@sniper>

* Mateusz Kowalczyk <fuuzetsu at fuuzetsu.co.uk> [2014-02-17 22:50:31+0000]
> On 17/02/14 22:25, David Thomas wrote:
> > Vim doesn't do concurrency either, so that wouldn't be a regression.
> > 
> > 
> 
> Yes, but it does single thread scheduling to compensate (as does emacs)
> while Yi doesn't which means implementing quickfix (and other modes)
> isn't too viable without halting the whole editor.

I have to admit I'm surprised.

The lack of (true) concurrency is, in my opinion, the single most
salient architectural problem in both vim and emacs. I'd definitely
expect Yi to tackle that.

Roman
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140218/9769cbf3/attachment.sig>

From fuuzetsu at fuuzetsu.co.uk  Mon Feb 17 23:05:41 2014
From: fuuzetsu at fuuzetsu.co.uk (Mateusz Kowalczyk)
Date: Mon, 17 Feb 2014 23:05:41 +0000
Subject: [Haskell-cafe] Yi documentation
In-Reply-To: <20140217230230.GA4494@sniper>
References: <53019184.5010702@fuuzetsu.co.uk>
 <CAJUDvciyp+fppxWsD19=eFjQNt=E9PRYEYPher9De5joZrMYzw@mail.gmail.com>
 <530260F2.6050704@fuuzetsu.co.uk>
 <CAJUDvcgSi9jKZ5VgkKUavg=bxvyCbRNC3qissEVgOEMUD_1SOA@mail.gmail.com>
 <53027EDC.2000306@fuuzetsu.co.uk>
 <CAJUDvcjmuWUCHSNF_zmdHL=_fPcH1rtM=CbvzewgxAK-2PDtKw@mail.gmail.com>
 <53029237.4070508@fuuzetsu.co.uk> <20140217230230.GA4494@sniper>
Message-ID: <530295C5.2000801@fuuzetsu.co.uk>

On 17/02/14 23:02, Roman Cheplyaka wrote:
> * Mateusz Kowalczyk <fuuzetsu at fuuzetsu.co.uk> [2014-02-17 22:50:31+0000]
>> On 17/02/14 22:25, David Thomas wrote:
>>> Vim doesn't do concurrency either, so that wouldn't be a regression.
>>>
>>>
>>
>> Yes, but it does single thread scheduling to compensate (as does emacs)
>> while Yi doesn't which means implementing quickfix (and other modes)
>> isn't too viable without halting the whole editor.
> 
> I have to admit I'm surprised.
> 
> The lack of (true) concurrency is, in my opinion, the single most
> salient architectural problem in both vim and emacs. I'd definitely
> expect Yi to tackle that.
> 
> Roman
> 

I was surprised when I found out as well. There are definitely plans to
implement it. If Haskell takes part in this year's GSOC, I hope to put
together a proposal which amongst some other things includes concurrency
support for Yi.

So yes, we definitely plan on tackling that.

-- 
Mateusz K.

From mantkiew at gsd.uwaterloo.ca  Mon Feb 17 23:13:15 2014
From: mantkiew at gsd.uwaterloo.ca (mantkiew at gsd.uwaterloo.ca)
Date: Mon, 17 Feb 2014 18:13:15 -0500
Subject: [Haskell-cafe] Yi documentation
In-Reply-To: <530295C5.2000801@fuuzetsu.co.uk>
References: <53019184.5010702@fuuzetsu.co.uk>
 <CAJUDvciyp+fppxWsD19=eFjQNt=E9PRYEYPher9De5joZrMYzw@mail.gmail.com>
 <530260F2.6050704@fuuzetsu.co.uk>
 <CAJUDvcgSi9jKZ5VgkKUavg=bxvyCbRNC3qissEVgOEMUD_1SOA@mail.gmail.com>
 <53027EDC.2000306@fuuzetsu.co.uk>
 <CAJUDvcjmuWUCHSNF_zmdHL=_fPcH1rtM=CbvzewgxAK-2PDtKw@mail.gmail.com>
 <53029237.4070508@fuuzetsu.co.uk> <20140217230230.GA4494@sniper>
 <530295C5.2000801@fuuzetsu.co.uk>
Message-ID: <20140217231315.6004885.82152.3797@gsd.uwaterloo.ca>

?How does Yi compare to Sublime Text + Sublime Haskell plug-in? For me, that's the Haskell IDE Of choice. And it does support ?concurrent tasks.

Cheers,
Michal

? Original Message ?
From: Mateusz Kowalczyk
Sent: Monday, February 17, 2014 6:05 PM
To: haskell-cafe
Subject: Re: [Haskell-cafe] Yi documentation

On 17/02/14 23:02, Roman Cheplyaka wrote:
> * Mateusz Kowalczyk <fuuzetsu at fuuzetsu.co.uk> [2014-02-17 22:50:31+0000]
>> On 17/02/14 22:25, David Thomas wrote:
>>> Vim doesn't do concurrency either, so that wouldn't be a regression.
>>>
>>>
>>
>> Yes, but it does single thread scheduling to compensate (as does emacs)
>> while Yi doesn't which means implementing quickfix (and other modes)
>> isn't too viable without halting the whole editor.
> 
> I have to admit I'm surprised.
> 
> The lack of (true) concurrency is, in my opinion, the single most
> salient architectural problem in both vim and emacs. I'd definitely
> expect Yi to tackle that.
> 
> Roman
> 

I was surprised when I found out as well. There are definitely plans to
implement it. If Haskell takes part in this year's GSOC, I hope to put
together a proposal which amongst some other things includes concurrency
support for Yi.

So yes, we definitely plan on tackling that.

-- 
Mateusz K.
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe at haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

From fuuzetsu at fuuzetsu.co.uk  Mon Feb 17 23:18:27 2014
From: fuuzetsu at fuuzetsu.co.uk (Mateusz Kowalczyk)
Date: Mon, 17 Feb 2014 23:18:27 +0000
Subject: [Haskell-cafe] Yi documentation
In-Reply-To: <20140217231315.6004885.82152.3797@gsd.uwaterloo.ca>
References: <53019184.5010702@fuuzetsu.co.uk>
 <CAJUDvciyp+fppxWsD19=eFjQNt=E9PRYEYPher9De5joZrMYzw@mail.gmail.com>
 <530260F2.6050704@fuuzetsu.co.uk>
 <CAJUDvcgSi9jKZ5VgkKUavg=bxvyCbRNC3qissEVgOEMUD_1SOA@mail.gmail.com>
 <53027EDC.2000306@fuuzetsu.co.uk>
 <CAJUDvcjmuWUCHSNF_zmdHL=_fPcH1rtM=CbvzewgxAK-2PDtKw@mail.gmail.com>
 <53029237.4070508@fuuzetsu.co.uk> <20140217230230.GA4494@sniper>
 <530295C5.2000801@fuuzetsu.co.uk>
 <20140217231315.6004885.82152.3797@gsd.uwaterloo.ca>
Message-ID: <530298C3.3020108@fuuzetsu.co.uk>

On 17/02/14 23:13, mantkiew at gsd.uwaterloo.ca wrote:
> ?How does Yi compare to Sublime Text + Sublime Haskell plug-in? For me, that's the Haskell IDE Of choice. And it does support  concurrent tasks.
> 
> Cheers,
> Michal
> 
Hi,

I don't know, I have never used Sublime Text and I don't think anyone
who works on Yi uses it as their main editor.

It'd be helpful if you listed some things that ST does that you'd like
to have in Yi. Maybe there are some good ideas that we haven't thought
about.

This thread kind of assumes that you tried (or attempted to use) Yi in
the past rather than trying to entice users of other editors to switch.

-- 
Mateusz K.

From aemulcahy at gmail.com  Mon Feb 17 23:21:43 2014
From: aemulcahy at gmail.com (Anthony Mulcahy)
Date: Tue, 18 Feb 2014 08:21:43 +0900
Subject: [Haskell-cafe] ANN: LambdaMC: demo Haskell Android app built
 with the ghc-android tool.
In-Reply-To: <CADgw9YbL1+VCakj1sVLv5=ovsS34ussNt-Kf=kGQhy+gkP2bkQ@mail.gmail.com>
References: <CADgw9YbL1+VCakj1sVLv5=ovsS34ussNt-Kf=kGQhy+gkP2bkQ@mail.gmail.com>
Message-ID: <CADgw9YbOdxEfbipJ+4MFV6PmZR9tgnx=70Nw1UmCviaD_HU9XQ@mail.gmail.com>

Sorry, I forgot to include the GitHub link:
https://github.com/amulcahy/LambdaMC
2014/02/18 6:00 "Anthony Mulcahy" <aemulcahy at gmail.com>:

> Announcing LambdaMC: a demo Haskell Android app to calculate option
> prices by Monte Carlo simulation built with the ghc-android tool.
>
> Based on the example app at
> https://github.com/neurocyte/android-haskell-activity
>
> Functionality is limited, but it may be a useful reference for anybody
> developing a Haskell Android app:
> - Android Pause / Resume functionality.
> - Screen Rotation support.
> - Background worker thread updates the UI when the calculation is complete.
> - Interaction between various Android UI elements and Haskell code.
>
> Google Play listing:
> https://play.google.com/store/apps/details?id=org.dragongate_technologies
>
> Files
> LambdaMC.hs : Haskell app code
> DgAndr.hs : Haskell wrapper for various Android library functions
> DgMath.hs : Haskell option pricing code
> LambdaMC.java : Minimal Java code to support the main Activity
> LicenseActivity.java : Java Activity to display license information
> (need to move more code to Haskell-land)
>
> Prerequisites
> - An Android cross-compiler built with the ghc-android tool at
> https://github.com/neurocyte/ghc-android
> - The foreign-jni package from https://github.com/neurocyte/foreign-jni
> - The Haskell packages base, deepseq, transformers, mtl, text, time
>
> Building
> ./build_workaround.sh ( to work around the -shared and -r issue
> described at
> https://github.com/neurocyte/android-haskell-activity/issues/3
> )
>
> Install
> sudo adb install -r bin/LambdaMC-debug.apk
>
> best regards,
> Anthony Mulcahy
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140218/358acdde/attachment.html>

From fuuzetsu at fuuzetsu.co.uk  Tue Feb 18 00:19:04 2014
From: fuuzetsu at fuuzetsu.co.uk (Mateusz Kowalczyk)
Date: Tue, 18 Feb 2014 00:19:04 +0000
Subject: [Haskell-cafe] Yi documentation
In-Reply-To: <CAJUDvcj=CYThc1+i89+BWUdTx9gdoZZL2PpHs7B14RAUBV8vxA@mail.gmail.com>
References: <53019184.5010702@fuuzetsu.co.uk>	<CAJUDvciyp+fppxWsD19=eFjQNt=E9PRYEYPher9De5joZrMYzw@mail.gmail.com>	<530260F2.6050704@fuuzetsu.co.uk>	<CAJUDvcgSi9jKZ5VgkKUavg=bxvyCbRNC3qissEVgOEMUD_1SOA@mail.gmail.com>	<53027EDC.2000306@fuuzetsu.co.uk>	<CAJUDvcjmuWUCHSNF_zmdHL=_fPcH1rtM=CbvzewgxAK-2PDtKw@mail.gmail.com>	<53029237.4070508@fuuzetsu.co.uk>
 <CAJUDvcj=CYThc1+i89+BWUdTx9gdoZZL2PpHs7B14RAUBV8vxA@mail.gmail.com>
Message-ID: <5302A6F8.9020902@fuuzetsu.co.uk>

On 17/02/14 23:54, David Thomas wrote:
> Does this mean generally I can't run an external command with output into a
> buffer (or buffer region)?
> 
> 
> On Mon, Feb 17, 2014 at 2:50 PM, Mateusz Kowalczyk
> <fuuzetsu at fuuzetsu.co.uk>wrote:
> 
>> On 17/02/14 22:25, David Thomas wrote:
>>> Vim doesn't do concurrency either, so that wouldn't be a regression.
>>>
>>>
>>
>> Yes, but it does single thread scheduling to compensate (as does emacs)
>> while Yi doesn't which means implementing quickfix (and other modes)
>> isn't too viable without halting the whole editor.
>>
>> --
>> Mateusz K.
>>
> 

You can, it will just hang the editor while it happens. An easy test is
having Yi call something like ?sleep 5; echo foo?.

It should be easy to see why it's a big problem at the moment.
Personally I stumbled upon it when trying to implement myself an IRC
client inside of Yi but there are many use cases.

Anyway, I feel that we're getting a bit off-topic here. If you're
interested in helping out with implementing the concurrency stuff, we'd
love to have you: pop into #yi, look around the issue tracker and maybe
even post to the Yi mailing list.

-- 
Mateusz K.

From achudnov at gmail.com  Tue Feb 18 00:24:43 2014
From: achudnov at gmail.com (Andrey Chudnov)
Date: Mon, 17 Feb 2014 19:24:43 -0500
Subject: [Haskell-cafe] HaskellWiki account
Message-ID: <5302A84B.8020206@gmail.com>

Hi,
Sorry for spamming the list with such trivialities. Long story short,
I'd like to get an account for HaskellWiki. Tried e-mailing "nominolo"
(at the email service from Google)", but to no avail. Could anyone,
please, help me with that?

Thanks!
/Andrey

From nominolo at googlemail.com  Tue Feb 18 02:06:54 2014
From: nominolo at googlemail.com (Thomas Schilling)
Date: Tue, 18 Feb 2014 03:06:54 +0100
Subject: [Haskell-cafe] HaskellWiki account
In-Reply-To: <5302A84B.8020206@gmail.com>
References: <5302A84B.8020206@gmail.com>
Message-ID: <CAOJG3uDR+ox=593ny9wiHWXwdb1xEUZWGZnAq6MEuBd3i-W0mg@mail.gmail.com>

Taken care of.

On 18 February 2014 01:24, Andrey Chudnov <achudnov at gmail.com> wrote:
> Hi,
> Sorry for spamming the list with such trivialities. Long story short,
> I'd like to get an account for HaskellWiki. Tried e-mailing "nominolo"
> (at the email service from Google)", but to no avail. Could anyone,
> please, help me with that?
>
> Thanks!
> /Andrey
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe

From fa-ml at ariis.it  Tue Feb 18 06:20:14 2014
From: fa-ml at ariis.it (fa-ml)
Date: Tue, 18 Feb 2014 07:20:14 +0100
Subject: [Haskell-cafe] Yi documentation
In-Reply-To: <53019184.5010702@fuuzetsu.co.uk>
References: <53019184.5010702@fuuzetsu.co.uk>
Message-ID: <20140218062014.GA12488@x60s.casa>

On Mon, Feb 17, 2014 at 04:35:16AM +0000, Mateusz Kowalczyk wrote:
> If you're looking for any specific guides, I'd also like to hear about
> it. I (and perhaps some others) can write documentation but it helps if
> we have specific topics to talk about rather than taking guesses in the
> dark.

Hello,
    while asking questions in #yi/freenode, I was pointed to
yi/doc/monads.html [1] as a way to grasp the inner mechanism of Yi.
A brief (or otherwise) description of what the datatypes (YiM a, EditorM a,
BufferM a, Action) do or represent would be greatly appreciated.

[1] https://github.com/yi-editor/yi/tree/master/doc

From fuuzetsu at fuuzetsu.co.uk  Tue Feb 18 07:13:04 2014
From: fuuzetsu at fuuzetsu.co.uk (Mateusz Kowalczyk)
Date: Tue, 18 Feb 2014 07:13:04 +0000
Subject: [Haskell-cafe] Yi documentation
In-Reply-To: <20140218062014.GA12488@x60s.casa>
References: <53019184.5010702@fuuzetsu.co.uk>
 <20140218062014.GA12488@x60s.casa>
Message-ID: <53030800.8090304@fuuzetsu.co.uk>

On 18/02/14 06:20, fa-ml wrote:
> On Mon, Feb 17, 2014 at 04:35:16AM +0000, Mateusz Kowalczyk wrote:
>> If you're looking for any specific guides, I'd also like to hear about
>> it. I (and perhaps some others) can write documentation but it helps if
>> we have specific topics to talk about rather than taking guesses in the
>> dark.
> 
> Hello,
>     while asking questions in #yi/freenode, I was pointed to
> yi/doc/monads.html [1] as a way to grasp the inner mechanism of Yi.
> A brief (or otherwise) description of what the datatypes (YiM a, EditorM a,
> BufferM a, Action) do or represent would be greatly appreciated.
> 
> [1] https://github.com/yi-editor/yi/tree/master/doc
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
> 

The very basic ?what it's intended to be? can be found for the basic
monads at
http://publications.lib.chalmers.se/records/fulltext/local_72549.pdf
which is linked at the bottom of the README. Please say if you need
anything more specific than that. Note that I do not know the answers
off-by-heart and I'll also be learning it all before doing any write-ups.

-- 
Mateusz K.

From cobbe at ccs.neu.edu  Tue Feb 18 12:57:53 2014
From: cobbe at ccs.neu.edu (Richard Cobbe)
Date: Tue, 18 Feb 2014 07:57:53 -0500
Subject: [Haskell-cafe] how to write cabal package file for executable
 with unit tests?
In-Reply-To: <CAPeieQHa5-FZBC2N-Bjk8Tmw=epMWjkJhr591zo4rQ0dnBzmNg@mail.gmail.com>
References: <20140216221525.GA238@ridcully.home>
 <20140216225241.GA18934@sniper>
 <20140217012618.GB238@ridcully.home>
 <CAPeieQHa5-FZBC2N-Bjk8Tmw=epMWjkJhr591zo4rQ0dnBzmNg@mail.gmail.com>
Message-ID: <20140218125753.GA256@ridcully.home>

On Mon, Feb 17, 2014 at 11:07:07AM +0100, Erik Hesselink wrote:
> Hi Richard,
>
> Where is your Parser module located?

The Happy source for the Parser module is in the src directory with the
rest of the files for the executable.

> Remember that your code will be compiled twice this way. What is, in
> my opinion, a better setup, is put the shared code in a library (like
> you had), and then have a shallow executable in the same package that
> depends on the library. The test-suite can then also depend on the
> library. All three should have distinct source dirs.
>
> Having most functionality in a library is a good design principle
> anyway: it makes it easier to re-use it in a different way later, and
> makes sure you think about API boundaries and such.

In principle, I agree.  However, it's not obvious that there's actually any
code that's suitable for re-use in this case (except for stuff I've already
moved out to other libraries, in separate Cabal packages).

And I'm not sure that I get many of the benefits of thinking about API
boundaries, because I have to expose modules from the library if I want to
write unit tests for them, even if they're not really part of the library's
public interface.

However, that seems to be the best way to go, so I'll leave it at that.

Thanks!

Richard

From mail at nh2.me  Tue Feb 18 14:30:36 2014
From: mail at nh2.me (=?ISO-8859-1?Q?Niklas_Hamb=FCchen?=)
Date: Tue, 18 Feb 2014 14:30:36 +0000
Subject: [Haskell-cafe] how to write cabal package file for executable
 with unit tests?
In-Reply-To: <20140218125753.GA256@ridcully.home>
References: <20140216221525.GA238@ridcully.home>
 <20140216225241.GA18934@sniper> <20140217012618.GB238@ridcully.home>
 <CAPeieQHa5-FZBC2N-Bjk8Tmw=epMWjkJhr591zo4rQ0dnBzmNg@mail.gmail.com>
 <20140218125753.GA256@ridcully.home>
Message-ID: <53036E8C.8080309@nh2.me>

On 18/02/14 12:57, Richard Cobbe wrote:
> And I'm not sure that I get many of the benefits of thinking about API
> boundaries, because I have to expose modules from the library if I want to
> write unit tests for them, even if they're not really part of the library's
> public interface.

Exactly that has bothered me for long.

If I want to make a proper cabal package with tests for internal API, I
have to expose the internal API (otherwise we get double building).

In general, I always recommend exposing all the code in .Internal
modules - I often run into problems with packages that don't do this.

Yet, the whole re-exporting overhead introduced by this is cumbersome,
and it doesn't make haddocks nicer either (e.g. when you come to a page
that is full of re-exports). I hope haddock will find a way to make this
nicer.

From dagitj at gmail.com  Tue Feb 18 18:12:17 2014
From: dagitj at gmail.com (Jason Dagit)
Date: Tue, 18 Feb 2014 10:12:17 -0800
Subject: [Haskell-cafe] Thank you for the donations to Haskell.org!
Message-ID: <CAJ-DSyzDjebR5jVHpjCo757=90FcGP+uimCgtogx0F4DcQv+Kw@mail.gmail.com>

On behalf of Haskell.org, we would like to thank all the generous donors we
had in 2013!

Just in the last week of the year, we received about half of the total
donations for the year. Nearly $900! That brings the total donations for
the year to $1976! Thank you very much!

We are very grateful for all the donations we receive, financial and
otherwise. As examples, GlobalSign graciously provides us with a free SSL
certificate for use on hackage and each year community members collectively
provide countless hours of time and energy towards making the Haskell
community vibrant, positive, and relevant.

At the moment our primary expenses are hosting for haskell.org and hackage.
The donations we have received will help ensure that we continue to have
adequate hosting for the ever growing hackage!

Thank you and let's continue our momentum into 2014!

Sincerely,
The Haskell.org Committee
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140218/a712fd92/attachment.html>

From doug at cs.dartmouth.edu  Tue Feb 18 20:11:58 2014
From: doug at cs.dartmouth.edu (Doug McIlroy)
Date: Tue, 18 Feb 2014 15:11:58 -0500
Subject: [Haskell-cafe] Haskell spec vs FlexibleInstances
Message-ID: <201402182011.s1IKBw2e003049@stowe.cs.dartmouth.edu>

What potential evil motivates  the prohibition of repeated type
parameters in an instance declaration? (Restriction removed
by FlexibleInstances)
Doug McIlroy

From allbery.b at gmail.com  Tue Feb 18 20:40:39 2014
From: allbery.b at gmail.com (Brandon Allbery)
Date: Tue, 18 Feb 2014 15:40:39 -0500
Subject: [Haskell-cafe] Haskell spec vs FlexibleInstances
In-Reply-To: <201402182011.s1IKBw2e003049@stowe.cs.dartmouth.edu>
References: <201402182011.s1IKBw2e003049@stowe.cs.dartmouth.edu>
Message-ID: <CAKFCL4VS8Ju2sJE+U4W4mUj7rySP13pWZp=t66krHuw=C_Rtvw@mail.gmail.com>

On Tue, Feb 18, 2014 at 3:11 PM, Doug McIlroy <doug at cs.dartmouth.edu> wrote:

> What potential evil motivates  the prohibition of repeated type
> parameters in an instance declaration? (Restriction removed
> by FlexibleInstances)
>

Isn't that just related to constraints not being part of instance
selection? (Assuming that `instance SomeClass a a` is interpreted as
`instance (a ~ b) => SomeClass a b`, since I don't quite see how it would
work otherwise given how instances work; the constraint is not necessarily
obvious from looking at it. Also note that standard Haskell can't therefore
describe this instance properly.)

-- 
brandon s allbery kf8nh                               sine nomine associates
allbery.b at gmail.com                                  ballbery at sinenomine.net
unix, openafs, kerberos, infrastructure, xmonad        http://sinenomine.net
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140218/d6dd741e/attachment.html>

From dan.doel at gmail.com  Tue Feb 18 20:51:15 2014
From: dan.doel at gmail.com (Dan Doel)
Date: Tue, 18 Feb 2014 15:51:15 -0500
Subject: [Haskell-cafe] Haskell spec vs FlexibleInstances
In-Reply-To: <CAKFCL4VS8Ju2sJE+U4W4mUj7rySP13pWZp=t66krHuw=C_Rtvw@mail.gmail.com>
References: <201402182011.s1IKBw2e003049@stowe.cs.dartmouth.edu>
 <CAKFCL4VS8Ju2sJE+U4W4mUj7rySP13pWZp=t66krHuw=C_Rtvw@mail.gmail.com>
Message-ID: <CAHEA9tO+FoLTDCrAnh729OGY-LSui7ec6BY94-0BqZ3L2kjawg@mail.gmail.com>

On Tue, Feb 18, 2014 at 3:40 PM, Brandon Allbery <allbery.b at gmail.com>wrote:

>
> On Tue, Feb 18, 2014 at 3:11 PM, Doug McIlroy <doug at cs.dartmouth.edu>wrote:
>
>> What potential evil motivates  the prohibition of repeated type
>> parameters in an instance declaration? (Restriction removed
>> by FlexibleInstances)
>>
>
> Isn't that just related to constraints not being part of instance
> selection? (Assuming that `instance SomeClass a a` is interpreted as
> `instance (a ~ b) => SomeClass a b`, since I don't quite see how it would
> work otherwise given how instances work; the constraint is not necessarily
> obvious from looking at it. Also note that standard Haskell can't therefore
> describe this instance properly.)
>

These two instances do not actually work the same way.

    instance (a ~ b) => SomeClass a b

says that any context containing 'SomeClass a b' can be reduced to a
context containing (a ~ b) instead.

    instance SomeClass a a

says that a 'SomeClass a b' constraint can be discharged if we enter a
state in which the type checker _decides_ that a = b.

In a sense, the first instance can provide information, while the second
requires it. Whether there should be such a distinction is left up to the
reader.

-- Dan
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140218/d02fa933/attachment.html>

From anthony_clayden at clear.net.nz  Tue Feb 18 20:53:31 2014
From: anthony_clayden at clear.net.nz (AntC)
Date: Tue, 18 Feb 2014 20:53:31 +0000 (UTC)
Subject: [Haskell-cafe] Haskell spec vs FlexibleInstances
References: <201402182011.s1IKBw2e003049@stowe.cs.dartmouth.edu>
Message-ID: <loom.20140218T212623-105@post.gmane.org>

> Doug McIlroy <doug <at> cs.dartmouth.edu> writes:
> 
> What potential evil motivates  the prohibition of repeated type
> parameters in an instance declaration?

Hi Doug, 

I guess the first reason would be to catch accidental duplicate names of 
typevars.

But as to "potential evils", the only point of such an instance:

    instance C a a where ...

would be to have another instance:

    instance C a b where ...

So we're into overlapping instances. (And discriminating on type equality -
- which only works if the types are grounded. See the HList paper, section 
9 'By chance or design?')

Overlapping instances like that will probably need FunDeps. So the more 
recent (and probably more blessed) approach is to use the Closed type 
families/branched instances doo-hicky upcoming with GHC 7.8.
http://www.haskell.org/haskellwiki/GHC/Indexed_types#Type_instance_declarat
ions

AntC




From carter.schonwald at gmail.com  Tue Feb 18 22:50:49 2014
From: carter.schonwald at gmail.com (Carter Schonwald)
Date: Tue, 18 Feb 2014 17:50:49 -0500
Subject: [Haskell-cafe] how to write cabal package file for executable
 with unit tests?
In-Reply-To: <53036E8C.8080309@nh2.me>
References: <20140216221525.GA238@ridcully.home>
 <20140216225241.GA18934@sniper>
 <20140217012618.GB238@ridcully.home>
 <CAPeieQHa5-FZBC2N-Bjk8Tmw=epMWjkJhr591zo4rQ0dnBzmNg@mail.gmail.com>
 <20140218125753.GA256@ridcully.home> <53036E8C.8080309@nh2.me>
Message-ID: <CAHYVw0wOdr6Vr4kwmO6_e8S1Kdc6WLW7ncXAbSxwLjxLsbkStQ@mail.gmail.com>

Indeed. Best practices are trending towards making internal Apis public.
But very very clearly making it clear "assume these get breaking changes
every single release.  "

On Tuesday, February 18, 2014, Niklas Hamb?chen <mail at nh2.me> wrote:

> On 18/02/14 12:57, Richard Cobbe wrote:
> > And I'm not sure that I get many of the benefits of thinking about API
> > boundaries, because I have to expose modules from the library if I want
> to
> > write unit tests for them, even if they're not really part of the
> library's
> > public interface.
>
> Exactly that has bothered me for long.
>
> If I want to make a proper cabal package with tests for internal API, I
> have to expose the internal API (otherwise we get double building).
>
> In general, I always recommend exposing all the code in .Internal
> modules - I often run into problems with packages that don't do this.
>
> Yet, the whole re-exporting overhead introduced by this is cumbersome,
> and it doesn't make haddocks nicer either (e.g. when you come to a page
> that is full of re-exports). I hope haddock will find a way to make this
> nicer.
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org <javascript:;>
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140218/58beff82/attachment.html>

From kiwamu at debian.or.jp  Wed Feb 19 05:39:00 2014
From: kiwamu at debian.or.jp (Kiwamu Okabe)
Date: Wed, 19 Feb 2014 14:39:00 +0900
Subject: [Haskell-cafe] Rewrite NetBSD kernel driver using Ajhc Haskell
	compiler
Message-ID: <CAEvX6dki6=N5D70pucRqsbVWhW8c9C9qbPKefYc1Um7UNiseqg@mail.gmail.com>

Hi all,

NetBSD kernel's HD Audio sound driver has interrupt handler.
The interrupt handler of the demo is re-written by Haskell language
using Ajhc Haskell Compiler http://ajhc.metasepi.org/.

Demo movie could be found at following link.

http://www.youtube.com/watch?v=XEYcR5RG5cA

At the demo, run following operations.

First, set breakpoint at the interrupt of finding headphone,
and see Haskell function names on backtrace.

Second, set breakpoint s_alloc() function, that allocate area
in Haskell heap. Make sure of calling the function while anytime
running kernel.

Nevertheless, playing wav file does not break up.

The source code is found at https://github.com/metasepi/netbsd-arafura-s1.
And a picture of the architecture is also at
http://www.flickr.com/photos/masterq/12616929055/.

Thank's,
-- 
Kiwamu Okabe

From fuuzetsu at fuuzetsu.co.uk  Wed Feb 19 05:57:23 2014
From: fuuzetsu at fuuzetsu.co.uk (Mateusz Kowalczyk)
Date: Wed, 19 Feb 2014 05:57:23 +0000
Subject: [Haskell-cafe] Rewrite NetBSD kernel driver using Ajhc Haskell
 compiler
In-Reply-To: <CAEvX6dki6=N5D70pucRqsbVWhW8c9C9qbPKefYc1Um7UNiseqg@mail.gmail.com>
References: <CAEvX6dki6=N5D70pucRqsbVWhW8c9C9qbPKefYc1Um7UNiseqg@mail.gmail.com>
Message-ID: <530447C3.40507@fuuzetsu.co.uk>

On 19/02/14 05:39, Kiwamu Okabe wrote:
> Hi all,
> 
> NetBSD kernel's HD Audio sound driver has interrupt handler.
> The interrupt handler of the demo is re-written by Haskell language
> using Ajhc Haskell Compiler http://ajhc.metasepi.org/.
> 
> Demo movie could be found at following link.
> 
> http://www.youtube.com/watch?v=XEYcR5RG5cA
> 
> At the demo, run following operations.
> 
> First, set breakpoint at the interrupt of finding headphone,
> and see Haskell function names on backtrace.
> 
> Second, set breakpoint s_alloc() function, that allocate area
> in Haskell heap. Make sure of calling the function while anytime
> running kernel.
> 
> Nevertheless, playing wav file does not break up.
> 
> The source code is found at https://github.com/metasepi/netbsd-arafura-s1.
> And a picture of the architecture is also at
> http://www.flickr.com/photos/masterq/12616929055/.
> 
> Thank's,
> 

That's pretty damn cool.

-- 
Mateusz K.

From lindsey at composition.al  Wed Feb 19 07:19:23 2014
From: lindsey at composition.al (Lindsey Kuper)
Date: Wed, 19 Feb 2014 02:19:23 -0500
Subject: [Haskell-cafe] Haskell Platform website error
In-Reply-To: <CA+aFgYB5oyqo4UnQOxgPuvSysg31W5nWfzL03MqAKYe=TA-86Q@mail.gmail.com>
References: <CA+aFgYB5oyqo4UnQOxgPuvSysg31W5nWfzL03MqAKYe=TA-86Q@mail.gmail.com>
Message-ID: <CALnXJipHMzwjVfQ6XYUoohQQMvAZDdWjQ8GUxDQTF=zr2bLwpQ@mail.gmail.com>

On Mon, Feb 17, 2014 at 5:27 PM, Omari Norman <omari at smileystation.com> wrote:
> Inaccuracy in Haskell Platform website: it says version 2013.2.0.0
> includes containers-0.4.2.1:
>
> http://www.haskell.org/platform/changelog.html
>
> However the containers included in GHC 7.6.3 and, therefore, with this
> version of Haskell Platform is in fact version 0.5.0.0.
>
> There's no apparent contact link on the website; who should I report
> this to? Thanks. --Omari

Hi, Omari,

You could file an issue at https://github.com/haskell/haskell-platform/issues .

The last time I found a typo on the Haskell Platform website, I opened
a pull request to fix it, and it was merged a couple of months later.
If you want to do that, the file you want to change in this case is
https://github.com/haskell/haskell-platform/blob/master/download-website/changelog.markdown
.

Lindsey

From difrumin at gmail.com  Wed Feb 19 08:36:06 2014
From: difrumin at gmail.com (Dan Frumin)
Date: Wed, 19 Feb 2014 12:36:06 +0400
Subject: [Haskell-cafe] Haskell Platform website error
In-Reply-To: <CALnXJipHMzwjVfQ6XYUoohQQMvAZDdWjQ8GUxDQTF=zr2bLwpQ@mail.gmail.com>
References: <CA+aFgYB5oyqo4UnQOxgPuvSysg31W5nWfzL03MqAKYe=TA-86Q@mail.gmail.com>
 <CALnXJipHMzwjVfQ6XYUoohQQMvAZDdWjQ8GUxDQTF=zr2bLwpQ@mail.gmail.com>
Message-ID: <F8F9D27F-5E27-4368-83AC-BAEA2582ABDE@gmail.com>



> On 19 Feb 2014, at 11:19, Lindsey Kuper <lindsey at composition.al> wrote:
> 
>> On Mon, Feb 17, 2014 at 5:27 PM, Omari Norman <omari at smileystation.com> wrote:
>> Inaccuracy in Haskell Platform website: it says version 2013.2.0.0
>> includes containers-0.4.2.1:
>> 
>> http://www.haskell.org/platform/changelog.html
>> 
>> However the containers included in GHC 7.6.3 and, therefore, with this
>> version of Haskell Platform is in fact version 0.5.0.0.
>> 
>> There's no apparent contact link on the website; who should I report
>> this to? Thanks. --Omari
> 
> Hi, Omari,
> 
> You could file an issue at https://github.com/haskell/haskell-platform/issues .
> 
> The last time I found a typo on the Haskell Platform website, I opened
> a pull request to fix it, and it was merged a couple of months later.

Ha, to be honest, it doesn't sound very encouraging :P

> If you want to do that, the file you want to change in this case is
> https://github.com/haskell/haskell-platform/blob/master/download-website/changelog.markdown
> .
> 
> Lindsey
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe

From obscaenvs at gmail.com  Wed Feb 19 09:40:46 2014
From: obscaenvs at gmail.com (Obscaenvs)
Date: Wed, 19 Feb 2014 10:40:46 +0100
Subject: [Haskell-cafe] Haskell-platform release information
Message-ID: <53047C1E.6050104@gmail.com>

I'd like a pointer to some place containing information as to why the
new HP is delayed (although I have my suspicions the reason being Xcode
5), and if there is a new schedule. Why isn't there a pointer on [1]? If
one can't stay on schedule, which is sometimes understandable and I
guess in this case highly so, then some info as to why this is is the
least damage control one could do. But maybe there is such info already,
and I am just unable to find it - except for the by now rather old
discussion [2].

/fredrik

[1] http://www.haskell.org/platform/
[2]
https://www.mail-archive.com/haskell-platform at projects.haskell.org/msg02594.html

-- 
bugthunk.net
@bugthunk

From difrumin at gmail.com  Wed Feb 19 09:53:48 2014
From: difrumin at gmail.com (Dan Frumin)
Date: Wed, 19 Feb 2014 13:53:48 +0400
Subject: [Haskell-cafe] Haskell-platform release information
In-Reply-To: <53047C1E.6050104@gmail.com>
References: <53047C1E.6050104@gmail.com>
Message-ID: <2F77D0A1-347A-42DD-B52B-4CC427F6457A@gmail.com>

I recon that it's delayed because the GHC release is delayed. 
I agree that a website update describing the delay would be nice

> On 19 Feb 2014, at 13:40, Obscaenvs <obscaenvs at gmail.com> wrote:
> 
> I'd like a pointer to some place containing information as to why the
> new HP is delayed (although I have my suspicions the reason being Xcode
> 5), and if there is a new schedule. Why isn't there a pointer on [1]? If
> one can't stay on schedule, which is sometimes understandable and I
> guess in this case highly so, then some info as to why this is is the
> least damage control one could do. But maybe there is such info already,
> and I am just unable to find it - except for the by now rather old
> discussion [2].
> 
> /fredrik
> 
> [1] http://www.haskell.org/platform/
> [2]
> https://www.mail-archive.com/haskell-platform at projects.haskell.org/msg02594.html
> 
> -- 
> bugthunk.net
> @bugthunk
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe

From amindfv at gmail.com  Wed Feb 19 14:36:37 2014
From: amindfv at gmail.com (amindfv at gmail.com)
Date: Wed, 19 Feb 2014 09:36:37 -0500
Subject: [Haskell-cafe] Rewrite NetBSD kernel driver using Ajhc Haskell
	compiler
In-Reply-To: <CAEvX6dki6=N5D70pucRqsbVWhW8c9C9qbPKefYc1Um7UNiseqg@mail.gmail.com>
References: <CAEvX6dki6=N5D70pucRqsbVWhW8c9C9qbPKefYc1Um7UNiseqg@mail.gmail.com>
Message-ID: <2562D045-28FB-4555-84F8-3326AFB0839F@gmail.com>

Nice!!

Tom


El Feb 19, 2014, a las 0:39, Kiwamu Okabe <kiwamu at debian.or.jp> escribi?:

> Hi all,
> 
> NetBSD kernel's HD Audio sound driver has interrupt handler.
> The interrupt handler of the demo is re-written by Haskell language
> using Ajhc Haskell Compiler http://ajhc.metasepi.org/.
> 
> Demo movie could be found at following link.
> 
> http://www.youtube.com/watch?v=XEYcR5RG5cA
> 
> At the demo, run following operations.
> 
> First, set breakpoint at the interrupt of finding headphone,
> and see Haskell function names on backtrace.
> 
> Second, set breakpoint s_alloc() function, that allocate area
> in Haskell heap. Make sure of calling the function while anytime
> running kernel.
> 
> Nevertheless, playing wav file does not break up.
> 
> The source code is found at https://github.com/metasepi/netbsd-arafura-s1.
> And a picture of the architecture is also at
> http://www.flickr.com/photos/masterq/12616929055/.
> 
> Thank's,
> -- 
> Kiwamu Okabe
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe

From allbery.b at gmail.com  Wed Feb 19 14:55:53 2014
From: allbery.b at gmail.com (Brandon Allbery)
Date: Wed, 19 Feb 2014 09:55:53 -0500
Subject: [Haskell-cafe] Haskell-platform release information
In-Reply-To: <53047C1E.6050104@gmail.com>
References: <53047C1E.6050104@gmail.com>
Message-ID: <CAKFCL4Wa=mbiJaff=-xBcV34d6yerA13aqFoMQSq4s4wUU59cw@mail.gmail.com>

On Wed, Feb 19, 2014 at 4:40 AM, Obscaenvs <obscaenvs at gmail.com> wrote:

> I'd like a pointer to some place containing information as to why the
> new HP is delayed (although I have my suspicions the reason being Xcode
> 5), and if there is a new schedule.
>

I don't know why a general status update was not sent out or put on the
web, but a decision was reached to skip to the next normal release in
April. Xcode 5 and ghc 7.8 were part of it but not all of it; there were
also issues involving (insufficient testing of?) recent changes to aeson
and text and how they impacted other packages in the Platform, IIRC.

-- 
brandon s allbery kf8nh                               sine nomine associates
allbery.b at gmail.com                                  ballbery at sinenomine.net
unix, openafs, kerberos, infrastructure, xmonad        http://sinenomine.net
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140219/1adc05ca/attachment.html>

From kiwamu at debian.or.jp  Wed Feb 19 15:08:13 2014
From: kiwamu at debian.or.jp (Kiwamu Okabe)
Date: Thu, 20 Feb 2014 00:08:13 +0900
Subject: [Haskell-cafe] Rewrite NetBSD kernel driver using Ajhc Haskell
	compiler
In-Reply-To: <5304C658.7050507@update.uu.se>
References: <CAEvX6dki6=N5D70pucRqsbVWhW8c9C9qbPKefYc1Um7UNiseqg@mail.gmail.com>
 <2562D045-28FB-4555-84F8-3326AFB0839F@gmail.com>
 <5304C658.7050507@update.uu.se>
Message-ID: <CAEvX6dn4wGbH3s7gbrcxyQ7xye+54=B3zvEwgP3MxDL6tqki5w@mail.gmail.com>

Hi Johnny,

On Wed, Feb 19, 2014 at 11:57 PM, Johnny Billquist <bqt at update.uu.se> wrote:
> Maybe someone with more insight could explain to an idiot like me how
> Haskell garbage collection is handled when running in the kernel?

First, s_alloc() is Ajhc Haskell compiler's allocator,
and gc_perform_gc() is GC runner.

https://github.com/ajhc/ajhc/blob/6c053b940812689fe22d2dbe2b7ad835dab8a3c7/rts/rts/gc_jgc.c#L560
https://github.com/ajhc/ajhc/blob/6c053b940812689fe22d2dbe2b7ad835dab8a3c7/rts/rts/gc_jgc.c#L119

The s_alloc() try to find free area. But if not, it runs GC.

https://github.com/ajhc/ajhc/blob/6c053b940812689fe22d2dbe2b7ad835dab8a3c7/rts/rts/gc_jgc.c#L435

By the way, where from s_alloc() get a memory chunk?
Now using kern_malloc(9).

https://github.com/metasepi/netbsd-arafura-s1/blob/arafura-s1/metasepi/sys/hsdummy/__dummy4jhc.c#L21

Regards,
-- 
Kiwamu Okabe

From allbery.b at gmail.com  Wed Feb 19 15:09:30 2014
From: allbery.b at gmail.com (Brandon Allbery)
Date: Wed, 19 Feb 2014 10:09:30 -0500
Subject: [Haskell-cafe] Haskell Platform website error
In-Reply-To: <F8F9D27F-5E27-4368-83AC-BAEA2582ABDE@gmail.com>
References: <CA+aFgYB5oyqo4UnQOxgPuvSysg31W5nWfzL03MqAKYe=TA-86Q@mail.gmail.com>
 <CALnXJipHMzwjVfQ6XYUoohQQMvAZDdWjQ8GUxDQTF=zr2bLwpQ@mail.gmail.com>
 <F8F9D27F-5E27-4368-83AC-BAEA2582ABDE@gmail.com>
Message-ID: <CAKFCL4UzMSxHwjh5Y3XpwV_=1xuVRM8Ugnmn=WHTTtdw3xBRdw@mail.gmail.com>

On Wed, Feb 19, 2014 at 3:36 AM, Dan Frumin <difrumin at gmail.com> wrote:

> > The last time I found a typo on the Haskell Platform website, I opened
> > a pull request to fix it, and it was merged a couple of months later.
>
> Ha, to be honest, it doesn't sound very encouraging :P


I suspect more helping hands would be gratefully accepted.

-- 
brandon s allbery kf8nh                               sine nomine associates
allbery.b at gmail.com                                  ballbery at sinenomine.net
unix, openafs, kerberos, infrastructure, xmonad        http://sinenomine.net
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140219/70e1e670/attachment.html>

From obscaenvs at gmail.com  Wed Feb 19 15:31:02 2014
From: obscaenvs at gmail.com (Obscaenvs)
Date: Wed, 19 Feb 2014 16:31:02 +0100
Subject: [Haskell-cafe] Haskell-platform release information
In-Reply-To: <CAKFCL4Wa=mbiJaff=-xBcV34d6yerA13aqFoMQSq4s4wUU59cw@mail.gmail.com>
References: <53047C1E.6050104@gmail.com>
 <CAKFCL4Wa=mbiJaff=-xBcV34d6yerA13aqFoMQSq4s4wUU59cw@mail.gmail.com>
Message-ID: <5304CE36.2050406@gmail.com>



Le 2014-02-19 15:55, Brandon Allbery a ?crit :
> On Wed, Feb 19, 2014 at 4:40 AM, Obscaenvs <obscaenvs at gmail.com
> <mailto:obscaenvs at gmail.com>> wrote:
> 
>     I'd like a pointer to some place containing information as to why the
>     new HP is delayed (although I have my suspicions the reason being Xcode
>     5), and if there is a new schedule.
> 
> 
> I don't know why a general status update was not sent out or put on the
> web, but a decision was reached to skip to the next normal release in
> April. Xcode 5 and ghc 7.8 were part of it but not all of it; there were
> also issues involving (insufficient testing of?) recent changes to aeson
> and text and how they impacted other packages in the Platform, IIRC.

Thank you for the answer! Should I interpret this as 2014.2.0.0 being
postponed? In that case 2013.4.0.0 is skipped altogether...or?

This means - *if* this is correct - that I am stuck with 2013.2.0.0 for
some time yet. Ah, well :)

f

> 
> -- 
> brandon s allbery kf8nh                               sine nomine associates
> allbery.b at gmail.com <mailto:allbery.b at gmail.com>                        
>          ballbery at sinenomine.net <mailto:ballbery at sinenomine.net>
> unix, openafs, kerberos, infrastructure, xmonad        http://sinenomine.net



From kiwamu at debian.or.jp  Wed Feb 19 15:30:59 2014
From: kiwamu at debian.or.jp (Kiwamu Okabe)
Date: Thu, 20 Feb 2014 00:30:59 +0900
Subject: [Haskell-cafe] Rewrite NetBSD kernel driver using Ajhc Haskell
	compiler
In-Reply-To: <CAEvX6dn4wGbH3s7gbrcxyQ7xye+54=B3zvEwgP3MxDL6tqki5w@mail.gmail.com>
References: <CAEvX6dki6=N5D70pucRqsbVWhW8c9C9qbPKefYc1Um7UNiseqg@mail.gmail.com>
 <2562D045-28FB-4555-84F8-3326AFB0839F@gmail.com>
 <5304C658.7050507@update.uu.se>
 <CAEvX6dn4wGbH3s7gbrcxyQ7xye+54=B3zvEwgP3MxDL6tqki5w@mail.gmail.com>
Message-ID: <CAEvX6dkYpcr1Janqwt6L+hqszjEE3b4hkiHP0y8wTrgQerKznw@mail.gmail.com>

Hi Johnny, I had forgotten important point.

> On Wed, Feb 19, 2014 at 11:57 PM, Johnny Billquist <bqt at update.uu.se> wrote:
>> Maybe someone with more insight could explain to an idiot like me how
>> Haskell garbage collection is handled when running in the kernel?

Running a simple logic in the kernel, it doesn't call GC.

http://www.slideshare.net/master_q/20140117-11th-wocs2/19

Ajhc Haskell compiler creates program binary that has "context local heap".
A lot of binaries have only one global heap.
If C language code calls Haskell code, Ajhc runtime create new arena for GC.
Sometime Haskell code runs allocator (s_alloc()),
then the runtime allocates Heap area.
Haskell context gets the end of life, the arena and heap are recovered
by the runtime.

In the kernel, the recover is called before the GC.
But I think my custom kernel is ready to call GC in interrupt handler.

Thank's,
-- 
Kiwamu Okabe

From mnegrete at gmail.com  Wed Feb 19 15:31:22 2014
From: mnegrete at gmail.com (Mike Negrete)
Date: Wed, 19 Feb 2014 07:31:22 -0800
Subject: [Haskell-cafe] Haskell Platform website error
In-Reply-To: <CA+aFgYB5oyqo4UnQOxgPuvSysg31W5nWfzL03MqAKYe=TA-86Q@mail.gmail.com>
References: <CA+aFgYB5oyqo4UnQOxgPuvSysg31W5nWfzL03MqAKYe=TA-86Q@mail.gmail.com>
Message-ID: <CAP4tRj2AhfW9=MPQMRW8zqs9fM7KragMQhHdu8-y596giX=V3A@mail.gmail.com>

On Feb 17, 2014 2:27 PM, "Omari Norman" <omari at smileystation.com> wrote:

> Inaccuracy in Haskell Platform website: it says version 2013.2.0.0
> includes containers-0.4.2.1:
>
> http://www.haskell.org/platform/changelog.html
>
> However the containers included in GHC 7.6.3 and, therefore, with this
> version of Haskell Platform is in fact version 0.5.0.0.
>
> There's no apparent contact link on the website; who should I report
> this to? Thanks. --Omari
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140219/2b583918/attachment.html>

From jmacristovao at gmail.com  Wed Feb 19 15:39:30 2014
From: jmacristovao at gmail.com (=?ISO-8859-1?B?Sm/jbyBDcmlzdPN2428=?=)
Date: Wed, 19 Feb 2014 15:39:30 +0000
Subject: [Haskell-cafe] [ANN] data-default-generics
Message-ID: <CAAbu24qe+OVDN30wBzEmGH9ZD_iEGZ-h8ouoE0v+9gLJuB-fNQ@mail.gmail.com>

Hi,

This project is a fork of the well known data-default package, since the
original author does not seem to be reachable, and has not accepted a
rather useful patch in the past.

It mainly adds:

* Regrouped everything into a single module
* Added several instances, namely Either, Text, ByteString, etc
* Added Generics support patch by Jonathan Fischoff, with some additional
support for recursive datatypes by me, with the precious help of Jos? Pedro
Magalh?es

This last point means that you can easily defined a default value for a
record.

See:

https://github.com/jcristovao/data-default-generics

http://hackage.haskell.org/package/data-default-generics-0.3/candidate

If this is a duplicate effort, or a better alternative exists, please let
me know.

If not, I will soon publish it to hackage as 'official'.

Thanks,
Jo?o
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140219/107ddeaa/attachment.html>

From roma at ro-che.info  Wed Feb 19 15:45:14 2014
From: roma at ro-che.info (Roman Cheplyaka)
Date: Wed, 19 Feb 2014 17:45:14 +0200
Subject: [Haskell-cafe] Haskell Platform website error
In-Reply-To: <CAKFCL4UzMSxHwjh5Y3XpwV_=1xuVRM8Ugnmn=WHTTtdw3xBRdw@mail.gmail.com>
References: <CA+aFgYB5oyqo4UnQOxgPuvSysg31W5nWfzL03MqAKYe=TA-86Q@mail.gmail.com>
 <CALnXJipHMzwjVfQ6XYUoohQQMvAZDdWjQ8GUxDQTF=zr2bLwpQ@mail.gmail.com>
 <F8F9D27F-5E27-4368-83AC-BAEA2582ABDE@gmail.com>
 <CAKFCL4UzMSxHwjh5Y3XpwV_=1xuVRM8Ugnmn=WHTTtdw3xBRdw@mail.gmail.com>
Message-ID: <20140219154514.GA2216@sniper>

* Brandon Allbery <allbery.b at gmail.com> [2014-02-19 10:09:30-0500]
> On Wed, Feb 19, 2014 at 3:36 AM, Dan Frumin <difrumin at gmail.com> wrote:
> 
> > > The last time I found a typo on the Haskell Platform website, I opened
> > > a pull request to fix it, and it was merged a couple of months later.
> >
> > Ha, to be honest, it doesn't sound very encouraging :P
> 
> I suspect more helping hands would be gratefully accepted.

What do you mean, specifically? Lindsey said she had sent a pull
request. What else could she do?

Roman
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140219/b01a97b3/attachment.sig>

From allbery.b at gmail.com  Wed Feb 19 15:46:23 2014
From: allbery.b at gmail.com (Brandon Allbery)
Date: Wed, 19 Feb 2014 10:46:23 -0500
Subject: [Haskell-cafe] Haskell-platform release information
In-Reply-To: <5304CE36.2050406@gmail.com>
References: <53047C1E.6050104@gmail.com>
 <CAKFCL4Wa=mbiJaff=-xBcV34d6yerA13aqFoMQSq4s4wUU59cw@mail.gmail.com>
 <5304CE36.2050406@gmail.com>
Message-ID: <CAKFCL4WFZ7_m_HjZJnqgvq7sDrxpvBUa=Y2Q+JKrVT=gW2TzfQ@mail.gmail.com>

On Wed, Feb 19, 2014 at 10:31 AM, Obscaenvs <obscaenvs at gmail.com> wrote:

> Le 2014-02-19 15:55, Brandon Allbery a ?crit :
> > I don't know why a general status update was not sent out or put on the
> > web, but a decision was reached to skip to the next normal release in
> > April. Xcode 5 and ghc 7.8 were part of it but not all of it; there were
> > also issues involving (insufficient testing of?) recent changes to aeson
> > and text and how they impacted other packages in the Platform, IIRC.
>
> Thank you for the answer! Should I interpret this as 2014.2.0.0 being
> postponed? In that case 2013.4.0.0 is skipped altogether...or?
>

2013.4.0.0 was completely skipped. The next normal release would be
2014.2.0.0 by recent timing (the slots for the others are reserved but not
generally used); beyond that you probably want to ask for something
official (and for them to make a public announcement...) on the
libraries at haskell.org list.

(Also please note, I am not involved with the libraries or HP process, I'm
just relaying what I recall reading. Check libraries at haskell.org archives
or ask there for the real story.)

-- 
brandon s allbery kf8nh                               sine nomine associates
allbery.b at gmail.com                                  ballbery at sinenomine.net
unix, openafs, kerberos, infrastructure, xmonad        http://sinenomine.net
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140219/086d9ae0/attachment.html>

From difrumin at gmail.com  Wed Feb 19 16:33:20 2014
From: difrumin at gmail.com (Daniil Frumin)
Date: Wed, 19 Feb 2014 20:33:20 +0400
Subject: [Haskell-cafe] Haskell Platform website error
In-Reply-To: <CAKFCL4UzMSxHwjh5Y3XpwV_=1xuVRM8Ugnmn=WHTTtdw3xBRdw@mail.gmail.com>
References: <CA+aFgYB5oyqo4UnQOxgPuvSysg31W5nWfzL03MqAKYe=TA-86Q@mail.gmail.com>
 <CALnXJipHMzwjVfQ6XYUoohQQMvAZDdWjQ8GUxDQTF=zr2bLwpQ@mail.gmail.com>
 <F8F9D27F-5E27-4368-83AC-BAEA2582ABDE@gmail.com>
 <CAKFCL4UzMSxHwjh5Y3XpwV_=1xuVRM8Ugnmn=WHTTtdw3xBRdw@mail.gmail.com>
Message-ID: <CACxkR4CVzE0t_ffSXAvtdj98hxiYFPu6MbUP-_ODqHJRZ30N=g@mail.gmail.com>

I can take on a role of merging small pull requests concerning
documentation (and I try to send those myself every time I see a typo
or mistake in the documentation), but I suspect one has to be an
active participant in the project in order to gain full commit access.

Btw, I didn't mean to discourage anyone for contributing. Nor I meant
to degrade the Platform developers with my comment.

On Wed, Feb 19, 2014 at 7:09 PM, Brandon Allbery <allbery.b at gmail.com> wrote:
> On Wed, Feb 19, 2014 at 3:36 AM, Dan Frumin <difrumin at gmail.com> wrote:
>>
>> > The last time I found a typo on the Haskell Platform website, I opened
>> > a pull request to fix it, and it was merged a couple of months later.
>>
>> Ha, to be honest, it doesn't sound very encouraging :P
>
>
> I suspect more helping hands would be gratefully accepted.
>
> --
> brandon s allbery kf8nh                               sine nomine associates
> allbery.b at gmail.com                                  ballbery at sinenomine.net
> unix, openafs, kerberos, infrastructure, xmonad        http://sinenomine.net



-- 
Sincerely yours,
-- Daniil

From cpa at crans.org  Wed Feb 19 17:36:07 2014
From: cpa at crans.org (Charles-Pierre Astolfi)
Date: Wed, 19 Feb 2014 18:36:07 +0100
Subject: [Haskell-cafe] How to benckmark a Word64 -> Bool?
Message-ID: <CAB6QvNNnafHYk1WDXUopq2cfn+mfkLgm4W6j2eqZGqzbNieDeA@mail.gmail.com>

Hi,

I have a Word64 -> Bool function called only012 that returns True iff the
digits in base 10 are 0, 1 or 2.
I wand to make sure that I'm competitive with C, so I wrote the following
code:

Haskell version:
http://lpaste.net/100129

C version:
http://lpaste.net/100128

$ ghc --make -O3 303only012.hs && time ./303only012 50000000 > /dev/null
./303only012 50000000 > /dev/null  21.44s user 0.41s system 91% cpu 23.754
total

$ g++ -O3 303only012.cpp -o 303cpponly012 && time ./303cpponly012 50000000
> /dev/null
./303cpponly012 50000000 > /dev/null  13.87s user 0.03s system 95% cpu
14.577 total

So there's a difference, but I'm not sure if it's related to my algorithm
or related to IO/RTS.

The core output of only012 looks quite tight: http://lpaste.net/100130

Am I doing the IO part right, that is fast IO that is not screwing my
benckmark? I'm not so sure about that since I use a convoluted way to print
the boolean result in Haskell.

Cheers,
--
Cp
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140219/b38c685d/attachment.html>

From alois.cochard at gmail.com  Wed Feb 19 18:17:49 2014
From: alois.cochard at gmail.com (Alois Cochard)
Date: Wed, 19 Feb 2014 18:17:49 +0000
Subject: [Haskell-cafe] How to benckmark a Word64 -> Bool?
In-Reply-To: <CAB6QvNNnafHYk1WDXUopq2cfn+mfkLgm4W6j2eqZGqzbNieDeA@mail.gmail.com>
References: <CAB6QvNNnafHYk1WDXUopq2cfn+mfkLgm4W6j2eqZGqzbNieDeA@mail.gmail.com>
Message-ID: <CAJHA+wpuXpncmsy2657G9smN7ig8Unq4Hhs8TJLg6MGWCqrmsw@mail.gmail.com>

Hi Charles,

Criterion might give you more precise results :
http://hackage.haskell.org/package/criterion

Cheers
On Feb 19, 2014 5:37 PM, "Charles-Pierre Astolfi" <cpa at crans.org> wrote:

> Hi,
>
> I have a Word64 -> Bool function called only012 that returns True iff the
> digits in base 10 are 0, 1 or 2.
> I wand to make sure that I'm competitive with C, so I wrote the following
> code:
>
> Haskell version:
> http://lpaste.net/100129
>
> C version:
> http://lpaste.net/100128
>
> $ ghc --make -O3 303only012.hs && time ./303only012 50000000 > /dev/null
> ./303only012 50000000 > /dev/null  21.44s user 0.41s system 91% cpu 23.754
> total
>
> $ g++ -O3 303only012.cpp -o 303cpponly012 && time ./303cpponly012 50000000
> > /dev/null
> ./303cpponly012 50000000 > /dev/null  13.87s user 0.03s system 95% cpu
> 14.577 total
>
> So there's a difference, but I'm not sure if it's related to my algorithm
> or related to IO/RTS.
>
> The core output of only012 looks quite tight: http://lpaste.net/100130
>
> Am I doing the IO part right, that is fast IO that is not screwing my
> benckmark? I'm not so sure about that since I use a convoluted way to print
> the boolean result in Haskell.
>
> Cheers,
> --
> Cp
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140219/0435a9b7/attachment.html>

From greg at gregorycollins.net  Wed Feb 19 18:19:51 2014
From: greg at gregorycollins.net (Gregory Collins)
Date: Wed, 19 Feb 2014 10:19:51 -0800
Subject: [Haskell-cafe] How to benckmark a Word64 -> Bool?
In-Reply-To: <CAB6QvNNnafHYk1WDXUopq2cfn+mfkLgm4W6j2eqZGqzbNieDeA@mail.gmail.com>
References: <CAB6QvNNnafHYk1WDXUopq2cfn+mfkLgm4W6j2eqZGqzbNieDeA@mail.gmail.com>
Message-ID: <CAHZrzdpcainh0W5_htBe7i3cCP6OK-K6ZaybWx6NLqvb0UTBEA@mail.gmail.com>

On Wed, Feb 19, 2014 at 9:36 AM, Charles-Pierre Astolfi <cpa at crans.org>wrote:

> So there's a difference, but I'm not sure if it's related to my algorithm
> or related to IO/RTS.


Text.Printf is slower than the C version (and uses String). Use
Data.ByteString.putStr instead.


-- 
Gregory Collins <greg at gregorycollins.net>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140219/2604b8c4/attachment.html>

From erkokl at gmail.com  Wed Feb 19 18:24:29 2014
From: erkokl at gmail.com (Levent Erkok)
Date: Wed, 19 Feb 2014 10:24:29 -0800
Subject: [Haskell-cafe] How to benckmark a Word64 -> Bool?
In-Reply-To: <CAHZrzdpcainh0W5_htBe7i3cCP6OK-K6ZaybWx6NLqvb0UTBEA@mail.gmail.com>
References: <CAB6QvNNnafHYk1WDXUopq2cfn+mfkLgm4W6j2eqZGqzbNieDeA@mail.gmail.com>
 <CAHZrzdpcainh0W5_htBe7i3cCP6OK-K6ZaybWx6NLqvb0UTBEA@mail.gmail.com>
Message-ID: <CACOpX0cse11Ku14B4NA22xYU02V7CRr04HxRJEvJT6F+v3=peQ@mail.gmail.com>

Also, prefer quotRem over divMod as the former is faster. See here:
http://stackoverflow.com/questions/339719/when-is-the-difference-between-quotrem-and-divmod-useful


On Wed, Feb 19, 2014 at 10:19 AM, Gregory Collins
<greg at gregorycollins.net>wrote:

>
> On Wed, Feb 19, 2014 at 9:36 AM, Charles-Pierre Astolfi <cpa at crans.org>wrote:
>
>> So there's a difference, but I'm not sure if it's related to my algorithm
>> or related to IO/RTS.
>
>
> Text.Printf is slower than the C version (and uses String). Use
> Data.ByteString.putStr instead.
>
>
> --
> Gregory Collins <greg at gregorycollins.net>
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140219/062d9329/attachment.html>

From cpa at crans.org  Wed Feb 19 18:49:36 2014
From: cpa at crans.org (Charles-Pierre Astolfi)
Date: Wed, 19 Feb 2014 19:49:36 +0100
Subject: [Haskell-cafe] How to benckmark a Word64 -> Bool?
In-Reply-To: <CACOpX0cse11Ku14B4NA22xYU02V7CRr04HxRJEvJT6F+v3=peQ@mail.gmail.com>
References: <CAB6QvNNnafHYk1WDXUopq2cfn+mfkLgm4W6j2eqZGqzbNieDeA@mail.gmail.com>
 <CAHZrzdpcainh0W5_htBe7i3cCP6OK-K6ZaybWx6NLqvb0UTBEA@mail.gmail.com>
 <CACOpX0cse11Ku14B4NA22xYU02V7CRr04HxRJEvJT6F+v3=peQ@mail.gmail.com>
Message-ID: <CAB6QvNOgvC9tZKaBp8b2Zj6sAuu-H0_kr8M+N5gpwbtSC0nq9A@mail.gmail.com>

Switching to quotRem gave no measurable improvements.
After switching to ByteString, the code now runs in 9 seconds, which
outperforms my C version. But honestly, I have no idea why.

New code:
http://lpaste.net/100136

$ ghc --make -O3 303only012.hs && time ./303only012 50000000 > /dev/null
./303only012 50000000 > /dev/null  9.72s user 0.21s system 90% cpu 10.961
total

@Alois, I'm not sure how criterion can help compare my code with the C
version, since in the C version I cannot measure the exec time of only012
only. What did you have in mind?

Thanks everyone!


--
Cp


On Wed, Feb 19, 2014 at 7:24 PM, Levent Erkok <erkokl at gmail.com> wrote:

> Also, prefer quotRem over divMod as the former is faster. See here:
> http://stackoverflow.com/questions/339719/when-is-the-difference-between-quotrem-and-divmod-useful
>
>
> On Wed, Feb 19, 2014 at 10:19 AM, Gregory Collins <greg at gregorycollins.net
> > wrote:
>
>>
>> On Wed, Feb 19, 2014 at 9:36 AM, Charles-Pierre Astolfi <cpa at crans.org>wrote:
>>
>>> So there's a difference, but I'm not sure if it's related to my
>>> algorithm or related to IO/RTS.
>>
>>
>> Text.Printf is slower than the C version (and uses String). Use
>> Data.ByteString.putStr instead.
>>
>>
>> --
>> Gregory Collins <greg at gregorycollins.net>
>>
>> _______________________________________________
>> Haskell-Cafe mailing list
>> Haskell-Cafe at haskell.org
>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>
>>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140219/1b53ad99/attachment.html>

From nikita at karetnikov.org  Wed Feb 19 19:06:42 2014
From: nikita at karetnikov.org (Nikita Karetnikov)
Date: Wed, 19 Feb 2014 23:06:42 +0400
Subject: [Haskell-cafe] hmatrix-labeled: request for comments
Message-ID: <87zjlm53ct.fsf@karetnikov.org>

I like how easy it is to import data in R and Octave.  (See [1] for a
typical workflow.)  Since I couldn?t find any matching library on
Hackage, I cooked up my own [2] in a couple of days.

Here?s an example.  Let?s start by creating a poorly formatted dataset:

$ cat > test.txt
   		         One         Two Longish   Four
     Foo  1       -2		3.0     4.0
Looooooong  5.0   6.0   -72.0		      8.0
	Baz 41.0 4.2324234e7  43.0 1.111111144E-12

Then we parse it with ?readFile?, mangle the data a bit, and display in
GHCi:

?> import qualified Data.Packed.LMatrix.IO as L
?> import qualified Data.Packed.LMatrix as L
?> do m <- L.readFile "test.txt"; return . L.trans . L.reverseRows $ L.map (+1) m
(4><3)
                       Baz Looooooong  Foo
    One               42.0        6.0  2.0
    Two        4.2324235e7        7.0 -1.0
Longish               44.0      -71.0  4.0
   Four 1.0000000000011111        9.0  5.0

Now I?m wondering how to make it better.  I?m planning to add the
documentation, augment the parser to accept CSV, and maybe support other
matrix libraries.  What?s missing?  Would you like to see it on Hackage?
And if not, why?

[1] http://astrostatistics.psu.edu/su09/lecturenotes/pca.html
[2] https://gitorious.org/hmatrix-labeled
-------------- next part --------------
A non-text attachment was scrubbed...
Name: not available
Type: application/pgp-signature
Size: 835 bytes
Desc: not available
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140219/2637de71/attachment.sig>

From alois.cochard at gmail.com  Wed Feb 19 19:21:07 2014
From: alois.cochard at gmail.com (Alois Cochard)
Date: Wed, 19 Feb 2014 19:21:07 +0000
Subject: [Haskell-cafe] How to benckmark a Word64 -> Bool?
In-Reply-To: <CAB6QvNOgvC9tZKaBp8b2Zj6sAuu-H0_kr8M+N5gpwbtSC0nq9A@mail.gmail.com>
References: <CAB6QvNNnafHYk1WDXUopq2cfn+mfkLgm4W6j2eqZGqzbNieDeA@mail.gmail.com>
 <CAHZrzdpcainh0W5_htBe7i3cCP6OK-K6ZaybWx6NLqvb0UTBEA@mail.gmail.com>
 <CACOpX0cse11Ku14B4NA22xYU02V7CRr04HxRJEvJT6F+v3=peQ@mail.gmail.com>
 <CAB6QvNOgvC9tZKaBp8b2Zj6sAuu-H0_kr8M+N5gpwbtSC0nq9A@mail.gmail.com>
Message-ID: <CAJHA+woJB6WeHshbLyKyzbVTmnR51k5hnCQWuJOAMJUeT17YSw@mail.gmail.com>

Hi Charles,

I had in mind comparing with similar tool the C version, but it looks like
I was a bit naive at thinking that same tooling exist for C (after googling
a bit it sounds there is no lib like that).
OTOH, Bryan O'Sullivan mention in his original blog past about criterion
that it could be potentially used to benchmark C code as well.

The cost of putting that in place might outperform the benefit though.

Cheers

Alois



On 19 February 2014 18:49, Charles-Pierre Astolfi <cpa at crans.org> wrote:

> Switching to quotRem gave no measurable improvements.
> After switching to ByteString, the code now runs in 9 seconds, which
> outperforms my C version. But honestly, I have no idea why.
>
> New code:
> http://lpaste.net/100136
>
> $ ghc --make -O3 303only012.hs && time ./303only012 50000000 > /dev/null
> ./303only012 50000000 > /dev/null  9.72s user 0.21s system 90% cpu 10.961
> total
>
> @Alois, I'm not sure how criterion can help compare my code with the C
> version, since in the C version I cannot measure the exec time of only012
> only. What did you have in mind?
>
> Thanks everyone!
>
>
> --
> Cp
>
>
> On Wed, Feb 19, 2014 at 7:24 PM, Levent Erkok <erkokl at gmail.com> wrote:
>
>> Also, prefer quotRem over divMod as the former is faster. See here:
>> http://stackoverflow.com/questions/339719/when-is-the-difference-between-quotrem-and-divmod-useful
>>
>>
>> On Wed, Feb 19, 2014 at 10:19 AM, Gregory Collins <
>> greg at gregorycollins.net> wrote:
>>
>>>
>>> On Wed, Feb 19, 2014 at 9:36 AM, Charles-Pierre Astolfi <cpa at crans.org>wrote:
>>>
>>>> So there's a difference, but I'm not sure if it's related to my
>>>> algorithm or related to IO/RTS.
>>>
>>>
>>> Text.Printf is slower than the C version (and uses String). Use
>>> Data.ByteString.putStr instead.
>>>
>>>
>>> --
>>> Gregory Collins <greg at gregorycollins.net>
>>>
>>> _______________________________________________
>>> Haskell-Cafe mailing list
>>> Haskell-Cafe at haskell.org
>>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>>
>>>
>>
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
>


-- 
*Alois Cochard*
http://aloiscochard.blogspot.com
http://twitter.com/aloiscochard
http://github.com/aloiscochard
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140219/ae25bd06/attachment.html>

From lindsey at composition.al  Wed Feb 19 19:41:11 2014
From: lindsey at composition.al (Lindsey Kuper)
Date: Wed, 19 Feb 2014 14:41:11 -0500
Subject: [Haskell-cafe] Haskell Platform website error
In-Reply-To: <20140219154514.GA2216@sniper>
References: <CA+aFgYB5oyqo4UnQOxgPuvSysg31W5nWfzL03MqAKYe=TA-86Q@mail.gmail.com>
 <CALnXJipHMzwjVfQ6XYUoohQQMvAZDdWjQ8GUxDQTF=zr2bLwpQ@mail.gmail.com>
 <F8F9D27F-5E27-4368-83AC-BAEA2582ABDE@gmail.com>
 <CAKFCL4UzMSxHwjh5Y3XpwV_=1xuVRM8Ugnmn=WHTTtdw3xBRdw@mail.gmail.com>
 <20140219154514.GA2216@sniper>
Message-ID: <CALnXJiqJiDFvafRXdG5ktqRbUydWjitY3JcJNznsQ=Z0vXw7mQ@mail.gmail.com>

On Wed, Feb 19, 2014 at 10:45 AM, Roman Cheplyaka <roma at ro-che.info> wrote:
> * Brandon Allbery <allbery.b at gmail.com> [2014-02-19 10:09:30-0500]
>> On Wed, Feb 19, 2014 at 3:36 AM, Dan Frumin <difrumin at gmail.com> wrote:
>>
>> > > The last time I found a typo on the Haskell Platform website, I opened
>> > > a pull request to fix it, and it was merged a couple of months later.
>> >
>> > Ha, to be honest, it doesn't sound very encouraging :P
>>
>> I suspect more helping hands would be gratefully accepted.
>
> What do you mean, specifically? Lindsey said she had sent a pull
> request. What else could she do?

I don't think Brandon was implying that I should have done anything
differently -- I think he just meant that the project might benefit
from another person to merge pull requests, as evidenced by the fact
that it took a while for mine to get merged.

Lindsey

From ian at skybluetrades.net  Wed Feb 19 19:47:29 2014
From: ian at skybluetrades.net (Ian Ross)
Date: Wed, 19 Feb 2014 20:47:29 +0100
Subject: [Haskell-cafe] hmatrix-labeled: request for comments
In-Reply-To: <87zjlm53ct.fsf@karetnikov.org>
References: <87zjlm53ct.fsf@karetnikov.org>
Message-ID: <CA+adx7s+Hxqvcimcv6W23r1FypdyGK2Ne0CQawbWMW2wuPeqrA@mail.gmail.com>

Hi Nikita,

I've been thinking about data import issues recently as well (in this case,
NetCDF files: https://github.com/ian-ross/hnetcdf is kind of nasty and
unfinished, but it will get there in the end).  The easy access to data
files of all different kinds in R is one of its really big advantages.
 I've done tasks in the past where I've needed to read CSV files, NetCDF
files, GeoTIFF data and ESRI shape files, all for the sam job.  R handles
them all seamlessly, giving you a very open data analysis platform.  I'd
like Haskell eventually to be a similarly open platform with as easy a
workflow as R for data analysis, but it's going to take some work to get
there.

As you kind of say, one thing that's tricky is deciding on what matrix
libraries to use.  I don't have any good ideas about that.  With the NetCDF
stuff, I've been experimenting with making all of the get and put functions
polymorphic in a "store" type, allowing you to read and write
Storable.Vectors, Repa arrays and hmatrix arrays.  I'm not convinced I'm
doing it right, but the alternative is to support only a single array type,
which, until the community settles on a single canonical array type (if
that's even possible), seems restrictive.

I guess from the perspective of what you could do with your hmatrix-labeled
code, aiming for something as flexible as R's read.table (which is
specialised for read.csv and variants) that supports at least a few of the
common Haskell array types would be nice.  However, there's a danger of
duplicating some of the good work that's already been done on fast CSV
parsers (cassava, csv-conduit and pipes-csv).  Cassava, in particular, has
a nice lightweight API that's very suitable for interactive work.  If you
extended the Cassava parser to support a wider range of file formats (like
read.table) and added some helpers for converting to array types where it
makes sense, that might be enough.

Cheers,

Ian.



On 19 February 2014 20:06, Nikita Karetnikov <nikita at karetnikov.org> wrote:

> I like how easy it is to import data in R and Octave.  (See [1] for a
> typical workflow.)  Since I couldn?t find any matching library on
> Hackage, I cooked up my own [2] in a couple of days.
>
> Here?s an example.  Let?s start by creating a poorly formatted dataset:
>
> $ cat > test.txt
>                          One         Two Longish   Four
>      Foo  1       -2            3.0     4.0
> Looooooong  5.0   6.0   -72.0                 8.0
>         Baz 41.0 4.2324234e7  43.0 1.111111144E-12
>
> Then we parse it with ?readFile?, mangle the data a bit, and display in
> GHCi:
>
> ?> import qualified Data.Packed.LMatrix.IO as L
> ?> import qualified Data.Packed.LMatrix as L
> ?> do m <- L.readFile "test.txt"; return . L.trans . L.reverseRows $ L.map
> (+1) m
> (4><3)
>                        Baz Looooooong  Foo
>     One               42.0        6.0  2.0
>     Two        4.2324235e7        7.0 -1.0
> Longish               44.0      -71.0  4.0
>    Four 1.0000000000011111        9.0  5.0
>
> Now I?m wondering how to make it better.  I?m planning to add the
> documentation, augment the parser to accept CSV, and maybe support other
> matrix libraries.  What?s missing?  Would you like to see it on Hackage?
> And if not, why?
>
> [1] http://astrostatistics.psu.edu/su09/lecturenotes/pca.html
> [2] https://gitorious.org/hmatrix-labeled
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
>


-- 
Ian Ross   Tel: +43(0)6804451378   ian at skybluetrades.net
www.skybluetrades.net
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140219/2dad8fb5/attachment-0001.html>

From allbery.b at gmail.com  Wed Feb 19 20:12:24 2014
From: allbery.b at gmail.com (Brandon Allbery)
Date: Wed, 19 Feb 2014 15:12:24 -0500
Subject: [Haskell-cafe] Haskell Platform website error
In-Reply-To: <CALnXJiqJiDFvafRXdG5ktqRbUydWjitY3JcJNznsQ=Z0vXw7mQ@mail.gmail.com>
References: <CA+aFgYB5oyqo4UnQOxgPuvSysg31W5nWfzL03MqAKYe=TA-86Q@mail.gmail.com>
 <CALnXJipHMzwjVfQ6XYUoohQQMvAZDdWjQ8GUxDQTF=zr2bLwpQ@mail.gmail.com>
 <F8F9D27F-5E27-4368-83AC-BAEA2582ABDE@gmail.com>
 <CAKFCL4UzMSxHwjh5Y3XpwV_=1xuVRM8Ugnmn=WHTTtdw3xBRdw@mail.gmail.com>
 <20140219154514.GA2216@sniper>
 <CALnXJiqJiDFvafRXdG5ktqRbUydWjitY3JcJNznsQ=Z0vXw7mQ@mail.gmail.com>
Message-ID: <CAKFCL4VrNZcArWe1xsG=0WfymJ+Oh6vWtNjyifM-PGE55RCwzw@mail.gmail.com>

On Wed, Feb 19, 2014 at 2:41 PM, Lindsey Kuper <lindsey at composition.al>wrote:

> On Wed, Feb 19, 2014 at 10:45 AM, Roman Cheplyaka <roma at ro-che.info>
> wrote:
> > * Brandon Allbery <allbery.b at gmail.com> [2014-02-19 10:09:30-0500]
> >> On Wed, Feb 19, 2014 at 3:36 AM, Dan Frumin <difrumin at gmail.com> wrote:
> >> > > The last time I found a typo on the Haskell Platform website, I
> opened
> >> > > a pull request to fix it, and it was merged a couple of months
> later.
> >> >
> >> > Ha, to be honest, it doesn't sound very encouraging :P
> >>
> >> I suspect more helping hands would be gratefully accepted.
> >
> > What do you mean, specifically? Lindsey said she had sent a pull
> > request. What else could she do?
>
> I don't think Brandon was implying that I should have done anything
> differently -- I think he just meant that the project might benefit
> from another person to merge pull requests, as evidenced by the fact
> that it took a while for mine to get merged.
>

Yes. Or, even more to the point, it's run by volunteers and it is as
responsive as the available time from the available volunteers; if you want
faster responses, you need more people with more available time to put into
it.

(Volunteer projects are almost invariably chronically short on manpower to
get stuff done.)

-- 
brandon s allbery kf8nh                               sine nomine associates
allbery.b at gmail.com                                  ballbery at sinenomine.net
unix, openafs, kerberos, infrastructure, xmonad        http://sinenomine.net
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140219/4741d9a6/attachment.html>

From cpa at crans.org  Wed Feb 19 20:47:51 2014
From: cpa at crans.org (Charles-Pierre Astolfi)
Date: Wed, 19 Feb 2014 21:47:51 +0100
Subject: [Haskell-cafe] How to benckmark a Word64 -> Bool?
In-Reply-To: <72d1fb20-1588-4e02-b980-7a317809768b@googlegroups.com>
References: <CAB6QvNNnafHYk1WDXUopq2cfn+mfkLgm4W6j2eqZGqzbNieDeA@mail.gmail.com>
 <CAHZrzdpcainh0W5_htBe7i3cCP6OK-K6ZaybWx6NLqvb0UTBEA@mail.gmail.com>
 <CACOpX0cse11Ku14B4NA22xYU02V7CRr04HxRJEvJT6F+v3=peQ@mail.gmail.com>
 <CAB6QvNOgvC9tZKaBp8b2Zj6sAuu-H0_kr8M+N5gpwbtSC0nq9A@mail.gmail.com>
 <72d1fb20-1588-4e02-b980-7a317809768b@googlegroups.com>
Message-ID: <CAB6QvNNFEDC+NxieyHffTDpfkLAJqKKmveqisA7wEo_mw_n+Dw@mail.gmail.com>

Thanks Erik!

I was kind of hoping for such a benchmark. On my system, the C version is
consistently twice as fast as the Haskell version. (I tried -fllvm, but it
doesn't change perf)

Then I added bang patterns for the argument of only012 and in the tuple
(p,q) and it now has the same runtime as C.

Just for fun, I tried to void writing explicit recursion and used only
combinators and this Haskell code is still as competitive as C, so the real
bottleneck really was the laziness in the tuple/argument.

http://lpaste.net/100153

In fact, this Haskell version takes 8 sec vs 10 sec for the C version on my
laptop (input: 1000000000).

I tried using Data.List.Stream, I couldn't get any performance gain,
probably because the code is very close to optimal.

So remember kids:
- Bang pattern the heck out of your code (not a silver bullet, but
definitely worth trying).
- Don't rely on too much IO for benchmark.
- Don't be afraid of combinators even if you want performance.
- Ask on haskell-cafe, chaps here are very helpful :)


--
Cp


On Wed, Feb 19, 2014 at 8:39 PM, Erik Rantapaa <erantapaa at gmail.com> wrote:

> I think a lot is being obscured by the IO subsystem.
>
> If you print just a count of the only012 numbers I get very different
> results.
>
> Here are the versions I compared:
>
> http://lpaste.net/100142
>
> and on my system the C version is about 10x faster.
>
>
> On Wednesday, February 19, 2014 12:49:36 PM UTC-6, Charles-Pierre Astolfi
> wrote:
>
>> Switching to quotRem gave no measurable improvements.
>> After switching to ByteString, the code now runs in 9 seconds, which
>> outperforms my C version. But honestly, I have no idea why.
>>
>> New code:
>> http://lpaste.net/100136
>>
>> $ ghc --make -O3 303only012.hs && time ./303only012 50000000 > /dev/null
>> ./303only012 50000000 > /dev/null  9.72s user 0.21s system 90% cpu 10.961
>> total
>>
>> @Alois, I'm not sure how criterion can help compare my code with the C
>> version, since in the C version I cannot measure the exec time of only012
>> only. What did you have in mind?
>>
>> Thanks everyone!
>>
>>
>> --
>> Cp
>>
>>
>> On Wed, Feb 19, 2014 at 7:24 PM, Levent Erkok <erk... at gmail.com> wrote:
>>
>>>  Also, prefer quotRem over divMod as the former is faster. See here:
>>> http://stackoverflow.com/questions/339719/when-is-
>>> the-difference-between-quotrem-and-divmod-useful
>>>
>>>
>>> On Wed, Feb 19, 2014 at 10:19 AM, Gregory Collins <
>>> gr... at gregorycollins.net> wrote:
>>>
>>>>
>>>> On Wed, Feb 19, 2014 at 9:36 AM, Charles-Pierre Astolfi <c... at crans.org
>>>> > wrote:
>>>>
>>>>> So there's a difference, but I'm not sure if it's related to my
>>>>> algorithm or related to IO/RTS.
>>>>
>>>>
>>>> Text.Printf is slower than the C version (and uses String). Use
>>>> Data.ByteString.putStr instead.
>>>>
>>>>
>>>>
>>>> --
>>>> Gregory Collins <gr... at gregorycollins.net>
>>>>
>>>> _______________________________________________
>>>> Haskell-Cafe mailing list
>>>> Haskel... at haskell.org
>>>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>>>
>>>>
>>>
>>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140219/474d5d6f/attachment.html>

From frantisek at farka.eu  Wed Feb 19 22:25:30 2014
From: frantisek at farka.eu (Frantisek Farka)
Date: Wed, 19 Feb 2014 23:25:30 +0100
Subject: [Haskell-cafe] Functor instance derived from Monad
Message-ID: <20140219232530.74c3f934@farka.eu>

Hi cafe,

when reading the Functor-Applicative-Monad proposal [1] on Haskell
wiki I remembered that I have seen instance similar to

    instance (Monad m) => Functor m where 
        fmap f a = a >>= \x -> return $ f x

with FlexibleInstances and UndecidableInstances language extensions.
But I cannot remember where it was nor can I find any useful reference.
Is there some library in Hackage with this and similar instances?

Can you point out some leading marks to me?


Thanks

FF


[1]
http://www.haskell.org/haskellwiki/Functor-Applicative-Monad_Proposal

From roma at ro-che.info  Wed Feb 19 21:34:35 2014
From: roma at ro-che.info (Roman Cheplyaka)
Date: Wed, 19 Feb 2014 23:34:35 +0200
Subject: [Haskell-cafe] Haskell Platform website error
In-Reply-To: <CAKFCL4VrNZcArWe1xsG=0WfymJ+Oh6vWtNjyifM-PGE55RCwzw@mail.gmail.com>
References: <CA+aFgYB5oyqo4UnQOxgPuvSysg31W5nWfzL03MqAKYe=TA-86Q@mail.gmail.com>
 <CALnXJipHMzwjVfQ6XYUoohQQMvAZDdWjQ8GUxDQTF=zr2bLwpQ@mail.gmail.com>
 <F8F9D27F-5E27-4368-83AC-BAEA2582ABDE@gmail.com>
 <CAKFCL4UzMSxHwjh5Y3XpwV_=1xuVRM8Ugnmn=WHTTtdw3xBRdw@mail.gmail.com>
 <20140219154514.GA2216@sniper>
 <CALnXJiqJiDFvafRXdG5ktqRbUydWjitY3JcJNznsQ=Z0vXw7mQ@mail.gmail.com>
 <CAKFCL4VrNZcArWe1xsG=0WfymJ+Oh6vWtNjyifM-PGE55RCwzw@mail.gmail.com>
Message-ID: <20140219213435.GA10388@sniper>

* Brandon Allbery <allbery.b at gmail.com> [2014-02-19 15:12:24-0500]
> On Wed, Feb 19, 2014 at 2:41 PM, Lindsey Kuper <lindsey at composition.al>wrote:
> 
> > On Wed, Feb 19, 2014 at 10:45 AM, Roman Cheplyaka <roma at ro-che.info>
> > wrote:
> > > * Brandon Allbery <allbery.b at gmail.com> [2014-02-19 10:09:30-0500]
> > >> On Wed, Feb 19, 2014 at 3:36 AM, Dan Frumin <difrumin at gmail.com> wrote:
> > >> > > The last time I found a typo on the Haskell Platform website, I
> > opened
> > >> > > a pull request to fix it, and it was merged a couple of months
> > later.
> > >> >
> > >> > Ha, to be honest, it doesn't sound very encouraging :P
> > >>
> > >> I suspect more helping hands would be gratefully accepted.
> > >
> > > What do you mean, specifically? Lindsey said she had sent a pull
> > > request. What else could she do?
> >
> > I don't think Brandon was implying that I should have done anything
> > differently -- I think he just meant that the project might benefit
> > from another person to merge pull requests, as evidenced by the fact
> > that it took a while for mine to get merged.
> >
> 
> Yes. Or, even more to the point, it's run by volunteers and it is as
> responsive as the available time from the available volunteers; if you want
> faster responses, you need more people with more available time to put into
> it.
> 
> (Volunteer projects are almost invariably chronically short on manpower to
> get stuff done.)

My point was that people *are* willing to help. It's not the case that
they are just demanding.

I'm sure that if Mark (or whoever is responsible for that page) called
for help to review and merge pull requests, people would respond.
Daniil Frumin has offered his help even without such a call.

Manpower does not appear to be the issue here. Rather, people are not
given an opportunity to help.

See also http://ro-che.info/articles/2014-02-08-my-haskell-will.html.
I think HP ought to have a backup person (or even a team).

Roman
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140219/8056e3dc/attachment.sig>

From allbery.b at gmail.com  Wed Feb 19 21:38:17 2014
From: allbery.b at gmail.com (Brandon Allbery)
Date: Wed, 19 Feb 2014 16:38:17 -0500
Subject: [Haskell-cafe] Functor instance derived from Monad
In-Reply-To: <20140219232530.74c3f934@farka.eu>
References: <20140219232530.74c3f934@farka.eu>
Message-ID: <CAKFCL4WetVHW44tK0Gk47HEDCdV69BK6-Gh11g533LY4Fu65qw@mail.gmail.com>

On Wed, Feb 19, 2014 at 5:25 PM, Frantisek Farka <frantisek at farka.eu> wrote:

> when reading the Functor-Applicative-Monad proposal [1] on Haskell
> wiki I remembered that I have seen instance similar to
>
>     instance (Monad m) => Functor m where
>         fmap f a = a >>= \x -> return $ f x
>
> with FlexibleInstances and UndecidableInstances language extensions.
> But I cannot remember where it was nor can I find any useful reference.
> Is there some library in Hackage with this and similar instances?
>

There is not, because the need for UndecidableInstances there is warning
you that this is perilous.

I thought some of the discussion behind the AMP touched on why this was not
considered as a solution?

-- 
brandon s allbery kf8nh                               sine nomine associates
allbery.b at gmail.com                                  ballbery at sinenomine.net
unix, openafs, kerberos, infrastructure, xmonad        http://sinenomine.net
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140219/fdc84873/attachment.html>

From dominic at steinitz.org  Wed Feb 19 22:31:07 2014
From: dominic at steinitz.org (Dominic Steinitz)
Date: Wed, 19 Feb 2014 22:31:07 +0000 (UTC)
Subject: [Haskell-cafe] hmatrix-labeled: request for comments
References: <87zjlm53ct.fsf@karetnikov.org>
Message-ID: <loom.20140219T232546-312@post.gmane.org>

Nikita Karetnikov <nikita <at> karetnikov.org> writes:

> 
> I like how easy it is to import data in R and Octave.  (See [1] for a
> typical workflow.)  Since I couldn?t find any matching library on
> Hackage, I cooked up my own [2] in a couple of days.
> 

As Ian has already pointed out there is cassava for CSV and there is also 
http://hackage.haskell.org/package/shapefile which worked fine for me but may need a few tweaks 
to make it build. See here for an example of usage of both of them:

http://idontgetoutmuch.wordpress.com/2013/10/23/parking-in-westminster-an-analysis-in-
haskell/


From ian at skybluetrades.net  Wed Feb 19 22:37:55 2014
From: ian at skybluetrades.net (Ian Ross)
Date: Wed, 19 Feb 2014 23:37:55 +0100
Subject: [Haskell-cafe] hmatrix-labeled: request for comments
In-Reply-To: <loom.20140219T232546-312@post.gmane.org>
References: <87zjlm53ct.fsf@karetnikov.org>
 <loom.20140219T232546-312@post.gmane.org>
Message-ID: <CA+adx7vL9HvJF2ZRk3HiFDKRghycTs7mL1be6gHL02PNhxB6sQ@mail.gmail.com>

Oh yeah, I should have remembered that parking analysis post.  I really
liked that, and I think it's a great example of the things we should be
able to do with Haskell.


On 19 February 2014 23:31, Dominic Steinitz <dominic at steinitz.org> wrote:

> Nikita Karetnikov <nikita <at> karetnikov.org> writes:
>
> >
> > I like how easy it is to import data in R and Octave.  (See [1] for a
> > typical workflow.)  Since I couldn't find any matching library on
> > Hackage, I cooked up my own [2] in a couple of days.
> >
>
> As Ian has already pointed out there is cassava for CSV and there is also
> http://hackage.haskell.org/package/shapefile which worked fine for me but
> may need a few tweaks
> to make it build. See here for an example of usage of both of them:
>
>
> http://idontgetoutmuch.wordpress.com/2013/10/23/parking-in-westminster-an-analysis-in-
> haskell/
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>



-- 
Ian Ross   Tel: +43(0)6804451378   ian at skybluetrades.net
www.skybluetrades.net
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140219/e8a5f52c/attachment.html>

From greg at gregorycollins.net  Wed Feb 19 22:53:58 2014
From: greg at gregorycollins.net (Gregory Collins)
Date: Wed, 19 Feb 2014 14:53:58 -0800
Subject: [Haskell-cafe] How to benckmark a Word64 -> Bool?
In-Reply-To: <CAB6QvNNFEDC+NxieyHffTDpfkLAJqKKmveqisA7wEo_mw_n+Dw@mail.gmail.com>
References: <CAB6QvNNnafHYk1WDXUopq2cfn+mfkLgm4W6j2eqZGqzbNieDeA@mail.gmail.com>
 <CAHZrzdpcainh0W5_htBe7i3cCP6OK-K6ZaybWx6NLqvb0UTBEA@mail.gmail.com>
 <CACOpX0cse11Ku14B4NA22xYU02V7CRr04HxRJEvJT6F+v3=peQ@mail.gmail.com>
 <CAB6QvNOgvC9tZKaBp8b2Zj6sAuu-H0_kr8M+N5gpwbtSC0nq9A@mail.gmail.com>
 <72d1fb20-1588-4e02-b980-7a317809768b@googlegroups.com>
 <CAB6QvNNFEDC+NxieyHffTDpfkLAJqKKmveqisA7wEo_mw_n+Dw@mail.gmail.com>
Message-ID: <CAHZrzdqVEDNxaiOFUhkrPnupcSv5uQK8srB_pWc_o41fhoeVzQ@mail.gmail.com>

This version is about 2x as fast as OP's on my system (look at h2.hs):
https://gist.github.com/gregorycollins/9103248

$  time ./dist/build/h1/h1 50000000 +RTS -A4M > /dev/null
./dist/build/h1/h1 50000000 +RTS -A4M > /dev/null  23.88s user 0.06s system
99% cpu 24.003 total

$  time ./dist/build/h2/h2 50000000 +RTS -A4M > /dev/null
./dist/build/h2/h2 50000000 +RTS -A4M > /dev/null  13.57s user 0.09s system
99% cpu 13.706 total

$  time ./dist/build/h3/h3 50000000 +RTS -A4M > /dev/null
./dist/build/h3/h3 50000000 +RTS -A4M > /dev/null  24.24s user 0.18s system
99% cpu 24.490 total

The "system" number here is especially telling: this program is spending
almost all of its time in syscalls.

G


On Wed, Feb 19, 2014 at 12:47 PM, Charles-Pierre Astolfi <cpa at crans.org>wrote:

> Thanks Erik!
>
> I was kind of hoping for such a benchmark. On my system, the C version is
> consistently twice as fast as the Haskell version. (I tried -fllvm, but it
> doesn't change perf)
>
> Then I added bang patterns for the argument of only012 and in the tuple
> (p,q) and it now has the same runtime as C.
>
> Just for fun, I tried to void writing explicit recursion and used only
> combinators and this Haskell code is still as competitive as C, so the real
> bottleneck really was the laziness in the tuple/argument.
>
> http://lpaste.net/100153
>
> In fact, this Haskell version takes 8 sec vs 10 sec for the C version on
> my laptop (input: 1000000000).
>
> I tried using Data.List.Stream, I couldn't get any performance gain,
> probably because the code is very close to optimal.
>
> So remember kids:
> - Bang pattern the heck out of your code (not a silver bullet, but
> definitely worth trying).
> - Don't rely on too much IO for benchmark.
> - Don't be afraid of combinators even if you want performance.
> - Ask on haskell-cafe, chaps here are very helpful :)
>
>
> --
> Cp
>
>
> On Wed, Feb 19, 2014 at 8:39 PM, Erik Rantapaa <erantapaa at gmail.com>wrote:
>
>> I think a lot is being obscured by the IO subsystem.
>>
>> If you print just a count of the only012 numbers I get very different
>> results.
>>
>> Here are the versions I compared:
>>
>> http://lpaste.net/100142
>>
>> and on my system the C version is about 10x faster.
>>
>>
>> On Wednesday, February 19, 2014 12:49:36 PM UTC-6, Charles-Pierre Astolfi
>> wrote:
>>
>>> Switching to quotRem gave no measurable improvements.
>>> After switching to ByteString, the code now runs in 9 seconds, which
>>> outperforms my C version. But honestly, I have no idea why.
>>>
>>> New code:
>>> http://lpaste.net/100136
>>>
>>> $ ghc --make -O3 303only012.hs && time ./303only012 50000000 > /dev/null
>>> ./303only012 50000000 > /dev/null  9.72s user 0.21s system 90% cpu
>>> 10.961 total
>>>
>>> @Alois, I'm not sure how criterion can help compare my code with the C
>>> version, since in the C version I cannot measure the exec time of only012
>>> only. What did you have in mind?
>>>
>>> Thanks everyone!
>>>
>>>
>>> --
>>> Cp
>>>
>>>
>>> On Wed, Feb 19, 2014 at 7:24 PM, Levent Erkok <erk... at gmail.com> wrote:
>>>
>>>>  Also, prefer quotRem over divMod as the former is faster. See here:
>>>> http://stackoverflow.com/questions/339719/when-is-
>>>> the-difference-between-quotrem-and-divmod-useful
>>>>
>>>>
>>>> On Wed, Feb 19, 2014 at 10:19 AM, Gregory Collins <
>>>> gr... at gregorycollins.net> wrote:
>>>>
>>>>>
>>>>> On Wed, Feb 19, 2014 at 9:36 AM, Charles-Pierre Astolfi <
>>>>> c... at crans.org> wrote:
>>>>>
>>>>>> So there's a difference, but I'm not sure if it's related to my
>>>>>> algorithm or related to IO/RTS.
>>>>>
>>>>>
>>>>> Text.Printf is slower than the C version (and uses String). Use
>>>>> Data.ByteString.putStr instead.
>>>>>
>>>>>
>>>>>
>>>>> --
>>>>> Gregory Collins <gr... at gregorycollins.net>
>>>>>
>>>>> _______________________________________________
>>>>> Haskell-Cafe mailing list
>>>>> Haskel... at haskell.org
>>>>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>>>>
>>>>>
>>>>
>>>
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
>


-- 
Gregory Collins <greg at gregorycollins.net>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140219/1f12b17a/attachment.html>

From allbery.b at gmail.com  Wed Feb 19 23:02:02 2014
From: allbery.b at gmail.com (Brandon Allbery)
Date: Wed, 19 Feb 2014 18:02:02 -0500
Subject: [Haskell-cafe] How to benckmark a Word64 -> Bool?
In-Reply-To: <CAHZrzdqVEDNxaiOFUhkrPnupcSv5uQK8srB_pWc_o41fhoeVzQ@mail.gmail.com>
References: <CAB6QvNNnafHYk1WDXUopq2cfn+mfkLgm4W6j2eqZGqzbNieDeA@mail.gmail.com>
 <CAHZrzdpcainh0W5_htBe7i3cCP6OK-K6ZaybWx6NLqvb0UTBEA@mail.gmail.com>
 <CACOpX0cse11Ku14B4NA22xYU02V7CRr04HxRJEvJT6F+v3=peQ@mail.gmail.com>
 <CAB6QvNOgvC9tZKaBp8b2Zj6sAuu-H0_kr8M+N5gpwbtSC0nq9A@mail.gmail.com>
 <72d1fb20-1588-4e02-b980-7a317809768b@googlegroups.com>
 <CAB6QvNNFEDC+NxieyHffTDpfkLAJqKKmveqisA7wEo_mw_n+Dw@mail.gmail.com>
 <CAHZrzdqVEDNxaiOFUhkrPnupcSv5uQK8srB_pWc_o41fhoeVzQ@mail.gmail.com>
Message-ID: <CAKFCL4W9SLmQToORLnYwtARJca-a_codNacLdUTXbeUcU_k_FA@mail.gmail.com>

On Wed, Feb 19, 2014 at 5:53 PM, Gregory Collins <greg at gregorycollins.net>wrote:

> This version is about 2x as fast as OP's on my system (look at h2.hs):
> https://gist.github.com/gregorycollins/9103248
>
> $  time ./dist/build/h1/h1 50000000 +RTS -A4M > /dev/null
> ./dist/build/h1/h1 50000000 +RTS -A4M > /dev/null  23.88s user 0.06s
> system 99% cpu 24.003 total
>
> $  time ./dist/build/h2/h2 50000000 +RTS -A4M > /dev/null
> ./dist/build/h2/h2 50000000 +RTS -A4M > /dev/null  13.57s user 0.09s
> system 99% cpu 13.706 total
>
> $  time ./dist/build/h3/h3 50000000 +RTS -A4M > /dev/null
> ./dist/build/h3/h3 50000000 +RTS -A4M > /dev/null  24.24s user 0.18s
> system 99% cpu 24.490 total
>
> The "system" number here is especially telling: this program is spending
> almost all of its time in syscalls.
>

You're reading it wrong. Using that last one:

24.2s on-CPU time in user mode
0.18s on-CPU time in system mode (kernel/syscalls)
99% of its total run time was actually spent on cpu (instead of, say, I/O
wait)
24.490 total run (wall) time

-- 
brandon s allbery kf8nh                               sine nomine associates
allbery.b at gmail.com                                  ballbery at sinenomine.net
unix, openafs, kerberos, infrastructure, xmonad        http://sinenomine.net
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140219/266de4be/attachment.html>

From greg at gregorycollins.net  Wed Feb 19 23:05:57 2014
From: greg at gregorycollins.net (Gregory Collins)
Date: Wed, 19 Feb 2014 15:05:57 -0800
Subject: [Haskell-cafe] How to benckmark a Word64 -> Bool?
In-Reply-To: <CAKFCL4W9SLmQToORLnYwtARJca-a_codNacLdUTXbeUcU_k_FA@mail.gmail.com>
References: <CAB6QvNNnafHYk1WDXUopq2cfn+mfkLgm4W6j2eqZGqzbNieDeA@mail.gmail.com>
 <CAHZrzdpcainh0W5_htBe7i3cCP6OK-K6ZaybWx6NLqvb0UTBEA@mail.gmail.com>
 <CACOpX0cse11Ku14B4NA22xYU02V7CRr04HxRJEvJT6F+v3=peQ@mail.gmail.com>
 <CAB6QvNOgvC9tZKaBp8b2Zj6sAuu-H0_kr8M+N5gpwbtSC0nq9A@mail.gmail.com>
 <72d1fb20-1588-4e02-b980-7a317809768b@googlegroups.com>
 <CAB6QvNNFEDC+NxieyHffTDpfkLAJqKKmveqisA7wEo_mw_n+Dw@mail.gmail.com>
 <CAHZrzdqVEDNxaiOFUhkrPnupcSv5uQK8srB_pWc_o41fhoeVzQ@mail.gmail.com>
 <CAKFCL4W9SLmQToORLnYwtARJca-a_codNacLdUTXbeUcU_k_FA@mail.gmail.com>
Message-ID: <CAHZrzdrB0XoQUSQeF-w1+PQy2q4nKAvKDPw8mvKWFGJBBjgVdg@mail.gmail.com>

On Wed, Feb 19, 2014 at 3:02 PM, Brandon Allbery <allbery.b at gmail.com>wrote:

> You're reading it wrong. Using that last one:


Oops. I stand corrected :)


-- 
Gregory Collins <greg at gregorycollins.net>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140219/70e6660d/attachment.html>

From frantisek at farka.eu  Thu Feb 20 00:29:17 2014
From: frantisek at farka.eu (Frantisek Farka)
Date: Thu, 20 Feb 2014 01:29:17 +0100
Subject: [Haskell-cafe] Functor instance derived from Monad
In-Reply-To: <CAKFCL4WetVHW44tK0Gk47HEDCdV69BK6-Gh11g533LY4Fu65qw@mail.gmail.com>
References: <20140219232530.74c3f934@farka.eu>
 <CAKFCL4WetVHW44tK0Gk47HEDCdV69BK6-Gh11g533LY4Fu65qw@mail.gmail.com>
Message-ID: <20140220012917.78ee4218@farka.eu>

On Wed, 19 Feb 2014 16:38:17 -0500
Brandon Allbery <allbery.b at gmail.com> wrote:

> On Wed, Feb 19, 2014 at 5:25 PM, Frantisek Farka <frantisek at farka.eu>
> wrote:
> 
> There is not, because the need for UndecidableInstances there is
> warning you that this is perilous.

Yes, I am aware of that. It's not the case I want to use this actual
code. I am rather interested in its impact on typeclass hierarchy 
compared to AMP and Default Superclass instances

> 
> I thought some of the discussion behind the AMP touched on why this
> was not considered as a solution?
> 

Could you elaborate on that? Although I gave it fair amount of googling
I did not find out anything. Was it on some mailing list? 

Thanks a lot

Cheers 

FF


From allbery.b at gmail.com  Wed Feb 19 23:32:54 2014
From: allbery.b at gmail.com (Brandon Allbery)
Date: Wed, 19 Feb 2014 18:32:54 -0500
Subject: [Haskell-cafe] Functor instance derived from Monad
In-Reply-To: <20140220012917.78ee4218@farka.eu>
References: <20140219232530.74c3f934@farka.eu>
 <CAKFCL4WetVHW44tK0Gk47HEDCdV69BK6-Gh11g533LY4Fu65qw@mail.gmail.com>
 <20140220012917.78ee4218@farka.eu>
Message-ID: <CAKFCL4UcWNWiEwjBcekqMeYMytOzuYbsA1eJZSbnXj2MpHE6aA@mail.gmail.com>

On Wed, Feb 19, 2014 at 7:29 PM, Frantisek Farka <frantisek at farka.eu> wrote:

> On Wed, 19 Feb 2014 16:38:17 -0500
> Brandon Allbery <allbery.b at gmail.com> wrote:
> > I thought some of the discussion behind the AMP touched on why this
> > was not considered as a solution?
>
> Could you elaborate on that? Although I gave it fair amount of googling
> I did not find out anything. Was it on some mailing list?
>

I thought it was on here, but it may have been libraries at haskell.org or one
of the other lists. I can try to dig in my archives.

-- 
brandon s allbery kf8nh                               sine nomine associates
allbery.b at gmail.com                                  ballbery at sinenomine.net
unix, openafs, kerberos, infrastructure, xmonad        http://sinenomine.net
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140219/a6d72d87/attachment.html>

From mwm at mired.org  Wed Feb 19 23:34:16 2014
From: mwm at mired.org (Mike Meyer)
Date: Wed, 19 Feb 2014 17:34:16 -0600
Subject: [Haskell-cafe] Rewrite NetBSD kernel driver using Ajhc Haskell
	compiler
In-Reply-To: <CAEvX6dkYpcr1Janqwt6L+hqszjEE3b4hkiHP0y8wTrgQerKznw@mail.gmail.com>
References: <CAEvX6dki6=N5D70pucRqsbVWhW8c9C9qbPKefYc1Um7UNiseqg@mail.gmail.com>
 <2562D045-28FB-4555-84F8-3326AFB0839F@gmail.com>
 <5304C658.7050507@update.uu.se>
 <CAEvX6dn4wGbH3s7gbrcxyQ7xye+54=B3zvEwgP3MxDL6tqki5w@mail.gmail.com>
 <CAEvX6dkYpcr1Janqwt6L+hqszjEE3b4hkiHP0y8wTrgQerKznw@mail.gmail.com>
Message-ID: <CAD=7U2A7DnRHEO-rHrGT0XkOXk+J7wAFLQu-0ewNTUju5Beo9A@mail.gmail.com>

On Wed, Feb 19, 2014 at 9:30 AM, Kiwamu Okabe <kiwamu at debian.or.jp> wrote:
> Hi Johnny, I had forgotten important point.
>
> > On Wed, Feb 19, 2014 at 11:57 PM, Johnny Billquist <bqt at update.uu.se>
wrote:
> >> Maybe someone with more insight could explain to an idiot like me how
> >> Haskell garbage collection is handled when running in the kernel?
>
> Running a simple logic in the kernel, it doesn't call GC.

Having looked over the source, I couldn't get much of a feel for it -
it mostly seemed to be FFI & type declarations. Which does make sense
since the goal is to provide strong type checking in the kernel. Maybe
I'm looking in the wrong place in that rather large repository?

My question is how much does coding to meet the requirements for a
device driver - not doing GC being one of them - warp the resulting
Haskell code? Is it still pretty much idiomatic Haskell, or would it
be easier for a Haskell programmer to figure out the C it replaced?
Most of the time I've seen people try and get a modern language to
meet such requirements (me included), you might as well have stuck
with C as far as code improvement goes.

One of the advantages C has in the kernel - the BSD kernels, anyway,
reading Linux kernel makes me queasy - is that it isn't that different
from C in userland. And the kernel groups have been working on
reducing over the differences.

       Thanks,
       <mike
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140219/91130348/attachment.html>

From reilithion at gmail.com  Thu Feb 20 00:12:55 2014
From: reilithion at gmail.com (Lucas Paul)
Date: Wed, 19 Feb 2014 17:12:55 -0700
Subject: [Haskell-cafe] Text and ByteString safety (was Naming scheme for
	partial functions)
Message-ID: <CAMvcYxCg7JX5ExkkTd6Q3X+cEs8nq80NStzrCeBH+vKkjvLcgw@mail.gmail.com>

I'm still a little new to Haskell. Could someone explain how Text and
ByteString "push the boundaries of 'unsafe'"?

On Sat, Feb 15, 2014 at 8:40 AM, Antoine Latter <aslatter at gmail.com> wrote:
> Yeah, that's a good point.Text and Bytestring (and other similar packages)
> have been pushing the boundaries of 'unsafe' and are in wide use.

From kiwamu at debian.or.jp  Thu Feb 20 04:34:08 2014
From: kiwamu at debian.or.jp (Kiwamu Okabe)
Date: Thu, 20 Feb 2014 13:34:08 +0900
Subject: [Haskell-cafe] Rewrite NetBSD kernel driver using Ajhc Haskell
	compiler
In-Reply-To: <CAD=7U2A7DnRHEO-rHrGT0XkOXk+J7wAFLQu-0ewNTUju5Beo9A@mail.gmail.com>
References: <CAEvX6dki6=N5D70pucRqsbVWhW8c9C9qbPKefYc1Um7UNiseqg@mail.gmail.com>
 <2562D045-28FB-4555-84F8-3326AFB0839F@gmail.com>
 <5304C658.7050507@update.uu.se>
 <CAEvX6dn4wGbH3s7gbrcxyQ7xye+54=B3zvEwgP3MxDL6tqki5w@mail.gmail.com>
 <CAEvX6dkYpcr1Janqwt6L+hqszjEE3b4hkiHP0y8wTrgQerKznw@mail.gmail.com>
 <CAD=7U2A7DnRHEO-rHrGT0XkOXk+J7wAFLQu-0ewNTUju5Beo9A@mail.gmail.com>
Message-ID: <CAEvX6dmP1iC+-wOXd9Tmu3YcukkNbRygeRURioFnvC59cSPb=g@mail.gmail.com>

Hi Mike,

On Thu, Feb 20, 2014 at 8:34 AM, Mike Meyer <mwm at mired.org> wrote:
>> Running a simple logic in the kernel, it doesn't call GC.
>
> Having looked over the source, I couldn't get much of a feel for it -
> it mostly seemed to be FFI & type declarations. Which does make sense
> since the goal is to provide strong type checking in the kernel. Maybe
> I'm looking in the wrong place in that rather large repository?

You are right. It's just "exercise".
I would like to prove that can write code with functional language in
interrupt context.

> My question is how much does coding to meet the requirements for a
> device driver - not doing GC being one of them - warp the resulting
> Haskell code? Is it still pretty much idiomatic Haskell, or would it
> be easier for a Haskell programmer to figure out the C it replaced?
> Most of the time I've seen people try and get a modern language to
> meet such requirements (me included), you might as well have stuck
> with C as far as code improvement goes.

This exercise has logic code at following.

https://github.com/metasepi/netbsd-arafura-s1/blob/arafura-s1/metasepi/sys/hssrc/Dev/Pci/Auich.hs
https://github.com/metasepi/netbsd-arafura-s1/blob/arafura-s1/metasepi/sys/hssrc/Dev/Pci/Auich/Intr.hs
https://github.com/metasepi/netbsd-arafura-s1/blob/arafura-s1/metasepi/sys/hssrc/Dev/Pci/Hdaudio/Hdaudio.hs

I re-write these from NetBSD's implementation, for a month.
But now can get more speed with our new tool,
convert C language API definition into Haskell API definition
semi-automatically.

https://github.com/ajhc/struct2hs

Following is usage of the tool.

$ struct2hs $HOME/src/netbsd-arafura-s1/obj/tooldir/bin/i486--netbsdelf-gcc
"-Di386 -I$HOME/src/netbsd-arafura-s1/sys/arch/i386/compile/obj/GENERIC_HS
... sys/dev/pci/hdaudio/hdaudio.c | tail -15

newtype {-# CTYPE "struct pdevinit" #-} Pdevinit = Pdevinit ()
foreign import primitive "const.sizeof(struct pdevinit)"
  sizeOf_Pdevinit :: Int
foreign import primitive "const.offsetof(struct pdevinit, pdev_attach)"
  offsetOf_Pdevinit_pdev_attach :: Int
p_Pdevinit_pdev_attach :: Ptr Pdevinit -> IO (Ptr (Ptr (FunPtr (Int -> IO ()))))
p_Pdevinit_pdev_attach p = return $ plusPtr p $ offsetOf_Pdevinit_pdev_attach
foreign import ccall "dynamic" call_Pdevinit_pdev_attach ::
  FunPtr (Int -> IO ()) -> Int -> IO ()
foreign import primitive "const.offsetof(struct pdevinit, pdev_count)"
  offsetOf_Pdevinit_pdev_count :: Int
p_Pdevinit_pdev_count :: Ptr Pdevinit -> IO (Ptr Int)
p_Pdevinit_pdev_count p = return $ plusPtr p $ offsetOf_Pdevinit_pdev_count

> One of the advantages C has in the kernel - the BSD kernels, anyway,
> reading Linux kernel makes me queasy - is that it isn't that different
> from C in userland. And the kernel groups have been working on
> reducing over the differences.

I hope so...
But, I think Ajhc is not good for real kernel products,
after this hard challenge.
ATS language is much betther than Ajhc.
Hongwei, as ATS author, says following. I perfectly agree his opinion.

http://metasepi.org/posts/2013-12-24-jats-ug.html#%E4%B8%80%E9%80%9A%E3%81%AE%E3%83%A1%E3%83%BC%E3%83%AB

Regards,
-- 
Kiwamu Okabe

From michael at snoyman.com  Thu Feb 20 04:50:21 2014
From: michael at snoyman.com (Michael Snoyman)
Date: Thu, 20 Feb 2014 06:50:21 +0200
Subject: [Haskell-cafe] Text and ByteString safety (was Naming scheme
 for partial functions)
In-Reply-To: <CAMvcYxCg7JX5ExkkTd6Q3X+cEs8nq80NStzrCeBH+vKkjvLcgw@mail.gmail.com>
References: <CAMvcYxCg7JX5ExkkTd6Q3X+cEs8nq80NStzrCeBH+vKkjvLcgw@mail.gmail.com>
Message-ID: <CAKA2JgLZdicLSAob+Yt-ykuLcED_L5qVeu5ESdWTOLbiw+CgRQ@mail.gmail.com>

I'm not sure about Text, but both the bytestring and vector packages
provide functions like unsafeIndex. The closest equivalent to that in base
would be (!!), which indexes on a list. If you give it an invalid index, it
will throw an exception from pure code (a.k.a., it's a partial function).
That kind of exception can cause problems if you don't expect it, but in
the nearest IO code, you can still catch that exception and let your
program continue operating.

unsafeIndex, on the other hand, performs a memory access which may not just
throw an exception, but could actually cause your program to segfault.
There would be no way to recover from that, unlike partial functions.

I think that's what Antoine is implying, please correct me if I'm mistaken
:).


On Thu, Feb 20, 2014 at 2:12 AM, Lucas Paul <reilithion at gmail.com> wrote:

> I'm still a little new to Haskell. Could someone explain how Text and
> ByteString "push the boundaries of 'unsafe'"?
>
> On Sat, Feb 15, 2014 at 8:40 AM, Antoine Latter <aslatter at gmail.com>
> wrote:
> > Yeah, that's a good point.Text and Bytestring (and other similar
> packages)
> > have been pushing the boundaries of 'unsafe' and are in wide use.
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140220/e16392a8/attachment.html>

From code at funwithsoftware.org  Thu Feb 20 07:15:16 2014
From: code at funwithsoftware.org (Patrick Pelletier)
Date: Wed, 19 Feb 2014 23:15:16 -0800
Subject: [Haskell-cafe] fromString and toString
In-Reply-To: <CADu1bNR8r1hZ9goukjoi+rjn=eQ6wLNedp1gFhQjPgAo=mbEiQ@mail.gmail.com>
References: <CADu1bNR8r1hZ9goukjoi+rjn=eQ6wLNedp1gFhQjPgAo=mbEiQ@mail.gmail.com>
Message-ID: <5305AB84.3070703@funwithsoftware.org>

On 2/4/14, 5:55 AM, Ben Foppa wrote:

> The reason this came up is that I'm getting pretty sick of type-juggling
> different string types from different libraries (String, Text, various
> ByteStrings), especially since I have to tweak all the functions I use
> if a type changes; discovering fromString was fantastic, but without
> toString, I can't define something like
>
> reString :: (IsString a, IsString b) => a -> b
>
> which is great to have if your putStrLn only accepts one kind of string,
> and you have several distinct ones floating around.

Although it doesn't seem to be used much, I noticed that there's this 
package on Hackage:

http://hackage.haskell.org/package/stringable-0.1.2/docs/Data-Stringable.html

which seems like it's addressing the same problem you're trying to solve.

--Patrick


From kiwamu at debian.or.jp  Thu Feb 20 09:01:08 2014
From: kiwamu at debian.or.jp (Kiwamu Okabe)
Date: Thu, 20 Feb 2014 18:01:08 +0900
Subject: [Haskell-cafe] Rewrite NetBSD kernel driver using Ajhc Haskell
	compiler
In-Reply-To: <5305BEB3.4090106@update.uu.se>
References: <CAEvX6dki6=N5D70pucRqsbVWhW8c9C9qbPKefYc1Um7UNiseqg@mail.gmail.com>
 <2562D045-28FB-4555-84F8-3326AFB0839F@gmail.com>
 <5304C658.7050507@update.uu.se>
 <CAEvX6dn4wGbH3s7gbrcxyQ7xye+54=B3zvEwgP3MxDL6tqki5w@mail.gmail.com>
 <CAEvX6dkYpcr1Janqwt6L+hqszjEE3b4hkiHP0y8wTrgQerKznw@mail.gmail.com>
 <5305BEB3.4090106@update.uu.se>
Message-ID: <CAEvX6dmJD4YbwMi1Mzj1JFiNq3zuksk93tf+ERD2nqxXucrYhw@mail.gmail.com>

Hi Johnny,

On Thu, Feb 20, 2014 at 5:37 PM, Johnny Billquist <bqt at update.uu.se> wrote:
> Are you saying that you essentially avoid GC by creating a large fresh heap
> every time you call something written in Haskell, and then delete the heap
> when the Haskell function returns? And that the current piece of code
> running in Haskell is short enough that GC never is done?

No, does not delete. Pool it.
See following code compiled by Ajhc.
Ajhc compile Haskell code into C code.

https://gist.github.com/master-q/9109334

Please note auichIntr() function that is entry point C => Haskell.

https://gist.github.com/master-q/9109334#file-hsmain-c-L2051

int
auichIntr(HsPtr x272)
{
        arena_t arena;
        gc_t gc;
        gc = NULL;
        arena = NULL;
        jhc_alloc_init(&gc,&arena);
        jhc_hs_init(gc,arena);
        int x273 = ((int)fFE$__CCall_auichIntr(gc,arena,(uintptr_t)x272));
        jhc_alloc_fini(gc,arena);
        return x273;
}

The code post-calls jhc_alloc_fini() that pool Haskell heap (named
megablock) into free_megablocks.

https://github.com/ajhc/ajhc/blob/d93468e34f4514209048d4a92b1549e079ccd3fb/rts/rts/gc_jgc.c#L251

void
jhc_alloc_fini(gc_t gc,arena_t arena) {
-- snip --
        SLIST_FOREACH(pg, &arena->monolithic_blocks, link) {
                SLIST_INSERT_HEAD(&free_monolithic_blocks, pg, link);
        }
        SLIST_FOREACH(mb, &arena->megablocks, next) {
                SLIST_INSERT_HEAD(&free_megablocks, mb, next);
        }
        if(arena->current_megablock) {
                SLIST_INSERT_HEAD(&free_megablocks,
arena->current_megablock, next);
        }

Also s_alloc(), Haskell heap allocator, try to get Haskell heap from the pool.
If not found, it posix_memalign new megablock.

https://github.com/ajhc/ajhc/blob/d93468e34f4514209048d4a92b1549e079ccd3fb/rts/rts/gc_jgc.c#L392

struct s_megablock *
s_new_megablock(arena_t arena)
{
        jhc_rts_lock();
        struct s_megablock *mb = SLIST_FIRST(&free_megablocks);
        if (mb) {
                SLIST_REMOVE(&free_megablocks, mb, s_megablock, next);
        } else {
                mb = malloc(sizeof(*mb));
#ifdef _JHC_JGC_LIMITED_NUM_MEGABLOCK
                static int count = 0;
                if (count >= _JHC_JGC_LIMITED_NUM_MEGABLOCK) {
                        abort();
                }
                mb->base = aligned_megablock + (MEGABLOCK_SIZE) * count;
                count++;
#else
                mb->base = jhc_aligned_alloc(MEGABLOCK_SIZE);
#endif

Regards,
-- 
Kiwamu Okabe

From marcus at gabriel.name  Thu Feb 20 21:12:54 2014
From: marcus at gabriel.name (Marcus D. Gabriel)
Date: Thu, 20 Feb 2014 22:12:54 +0100
Subject: [Haskell-cafe] Data.Foldable UArray
Message-ID: <53066FD6.9060302@gabriel.name>

Hello,

I wanted to make a simple Data.Foldable UArray, and I naively modelled
it on

> instance Ix i => Foldable (Array i) where
>  foldr f z = Prelude.foldr f z . elems

with, of course,

> instance Ix i => Foldable (UArray i) where
> foldr f z = Prelude.foldr f z . elems

which did not work yielding the following type message

  Could not deduce (IArray UArray a) arising from a use of `elems'
  from the context (Ix i) bound by the instance declaration at
  ... Possible fix: add an instance declaration for (IArray UArray
  a) In the second argument of `(.)', namely `elems' In the
  expression: Data.List.foldr f z . elems In an equation for
  `foldr': foldr f z = Data.List.foldr f z . elems

I clearly do not understand something because I cannot make this work,
and I am not sure why.

With the Haskell type system or even with ghc extensions, can one even
make a Data.Foldable UArray?  If so, how?

Thanks in advance,
- Marcus

From maxim.kulkin at gmail.com  Thu Feb 20 21:16:25 2014
From: maxim.kulkin at gmail.com (Maxim Kulkin)
Date: Fri, 21 Feb 2014 01:16:25 +0400
Subject: [Haskell-cafe] Hdevtools cabal support
Message-ID: <2F80D7B3-609E-4E97-A7AE-C3C235DBD989@gmail.com>

Hi,

I'm pretty new to Haskell, but was doing Haskell development for several month. I'm fan of Vim editor and was happy to find out that there are good tools to support Haskell development with Vim, e.g. vim-hdevtools. But it turned out that it not of much use in my project where we rely on Cabal packages and sandboxes.

As part of scratching own itch I have implemented support for Cabal packages for Hdevtools.

I invite everyone interested to try, review and provide feedback on this.

The patch is not yet merged into master branch, so to install it you need to check it out from my repository:

  git clone https://github.com/maximkulkin/hdevtools.git
  cd hdevtools
  git checkout cabal-support
  cabal install

So, to be able to use hdevtools with Cabal, you just need to run hdevtools from inside your Cabal project, e.g.

  hdevtools check src/MyFile.hs
  hdevtools info src/MyOtherFile.hs DoThat

Hope this will save someone's day.
Max

From benjamin.foppa at gmail.com  Thu Feb 20 21:18:45 2014
From: benjamin.foppa at gmail.com (Ben Foppa)
Date: Thu, 20 Feb 2014 16:18:45 -0500
Subject: [Haskell-cafe] fromString and toString
In-Reply-To: <5305AB84.3070703@funwithsoftware.org>
References: <CADu1bNR8r1hZ9goukjoi+rjn=eQ6wLNedp1gFhQjPgAo=mbEiQ@mail.gmail.com>
 <5305AB84.3070703@funwithsoftware.org>
Message-ID: <CADu1bNShF9UD4kemDhmZatUE6DMNhx2u6DrxdL6rFzHR8sAydA@mail.gmail.com>

That's exactly what I want, thank you!
On Feb 20, 2014 2:15 AM, "Patrick Pelletier" <code at funwithsoftware.org>
wrote:

> On 2/4/14, 5:55 AM, Ben Foppa wrote:
>
>  The reason this came up is that I'm getting pretty sick of type-juggling
>> different string types from different libraries (String, Text, various
>> ByteStrings), especially since I have to tweak all the functions I use
>> if a type changes; discovering fromString was fantastic, but without
>> toString, I can't define something like
>>
>> reString :: (IsString a, IsString b) => a -> b
>>
>> which is great to have if your putStrLn only accepts one kind of string,
>> and you have several distinct ones floating around.
>>
>
> Although it doesn't seem to be used much, I noticed that there's this
> package on Hackage:
>
> http://hackage.haskell.org/package/stringable-0.1.2/docs/
> Data-Stringable.html
>
> which seems like it's addressing the same problem you're trying to solve.
>
> --Patrick
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140220/67edd207/attachment.html>

From carter.schonwald at gmail.com  Thu Feb 20 21:27:39 2014
From: carter.schonwald at gmail.com (Carter Schonwald)
Date: Thu, 20 Feb 2014 16:27:39 -0500
Subject: [Haskell-cafe] Data.Foldable UArray
In-Reply-To: <53066FD6.9060302@gabriel.name>
References: <53066FD6.9060302@gabriel.name>
Message-ID: <CAHYVw0zk=_06NgYwhW_CYOdud6DBrxoX6aJ00GqHwU2pTSDdLw@mail.gmail.com>

not every value can be unboxed. A good example for understanding this would
be looking at the Unboxed Modules in the Vector package


On Thu, Feb 20, 2014 at 4:12 PM, Marcus D. Gabriel <marcus at gabriel.name>wrote:

> Hello,
>
> I wanted to make a simple Data.Foldable UArray, and I naively modelled
> it on
>
> > instance Ix i => Foldable (Array i) where
> >  foldr f z = Prelude.foldr f z . elems
>
> with, of course,
>
> > instance Ix i => Foldable (UArray i) where
> > foldr f z = Prelude.foldr f z . elems
>
> which did not work yielding the following type message
>
>   Could not deduce (IArray UArray a) arising from a use of `elems'
>   from the context (Ix i) bound by the instance declaration at
>   ... Possible fix: add an instance declaration for (IArray UArray
>   a) In the second argument of `(.)', namely `elems' In the
>   expression: Data.List.foldr f z . elems In an equation for
>   `foldr': foldr f z = Data.List.foldr f z . elems
>
> I clearly do not understand something because I cannot make this work,
> and I am not sure why.
>
> With the Haskell type system or even with ghc extensions, can one even
> make a Data.Foldable UArray?  If so, how?
>
> Thanks in advance,
> - Marcus
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140220/af1c1841/attachment.html>

From vogt.adam at gmail.com  Fri Feb 21 01:15:31 2014
From: vogt.adam at gmail.com (adam vogt)
Date: Thu, 20 Feb 2014 20:15:31 -0500
Subject: [Haskell-cafe] hmatrix-labeled: request for comments
In-Reply-To: <87zjlm53ct.fsf@karetnikov.org>
References: <87zjlm53ct.fsf@karetnikov.org>
Message-ID: <CAHfjoWnCf_ZS+eC32JHQXV=-YMdx6rrUTu00bdcYZfrc2Own4A@mail.gmail.com>

Hi Nikita,

My package http://hackage.haskell.org/package/Rlang-QQ may be of
interest. Reading a data.frame into a HList of Vector, provided you
first coerce it to a list (as.list). That's a bit noisy if you look at
the first example of
<http://code.haskell.org/~aavogt/Rlang-QQ/examples/tests.hs>.

Another option would be to as.array the data.frame, to be able to read
it in as an array (repa or array). That limits you to having all
columns of the data frame be the same type. It should be
straightforward for RlangQQ to produce a LMatrix.

Regards,
Adam

On Wed, Feb 19, 2014 at 2:06 PM, Nikita Karetnikov
<nikita at karetnikov.org> wrote:
> I like how easy it is to import data in R and Octave.  (See [1] for a
> typical workflow.)  Since I couldn?t find any matching library on
> Hackage, I cooked up my own [2] in a couple of days.
>
> Here?s an example.  Let?s start by creating a poorly formatted dataset:
>
> $ cat > test.txt
>                          One         Two Longish   Four
>      Foo  1       -2            3.0     4.0
> Looooooong  5.0   6.0   -72.0                 8.0
>         Baz 41.0 4.2324234e7  43.0 1.111111144E-12
>
> Then we parse it with ?readFile?, mangle the data a bit, and display in
> GHCi:
>
> ?> import qualified Data.Packed.LMatrix.IO as L
> ?> import qualified Data.Packed.LMatrix as L
> ?> do m <- L.readFile "test.txt"; return . L.trans . L.reverseRows $ L.map (+1) m
> (4><3)
>                        Baz Looooooong  Foo
>     One               42.0        6.0  2.0
>     Two        4.2324235e7        7.0 -1.0
> Longish               44.0      -71.0  4.0
>    Four 1.0000000000011111        9.0  5.0
>
> Now I?m wondering how to make it better.  I?m planning to add the
> documentation, augment the parser to accept CSV, and maybe support other
> matrix libraries.  What?s missing?  Would you like to see it on Hackage?
> And if not, why?
>
> [1] http://astrostatistics.psu.edu/su09/lecturenotes/pca.html
> [2] https://gitorious.org/hmatrix-labeled
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>

From michael at snoyman.com  Fri Feb 21 06:06:18 2014
From: michael at snoyman.com (Michael Snoyman)
Date: Fri, 21 Feb 2014 08:06:18 +0200
Subject: [Haskell-cafe] Data.Foldable UArray
In-Reply-To: <53066FD6.9060302@gabriel.name>
References: <53066FD6.9060302@gabriel.name>
Message-ID: <CAKA2JgKs9-qcV933=fGqswd81tP_VbgzZ3EGgO0McXPuTmRY=Q@mail.gmail.com>

On Thu, Feb 20, 2014 at 11:12 PM, Marcus D. Gabriel <marcus at gabriel.name>wrote:

> Hello,
>
> I wanted to make a simple Data.Foldable UArray, and I naively modelled
> it on
>
> > instance Ix i => Foldable (Array i) where
> >  foldr f z = Prelude.foldr f z . elems
>
> with, of course,
>
> > instance Ix i => Foldable (UArray i) where
> > foldr f z = Prelude.foldr f z . elems
>
> which did not work yielding the following type message
>
>   Could not deduce (IArray UArray a) arising from a use of `elems'
>   from the context (Ix i) bound by the instance declaration at
>   ... Possible fix: add an instance declaration for (IArray UArray
>   a) In the second argument of `(.)', namely `elems' In the
>   expression: Data.List.foldr f z . elems In an equation for
>   `foldr': foldr f z = Data.List.foldr f z . elems
>
> I clearly do not understand something because I cannot make this work,
> and I am not sure why.
>
> With the Haskell type system or even with ghc extensions, can one even
> make a Data.Foldable UArray?  If so, how?
>
> Thanks in advance,
> - Marcus
>

You could create an instance of MonoFoldable for UArray, similar to how the
instance for unboxed vectors works[1]. There's no inherent reason why the
Array instances don't exist there yet, I simply didn't get around to adding
them yet.

[1]
https://github.com/snoyberg/mono-traversable/blob/d81bf2fe5ef4ee5957f3a5c54af07a00637c932f/src/Data/MonoTraversable.hs#L502
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140221/a8daa9d1/attachment.html>

From tom-lists-haskell-cafe-2013 at jaguarpaw.co.uk  Fri Feb 21 08:47:29 2014
From: tom-lists-haskell-cafe-2013 at jaguarpaw.co.uk (Tom Ellis)
Date: Fri, 21 Feb 2014 08:47:29 +0000
Subject: [Haskell-cafe] Data.Foldable UArray
In-Reply-To: <53066FD6.9060302@gabriel.name>
References: <53066FD6.9060302@gabriel.name>
Message-ID: <20140221084729.GH15030@weber>

On Thu, Feb 20, 2014 at 10:12:54PM +0100, Marcus D. Gabriel wrote:
> Hello,
> 
> I wanted to make a simple Data.Foldable UArray, and I naively modelled
> it on
> 
> > instance Ix i => Foldable (Array i) where
> >  foldr f z = Prelude.foldr f z . elems
> 
> with, of course,
> 
> > instance Ix i => Foldable (UArray i) where
> > foldr f z = Prelude.foldr f z . elems
> 
> which did not work yielding the following type message
> 
>   Could not deduce (IArray UArray a) arising from a use of `elems'
[...]

The problem is that the argument 'e' in 'UArray i e' is a phantom type
argument used only for looking up the relevant instance of 'IArray'.  It
doesn't actually have anything to do with the underlying contents of the
array, which is basically just a 'ByteString'.

Since all 'Foldable' functions factor through 'toList', you can't go too
wrong by using '(foldableFunction . toList) myArray' wherever you would have
wanted to use 'foldableFunction myArray'.

Tom


From daniel.trstenjak at gmail.com  Fri Feb 21 10:04:24 2014
From: daniel.trstenjak at gmail.com (Daniel Trstenjak)
Date: Fri, 21 Feb 2014 11:04:24 +0100
Subject: [Haskell-cafe] Hdevtools cabal support
In-Reply-To: <2F80D7B3-609E-4E97-A7AE-C3C235DBD989@gmail.com>
References: <2F80D7B3-609E-4E97-A7AE-C3C235DBD989@gmail.com>
Message-ID: <20140221100424.GA8528@machine>


Hi Maxim,

> I'm pretty new to Haskell, but was doing Haskell development for
> several month. I'm fan of Vim editor and was happy to find out that
> there are good tools to support Haskell development with Vim, e.g.
> vim-hdevtools. But it turned out that it not of much use in my project
> where we rely on Cabal packages and sandboxes.

You don't need to modify hdevtools to get support for cabal sandboxes.
But you have to tell hdevtools the position of the package database of
the cabal sandbox.


For vim you could use something like:

function! s:FindCabalSandbox()
   let l:sandbox    = finddir('.cabal-sandbox', './;')
   let l:absSandbox = fnamemodify(l:sandbox, ':p')
   return l:absSandbox
endfunction

function! s:FindCabalSandboxPackageConf()
   return glob(s:FindCabalSandbox() . '*-packages.conf.d')
endfunction

function! s:HaskellSourceDir()
   return fnamemodify(s:FindCabalSandbox(), ':h:h') . '/src'
endfunction

let g:hdevtools_options  = '-g-package-conf=' . s:FindCabalSandboxPackageConf()
let g:hdevtools_options .= ' ' . '-g-i' . s:HaskellSourceDir()


This also assumes, that your Haskell source code is contained in a
directory named 'src' which lies in the same directory then your
projects cabal file.


Using hdevtools this way is more generic than modify it, because this
solution also works for cabal-dev or any other package database.


Greetings,
Daniel

From daniel.trstenjak at gmail.com  Fri Feb 21 10:11:10 2014
From: daniel.trstenjak at gmail.com (Daniel Trstenjak)
Date: Fri, 21 Feb 2014 11:11:10 +0100
Subject: [Haskell-cafe] Hdevtools cabal support
In-Reply-To: <2F80D7B3-609E-4E97-A7AE-C3C235DBD989@gmail.com>
References: <2F80D7B3-609E-4E97-A7AE-C3C235DBD989@gmail.com>
Message-ID: <20140221101110.GA8973@machine>


Hi Maxim,

> I'm pretty new to Haskell, but was doing Haskell development for
> several month. I'm fan of Vim editor and was happy to find out that
> there are good tools to support Haskell development with Vim, e.g.
> vim-hdevtools. But it turned out that it not of much use in my project
> where we rely on Cabal packages and sandboxes.

You don't need to modify hdevtools to get support for cabal sandboxes.
But you have to tell hdevtools the position of the package database of
the cabal sandbox.


For vim you could use something like:

function! s:FindCabalSandbox()
   let l:sandbox    = finddir('.cabal-sandbox', './;')
   let l:absSandbox = fnamemodify(l:sandbox, ':p')
   return l:absSandbox
endfunction

function! s:FindCabalSandboxPackageConf()
   return glob(s:FindCabalSandbox() . '*-packages.conf.d')
endfunction

function! s:HaskellSourceDir()
   return fnamemodify(s:FindCabalSandbox(), ':h:h') . '/src'
endfunction

let g:hdevtools_options  = '-g-package-conf=' . s:FindCabalSandboxPackageConf()
let g:hdevtools_options .= ' ' . '-g-i' . s:HaskellSourceDir()


This also assumes, that your Haskell source code is contained in a
directory named 'src' which lies in the same directory then your
projects cabal file.


Using hdevtools this way is more generic than modify it, because this
solution also works for cabal-dev or any other package database.


Greetings,
Daniel

From dominic at steinitz.org  Fri Feb 21 11:06:15 2014
From: dominic at steinitz.org (Dominic Steinitz)
Date: Fri, 21 Feb 2014 11:06:15 +0000
Subject: [Haskell-cafe] Haskell Statistics
Message-ID: <2361A000-E534-4FE9-8FCE-3A5AC956A932@steinitz.org>

Hi

I am looking for statistics on usage of Haskell, ghc and the Haskell Platform and their growth. Current usage would be great but I?d also like usage by year or month. Useful proxies might be number of people signed up to haskell-cafe and #haskell (also by year or month). The impression I have from the number of jobs posted recently is that Haskell is experiencing some growth.

I have the redmonk stats: http://redmonk.com/sogrady/category/programming-languages/ and http://sogrady-media.redmonk.com/sogrady/files/2014/01/lang-rank-114-wm.png which shows that Haskell is maintaining its position.

My google trend analysis shows Haskell roughly matching Scala and both of them somewhat higher than F#. I admit to being a google trend novice so caveat lector!
I have this using google trends: http://www.google.com/trends/explore#q=haskell%20programming%2C%20scala%20programming%2C%20f%23%20programming&cmpt=q

Thanks in advance for any help in this.

Dominic Steinitz
dominic at steinitz.org
http://idontgetoutmuch.wordpress.com


From maxim.kulkin at gmail.com  Fri Feb 21 11:29:01 2014
From: maxim.kulkin at gmail.com (Maxim Kulkin)
Date: Fri, 21 Feb 2014 15:29:01 +0400
Subject: [Haskell-cafe] Hdevtools cabal support
In-Reply-To: <20140221101110.GA8973@machine>
References: <2F80D7B3-609E-4E97-A7AE-C3C235DBD989@gmail.com>
 <20140221101110.GA8973@machine>
Message-ID: <CAORmg62dhZWD=rdZeReXpoHDJsMGFLg1S4FKMet_XE7+1ymtNg@mail.gmail.com>

Oh, thank you, Sir, for pointing that out.

I was aware of this hackish vim-script. I even tried to use that but fell
into lots of corner cases and dropped. It does not handle inter-package
dependencies, haskell language extensions, different code or sandbox layout.
Although currently it has limitations (locked to particular ghc and cabal
versions) I personally find it way more easy to use.
I believe, with release of GHC-7.8, Cabal-1.18 will become ubiquitous,
bringing sandbox support out of the box. With evolving of the compiler I do
not see why dev tools shouldn't evolve too. If someone uses cabal-dev, I
would happy to see him adding support for it to hdevtools. BTW, cabal-dev
just changes the sandbox layout, other things are left unchanged, so you
can still benefit from having cabal support in hdevtools. You just need to
pass location of cabal-dev sandboxed package db explicitly (via "-g"
option).


On Fri, Feb 21, 2014 at 2:11 PM, Daniel Trstenjak <
daniel.trstenjak at gmail.com> wrote:

>
> Hi Maxim,
>
> > I'm pretty new to Haskell, but was doing Haskell development for
> > several month. I'm fan of Vim editor and was happy to find out that
> > there are good tools to support Haskell development with Vim, e.g.
> > vim-hdevtools. But it turned out that it not of much use in my project
> > where we rely on Cabal packages and sandboxes.
>
> You don't need to modify hdevtools to get support for cabal sandboxes.
> But you have to tell hdevtools the position of the package database of
> the cabal sandbox.
>
>
> For vim you could use something like:
>
> function! s:FindCabalSandbox()
>    let l:sandbox    = finddir('.cabal-sandbox', './;')
>    let l:absSandbox = fnamemodify(l:sandbox, ':p')
>    return l:absSandbox
> endfunction
>
> function! s:FindCabalSandboxPackageConf()
>    return glob(s:FindCabalSandbox() . '*-packages.conf.d')
> endfunction
>
> function! s:HaskellSourceDir()
>    return fnamemodify(s:FindCabalSandbox(), ':h:h') . '/src'
> endfunction
>
> let g:hdevtools_options  = '-g-package-conf=' .
> s:FindCabalSandboxPackageConf()
> let g:hdevtools_options .= ' ' . '-g-i' . s:HaskellSourceDir()
>
>
> This also assumes, that your Haskell source code is contained in a
> directory named 'src' which lies in the same directory then your
> projects cabal file.
>
>
> Using hdevtools this way is more generic than modify it, because this
> solution also works for cabal-dev or any other package database.
>
>
> Greetings,
> Daniel
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140221/a4d28720/attachment.html>

From daniel.trstenjak at gmail.com  Fri Feb 21 12:05:47 2014
From: daniel.trstenjak at gmail.com (Daniel Trstenjak)
Date: Fri, 21 Feb 2014 13:05:47 +0100
Subject: [Haskell-cafe] Hdevtools cabal support
In-Reply-To: <CAORmg62dhZWD=rdZeReXpoHDJsMGFLg1S4FKMet_XE7+1ymtNg@mail.gmail.com>
References: <2F80D7B3-609E-4E97-A7AE-C3C235DBD989@gmail.com>
 <20140221101110.GA8973@machine>
 <CAORmg62dhZWD=rdZeReXpoHDJsMGFLg1S4FKMet_XE7+1ymtNg@mail.gmail.com>
Message-ID: <20140221120547.GA11244@machine>


Hi Maxim,

> I was aware of this hackish vim-script. I even tried to use that but fell into
> lots of corner cases and dropped. It does not handle inter-package
> dependencies, haskell language extensions, different code or sandbox layout.

It's definitively nice to reuse the information of the cabal file, I
just don't like the coupling of tools that much.

Also there seems to be duplicate effort for supporting cabal sandboxes in
ghc-mod and hdevtools.

It would be nice to have a tool that extracts the ghc relevant options
from the cabal file which then could be used by ghc-mod, hdevtools or
any other tool that wants to use ghc in conjunction with cabal.

Getting the ghc options right you also have to use the right cabal
section (which executable, library, which test suite ...), so a seperate
tool could nicely support this.


Greetings,
Daniel

From alan.zimm at gmail.com  Fri Feb 21 12:09:28 2014
From: alan.zimm at gmail.com (AlanKim Zimmerman)
Date: Fri, 21 Feb 2014 14:09:28 +0200
Subject: [Haskell-cafe] Hdevtools cabal support
In-Reply-To: <20140221120547.GA11244@machine>
References: <2F80D7B3-609E-4E97-A7AE-C3C235DBD989@gmail.com>
 <20140221101110.GA8973@machine>
 <CAORmg62dhZWD=rdZeReXpoHDJsMGFLg1S4FKMet_XE7+1ymtNg@mail.gmail.com>
 <20140221120547.GA11244@machine>
Message-ID: <CANma=H9-XjdZmyc=G0TJfZKwUf0vyoBA=uEddO8tLRDDs5TbGg@mail.gmail.com>

In terms of using the right section of cabal, in the dev/editor environment
you actually need to union of all the cabal targets, so all the various
hs-src directories etc are in scope.

Alan


On Fri, Feb 21, 2014 at 2:05 PM, Daniel Trstenjak <
daniel.trstenjak at gmail.com> wrote:

>
> Hi Maxim,
>
> > I was aware of this hackish vim-script. I even tried to use that but
> fell into
> > lots of corner cases and dropped. It does not handle inter-package
> > dependencies, haskell language extensions, different code or sandbox
> layout.
>
> It's definitively nice to reuse the information of the cabal file, I
> just don't like the coupling of tools that much.
>
> Also there seems to be duplicate effort for supporting cabal sandboxes in
> ghc-mod and hdevtools.
>
> It would be nice to have a tool that extracts the ghc relevant options
> from the cabal file which then could be used by ghc-mod, hdevtools or
> any other tool that wants to use ghc in conjunction with cabal.
>
> Getting the ghc options right you also have to use the right cabal
> section (which executable, library, which test suite ...), so a seperate
> tool could nicely support this.
>
>
> Greetings,
> Daniel
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140221/5cb584b2/attachment.html>

From daniel.trstenjak at gmail.com  Fri Feb 21 12:22:30 2014
From: daniel.trstenjak at gmail.com (Daniel Trstenjak)
Date: Fri, 21 Feb 2014 13:22:30 +0100
Subject: [Haskell-cafe] Hdevtools cabal support
In-Reply-To: <CANma=H9-XjdZmyc=G0TJfZKwUf0vyoBA=uEddO8tLRDDs5TbGg@mail.gmail.com>
References: <2F80D7B3-609E-4E97-A7AE-C3C235DBD989@gmail.com>
 <20140221101110.GA8973@machine>
 <CAORmg62dhZWD=rdZeReXpoHDJsMGFLg1S4FKMet_XE7+1ymtNg@mail.gmail.com>
 <20140221120547.GA11244@machine>
 <CANma=H9-XjdZmyc=G0TJfZKwUf0vyoBA=uEddO8tLRDDs5TbGg@mail.gmail.com>
Message-ID: <20140221122230.GA11723@machine>


Hi Alan,

On Fri, Feb 21, 2014 at 02:09:28PM +0200, AlanKim Zimmerman wrote:
> In terms of using the right section of cabal, in the dev/editor environment you
> actually need to union of all the cabal targets, so all the various hs-src
> directories etc are in scope.

You might get an issue by doing it that way, just think about two
executables having modules with the same name.

I think the "right" way might be to find the associated cabal target
for the current source file.

But I don't know if it's possible to always get a unique cabal target.


Greetings,
Daniel

From alan.zimm at gmail.com  Fri Feb 21 12:36:34 2014
From: alan.zimm at gmail.com (AlanKim Zimmerman)
Date: Fri, 21 Feb 2014 14:36:34 +0200
Subject: [Haskell-cafe] Hdevtools cabal support
In-Reply-To: <20140221122230.GA11723@machine>
References: <2F80D7B3-609E-4E97-A7AE-C3C235DBD989@gmail.com>
 <20140221101110.GA8973@machine>
 <CAORmg62dhZWD=rdZeReXpoHDJsMGFLg1S4FKMet_XE7+1ymtNg@mail.gmail.com>
 <20140221120547.GA11244@machine>
 <CANma=H9-XjdZmyc=G0TJfZKwUf0vyoBA=uEddO8tLRDDs5TbGg@mail.gmail.com>
 <20140221122230.GA11723@machine>
Message-ID: <CANma=H9NFu3-0taFK6KvtJG4oxxqbp-D0urmv-OUh7-e7StPJQ@mail.gmail.com>

What I am doing in HaRe (as a trial at this stage) is to load the module
graph for each cabal target in turn, and take the union of all non-Main
modules. This will work for a large proportion of cabal files.

Where something special is going on in terms of e.g. flags pulling on one
of two mutually exclusive files with the same name, a different approach
will be needed, probably by specifying how to break the tie in a config
section for the tool.

But I agree that a separate tool could be useful for this, I am pretty sure
BuildWrapper is wrestling with the same problem.

Alan



On Fri, Feb 21, 2014 at 2:22 PM, Daniel Trstenjak <
daniel.trstenjak at gmail.com> wrote:

>
> Hi Alan,
>
> On Fri, Feb 21, 2014 at 02:09:28PM +0200, AlanKim Zimmerman wrote:
> > In terms of using the right section of cabal, in the dev/editor
> environment you
> > actually need to union of all the cabal targets, so all the various
> hs-src
> > directories etc are in scope.
>
> You might get an issue by doing it that way, just think about two
> executables having modules with the same name.
>
> I think the "right" way might be to find the associated cabal target
> for the current source file.
>
> But I don't know if it's possible to always get a unique cabal target.
>
>
> Greetings,
> Daniel
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140221/84fb29c3/attachment.html>

From jmacristovao at gmail.com  Fri Feb 21 12:37:32 2014
From: jmacristovao at gmail.com (=?ISO-8859-1?B?Sm/jbyBDcmlzdPN2428=?=)
Date: Fri, 21 Feb 2014 12:37:32 +0000
Subject: [Haskell-cafe] Hdevtools cabal support
In-Reply-To: <20140221122230.GA11723@machine>
References: <2F80D7B3-609E-4E97-A7AE-C3C235DBD989@gmail.com>
 <20140221101110.GA8973@machine>
 <CAORmg62dhZWD=rdZeReXpoHDJsMGFLg1S4FKMet_XE7+1ymtNg@mail.gmail.com>
 <20140221120547.GA11244@machine>
 <CANma=H9-XjdZmyc=G0TJfZKwUf0vyoBA=uEddO8tLRDDs5TbGg@mail.gmail.com>
 <20140221122230.GA11723@machine>
Message-ID: <CAAbu24oAJ8mAdmMbJj0jp4NzKPnn2oM4B_rTM4TVwxFMep=jNw@mail.gmail.com>

> It would be nice to have a tool that extracts the ghc relevant options
> from the cabal file which then could be used by ghc-mod, hdevtools or
> any other tool that wants to use ghc in conjunction with cabal.

Personally, I would like that very much, and I would be an active user.

Why not just a parameter, much like cabal own behaviour:

cabal build - sane default
cabal build exe:whatever - build executable whatever
babal build lib:whatever - build executable whatever

Its not really critical that the default is a cover all scenario, as long
as you have those other options. Then you could just configure an editor
(vim) setting to manually tell it what should it do.

I would prefer that, even if it meant a little more configuration work,
than having a 'merge all' situation that does, typically, more harm than
good.

> I think the "right" way might be to find the associated cabal target
> for the current source file.

I also have doubts that this is possible.

Cheers,
Jo?o


2014-02-21 12:22 GMT+00:00 Daniel Trstenjak <daniel.trstenjak at gmail.com>:

>
> Hi Alan,
>
> On Fri, Feb 21, 2014 at 02:09:28PM +0200, AlanKim Zimmerman wrote:
> > In terms of using the right section of cabal, in the dev/editor
> environment you
> > actually need to union of all the cabal targets, so all the various
> hs-src
> > directories etc are in scope.
>
> You might get an issue by doing it that way, just think about two
> executables having modules with the same name.
>
> I think the "right" way might be to find the associated cabal target
> for the current source file.
>
> But I don't know if it's possible to always get a unique cabal target.
>
>
> Greetings,
> Daniel
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140221/9d0ea947/attachment.html>

From maxim.kulkin at gmail.com  Fri Feb 21 12:51:45 2014
From: maxim.kulkin at gmail.com (Maxim Kulkin)
Date: Fri, 21 Feb 2014 16:51:45 +0400
Subject: [Haskell-cafe] Hdevtools cabal support
In-Reply-To: <CANma=H9-XjdZmyc=G0TJfZKwUf0vyoBA=uEddO8tLRDDs5TbGg@mail.gmail.com>
References: <2F80D7B3-609E-4E97-A7AE-C3C235DBD989@gmail.com>
 <20140221101110.GA8973@machine>
 <CAORmg62dhZWD=rdZeReXpoHDJsMGFLg1S4FKMet_XE7+1ymtNg@mail.gmail.com>
 <20140221120547.GA11244@machine>
 <CANma=H9-XjdZmyc=G0TJfZKwUf0vyoBA=uEddO8tLRDDs5TbGg@mail.gmail.com>
Message-ID: <CAORmg61NbKXDNCFvz-Re8wdGjN_rq4C6w5pZzykOrg5FqVOfaQ@mail.gmail.com>

This is what I do currently, although I'm not sure if this won't cause
troubles.

As of ghc-mod: as far as I understand (didn't dig into this much, just read
in hdevtools documentation), hdevtools is just ghc-mod with client-server
architecture, so that it supports incremental recompiles (and thus faster
for subsequent invocations). If this is so, I do not see reason to continue
supporting ghc-mod.


On Fri, Feb 21, 2014 at 4:09 PM, AlanKim Zimmerman <alan.zimm at gmail.com>wrote:

> In terms of using the right section of cabal, in the dev/editor
> environment you actually need to union of all the cabal targets, so all the
> various hs-src directories etc are in scope.
>
> Alan
>
>
> On Fri, Feb 21, 2014 at 2:05 PM, Daniel Trstenjak <
> daniel.trstenjak at gmail.com> wrote:
>
>>
>> Hi Maxim,
>>
>> > I was aware of this hackish vim-script. I even tried to use that but
>> fell into
>> > lots of corner cases and dropped. It does not handle inter-package
>> > dependencies, haskell language extensions, different code or sandbox
>> layout.
>>
>> It's definitively nice to reuse the information of the cabal file, I
>> just don't like the coupling of tools that much.
>>
>> Also there seems to be duplicate effort for supporting cabal sandboxes in
>> ghc-mod and hdevtools.
>>
>> It would be nice to have a tool that extracts the ghc relevant options
>> from the cabal file which then could be used by ghc-mod, hdevtools or
>> any other tool that wants to use ghc in conjunction with cabal.
>>
>> Getting the ghc options right you also have to use the right cabal
>> section (which executable, library, which test suite ...), so a seperate
>> tool could nicely support this.
>>
>>
>> Greetings,
>> Daniel
>> _______________________________________________
>> Haskell-Cafe mailing list
>> Haskell-Cafe at haskell.org
>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>
>
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140221/d4635a34/attachment.html>

From maxim.kulkin at gmail.com  Fri Feb 21 13:00:49 2014
From: maxim.kulkin at gmail.com (Maxim Kulkin)
Date: Fri, 21 Feb 2014 17:00:49 +0400
Subject: [Haskell-cafe] Hdevtools cabal support
In-Reply-To: <CAAbu24oAJ8mAdmMbJj0jp4NzKPnn2oM4B_rTM4TVwxFMep=jNw@mail.gmail.com>
References: <2F80D7B3-609E-4E97-A7AE-C3C235DBD989@gmail.com>
 <20140221101110.GA8973@machine>
 <CAORmg62dhZWD=rdZeReXpoHDJsMGFLg1S4FKMet_XE7+1ymtNg@mail.gmail.com>
 <20140221120547.GA11244@machine>
 <CANma=H9-XjdZmyc=G0TJfZKwUf0vyoBA=uEddO8tLRDDs5TbGg@mail.gmail.com>
 <20140221122230.GA11723@machine>
 <CAAbu24oAJ8mAdmMbJj0jp4NzKPnn2oM4B_rTM4TVwxFMep=jNw@mail.gmail.com>
Message-ID: <CAORmg63_XtKxX3sAC39=XUJ59=VSWuraSV_W_jA5guLRdP3zBw@mail.gmail.com>

Having to manually set up cabal target explicitly won't work if you e.g.
develop a library and unit tests for it and switch between test and library
modules (which are obviously different targets in cabal file).

I think the best approach would be to determine a first cabal target source
file belongs to and using it. This won't expose problems that would occur
bulding other targets that also use that file, but I guess it is ok.

Also, I was thinking about adding suport for passing cabal options to allow
e.g. using different flags.



On Fri, Feb 21, 2014 at 4:37 PM, Jo?o Crist?v?o <jmacristovao at gmail.com>wrote:

> > It would be nice to have a tool that extracts the ghc relevant options
> > from the cabal file which then could be used by ghc-mod, hdevtools or
> > any other tool that wants to use ghc in conjunction with cabal.
>
> Personally, I would like that very much, and I would be an active user.
>
> Why not just a parameter, much like cabal own behaviour:
>
> cabal build - sane default
> cabal build exe:whatever - build executable whatever
> babal build lib:whatever - build executable whatever
>
> Its not really critical that the default is a cover all scenario, as long
> as you have those other options. Then you could just configure an editor
> (vim) setting to manually tell it what should it do.
>
> I would prefer that, even if it meant a little more configuration work,
> than having a 'merge all' situation that does, typically, more harm than
> good.
>
> > I think the "right" way might be to find the associated cabal target
> > for the current source file.
>
> I also have doubts that this is possible.
>
> Cheers,
> Jo?o
>
>
> 2014-02-21 12:22 GMT+00:00 Daniel Trstenjak <daniel.trstenjak at gmail.com>:
>
>
>> Hi Alan,
>>
>> On Fri, Feb 21, 2014 at 02:09:28PM +0200, AlanKim Zimmerman wrote:
>> > In terms of using the right section of cabal, in the dev/editor
>> environment you
>> > actually need to union of all the cabal targets, so all the various
>> hs-src
>> > directories etc are in scope.
>>
>> You might get an issue by doing it that way, just think about two
>> executables having modules with the same name.
>>
>> I think the "right" way might be to find the associated cabal target
>> for the current source file.
>>
>> But I don't know if it's possible to always get a unique cabal target.
>>
>>
>> Greetings,
>> Daniel
>> _______________________________________________
>> Haskell-Cafe mailing list
>> Haskell-Cafe at haskell.org
>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>
>
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140221/56c0eef7/attachment.html>

From mark.lentczner at gmail.com  Fri Feb 21 14:51:10 2014
From: mark.lentczner at gmail.com (Mark Lentczner)
Date: Fri, 21 Feb 2014 06:51:10 -0800
Subject: [Haskell-cafe] Haskell Platform website error
In-Reply-To: <20140219213435.GA10388@sniper>
References: <CA+aFgYB5oyqo4UnQOxgPuvSysg31W5nWfzL03MqAKYe=TA-86Q@mail.gmail.com>
 <CALnXJipHMzwjVfQ6XYUoohQQMvAZDdWjQ8GUxDQTF=zr2bLwpQ@mail.gmail.com>
 <F8F9D27F-5E27-4368-83AC-BAEA2582ABDE@gmail.com>
 <CAKFCL4UzMSxHwjh5Y3XpwV_=1xuVRM8Ugnmn=WHTTtdw3xBRdw@mail.gmail.com>
 <20140219154514.GA2216@sniper>
 <CALnXJiqJiDFvafRXdG5ktqRbUydWjitY3JcJNznsQ=Z0vXw7mQ@mail.gmail.com>
 <CAKFCL4VrNZcArWe1xsG=0WfymJ+Oh6vWtNjyifM-PGE55RCwzw@mail.gmail.com>
 <20140219213435.GA10388@sniper>
Message-ID: <CAAOoiFbqJ2=NdSwn+DWs89wr82FUEq=T44_bYdkxnrtZo=PhYg@mail.gmail.com>

If you'd like to come help Haskell Platform, please join the mailing
list: *haskell-platform at projects.haskell.org
<haskell-platform at projects.haskell.org>*

Work on the platform tends to be very seasonal. I apologize for not getting
web fixes in sooner.

There are some bigger changes afoot with the platform. For one, I'm deep in
the middle of recoding the entire build system for it with several aims:

   - A fully automated build (based on shake) of both the source tarball,
   generic linux, and OS targets
   - Ability to run on build bots and validate as we improve the platform
   - Support for running validation tests of included packages
   - Automatic generation of most of the web site (currently all by hand)
   - Generation of "what version of package x is in HP y?" chart

With these changes we should be able to "turn the crank" more quickly, be
able to put out point releases if bugs in packages warrant, and focus our
energies on getting more diverse packages under the platform umbrella.

If you'd like to help with the project, here are some pots that need
stirring:

   - New web site design. Current one is stale, and probably isn't the best
   way to present the info. (*)
   - We are in issue tracking hell: The project uses trac, but many people
   use github to file bugs and features. This needs sorting out, cleaning up,
   and migrating all one way or the other. Then the list needs curation.
   - Automating builds for various OS targets (*)
   - Bringing existing packages under test. That is, where packages have
   tests, getting the new build system to use them. (*)
   - Writing some form of "whole system test" for the platform. Perhaps
   compiling pandoc is sufficient! :-) Or perhaps several key applications
   (real or synthetic) that cover the platform. It would be nice to be able to
   validate that a build and install works!

Now, items marked (*) may want to wait a week or two until I have the first
version of the new build up on github... but finding volunteers for these
would be great.

- Mark "waiting for quarter million lines to compile? again" Lentczner
  Release Manager, Haskell Platform

*P.S.: The platform now adds 34 packages to the GHC core: 248k lines of
source in 1.6k files, of which 164k lines are haskell in 1.1k files!*
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140221/998c2a15/attachment.html>

From rodrigogribeiro at gmail.com  Fri Feb 21 18:52:35 2014
From: rodrigogribeiro at gmail.com (Rodrigo Ribeiro)
Date: Fri, 21 Feb 2014 15:52:35 -0300
Subject: [Haskell-cafe] Problems on installing sizes-types package
Message-ID: <CAOViy-qQHtFTd9_2hYd4=K6eDrJqzW8QfPoLvD+wPCcrOCJt2g@mail.gmail.com>

Hello to all!

I'm trying to install the sized-types package, a dependency for kansas lava:

http://hackage.haskell.org/package/sized-types

using cabal, and the following error message is returned:

Data/Sized/Sparse/Matrix.hs:61:26:
    Could not deduce (Eq a) arising from a use of `prune'
    from the context (Size m, Size n, Size m', Size n', n ~ m', Num a)
      bound by the type signature for
                 mm :: (Size m, Size n, Size m', Size n', n ~ m', Num a) =>
                       Matrix (m, n) a -> Matrix (m', n') a -> Matrix (m,
n') a
      at Data/Sized/Sparse/Matrix.hs:50:7-112

Is it a known issue? Is there some way to solve it? I'm using GHC 7.6.3 and
plataform 2013.2.0.0.

Best,

Rodrigo
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140221/d4414a8c/attachment.html>

From fuuzetsu at fuuzetsu.co.uk  Fri Feb 21 19:01:34 2014
From: fuuzetsu at fuuzetsu.co.uk (Mateusz Kowalczyk)
Date: Fri, 21 Feb 2014 19:01:34 +0000
Subject: [Haskell-cafe] Problems on installing sizes-types package
In-Reply-To: <CAOViy-qQHtFTd9_2hYd4=K6eDrJqzW8QfPoLvD+wPCcrOCJt2g@mail.gmail.com>
References: <CAOViy-qQHtFTd9_2hYd4=K6eDrJqzW8QfPoLvD+wPCcrOCJt2g@mail.gmail.com>
Message-ID: <5307A28E.4000702@fuuzetsu.co.uk>

On 21/02/14 18:52, Rodrigo Ribeiro wrote:
> Hello to all!
> 
> I'm trying to install the sized-types package, a dependency for kansas lava:
> 
> http://hackage.haskell.org/package/sized-types
> 
> using cabal, and the following error message is returned:
> 
> Data/Sized/Sparse/Matrix.hs:61:26:
>     Could not deduce (Eq a) arising from a use of `prune'
>     from the context (Size m, Size n, Size m', Size n', n ~ m', Num a)
>       bound by the type signature for
>                  mm :: (Size m, Size n, Size m', Size n', n ~ m', Num a) =>
>                        Matrix (m, n) a -> Matrix (m', n') a -> Matrix (m,
> n') a
>       at Data/Sized/Sparse/Matrix.hs:50:7-112
> 
> Is it a known issue? Is there some way to solve it? I'm using GHC 7.6.3 and
> plataform 2013.2.0.0.
> 
> Best,
> 
> Rodrigo
> 
> 
> 
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
> 

You can just add the ?Eq a? constraint to the relevant line and it all
compiles fine with 7.6.3. It might be worth-while to e-mail the authors
and ask for a new release with the fix in place (and removing all the
hard tabs from the code?). You can use ?cabal unpack sized-types? to
fetch the package source, make the change and then ?cabal install? it
from there.

The relevant line becomes:
mm :: (Eq a, Size m, Size n, Size m', Size n', n ~ m', Num a) => Matrix
(m,n) a -> Matrix (m',n') a -> Matrix (m,n') a

-- 
Mateusz K.

From marcus at gabriel.name  Fri Feb 21 20:30:12 2014
From: marcus at gabriel.name (Marcus D. Gabriel)
Date: Fri, 21 Feb 2014 21:30:12 +0100
Subject: [Haskell-cafe] Data.Foldable UArray
In-Reply-To: <20140221084729.GH15030@weber>
References: <53066FD6.9060302@gabriel.name> <20140221084729.GH15030@weber>
Message-ID: <5307B754.4050501@gabriel.name>

Hello Tom,

Basically, I follow what you have written but ...

We have

> Prelude> :k Data.Array.Unboxed.UArray
> Data.Array.Unboxed.UArray :: * -> * -> *

which is why I tried my first naive solution.  I note that we have also

> Prelude> :k Data.Array.IArray.IArray
> Data.Array.IArray.IArray :: (* -> * -> *) -> * -> Constraint

This last one I do not follow.  A short explanation and/or a pointer
to some documentation would help.

Thanks,
- Marcus

On 21/02/2014 09:47, Tom Ellis wrote:
> On Thu, Feb 20, 2014 at 10:12:54PM +0100, Marcus D. Gabriel wrote:
>> Hello,
>>
>> I wanted to make a simple Data.Foldable UArray, and I naively modelled
>> it on
>>
>>> instance Ix i => Foldable (Array i) where
>>>  foldr f z = Prelude.foldr f z . elems
>> with, of course,
>>
>>> instance Ix i => Foldable (UArray i) where
>>> foldr f z = Prelude.foldr f z . elems
>> which did not work yielding the following type message
>>
>>   Could not deduce (IArray UArray a) arising from a use of `elems'
> [...]
>
> The problem is that the argument 'e' in 'UArray i e' is a phantom type
> argument used only for looking up the relevant instance of 'IArray'.  It
> doesn't actually have anything to do with the underlying contents of the
> array, which is basically just a 'ByteString'.
>
> Since all 'Foldable' functions factor through 'toList', you can't go too
> wrong by using '(foldableFunction . toList) myArray' wherever you would have
> wanted to use 'foldableFunction myArray'.
>
> Tom

From tom-lists-haskell-cafe-2013 at jaguarpaw.co.uk  Fri Feb 21 21:14:33 2014
From: tom-lists-haskell-cafe-2013 at jaguarpaw.co.uk (Tom Ellis)
Date: Fri, 21 Feb 2014 21:14:33 +0000
Subject: [Haskell-cafe] Data.Foldable UArray
In-Reply-To: <5307B754.4050501@gabriel.name>
References: <53066FD6.9060302@gabriel.name> <20140221084729.GH15030@weber>
 <5307B754.4050501@gabriel.name>
Message-ID: <20140221211433.GT15030@weber>

On Fri, Feb 21, 2014 at 09:30:12PM +0100, Marcus D. Gabriel wrote:
> > Prelude> :k Data.Array.Unboxed.UArray
> > Data.Array.Unboxed.UArray :: * -> * -> *
> 
> which is why I tried my first naive solution.

Hi Marcus,

This means that 'UArray' is a type constructor of two arguments, i.e. for
types 'i' and 'e'

    UArray i e

is a type.  It is an array that is indexed by elements of type 'i' (which
would typically be something like 'Int' in practice).  It is also declaring
that ostensibly it contains unboxed values of type 'e' (which in practice
could be 'Bool', 'Char', 'Int', 'Double' and many other things besides). 
For example, a type of an unboxed array you might use could be

    UArray Int Double

an array of doubles indexed by ints.  However if you look at the definition
of 'UArray'

    http://hackage.haskell.org/package/array-0.5.0.0/docs/src/Data-Array-Base.html#UArray

you will see that the 'e' type parameter is not actually used in the
definition of the datatype!  It is a so-called "phantom type".  The datatype
doesn't "actually" contain any 'e's.  Instead it contains a ByteString into
which certain 'e's can be written in a way which is in a sense "unsafe" but
only a "safe" interface is provided.  (See below).

> I note that we have also
>
> > Prelude> :k Data.Array.IArray.IArray
> > Data.Array.IArray.IArray :: (* -> * -> *) -> * -> Constraint
> 
> This last one I do not follow.  A short explanation and/or a pointer
> to some documentation would help.

'IArray' is a typeclass, in this case essentially used as means of providing
a standard interface to arrays.  The kind signature above means that the
interface is parametrised by the array constructor (of kind * -> * -> *,
like UArray, see above) and the type of the index.  If you give 'IArray' an
array constructor and an index type you get a 'Constraint', in this case a
typeclass context which essentially provides you with an interface to access
your 'UArray' with.

However, these constructions are not suitible for making an instance of
Foldable, because Foldable would require implementing functions that are
uniform in the way they treat the type argument 'e', and as we've seen, the
usage of 'e' in the datatype and interface is far from uniform.

Hope that helps,

Tom

From marcus at gabriel.name  Fri Feb 21 21:27:21 2014
From: marcus at gabriel.name (Marcus D. Gabriel)
Date: Fri, 21 Feb 2014 22:27:21 +0100
Subject: [Haskell-cafe] Data.Foldable UArray
In-Reply-To: <20140221211433.GT15030@weber>
References: <53066FD6.9060302@gabriel.name> <20140221084729.GH15030@weber>
 <5307B754.4050501@gabriel.name> <20140221211433.GT15030@weber>
Message-ID: <5307C4B9.4000100@gabriel.name>

Yes, Tom it does help.  I will not cogitate on this in the morning.

- Marcus

On 21/02/2014 22:14, Tom Ellis wrote:
> On Fri, Feb 21, 2014 at 09:30:12PM +0100, Marcus D. Gabriel wrote:
>>> Prelude> :k Data.Array.Unboxed.UArrays
>>> Data.Array.Unboxed.UArray :: * -> * -> *
>> which is why I tried my first naive solution.
> Hi Marcus,
>
> This means that 'UArray' is a type constructor of two arguments, i.e. for
> types 'i' and 'e'
>
>     UArray i e
>
> is a type.  It is an array that is indexed by elements of type 'i' (which
> would typically be something like 'Int' in practice).  It is also declaring
> that ostensibly it contains unboxed values of type 'e' (which in practice
> could be 'Bool', 'Char', 'Int', 'Double' and many other things besides). 
> For example, a type of an unboxed array you might use could be
>
>     UArray Int Double
>
> an array of doubles indexed by ints.  However if you look at the definition
> of 'UArray'
>
>     http://hackage.haskell.org/package/array-0.5.0.0/docs/src/Data-Array-Base.html#UArray
>
> you will see that the 'e' type parameter is not actually used in the
> definition of the datatype!  It is a so-called "phantom type".  The datatype
> doesn't "actually" contain any 'e's.  Instead it contains a ByteString into
> which certain 'e's can be written in a way which is in a sense "unsafe" but
> only a "safe" interface is provided.  (See below).
>
>> I note that we have also
>>
>>> Prelude> :k Data.Array.IArray.IArray
>>> Data.Array.IArray.IArray :: (* -> * -> *) -> * -> Constraint
>> This last one I do not follow.  A short explanation and/or a pointer
>> to some documentation would help.
> 'IArray' is a typeclass, in this case essentially used as means of providing
> a standard interface to arrays.  The kind signature above means that the
> interface is parametrised by the array constructor (of kind * -> * -> *,
> like UArray, see above) and the type of the index.  If you give 'IArray' an
> array constructor and an index type you get a 'Constraint', in this case a
> typeclass context which essentially provides you with an interface to access
> your 'UArray' with.
>
> However, these constructions are not suitible for making an instance of
> Foldable, because Foldable would require implementing functions that are
> uniform in the way they treat the type argument 'e', and as we've seen, the
> usage of 'e' in the datatype and interface is far from uniform.
>
> Hope that helps,
>
> Tom

From joey at kitenet.net  Fri Feb 21 22:07:18 2014
From: joey at kitenet.net (Joey Hess)
Date: Fri, 21 Feb 2014 18:07:18 -0400
Subject: [Haskell-cafe] Hdevtools cabal support
In-Reply-To: <2F80D7B3-609E-4E97-A7AE-C3C235DBD989@gmail.com>
References: <2F80D7B3-609E-4E97-A7AE-C3C235DBD989@gmail.com>
Message-ID: <20140221220718.GA14325@kitenet.net>

Maxim Kulkin wrote:
> I'm pretty new to Haskell, but was doing Haskell development for several month. I'm fan of Vim editor and was happy to find out that there are good tools to support Haskell development with Vim, e.g. vim-hdevtools. But it turned out that it not of much use in my project where we rely on Cabal packages and sandboxes.
> 
> As part of scratching own itch I have implemented support for Cabal packages for Hdevtools.

Sandboxes aside, there seem to be plenty of reasons for hdevtools to
integrate with cabal.

To use hdevtools in one of my projects, I have to run it like this.

hdevtools check git-annex.hs -g -cpp -g -i -g -idist/build/git-annex/git-annex-tmp -g -i. -g -idist/build/autogen -g -Idist/build/autogen -g -Idist/build/git-annex/git-annex-tmp -g -IUtility -g -DWITH_TESTSUITE -g -DWITH_S3 -g -DWITH_ASSISTANT -g -DWITH_INOTIFY -g -DWITH_DBUS -g -DWITH_PAIRING -g -DWITH_XMPP -g -optP-include -g -optPdist/build/autogen/cabal_macros.h -g -odir -g dist/build/git-annex/git-annex-tmp -g -hidir -g dist/build/git-annex/git-annex-tmp -g -stubdir -g dist/build/git-annex/git-annex-tmp -g -threaded -g -Wall -g -XHaskell98 -g -XPackageImports

This was obviously not an easy command line to come up with, and it frequently
breaks. And all of it should be able to be derived from the cabal file.

So, I am excited about your branch. But it doesn't seem to have the
smarts to avoid needing that yet.

joey at darkstar:~/src/git-annex>~/tmp/hdevtools/dist/build/hdevtools/hdevtools --version
hdevtools: version 0.1.0.6 (ghc-7.6.3-x86_64-linux, cabal-1.16.0)
joey at darkstar:~/src/git-annex>~/tmp/hdevtools/dist/build/hdevtools/hdevtools check git-annex.hs
Utility/DiskFree.hs:61:2:
     warning: #warning Building without disk free space checking support [-Wcpp]
     #warning Building without disk free space checking support
      ^
Logs/Unused.hs:97:0:
     error: missing binary operator before token "("
     #if MIN_VERSION_directory(1,2,0)
     ^
Logs/Unused.hs:102:2:
     warning: #warning foo [-Wcpp]
     #warning foo
      ^
phase `C pre-processor' failed (exitcode = 1)
- exit 1

-- 
see shy jo
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 811 bytes
Desc: Digital signature
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140221/4aec0837/attachment.sig>

From maxim.kulkin at gmail.com  Sat Feb 22 03:46:06 2014
From: maxim.kulkin at gmail.com (Maxim Kulkin)
Date: Sat, 22 Feb 2014 07:46:06 +0400
Subject: [Haskell-cafe] Hdevtools cabal support
In-Reply-To: <20140221220718.GA14325@kitenet.net>
References: <2F80D7B3-609E-4E97-A7AE-C3C235DBD989@gmail.com>
 <20140221220718.GA14325@kitenet.net>
Message-ID: <CAORmg63EbXVVhGB80EhMK3ygBk_SaGZxtwBiDquecbnvSUqrEg@mail.gmail.com>

Thanks for the support Joey!

Could you send me the full list of GHC options that your application is
built with. You can do that by issuing "cabal build -v" and then finding
options that you ghc is run with. I do not need list of your modules or
your defines though. That would help.

This is one downside of using all GHC options. I have already done
workaround for -Werror and seems like there are other situations that cause
problems (looks like CPP warnings for some reason cause preprocessing fail).


On Sat, Feb 22, 2014 at 2:07 AM, Joey Hess <joey at kitenet.net> wrote:

> Maxim Kulkin wrote:
> > I'm pretty new to Haskell, but was doing Haskell development for several
> month. I'm fan of Vim editor and was happy to find out that there are good
> tools to support Haskell development with Vim, e.g. vim-hdevtools. But it
> turned out that it not of much use in my project where we rely on Cabal
> packages and sandboxes.
> >
> > As part of scratching own itch I have implemented support for Cabal
> packages for Hdevtools.
>
> Sandboxes aside, there seem to be plenty of reasons for hdevtools to
> integrate with cabal.
>
> To use hdevtools in one of my projects, I have to run it like this.
>
> hdevtools check git-annex.hs -g -cpp -g -i -g
> -idist/build/git-annex/git-annex-tmp -g -i. -g -idist/build/autogen -g
> -Idist/build/autogen -g -Idist/build/git-annex/git-annex-tmp -g -IUtility
> -g -DWITH_TESTSUITE -g -DWITH_S3 -g -DWITH_ASSISTANT -g -DWITH_INOTIFY -g
> -DWITH_DBUS -g -DWITH_PAIRING -g -DWITH_XMPP -g -optP-include -g
> -optPdist/build/autogen/cabal_macros.h -g -odir -g
> dist/build/git-annex/git-annex-tmp -g -hidir -g
> dist/build/git-annex/git-annex-tmp -g -stubdir -g
> dist/build/git-annex/git-annex-tmp -g -threaded -g -Wall -g -XHaskell98 -g
> -XPackageImports
>
> This was obviously not an easy command line to come up with, and it
> frequently
> breaks. And all of it should be able to be derived from the cabal file.
>
> So, I am excited about your branch. But it doesn't seem to have the
> smarts to avoid needing that yet.
>
> joey at darkstar:~/src/git-annex>~/tmp/hdevtools/dist/build/hdevtools/hdevtools
> --version
> hdevtools: version 0.1.0.6 (ghc-7.6.3-x86_64-linux, cabal-1.16.0)
> joey at darkstar:~/src/git-annex>~/tmp/hdevtools/dist/build/hdevtools/hdevtools
> check git-annex.hs
> Utility/DiskFree.hs:61:2:
>      warning: #warning Building without disk free space checking support
> [-Wcpp]
>      #warning Building without disk free space checking support
>       ^
> Logs/Unused.hs:97:0:
>      error: missing binary operator before token "("
>      #if MIN_VERSION_directory(1,2,0)
>      ^
> Logs/Unused.hs:102:2:
>      warning: #warning foo [-Wcpp]
>      #warning foo
>       ^
> phase `C pre-processor' failed (exitcode = 1)
> - exit 1
>
> --
> see shy jo
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140222/c0045f10/attachment.html>

From carlo at carlo-hamalainen.net  Sat Feb 22 09:21:11 2014
From: carlo at carlo-hamalainen.net (Carlo Hamalainen)
Date: Sat, 22 Feb 2014 10:21:11 +0100
Subject: [Haskell-cafe] Hdevtools cabal support
In-Reply-To: <CAORmg63EbXVVhGB80EhMK3ygBk_SaGZxtwBiDquecbnvSUqrEg@mail.gmail.com>
References: <2F80D7B3-609E-4E97-A7AE-C3C235DBD989@gmail.com>
 <20140221220718.GA14325@kitenet.net>
 <CAORmg63EbXVVhGB80EhMK3ygBk_SaGZxtwBiDquecbnvSUqrEg@mail.gmail.com>
Message-ID: <53086C07.90202@carlo-hamalainen.net>

On 22/02/14 04:46, Maxim Kulkin wrote:
> Thanks for the support Joey!
>
> Could you send me the full list of GHC options that your application
> is built with. You can do that by issuing "cabal build -v" and then
> finding options that you ghc is run with. I do not need list of your
> modules or your defines though. That would help.
>
> This is one downside of using all GHC options. I have already done
> workaround for -Werror and seems like there are other situations that
> cause problems (looks like CPP warnings for some reason cause
> preprocessing fail).

Does ghc-mod handle this case? It has some code for automatically
finding a project's cabal file and/or sandbox.

Also the latest Cabal library has some functionality (related to what
happens when you call "cabal repl") that both hdevtools and ghc-mod (and
even my project ghc-imported-from) could benefit from. There's no reason
to duplicate the work that is already done in Cabal for working out GHC
options, cabal package options, etc.

-- 
Carlo Hamalainen
http://carlo-hamalainen.net


From maxim.kulkin at gmail.com  Sat Feb 22 10:26:57 2014
From: maxim.kulkin at gmail.com (Maxim Kulkin)
Date: Sat, 22 Feb 2014 14:26:57 +0400
Subject: [Haskell-cafe] Hdevtools cabal support
In-Reply-To: <53086C07.90202@carlo-hamalainen.net>
References: <2F80D7B3-609E-4E97-A7AE-C3C235DBD989@gmail.com>
 <20140221220718.GA14325@kitenet.net>
 <CAORmg63EbXVVhGB80EhMK3ygBk_SaGZxtwBiDquecbnvSUqrEg@mail.gmail.com>
 <53086C07.90202@carlo-hamalainen.net>
Message-ID: <CD9FB065-94B4-48C2-8A89-1535FFF48684@gmail.com>

As far as I have understood ghc-mod code for supporting Cabal, they do parse cabal file, but rather cherry pick individual options and generate GHC options manually. In hdevtools I use the code from Cabal to generate the same set of GHC options that will be use by Cabal itself to compile code in package. Thus, ghc-mod do not have problems with filtering -Werror, but though it doesn't handle extra options and/or flags (e.g. -Dsymbol CLI options).

Not sure what new functionality in Cabal you are referring to, but I should notice that currently Hdevtools is built with Cabal 1.16 library and not with 1.18. Thus I had to reimplement sandbox detection. The problem is that Hdevtools depend on "ghc" package and "ghc" (for some reason) depend on "Cabal" (and thus the version is a bit outdated). With release of GHC-7.8 Cabal 1.18 will be official and Hdevtools could start using it's built-in functionality for detecting sandbox etc.

On Feb 22, 2014, at 13:21, Carlo Hamalainen <carlo at carlo-hamalainen.net> wrote:

> On 22/02/14 04:46, Maxim Kulkin wrote:
>> Thanks for the support Joey!
>> 
>> Could you send me the full list of GHC options that your application
>> is built with. You can do that by issuing "cabal build -v" and then
>> finding options that you ghc is run with. I do not need list of your
>> modules or your defines though. That would help.
>> 
>> This is one downside of using all GHC options. I have already done
>> workaround for -Werror and seems like there are other situations that
>> cause problems (looks like CPP warnings for some reason cause
>> preprocessing fail).
> 
> Does ghc-mod handle this case? It has some code for automatically
> finding a project's cabal file and/or sandbox.
> 
> Also the latest Cabal library has some functionality (related to what
> happens when you call "cabal repl") that both hdevtools and ghc-mod (and
> even my project ghc-imported-from) could benefit from. There's no reason
> to duplicate the work that is already done in Cabal for working out GHC
> options, cabal package options, etc.
> 
> -- 
> Carlo Hamalainen
> http://carlo-hamalainen.net
> 
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe


From joey at kitenet.net  Sat Feb 22 17:02:55 2014
From: joey at kitenet.net (Joey Hess)
Date: Sat, 22 Feb 2014 13:02:55 -0400
Subject: [Haskell-cafe] Hdevtools cabal support
In-Reply-To: <CAORmg63EbXVVhGB80EhMK3ygBk_SaGZxtwBiDquecbnvSUqrEg@mail.gmail.com>
References: <2F80D7B3-609E-4E97-A7AE-C3C235DBD989@gmail.com>
 <20140221220718.GA14325@kitenet.net>
 <CAORmg63EbXVVhGB80EhMK3ygBk_SaGZxtwBiDquecbnvSUqrEg@mail.gmail.com>
Message-ID: <20140222170255.GA16199@kitenet.net>

Maxim Kulkin wrote:
> Thanks for the support Joey!
> 
> Could you send me the full list of GHC options that your application is built
> with. You can do that by issuing "cabal build -v" and then finding options that
> you ghc is run with. I do not need list of your modules or your defines though.
> That would help.

Sure, with the -package-id's left out, it is:

/usr/bin/ghc --make -fbuilding-cabal-package -odir dist/build/git-annex/git-annex-tmp -hidir dist/build/git-annex/git-annex-tmp -stubdir dist/build/git-annex/git-annex-tmp -i -idist/build/git-annex/git-annex-tmp -i. -idist/build/autogen -Idist/build/autogen -Idist/build/git-annex/git-annex-tmp -IUtility -optP-DWITH_CLIBS -optP-DWITH_TESTSUITE -optP-DWITH_TDFA -optP-DWITH_CRYPTOHASH -optP-DWITH_S3 -optP-DWITH_WEBDAV -optP-DWITH_ASSISTANT -optP-DWITH_INOTIFY -optP-DWITH_DBUS -optP-DWITH_WEBAPP -optP-DWITH_PAIRING -optP-DWITH_XMPP -optP-DWITH_DNS -optP-DWITH_FEED -optP-DWITH_QUVI -optP-DWITH_TAHOE -optP-include -optPdist/build/autogen/cabal_macros.h -hide-all-packages -package-db dist/package.conf.inplace

(You can also find git-annex's source on hackage.)

-- 
see shy jo
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 811 bytes
Desc: Digital signature
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140222/8f148b3b/attachment.sig>

From dominic at steinitz.org  Sat Feb 22 19:15:22 2014
From: dominic at steinitz.org (Dominic Steinitz)
Date: Sat, 22 Feb 2014 19:15:22 +0000 (UTC)
Subject: [Haskell-cafe] Data.Foldable UArray
References: <53066FD6.9060302@gabriel.name> <20140221084729.GH15030@weber>
Message-ID: <loom.20140222T201314-833@post.gmane.org>


> Since all 'Foldable' functions factor through 'toList', you can't go too
> wrong by using '(foldableFunction . toList) myArray' wherever you would have
> wanted to use 'foldableFunction myArray'.


Isn't this going to be rather inefficient? Presumably the point of
using an array is to avoid using lists for an application where they
are not appropriate?



From mikesteele81 at gmail.com  Sat Feb 22 20:07:23 2014
From: mikesteele81 at gmail.com (Michael Steele)
Date: Sat, 22 Feb 2014 12:07:23 -0800
Subject: [Haskell-cafe] ANNOUNCE: Win32-dhcp-server
Message-ID: <CAAFFR7B6xSnYVkbGEJ9nGsj3Xu6q8TfnP4kKrBP8s6fmCbJW8g@mail.gmail.com>

I'm pleased to announce the first version of Win32-dhcp-server [1].
The purpose of this library is to query and control a Microsoft DHCP
server. Enough functionality is defined so so that Ipv4 client lease
and reservation records can be manipulated from software.

I started this at the 2011 Portland hackathon (HacPDX-II), and have
been working on it off and on since then. After adding support for a
few more commands last month I realized it was probably ready to
publish. Please report any bugs, comments, or feature requests to the
github [2] repository.

[1]: http://hackage.haskell.org/package/Win32-dhcp-server
[2]: https://github.com/mikesteele81/Win32-dhcp-server

-- 
-- Michael Steele

From tom-lists-haskell-cafe-2013 at jaguarpaw.co.uk  Sat Feb 22 20:17:17 2014
From: tom-lists-haskell-cafe-2013 at jaguarpaw.co.uk (Tom Ellis)
Date: Sat, 22 Feb 2014 20:17:17 +0000
Subject: [Haskell-cafe] Data.Foldable UArray
In-Reply-To: <loom.20140222T201314-833@post.gmane.org>
References: <53066FD6.9060302@gabriel.name> <20140221084729.GH15030@weber>
 <loom.20140222T201314-833@post.gmane.org>
Message-ID: <20140222201717.GB3007@weber>

On Sat, Feb 22, 2014 at 07:15:22PM +0000, Dominic Steinitz wrote:
> > Since all 'Foldable' functions factor through 'toList', you can't go too
> > wrong by using '(foldableFunction . toList) myArray' wherever you would have
> > wanted to use 'foldableFunction myArray'.
> 
> Isn't this going to be rather inefficient? Presumably the point of
> using an array is to avoid using lists for an application where they
> are not appropriate?

(I'll take this opportunity to correct myself: I meant 'foldableFunction .
elems', not 'foldableFunction . toList')

Marcus's proposed Foldable instance used 'elems' anyway, and furthermore the
public API to UArray (which is just IArray) provides no other suitable means
of folding the elements, so there's hardly something "more efficient" to
compare to.

It would be interesting to see if a more efficient implementation of 'foldr'
and friends could be written using the internal interface, but I wouldn't be
terribly surprised if it were no better that the naive approach plus list
fusion.  (I'm far from expert though).

Tom

From michael at snoyman.com  Sun Feb 23 04:56:17 2014
From: michael at snoyman.com (Michael Snoyman)
Date: Sun, 23 Feb 2014 06:56:17 +0200
Subject: [Haskell-cafe] Data.Foldable UArray
In-Reply-To: <20140222201717.GB3007@weber>
References: <53066FD6.9060302@gabriel.name> <20140221084729.GH15030@weber>
 <loom.20140222T201314-833@post.gmane.org> <20140222201717.GB3007@weber>
Message-ID: <CAKA2JgJqGY3E7NJUFzm5vuDGXuY7oz-8Pkv-LHYh=WewmMtaLw@mail.gmail.com>

On Sat, Feb 22, 2014 at 10:17 PM, Tom Ellis <
tom-lists-haskell-cafe-2013 at jaguarpaw.co.uk> wrote:

> On Sat, Feb 22, 2014 at 07:15:22PM +0000, Dominic Steinitz wrote:
> > > Since all 'Foldable' functions factor through 'toList', you can't go
> too
> > > wrong by using '(foldableFunction . toList) myArray' wherever you
> would have
> > > wanted to use 'foldableFunction myArray'.
> >
> > Isn't this going to be rather inefficient? Presumably the point of
> > using an array is to avoid using lists for an application where they
> > are not appropriate?
>
> (I'll take this opportunity to correct myself: I meant 'foldableFunction .
> elems', not 'foldableFunction . toList')
>
> Marcus's proposed Foldable instance used 'elems' anyway, and furthermore
> the
> public API to UArray (which is just IArray) provides no other suitable
> means
> of folding the elements, so there's hardly something "more efficient" to
> compare to.
>
> It would be interesting to see if a more efficient implementation of
> 'foldr'
> and friends could be written using the internal interface, but I wouldn't
> be
> terribly surprised if it were no better that the naive approach plus list
> fusion.  (I'm far from expert though).
>
>
It's not exactly the same thing, but I recently sent a pull request for a
more efficient version of mapM_ in bytestring[1] which avoids an
intermediate list representation. This implementation is already used in
both mono-traversable's omapM_ and Data.Conduit.Binary.mapM_, and I've seen
significant performance gain by using it. I'd imagine the same would be
true for UArray. At the very least, I'd try using explicit array indexing
instead of converting to a list and see how that affects performance.

[1] https://github.com/haskell/bytestring/pull/9
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140223/f3eb5063/attachment.html>

From marcus at gabriel.name  Sun Feb 23 09:52:16 2014
From: marcus at gabriel.name (Marcus D. Gabriel)
Date: Sun, 23 Feb 2014 10:52:16 +0100
Subject: [Haskell-cafe] Data.Foldable UArray
In-Reply-To: <CAKA2JgJqGY3E7NJUFzm5vuDGXuY7oz-8Pkv-LHYh=WewmMtaLw@mail.gmail.com>
References: <53066FD6.9060302@gabriel.name> <20140221084729.GH15030@weber>
 <loom.20140222T201314-833@post.gmane.org> <20140222201717.GB3007@weber>
 <CAKA2JgJqGY3E7NJUFzm5vuDGXuY7oz-8Pkv-LHYh=WewmMtaLw@mail.gmail.com>
Message-ID: <5309C4D0.9010709@gabriel.name>

My intuition is that Tom is correct in his supposition.

> -- Performance comparaisons
> arrayFoldl' :: (Ix i, IArray a e) => (t -> e -> t) -> t -> a i e -> t
> arrayFoldl' f z = L.foldl' f z . elems
>
> arrayFold :: (Enum i, Ix i, IArray a e) => (t -> e -> t) -> t -> a i e -> t
> arrayFold f z a =
>   let (lo, hi) = bounds a
>       arrayFold_ i z' =
>         if i <= hi
>         then arrayFold_ (succ i) (f z' (a!i) )
>         else z'
>   in arrayFold_ lo z

If you are willing to accept the (Enum i), then I did not observe any
differences in space and time performance between the two functions
above with the '-O2' option and using UArray.  Note I used the word
experience, not test.

- Marcus

On 23/02/2014 05:56, Michael Snoyman wrote:
>
>
>
> On Sat, Feb 22, 2014 at 10:17 PM, Tom Ellis <tom-lists-haskell-cafe-2013 at jaguarpaw.co.uk <mailto:tom-lists-haskell-cafe-2013 at jaguarpaw.co.uk>> wrote:
>
>     On Sat, Feb 22, 2014 at 07:15:22PM +0000, Dominic Steinitz wrote:
>     > > Since all 'Foldable' functions factor through 'toList', you can't go too
>     > > wrong by using '(foldableFunction . toList) myArray' wherever you would have
>     > > wanted to use 'foldableFunction myArray'.
>     >
>     > Isn't this going to be rather inefficient? Presumably the point of
>     > using an array is to avoid using lists for an application where they
>     > are not appropriate?
>
>     (I'll take this opportunity to correct myself: I meant 'foldableFunction .
>     elems', not 'foldableFunction . toList')
>
>     Marcus's proposed Foldable instance used 'elems' anyway, and furthermore the
>     public API to UArray (which is just IArray) provides no other suitable means
>     of folding the elements, so there's hardly something "more efficient" to
>     compare to.
>
>     It would be interesting to see if a more efficient implementation of 'foldr'
>     and friends could be written using the internal interface, but I wouldn't be
>     terribly surprised if it were no better that the naive approach plus list
>     fusion.  (I'm far from expert though).
>
>
> It's not exactly the same thing, but I recently sent a pull request for a more efficient version of mapM_ in bytestring[1] which avoids an intermediate list representation. This implementation is already used in both mono-traversable's omapM_ and Data.Conduit.Binary.mapM_, and I've seen significant performance gain
> by using it. I'd imagine the same would be true for UArray. At the very least, I'd try using explicit array indexing instead of converting to a list and see how that affects performance.
>
> [1] https://github.com/haskell/bytestring/pull/9
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140223/9a2237ed/attachment.html>

From dominic at steinitz.org  Sun Feb 23 14:15:34 2014
From: dominic at steinitz.org (Dominic Steinitz)
Date: Sun, 23 Feb 2014 14:15:34 +0000
Subject: [Haskell-cafe] Is the wiki really this out of date?
Message-ID: <4A82247D-D5EA-4111-98F9-3F1BB919E246@steinitz.org>

I just looked at the wiki page for the IRC channel: http://www.haskell.org/haskellwiki/IRC_channel. It?s got some great charts but they last seem to have been updated in 2009. Is that really the case?

And does anyone know how to get them up to date. I can see this: http://tunes.org/~nef/logs/haskell/ so I think the chart showing kb of text per day should be easy enough.

Not sure about the social graph or the noun chart though.

I know I can get number of people on the channel by /names but that only gives a snapshot. Has anyone any idea on how to get historical data on number of names?

Dominic Steinitz
dominic at steinitz.org
http://idontgetoutmuch.wordpress.com


From difrumin at gmail.com  Sun Feb 23 14:27:51 2014
From: difrumin at gmail.com (Daniil Frumin)
Date: Sun, 23 Feb 2014 18:27:51 +0400
Subject: [Haskell-cafe] Is the wiki really this out of date?
In-Reply-To: <4A82247D-D5EA-4111-98F9-3F1BB919E246@steinitz.org>
References: <4A82247D-D5EA-4111-98F9-3F1BB919E246@steinitz.org>
Message-ID: <CACxkR4BZsgwopyGCnL0tEC_2B=ynPc-Fk53LjBV6kBLbfH__-g@mail.gmail.com>

There are also some interesting charts on ircbrowse:
http://ircbrowse.net/haskell

On Sun, Feb 23, 2014 at 6:15 PM, Dominic Steinitz <dominic at steinitz.org> wrote:
> I just looked at the wiki page for the IRC channel: http://www.haskell.org/haskellwiki/IRC_channel. It's got some great charts but they last seem to have been updated in 2009. Is that really the case?
>
> And does anyone know how to get them up to date. I can see this: http://tunes.org/~nef/logs/haskell/ so I think the chart showing kb of text per day should be easy enough.
>
> Not sure about the social graph or the noun chart though.
>
> I know I can get number of people on the channel by /names but that only gives a snapshot. Has anyone any idea on how to get historical data on number of names?
>
> Dominic Steinitz
> dominic at steinitz.org
> http://idontgetoutmuch.wordpress.com
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe



-- 
Sincerely yours,
-- Daniil

From dario.rehman at gmail.com  Sun Feb 23 15:24:54 2014
From: dario.rehman at gmail.com (dabd)
Date: Sun, 23 Feb 2014 07:24:54 -0800 (PST)
Subject: [Haskell-cafe] Haskell minimal (portable) development environment
Message-ID: <e8b56cb7-9d99-4d5a-9878-b3969db8c548@googlegroups.com>

Hi,

I am currently reading through Packer documentation http://www.packer.io/ 
and vagrant http://www.vagrantup.com/. 

I would like to set up a minimal reproducible Haskell development 
environment on Manjaro Linux (64-bit) running on VirtualBox.

Does anyone have a Packer template for this distro or a Vagrant box for 
Haskell development on any other distro?

Thanks.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140223/5053ea9a/attachment.html>

From roma at ro-che.info  Sun Feb 23 14:54:18 2014
From: roma at ro-che.info (Roman Cheplyaka)
Date: Sun, 23 Feb 2014 16:54:18 +0200
Subject: [Haskell-cafe] Want to create your first Haskell project?
Message-ID: <20140223145418.GA20347@sniper>

Hi,

I'd like to see an html test reporter for the tasty testing framework
(http://documentup.com/feuerbach/tasty)

I could do that myself, but I thought it would be a nice little project
for someone who's about to write their first useful piece of Haskell.

To participate you need to know Haskell on LYAH level and be good at
html/css/js.

If you're interested, get in touch. I'll provide help, review your code
etc.

Roman
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140223/fe1ffdf2/attachment.sig>

From daniel.trstenjak at gmail.com  Sun Feb 23 17:47:12 2014
From: daniel.trstenjak at gmail.com (Daniel Trstenjak)
Date: Sun, 23 Feb 2014 18:47:12 +0100
Subject: [Haskell-cafe] [ANN] cabal-bounds: A command line program for
 managing the bounds/versions of the dependencies in a cabal file.
Message-ID: <20140223174712.GA16080@machine>


Hi all,

If you have several cabalized projects, then it can be quite time consuming to keep the
bounds of your dependencies up to date. Especially if you're following the package versioning policy,
then you want to raise your upper bounds from time to time, to allow the building with newer
versions of the dependencies.

`cabal-bounds` tries to automate this update process to some degree. So a typical update process might look like:

    $> # update the version infos of all libraries
    $> cabal update

    $> # drops the upper bound of all dependencies in 'myproject.cabal', most likely you want to ignore 'base'
    $> cabal-bounds drop --upper --ignore=base myproject.cabal

    $> # create a cabal sandbox for building of 'myproject'
    $> cabal sandbox init
      
    $> # build 'myproject'
    $> cabal install

    $> # update the upper bound of all dependencies in 'myproject.cabal' by the cabal build information
    $> cabal-bounds update --upper --ignore=base myproject.cabal dist/dist-sandbox-*/setup-config


Perhaps the currently most annoying thing is, that you have to live with the reformating of your
`cabal` file done by the pretty printer of the `Cabal` library.

https://github.com/dan-t/cabal-bounds


Greetings,
Daniel

From j at dannynavarro.net  Sun Feb 23 18:16:08 2014
From: j at dannynavarro.net (Danny Navarro)
Date: Sun, 23 Feb 2014 19:16:08 +0100
Subject: [Haskell-cafe] Want to create your first Haskell project?
In-Reply-To: <20140223145418.GA20347@sniper>
References: <20140223145418.GA20347@sniper>
Message-ID: <CAMO1vvSdE3d0vm92FK7vxpTpHAa-tNNF7MqYu-677EZbpOZZew@mail.gmail.com>

Hi Roman,

Is there any canonical example of an HTML test report, perhaps from
another language or another tool, that could give an idea of what you
have in mind?

On Sun, Feb 23, 2014 at 3:54 PM, Roman Cheplyaka <roma at ro-che.info> wrote:
> Hi,
>
> I'd like to see an html test reporter for the tasty testing framework
> (http://documentup.com/feuerbach/tasty)
>
> I could do that myself, but I thought it would be a nice little project
> for someone who's about to write their first useful piece of Haskell.
>
> To participate you need to know Haskell on LYAH level and be good at
> html/css/js.
>
> If you're interested, get in touch. I'll provide help, review your code
> etc.
>
> Roman
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>

From tacla.yamada at gmail.com  Sun Feb 23 20:10:42 2014
From: tacla.yamada at gmail.com (Pedro Yamada)
Date: Sun, 23 Feb 2014 12:10:42 -0800 (PST)
Subject: [Haskell-cafe] Want to create your first Haskell project?
In-Reply-To: <CAMO1vvSdE3d0vm92FK7vxpTpHAa-tNNF7MqYu-677EZbpOZZew@mail.gmail.com>
References: <CAMO1vvSdE3d0vm92FK7vxpTpHAa-tNNF7MqYu-677EZbpOZZew@mail.gmail.com>
Message-ID: <1393186242501.4164f974@Nodemailer>

Hey Danny and Roman,



I can only think of Mocha (http://visionmedia.github.io/mocha/), for node.js, out of the top of my head.(Look under the reporters section, there's an HTML one)



But I think I've seen other JavaScript implementations.?


Yamada

---

https://www.github.com/yamadapc

https://www.twitter.com/yamadapc




?
Sent from Mailbox for iPhone

On Sun, Feb 23, 2014 at 3:16 PM, Danny Navarro <j at dannynavarro.net> wrote:

> Hi Roman,
> Is there any canonical example of an HTML test report, perhaps from
> another language or another tool, that could give an idea of what you
> have in mind?
> On Sun, Feb 23, 2014 at 3:54 PM, Roman Cheplyaka <roma at ro-che.info> wrote:
>> Hi,
>>
>> I'd like to see an html test reporter for the tasty testing framework
>> (http://documentup.com/feuerbach/tasty)
>>
>> I could do that myself, but I thought it would be a nice little project
>> for someone who's about to write their first useful piece of Haskell.
>>
>> To participate you need to know Haskell on LYAH level and be good at
>> html/css/js.
>>
>> If you're interested, get in touch. I'll provide help, review your code
>> etc.
>>
>> Roman
>>
>> _______________________________________________
>> Haskell-Cafe mailing list
>> Haskell-Cafe at haskell.org
>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140223/4521afb8/attachment.html>

From marcus at gabriel.name  Sun Feb 23 22:17:49 2014
From: marcus at gabriel.name (Marcus D. Gabriel)
Date: Sun, 23 Feb 2014 23:17:49 +0100
Subject: [Haskell-cafe] Data.Foldable UArray
In-Reply-To: <CAKA2JgKs9-qcV933=fGqswd81tP_VbgzZ3EGgO0McXPuTmRY=Q@mail.gmail.com>
References: <53066FD6.9060302@gabriel.name>
 <CAKA2JgKs9-qcV933=fGqswd81tP_VbgzZ3EGgO0McXPuTmRY=Q@mail.gmail.com>
Message-ID: <530A738D.4070007@gabriel.name>

For the record, Michael's suggestion worked for me, and it was quite space and time efficient.

Here is a code fragment in case someone like me is looking for this:

> {-# LANGUAGE FlexibleContexts, TypeFamilies #-}

> import Data.Array.IArray (IArray)
> import Data.Array.Unboxed (UArray, (!), array, elems, bounds)
> import Data.Ix (Ix)
> import qualified Data.List as L
> import qualified Data.Foldable.Mono as F

> instance (Ix i, IArray UArray e) => F.MFoldable (UArray i e) where
>   type Elem (UArray i e) = e
>   foldl   f z = L.foldl   f z . elems
>   foldl'  f z = L.foldl'  f z . elems
>   foldl1  f   = L.foldl1  f   . elems
>   foldr   f z = L.foldr   f z . elems
>   foldr1  f   = L.foldr1  f   . elems

To be honest, I was aware of TypeFamilies, but they are new to me
so I need a little study.

Cheers,
- Marcus

On 21/02/2014 07:06, Michael Snoyman wrote:
>
>
> On Thu, Feb 20, 2014 at 11:12 PM, Marcus D. Gabriel <marcus at gabriel.name <mailto:marcus at gabriel.name>> wrote:
>
>     Hello,
>
>     I wanted to make a simple Data.Foldable UArray, and I naively modelled
>     it on
>
>     > instance Ix i => Foldable (Array i) where
>     >  foldr f z = Prelude.foldr f z . elems
>
>     with, of course,
>
>     > instance Ix i => Foldable (UArray i) where
>     > foldr f z = Prelude.foldr f z . elems
>
>     which did not work yielding the following type message
>
>       Could not deduce (IArray UArray a) arising from a use of `elems'
>       from the context (Ix i) bound by the instance declaration at
>       ... Possible fix: add an instance declaration for (IArray UArray
>       a) In the second argument of `(.)', namely `elems' In the
>       expression: Data.List.foldr f z . elems In an equation for
>       `foldr': foldr f z = Data.List.foldr f z . elems
>
>     I clearly do not understand something because I cannot make this work,
>     and I am not sure why.
>
>     With the Haskell type system or even with ghc extensions, can one even
>     make a Data.Foldable UArray?  If so, how?
>
>     Thanks in advance,
>     - Marcus
>
>
> You could create an instance of MonoFoldable for UArray, similar to how the instance for unboxed vectors works[1]. There's no inherent reason why the Array instances don't exist there yet, I simply didn't get around to adding them yet.
>
> [1] https://github.com/snoyberg/mono-traversable/blob/d81bf2fe5ef4ee5957f3a5c54af07a00637c932f/src/Data/MonoTraversable.hs#L502 
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140223/11a1d82c/attachment.html>

From roma at ro-che.info  Sun Feb 23 23:25:48 2014
From: roma at ro-che.info (Roman Cheplyaka)
Date: Mon, 24 Feb 2014 01:25:48 +0200
Subject: [Haskell-cafe] Want to create your first Haskell project?
In-Reply-To: <20140223145418.GA20347@sniper>
References: <20140223145418.GA20347@sniper>
Message-ID: <20140223232548.GA24474@sniper>

I'm glad to say I've got responses from four people in just a few hours.

Further discussion will happen on the (just created) tasty mailing list
https://groups.google.com/forum/#!forum/haskell-tasty

(Also subscribe if you're generally interested in tasty ? I'll use this
mailing list for announces, surveys, and you can ask any tasty-related
questions there, too.)

* Roman Cheplyaka <roma at ro-che.info> [2014-02-23 16:54:18+0200]
> Hi,
> 
> I'd like to see an html test reporter for the tasty testing framework
> (http://documentup.com/feuerbach/tasty)
> 
> I could do that myself, but I thought it would be a nice little project
> for someone who's about to write their first useful piece of Haskell.
> 
> To participate you need to know Haskell on LYAH level and be good at
> html/css/js.
> 
> If you're interested, get in touch. I'll provide help, review your code
> etc.
> 
> Roman
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140224/0cf81b43/attachment.sig>

From corentin.dupont at gmail.com  Mon Feb 24 11:18:48 2014
From: corentin.dupont at gmail.com (Corentin Dupont)
Date: Mon, 24 Feb 2014 12:18:48 +0100
Subject: [Haskell-cafe] manage effects in a DSL
In-Reply-To: <20140213072825.96930.qmail@www1.g3.pair.com>
References: <CAEyhvmow1XbdLJv00iDVA4uBWEXmMGeLsVg1g6jpUCt2=d8CPQ@mail.gmail.com>
 <20140213072825.96930.qmail@www1.g3.pair.com>
Message-ID: <CAEyhvmqRucnJ4eVfXFV+hCFpkM5QPm68BvgQJfGnUS49WzdHJw@mail.gmail.com>

Thanks a lot Oleg. I finally had time to fully read and understand your
comments :)

>From all the comments I got, I put everything together in two blog posts:
http://www.corentindupont.info/blog/posts/2014-02-12-Effect-Class.html
Thanks!


On Thu, Feb 13, 2014 at 8:28 AM, <oleg at okmij.org> wrote:

>
> Sorry for the very late and probably no longer relevant reply.
>
> > Building up on the exemple below, I have a problem with mixing
> > effectful/effectless computations. For example, this would not compile:
> >
> > > noEff :: Exp NoEffect ()
> > > noEff = return ()
> >
> > > hasEffect :: Exp Effect ()
> > > hasEffect = do
> > >   noEff                    <--- won't compile
> > >   return ()
> >
> > But it should: you should be able to run an effectless monad in an
> > effectful one.  How to encode this semantic?
>
> This is a very, very common problem. We have an expression e of type
> T1, and we want to use it in the context that requires the type T2 (e.g.,
> we want to pass 'e' to a function whose argument type is T2). We feel
> that we ought to be able to do that. One example is the one you
> cited: a computation that performs no effect can be regarded as a
> computation that _may_ perform an effect, and so we should be able to
> use a non-effectful expression in an effectful context. Another
> example is numerics: natural numbers are subset of rationals; so it
> should be morally OK to use a natural number where a rational is
> required.
>
> There are two ways of solving this problem. One is polymorphism,
> another is subtyping. In the first approach, we define noEff above
> with the polymorphic type:
>
> > noEff :: forall r. Exp r ()
> > noEff = return ()
>
> This says that noEff can be used either in NoEffect or Effect
> contexts.  Polymorphic terms can be regarded as `macros', at least
> conceptually, -- sort of as an abbreviation for the family of definitions
>
> noEff_1 :: Exp NoEffect ()
> noEff_1 = return ()
>
> noEff_2 :: Exp Effect ()
> noEff_2 = return ()
>
> When you use noEff in the program, the compiler chooses either noEff_1 or
> noEff_2 depending on the type required by the context. (GHC actually
> does that in some circumstances).
>
> Subtyping means defining a (partial) order among types T2 >= T1
> and adding a subsumption rule to the type system
>
>         e :: T1  T2 >= T1
>         -----------------
>         e :: T2
>
> That is, if e has type T1 and T2 is at least as great, e can be given
> the type T2. Such a rule is very common in various object systems. Since
> we can't add new rules into the Haskell type system, we have to use a
> work-around, the explicit coercion. We introduce a function
>         coerce :: T1 -> T2
> (often an identity), which is a proof that it is really
> OK to use (e::T1) at the type T2. We have to explicitly write this
> coercion function:
>
> > hasEffect :: Exp Effect ()
> > hasEffect = do
> >   coerceEff noEff
> >   return ()
>
> We are all familiar with this approach, explicitly writing 'return 1'
> to, say, return an integer result from a monadic function. Here, return
> is the explicit coercion, from 1::Int (the pure expression) to m Int
> (the potentially effectful expression).
>
> Other familiar example is newtype:
>         newtype Speed = Speed{unSpeed :: Float}
> Then expressions (Speed 1.0) or (unSpeed x) / 10.0 etc. are all
> examples of explicit coercions (which are operationally identity).
> [Here were do want the coercions to be explicit, at least the
> Float->Speed coercion. The other could be implicit.]
>
> Haskell uses this approach for numeric literals. When we want to
> use an integer 1 where a rational number is required, we have to write
> fromInteger 1. Here fromInteger being the explicit coercion.
>
> Only we don't have to write 'fromInteger' because GHC inserts it
> implicitly. The latter example makes too points: explicit coercions
> are cumbersome to write and we'd rather had them out of sight. The
> second point is that the coercion is not a single function, but an
> overloaded function (e.g., return fromInteger). The coercions return
> and fromInteger are also not operationally identity, which actually do
> something at run-time.
>
> Let's go back to our example and change it to be more interesting,
> splitting Effect into Read and Write effects, with the order
> NoEffect < ReadEff < WriteEff. To witness the order, we define
>
> class Coerce t1 t2 where coerce :: Exp t1 a -> Exp t2 a
>
> instance Coerce NoEffect   ReadEff where ...
> instance Coerce NoEffect   WriteEff where ...
> instance Coerce ReadEffect WriteEff where ...
>
> so that we can define
>
> > noEff :: Exp NoEffect ()
> > noEff = return ()
>
> and write (coerce noEff) if we want to use noEff in effectful
> situations. We observe that if we make Coerce reflexive, that is, add
>
> instance Coerce NoEffect NoEffect where coerce = id
> ...
>
> then we can write (coerce noEff) all the time. And if we do
> that, why not to fuse coerce into the definition of noEff:
>
> > noEff :: Coerce Noeff r => Exp r ()
> > noEff = coerce (return ())
>
> We come the full circle to polymorphism -- although generally bounded
> polymorphism. (In noEff example above we can drop the Coerce
> constraint since Noeff can be coerced to any other effect. Not so for
> ReadEffect).
>
>
> > > data Exp :: Eff -> * -> * where
> > >   ReadAccount  :: Exp NoEffect Int      --ReadAccount has no effect
> > >   Bind         :: Effects m n r => Exp m a -> (a -> Exp n b) -> Exp r b
> > >  ...
> > > hasEffect :: Exp Effect ()
> > > hasEffect = ReadAccount >> (returnM () :: Exp Effect ())
>
> > This is working more or less, however I am obliged to put the type
> > signature on the returnM (last line): why?
>
> This is the infamous read-show problem. See for example
>
> http://book.realworldhaskell.org/read/using-typeclasses.html#typeclasses.wellknown.read
>
> > eval :: Nomex r a -> State Game a
> > eval a at ReadAccount    = liftEval $ evalNoEffect a
> > eval (WriteAccount a) = modify (\g -> g{account = a})
> > eval (SetVictory v)   = modify (\g -> g{victory = v})
> > eval a@(Return _)     = liftEval $ evalNoEffect a
> > eval (Bind exp f)     = eval exp >>= eval . f
>
> This is a common pitfall. We should write
>
> > eval :: Nomex r a -> State Game a
> > eval ReadAccount    = liftEval $ evalNoEffect ReadAccount
> > eval (Return x)     = liftEval $ evalNoEffect (Return x)
> > ...
>
> It seems like a boilerplate: why do we have to write the same
> 'ReadAccount' on the left hand side and on the right-hand side (ditto
> for Return x). Can't we just share, like in the original code? The
> answer is no: The ReadAccount on the left hand side of the eval
> equation is different from ReadAccount on the right-hand side.
> They are spelled the same, but their types differ. On the
> left-hand-side, ReadAccount :: Nomex Effect (), but on the right-hand
> side, ReadAccount :: Nomex Effect (). This is a frequent problem with
> constants like [] which may have more than one type.
>
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140224/2eafe1b6/attachment.html>

From fabian.bergmark at gmail.com  Mon Feb 24 13:12:12 2014
From: fabian.bergmark at gmail.com (Fabian Bergmark)
Date: Mon, 24 Feb 2014 14:12:12 +0100
Subject: [Haskell-cafe] GHC 7.6.3 and Plugins 1.5.4.0
Message-ID: <CAG=SMqZprEL7HOMMrjuDQ8FrskSCkNkhyg=Q7g30Dq7PfPJDDA@mail.gmail.com>

Im using the plugins library and am unable get it to work with user
defined types. I.e. evaluating the string "id :: Int -> Int" works,
but "id :: Test -> Test" yield the runtime-error.

test: /tmp/MXXXXX27601.o: unknown symbol
`testdzm0zi0zi0_DataziTestD_zdfTypeableTestD_closure'

I have created a small compiling example of the bug here

https://github.com/fabianbergmark/plugins-bug

I have tried to move the data-type to a separate library without success.

Curiously, loading the library exposing the data-type in GHCi, and
running eval "id :: Test -> Test" works and yields the correct result.

From christianlaustsen at gmail.com  Mon Feb 24 13:13:58 2014
From: christianlaustsen at gmail.com (Christian Laustsen)
Date: Mon, 24 Feb 2014 13:13:58 +0000 (UTC)
Subject: [Haskell-cafe] Haskell minimal (portable) development
	environment
References: <e8b56cb7-9d99-4d5a-9878-b3969db8c548@googlegroups.com>
Message-ID: <loom.20140224T135653-417@post.gmane.org>

dabd <dario.rehman <at> gmail.com> writes:

> 
> Hi,
> I am currently reading through Packer documentation?http://www.packer.io/ 
> and vagrant?http://www.vagrantup.com/.?
> 
> I would like to?set up a minimal reproducible Haskell development 
> environment on Manjaro Linux (64-bit) running on VirtualBox.
> 
> 
> Does anyone have a Packer template for this distro or a?Vagrant box 
>for Haskell development on any other distro?
> 
> Thanks.
> 
> 
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe <at> haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
> 

Setting up your own vagrant box is fairly straight forward, you can 
then just install the tools you want to always be available and then 
use that as a base box.

I recently went through itself myself and wrote an article[0] about it, it 
should be easy to follow and just change the distro I used (Debian) with 
whatever you want.

Since you mentioned packer.io this might also be relevant to 
you https://github.com/opscode/bento ..

//Christian

[0] http://codetalk.io/blog/5/deploying-with-vagrant


From dominic at steinitz.org  Mon Feb 24 14:11:39 2014
From: dominic at steinitz.org (Dominic Steinitz)
Date: Mon, 24 Feb 2014 14:11:39 +0000 (UTC)
Subject: [Haskell-cafe] Is the wiki really this out of date?
References: <4A82247D-D5EA-4111-98F9-3F1BB919E246@steinitz.org>
 <CACxkR4BZsgwopyGCnL0tEC_2B=ynPc-Fk53LjBV6kBLbfH@mail.gmail.com>
Message-ID: <loom.20140224T151013-375@post.gmane.org>

Daniil Frumin <difrumin <at> gmail.com> writes:

> 
> There are also some interesting charts on ircbrowse:
> http://ircbrowse.net/haskell
> 

Very cool! Unless someone objects, I will update the 2009 data on the
wiki with these more up-to- date presentations of the data.




From fuuzetsu at fuuzetsu.co.uk  Mon Feb 24 16:19:32 2014
From: fuuzetsu at fuuzetsu.co.uk (Mateusz Kowalczyk)
Date: Mon, 24 Feb 2014 16:19:32 +0000
Subject: [Haskell-cafe] #haddock lives
Message-ID: <530B7114.1010609@fuuzetsu.co.uk>

Hi all,

This is just a small heads up that the IRC channel, #haddock (on
Freenode) is now revived. Previously any Haddock chatter would have
taken place across #ghc, #hackage, #hspec and #haskell which made it
difficult to track. Please use this channel if you have questions.

Thanks
-- 
Mateusz K.

From hoerdegen at funktional.info  Mon Feb 24 17:15:38 2014
From: hoerdegen at funktional.info (=?ISO-8859-15?Q?Heinrich_H=F6rdegen?=)
Date: Mon, 24 Feb 2014 18:15:38 +0100
Subject: [Haskell-cafe] Munich Haskell Meeting
Message-ID: <530B7E3A.7000308@funktional.info>


Dear all,

Wednesday, the 26th of February, our Monthly Haskell Meeting is taking
place once again in Munich, Cafe Puck. We start at 19h30. If you plan to
join, please go to

http://www.haskell-munich.de/dates

and hit the button.

This time, we will have a guest from India, Raman, who will bring along
some boards and shows us how to run PicoLisp [1] on bare metal. There is
also work in progress for running Hugs [2] on bare metal. If you are
interested in embedded systems, this will be surely an enlightening meeting.

Raman is looking also for people from the Haskell community who are
willing to help him embed Hugs or some other Haskell programming system
on bare metal. If you are interested, I can make the contact.

With hope to see many of you on Wednesday,
Heinrich


[1] http://picolisp.com/wiki/?home
[2] http://www.haskell.org/hugs/

From dario.rehman at gmail.com  Mon Feb 24 17:41:05 2014
From: dario.rehman at gmail.com (dabd)
Date: Mon, 24 Feb 2014 09:41:05 -0800 (PST)
Subject: [Haskell-cafe] Haskell minimal (portable) development
 environment
In-Reply-To: <loom.20140224T135653-417@post.gmane.org>
References: <e8b56cb7-9d99-4d5a-9878-b3969db8c548@googlegroups.com>
 <loom.20140224T135653-417@post.gmane.org>
Message-ID: <514ee771-6fca-4988-97e7-09c446ccdc2c@googlegroups.com>

Thanks. I am also reading about provisioning tools like Chef, Puppet and 
Ansible.  So far I liked Ansible the most because it looks simpler.

On Monday, February 24, 2014 1:13:58 PM UTC, Christian Laustsen wrote:
>
> dabd <dario.rehman <at> gmail.com> writes:
>
> > 
> > Hi,
> > I am currently reading through Packer documentation 
> http://www.packer.io/ 
> > and vagrant http://www.vagrantup.com/. 
> > 
> > I would like to set up a minimal reproducible Haskell development 
> > environment on Manjaro Linux (64-bit) running on VirtualBox.
> > 
> > 
> > Does anyone have a Packer template for this distro or a Vagrant box 
> >for Haskell development on any other distro?
> > 
> > Thanks.
> > 
> > 
> > _______________________________________________
> > Haskell-Cafe mailing list
> > Haskell-Cafe <at> haskell.org
> > http://www.haskell.org/mailman/listinfo/haskell-cafe
> > 
>
> Setting up your own vagrant box is fairly straight forward, you can 
> then just install the tools you want to always be available and then 
> use that as a base box.
>
> I recently went through itself myself and wrote an article[0] about it, it 
> should be easy to follow and just change the distro I used (Debian) with 
> whatever you want.
>
> Since you mentioned packer.io this might also be relevant to 
> you https://github.com/opscode/bento ..
>
> //Christian
>
> [0] http://codetalk.io/blog/5/deploying-with-vagrant
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskel... at haskell.org <javascript:>
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140224/4cc7daa1/attachment.html>

From erantapaa at gmail.com  Mon Feb 24 19:46:35 2014
From: erantapaa at gmail.com (Erik Rantapaa)
Date: Mon, 24 Feb 2014 13:46:35 -0600
Subject: [Haskell-cafe] segfault on fromIntegral (floor $ sqrt (-123.123))
	== -123.123
Message-ID: <CA+NR3OsA_uaEvxF0WUd9=uicpRHyQQ5XpKA04YXCzTrUMJj3qw@mail.gmail.com>

I'm getting a segfault on this expression entered into ghci:

GHCi, version 7.6.3: http://www.haskell.org/ghc/  :? for help
Loading package ghc-prim ... linking ... done.
Loading package integer-gmp ... linking ... done.
Loading package base ... linking ... done.
Prelude> fromIntegral (floor $ sqrt (-123.123)) == -123.123
Segmentation fault: 11

I'm running the 32-bit version of the Haskell Platform on OSX.

Is this a bug? a problem with my setup? "Just don't take square roots of
negative numbers - you should know better!"???
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140224/0cefcab8/attachment.html>

From allbery.b at gmail.com  Mon Feb 24 19:48:05 2014
From: allbery.b at gmail.com (Brandon Allbery)
Date: Mon, 24 Feb 2014 14:48:05 -0500
Subject: [Haskell-cafe] segfault on fromIntegral (floor $ sqrt
 (-123.123)) == -123.123
In-Reply-To: <CA+NR3OsA_uaEvxF0WUd9=uicpRHyQQ5XpKA04YXCzTrUMJj3qw@mail.gmail.com>
References: <CA+NR3OsA_uaEvxF0WUd9=uicpRHyQQ5XpKA04YXCzTrUMJj3qw@mail.gmail.com>
Message-ID: <CAKFCL4Vkce0jnv+G_1r8cjj+x728x-ujQCAB=hhdHspugfkUGA@mail.gmail.com>

On Mon, Feb 24, 2014 at 2:46 PM, Erik Rantapaa <erantapaa at gmail.com> wrote:

> I'm getting a segfault on this expression entered into ghci:
>
> GHCi, version 7.6.3: http://www.haskell.org/ghc/  :? for help
> Loading package ghc-prim ... linking ... done.
> Loading package integer-gmp ... linking ... done.
> Loading package base ... linking ... done.
> Prelude> fromIntegral (floor $ sqrt (-123.123)) == -123.123
> Segmentation fault: 11
>
> I'm running the 32-bit version of the Haskell Platform on OSX.
>

Known bug with floating point on OS X. Not sure what the workaround is, but
known to be fixed in 7.8.1 (which is in release candidate stage).

-- 
brandon s allbery kf8nh                               sine nomine associates
allbery.b at gmail.com                                  ballbery at sinenomine.net
unix, openafs, kerberos, infrastructure, xmonad        http://sinenomine.net
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140224/432dce6e/attachment.html>

From dario.rehman at gmail.com  Tue Feb 25 02:19:25 2014
From: dario.rehman at gmail.com (dabd)
Date: Mon, 24 Feb 2014 18:19:25 -0800 (PST)
Subject: [Haskell-cafe] Haskell minimal (portable) development
 environment
In-Reply-To: <514ee771-6fca-4988-97e7-09c446ccdc2c@googlegroups.com>
References: <e8b56cb7-9d99-4d5a-9878-b3969db8c548@googlegroups.com>
 <loom.20140224T135653-417@post.gmane.org>
 <514ee771-6fca-4988-97e7-09c446ccdc2c@googlegroups.com>
Message-ID: <3d0191a1-c22c-4d98-b752-08edfb099eb9@googlegroups.com>

I followed your nice post and made a minimal debian machine with 
haskell installed (skipped the ruby and puppet stuff). 

I had some problems installing debian jessie on virtualbox but managed to 
get there by first installing debian stable and then upgrading to jessie.

It would be nice to be able to automate the whole process of creating a box 
with packer and vagrant. I may attempt to do this using ansible instead of 
puppet or chef.

Thanks.


On Monday, February 24, 2014 5:41:05 PM UTC, dabd wrote:
>
> Thanks. I am also reading about provisioning tools like Chef, Puppet and 
> Ansible.  So far I liked Ansible the most because it looks simpler.
>
> On Monday, February 24, 2014 1:13:58 PM UTC, Christian Laustsen wrote:
>>
>> dabd <dario.rehman <at> gmail.com> writes:
>>
>> > 
>> > Hi,
>> > I am currently reading through Packer documentation 
>> http://www.packer.io/ 
>> > and vagrant http://www.vagrantup.com/. 
>> > 
>> > I would like to set up a minimal reproducible Haskell development 
>> > environment on Manjaro Linux (64-bit) running on VirtualBox.
>> > 
>> > 
>> > Does anyone have a Packer template for this distro or a Vagrant box 
>> >for Haskell development on any other distro?
>> > 
>> > Thanks.
>> > 
>> > 
>> > _______________________________________________
>> > Haskell-Cafe mailing list
>> > Haskell-Cafe <at> haskell.org
>> > http://www.haskell.org/mailman/listinfo/haskell-cafe
>> > 
>>
>> Setting up your own vagrant box is fairly straight forward, you can 
>> then just install the tools you want to always be available and then 
>> use that as a base box.
>>
>> I recently went through itself myself and wrote an article[0] about it, 
>> it 
>> should be easy to follow and just change the distro I used (Debian) with 
>> whatever you want.
>>
>> Since you mentioned packer.io this might also be relevant to 
>> you https://github.com/opscode/bento ..
>>
>> //Christian
>>
>> [0] http://codetalk.io/blog/5/deploying-with-vagrant
>>
>> _______________________________________________
>> Haskell-Cafe mailing list
>> Haskel... at haskell.org
>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>
>>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140224/2cbbed0e/attachment.html>

From alex.solla at gmail.com  Tue Feb 25 03:12:26 2014
From: alex.solla at gmail.com (Alexander Solla)
Date: Mon, 24 Feb 2014 19:12:26 -0800
Subject: [Haskell-cafe] Haskell minimal (portable) development
	environment
In-Reply-To: <3d0191a1-c22c-4d98-b752-08edfb099eb9@googlegroups.com>
References: <e8b56cb7-9d99-4d5a-9878-b3969db8c548@googlegroups.com>
 <loom.20140224T135653-417@post.gmane.org>
 <514ee771-6fca-4988-97e7-09c446ccdc2c@googlegroups.com>
 <3d0191a1-c22c-4d98-b752-08edfb099eb9@googlegroups.com>
Message-ID: <CAO0Ooq0p7nOyZ6fv+x53umXrjCd_Mpbu5fVW7_ezT+daBZvT1w@mail.gmail.com>

I'm doing something similar.  I'm using Vagrant with SaltStack to do my
configuration management.  I would recommend you do the same (or similar,
with puppet/chef/etc).  I went through quite a bit of pain at one point
when I lost track of a machine's configuration, and I don't want to repeat
that experience.  Also, SaltStack has a nice provisioning system.


On Mon, Feb 24, 2014 at 6:19 PM, dabd <dario.rehman at gmail.com> wrote:

> I followed your nice post and made a minimal debian machine with
> haskell installed (skipped the ruby and puppet stuff).
>
> I had some problems installing debian jessie on virtualbox but managed to
> get there by first installing debian stable and then upgrading to jessie.
>
> It would be nice to be able to automate the whole process of creating a
> box with packer and vagrant. I may attempt to do this using ansible instead
> of puppet or chef.
>
> Thanks.
>
>
> On Monday, February 24, 2014 5:41:05 PM UTC, dabd wrote:
>>
>> Thanks. I am also reading about provisioning tools like Chef, Puppet and
>> Ansible.  So far I liked Ansible the most because it looks simpler.
>>
>> On Monday, February 24, 2014 1:13:58 PM UTC, Christian Laustsen wrote:
>>>
>>> dabd <dario.rehman <at> gmail.com> writes:
>>>
>>> >
>>> > Hi,
>>> > I am currently reading through Packer documentation http://www.
>>> packer.io/
>>> > and vagrant http://www.vagrantup.com/.
>>> >
>>> > I would like to set up a minimal reproducible Haskell development
>>> > environment on Manjaro Linux (64-bit) running on VirtualBox.
>>> >
>>> >
>>> > Does anyone have a Packer template for this distro or a Vagrant box
>>> >for Haskell development on any other distro?
>>> >
>>> > Thanks.
>>> >
>>> >
>>> > _______________________________________________
>>> > Haskell-Cafe mailing list
>>> > Haskell-Cafe <at> haskell.org
>>> > http://www.haskell.org/mailman/listinfo/haskell-cafe
>>> >
>>>
>>> Setting up your own vagrant box is fairly straight forward, you can
>>> then just install the tools you want to always be available and then
>>> use that as a base box.
>>>
>>> I recently went through itself myself and wrote an article[0] about it,
>>> it
>>> should be easy to follow and just change the distro I used (Debian) with
>>> whatever you want.
>>>
>>> Since you mentioned packer.io this might also be relevant to
>>> you https://github.com/opscode/bento ..
>>>
>>> //Christian
>>>
>>> [0] http://codetalk.io/blog/5/deploying-with-vagrant
>>>
>>> _______________________________________________
>>> Haskell-Cafe mailing list
>>> Haskel... at haskell.org
>>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>>
>>>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140224/e6b27f61/attachment.html>

From corentin.dupont at gmail.com  Tue Feb 25 10:14:29 2014
From: corentin.dupont at gmail.com (Corentin Dupont)
Date: Tue, 25 Feb 2014 11:14:29 +0100
Subject: [Haskell-cafe] manage effects in a DSL
In-Reply-To: <CAEyhvmqRucnJ4eVfXFV+hCFpkM5QPm68BvgQJfGnUS49WzdHJw@mail.gmail.com>
References: <CAEyhvmow1XbdLJv00iDVA4uBWEXmMGeLsVg1g6jpUCt2=d8CPQ@mail.gmail.com>
 <20140213072825.96930.qmail@www1.g3.pair.com>
 <CAEyhvmqRucnJ4eVfXFV+hCFpkM5QPm68BvgQJfGnUS49WzdHJw@mail.gmail.com>
Message-ID: <CAEyhvmrv2AZj8-APabvjLuk1BGRdwuvjhSusk1hF_-J-iZz7Nw@mail.gmail.com>

So finally, I think there are really 3 solutions to the problem of
representing the semantic of effects/no effects (effect-less instructions
can be run in effect-full context, but not the opposite).
We can encode this semantic at:
- value level
- type level
- typeclass level

At value level, the semantic is encoded by a DSL instruction 'NoEff' that
wraps an effect-less instruction into an effect-full one:
NoEff        :: Nomex NoEffect a -> Nomex Effect a
See
https://github.com/cdupont/Nomyx-design/blob/master/TypeParamEffect-Concrete.hs

At type level, the semantic is encoded by using a polymorphic type
parameter that can take two concrete type, 'Effect' or 'NoEffect':
ReadAccount  :: Nomex r Int
See
https://github.com/cdupont/Nomyx-design/blob/master/TypeParamEffect-Polymorphic.hs

At typeclass level, the semantic is encoded by the hierarchy of classes:
class Nomex m => NomexEffect m where...
See https://github.com/cdupont/Nomyx-design/blob/master/TypeClassEffect.hs

Now I have to choose one :))




On Mon, Feb 24, 2014 at 12:18 PM, Corentin Dupont <corentin.dupont at gmail.com
> wrote:

> Thanks a lot Oleg. I finally had time to fully read and understand your
> comments :)
>
> From all the comments I got, I put everything together in two blog posts:
> http://www.corentindupont.info/blog/posts/2014-02-12-Effect-Class.html
> Thanks!
>
>
> On Thu, Feb 13, 2014 at 8:28 AM, <oleg at okmij.org> wrote:
>
>>
>> Sorry for the very late and probably no longer relevant reply.
>>
>> > Building up on the exemple below, I have a problem with mixing
>> > effectful/effectless computations. For example, this would not compile:
>> >
>> > > noEff :: Exp NoEffect ()
>> > > noEff = return ()
>> >
>> > > hasEffect :: Exp Effect ()
>> > > hasEffect = do
>> > >   noEff                    <--- won't compile
>> > >   return ()
>> >
>> > But it should: you should be able to run an effectless monad in an
>> > effectful one.  How to encode this semantic?
>>
>> This is a very, very common problem. We have an expression e of type
>> T1, and we want to use it in the context that requires the type T2 (e.g.,
>> we want to pass 'e' to a function whose argument type is T2). We feel
>> that we ought to be able to do that. One example is the one you
>> cited: a computation that performs no effect can be regarded as a
>> computation that _may_ perform an effect, and so we should be able to
>> use a non-effectful expression in an effectful context. Another
>> example is numerics: natural numbers are subset of rationals; so it
>> should be morally OK to use a natural number where a rational is
>> required.
>>
>> There are two ways of solving this problem. One is polymorphism,
>> another is subtyping. In the first approach, we define noEff above
>> with the polymorphic type:
>>
>> > noEff :: forall r. Exp r ()
>> > noEff = return ()
>>
>> This says that noEff can be used either in NoEffect or Effect
>> contexts.  Polymorphic terms can be regarded as `macros', at least
>> conceptually, -- sort of as an abbreviation for the family of definitions
>>
>> noEff_1 :: Exp NoEffect ()
>> noEff_1 = return ()
>>
>> noEff_2 :: Exp Effect ()
>> noEff_2 = return ()
>>
>> When you use noEff in the program, the compiler chooses either noEff_1 or
>> noEff_2 depending on the type required by the context. (GHC actually
>> does that in some circumstances).
>>
>> Subtyping means defining a (partial) order among types T2 >= T1
>> and adding a subsumption rule to the type system
>>
>>         e :: T1  T2 >= T1
>>         -----------------
>>         e :: T2
>>
>> That is, if e has type T1 and T2 is at least as great, e can be given
>> the type T2. Such a rule is very common in various object systems. Since
>> we can't add new rules into the Haskell type system, we have to use a
>> work-around, the explicit coercion. We introduce a function
>>         coerce :: T1 -> T2
>> (often an identity), which is a proof that it is really
>> OK to use (e::T1) at the type T2. We have to explicitly write this
>> coercion function:
>>
>> > hasEffect :: Exp Effect ()
>> > hasEffect = do
>> >   coerceEff noEff
>> >   return ()
>>
>> We are all familiar with this approach, explicitly writing 'return 1'
>> to, say, return an integer result from a monadic function. Here, return
>> is the explicit coercion, from 1::Int (the pure expression) to m Int
>> (the potentially effectful expression).
>>
>> Other familiar example is newtype:
>>         newtype Speed = Speed{unSpeed :: Float}
>> Then expressions (Speed 1.0) or (unSpeed x) / 10.0 etc. are all
>> examples of explicit coercions (which are operationally identity).
>> [Here were do want the coercions to be explicit, at least the
>> Float->Speed coercion. The other could be implicit.]
>>
>> Haskell uses this approach for numeric literals. When we want to
>> use an integer 1 where a rational number is required, we have to write
>> fromInteger 1. Here fromInteger being the explicit coercion.
>>
>> Only we don't have to write 'fromInteger' because GHC inserts it
>> implicitly. The latter example makes too points: explicit coercions
>> are cumbersome to write and we'd rather had them out of sight. The
>> second point is that the coercion is not a single function, but an
>> overloaded function (e.g., return fromInteger). The coercions return
>> and fromInteger are also not operationally identity, which actually do
>> something at run-time.
>>
>> Let's go back to our example and change it to be more interesting,
>> splitting Effect into Read and Write effects, with the order
>> NoEffect < ReadEff < WriteEff. To witness the order, we define
>>
>> class Coerce t1 t2 where coerce :: Exp t1 a -> Exp t2 a
>>
>> instance Coerce NoEffect   ReadEff where ...
>> instance Coerce NoEffect   WriteEff where ...
>> instance Coerce ReadEffect WriteEff where ...
>>
>> so that we can define
>>
>> > noEff :: Exp NoEffect ()
>> > noEff = return ()
>>
>> and write (coerce noEff) if we want to use noEff in effectful
>> situations. We observe that if we make Coerce reflexive, that is, add
>>
>> instance Coerce NoEffect NoEffect where coerce = id
>> ...
>>
>> then we can write (coerce noEff) all the time. And if we do
>> that, why not to fuse coerce into the definition of noEff:
>>
>> > noEff :: Coerce Noeff r => Exp r ()
>> > noEff = coerce (return ())
>>
>> We come the full circle to polymorphism -- although generally bounded
>> polymorphism. (In noEff example above we can drop the Coerce
>> constraint since Noeff can be coerced to any other effect. Not so for
>> ReadEffect).
>>
>>
>> > > data Exp :: Eff -> * -> * where
>> > >   ReadAccount  :: Exp NoEffect Int      --ReadAccount has no effect
>> > >   Bind         :: Effects m n r => Exp m a -> (a -> Exp n b) -> Exp r
>> b
>> > >  ...
>> > > hasEffect :: Exp Effect ()
>> > > hasEffect = ReadAccount >> (returnM () :: Exp Effect ())
>>
>> > This is working more or less, however I am obliged to put the type
>> > signature on the returnM (last line): why?
>>
>> This is the infamous read-show problem. See for example
>>
>> http://book.realworldhaskell.org/read/using-typeclasses.html#typeclasses.wellknown.read
>>
>> > eval :: Nomex r a -> State Game a
>> > eval a at ReadAccount    = liftEval $ evalNoEffect a
>> > eval (WriteAccount a) = modify (\g -> g{account = a})
>> > eval (SetVictory v)   = modify (\g -> g{victory = v})
>> > eval a@(Return _)     = liftEval $ evalNoEffect a
>> > eval (Bind exp f)     = eval exp >>= eval . f
>>
>> This is a common pitfall. We should write
>>
>> > eval :: Nomex r a -> State Game a
>> > eval ReadAccount    = liftEval $ evalNoEffect ReadAccount
>> > eval (Return x)     = liftEval $ evalNoEffect (Return x)
>> > ...
>>
>> It seems like a boilerplate: why do we have to write the same
>> 'ReadAccount' on the left hand side and on the right-hand side (ditto
>> for Return x). Can't we just share, like in the original code? The
>> answer is no: The ReadAccount on the left hand side of the eval
>> equation is different from ReadAccount on the right-hand side.
>> They are spelled the same, but their types differ. On the
>> left-hand-side, ReadAccount :: Nomex Effect (), but on the right-hand
>> side, ReadAccount :: Nomex Effect (). This is a frequent problem with
>> constants like [] which may have more than one type.
>>
>>
>>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140225/a6b59628/attachment.html>

From xudifsd at gmail.com  Tue Feb 25 13:38:56 2014
From: xudifsd at gmail.com (Di Xu)
Date: Tue, 25 Feb 2014 21:38:56 +0800
Subject: [Haskell-cafe] Q: haskell type inference algorithm paper
Message-ID: <CAMocUqQ=uhVncsW5+q8YUWN_kTznf515Prg7=gx-XxiaM9ajTQ@mail.gmail.com>

Hi, all

I'm new to haskell, I'm learning haskell for its type system, and I found
haskell type inference is excellent, I'm interested in its type inference
algorithm, could you give me some paper or material reference that describe
the haskell type inference algorithm? I want to port it to typed clojure.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140225/31b201f2/attachment.html>

From trupill at gmail.com  Tue Feb 25 13:46:40 2014
From: trupill at gmail.com (Alejandro Serrano Mena)
Date: Tue, 25 Feb 2014 14:46:40 +0100
Subject: [Haskell-cafe] Q: haskell type inference algorithm paper
In-Reply-To: <CAMocUqQ=uhVncsW5+q8YUWN_kTznf515Prg7=gx-XxiaM9ajTQ@mail.gmail.com>
References: <CAMocUqQ=uhVncsW5+q8YUWN_kTznf515Prg7=gx-XxiaM9ajTQ@mail.gmail.com>
Message-ID: <CAHnFXOv9LUoxz+A0d2EuYM7HPyNx46mRWGQDUXxCM8XpoOH7jQ@mail.gmail.com>

The current version of GHC does type inference by (an advanced version of)
the OutsideIn(X) algorithm.
You can check the original paper at
http://research.microsoft.com/en-us/um/people/simonpj/papers/constraints/jfp-outsidein.pdf
The initial algorithm was then enhanced with datatype promotion and closed
type families, which you can learn about in "Giving Haskell a Promotion"
and "Closed Type Families with Overlapping Equations".


2014-02-25 14:38 GMT+01:00 Di Xu <xudifsd at gmail.com>:

> Hi, all
>
> I'm new to haskell, I'm learning haskell for its type system, and I found
> haskell type inference is excellent, I'm interested in its type inference
> algorithm, could you give me some paper or material reference that describe
> the haskell type inference algorithm? I want to port it to typed clojure.
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140225/dcd3a9a1/attachment.html>

From eir at cis.upenn.edu  Tue Feb 25 14:30:03 2014
From: eir at cis.upenn.edu (Richard Eisenberg)
Date: Tue, 25 Feb 2014 09:30:03 -0500
Subject: [Haskell-cafe] Q: haskell type inference algorithm paper
In-Reply-To: <CAHnFXOv9LUoxz+A0d2EuYM7HPyNx46mRWGQDUXxCM8XpoOH7jQ@mail.gmail.com>
References: <CAMocUqQ=uhVncsW5+q8YUWN_kTznf515Prg7=gx-XxiaM9ajTQ@mail.gmail.com>
 <CAHnFXOv9LUoxz+A0d2EuYM7HPyNx46mRWGQDUXxCM8XpoOH7jQ@mail.gmail.com>
Message-ID: <10CE30AD-5AA2-4C19-B427-0D128ABF53D7@cis.upenn.edu>

To refine Alejandro's answer a bit: The OutsideIn(X) paper is really the one to read. It's long, but I think it would have to be! The later papers he mentions describe enhancements to the internal, typed language (called variously System FC or GHC Core -- they're more or less the same). With these enhancements came some changes to type inference, but not major ones. The "Promotion" paper describes a bit about polymorphic kind inference in datatype definitions, but the details aren't really there. The "Closed Type Families" paper does not really address type inference, as the closed type families feature (somewhat surprisingly) doesn't interact much with type inference at all.

It would be great to see this work be adopted into another language. Good luck!
Richard

On Feb 25, 2014, at 8:46 AM, Alejandro Serrano Mena <trupill at gmail.com> wrote:

> The current version of GHC does type inference by (an advanced version of) the OutsideIn(X) algorithm.
> You can check the original paper at http://research.microsoft.com/en-us/um/people/simonpj/papers/constraints/jfp-outsidein.pdf
> The initial algorithm was then enhanced with datatype promotion and closed type families, which you can learn about in "Giving Haskell a Promotion" and "Closed Type Families with Overlapping Equations".
> 
> 
> 2014-02-25 14:38 GMT+01:00 Di Xu <xudifsd at gmail.com>:
> Hi, all
> 
> I'm new to haskell, I'm learning haskell for its type system, and I found haskell type inference is excellent, I'm interested in its type inference algorithm, could you give me some paper or material reference that describe the haskell type inference algorithm? I want to port it to typed clojure.
> 
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
> 
> 
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140225/c2284b3e/attachment.html>

From dario.rehman at gmail.com  Tue Feb 25 14:36:36 2014
From: dario.rehman at gmail.com (dabd)
Date: Tue, 25 Feb 2014 06:36:36 -0800 (PST)
Subject: [Haskell-cafe] Haskell minimal (portable) development
 environment
In-Reply-To: <CAO0Ooq0p7nOyZ6fv+x53umXrjCd_Mpbu5fVW7_ezT+daBZvT1w@mail.gmail.com>
References: <e8b56cb7-9d99-4d5a-9878-b3969db8c548@googlegroups.com>
 <loom.20140224T135653-417@post.gmane.org>
 <514ee771-6fca-4988-97e7-09c446ccdc2c@googlegroups.com>
 <3d0191a1-c22c-4d98-b752-08edfb099eb9@googlegroups.com>
 <CAO0Ooq0p7nOyZ6fv+x53umXrjCd_Mpbu5fVW7_ezT+daBZvT1w@mail.gmail.com>
Message-ID: <d1e69ada-d6bf-4d0b-a33b-bf9e0bbb411e@googlegroups.com>

I read here a comparison of salt vs ansible. It looks like ansible is 
simpler, especially when dealing with execution order and dependencies.

On Tuesday, February 25, 2014 3:12:26 AM UTC, Alexander Solla wrote:
>
> I'm doing something similar.  I'm using Vagrant with SaltStack to do my 
> configuration management.  I would recommend you do the same (or similar, 
> with puppet/chef/etc).  I went through quite a bit of pain at one point 
> when I lost track of a machine's configuration, and I don't want to repeat 
> that experience.  Also, SaltStack has a nice provisioning system.
>
>
> On Mon, Feb 24, 2014 at 6:19 PM, dabd <dario.... at gmail.com <javascript:>>wrote:
>
>> I followed your nice post and made a minimal debian machine with 
>> haskell installed (skipped the ruby and puppet stuff). 
>>
>> I had some problems installing debian jessie on virtualbox but managed to 
>> get there by first installing debian stable and then upgrading to jessie.
>>
>> It would be nice to be able to automate the whole process of creating a 
>> box with packer and vagrant. I may attempt to do this using ansible instead 
>> of puppet or chef.
>>
>> Thanks.
>>
>>
>> On Monday, February 24, 2014 5:41:05 PM UTC, dabd wrote:
>>>
>>> Thanks. I am also reading about provisioning tools like Chef, Puppet and 
>>> Ansible.  So far I liked Ansible the most because it looks simpler.
>>>
>>> On Monday, February 24, 2014 1:13:58 PM UTC, Christian Laustsen wrote:
>>>>
>>>> dabd <dario.rehman <at> gmail.com> writes:
>>>>
>>>> > 
>>>> > Hi,
>>>> > I am currently reading through Packer documentation http://www.
>>>> packer.io/ 
>>>> > and vagrant http://www.vagrantup.com/. 
>>>> > 
>>>> > I would like to set up a minimal reproducible Haskell development 
>>>> > environment on Manjaro Linux (64-bit) running on VirtualBox.
>>>> > 
>>>> > 
>>>> > Does anyone have a Packer template for this distro or a Vagrant box 
>>>> >for Haskell development on any other distro?
>>>> > 
>>>> > Thanks.
>>>> > 
>>>> > 
>>>> > _______________________________________________
>>>> > Haskell-Cafe mailing list
>>>> > Haskell-Cafe <at> haskell.org
>>>> > http://www.haskell.org/mailman/listinfo/haskell-cafe
>>>> > 
>>>>
>>>> Setting up your own vagrant box is fairly straight forward, you can 
>>>> then just install the tools you want to always be available and then 
>>>> use that as a base box.
>>>>
>>>> I recently went through itself myself and wrote an article[0] about it, 
>>>> it 
>>>> should be easy to follow and just change the distro I used (Debian) 
>>>> with 
>>>> whatever you want.
>>>>
>>>> Since you mentioned packer.io this might also be relevant to 
>>>> you https://github.com/opscode/bento ..
>>>>
>>>> //Christian
>>>>
>>>> [0] http://codetalk.io/blog/5/deploying-with-vagrant
>>>>
>>>> _______________________________________________
>>>> Haskell-Cafe mailing list
>>>> Haskel... at haskell.org
>>>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>>>
>>>>
>> _______________________________________________
>> Haskell-Cafe mailing list
>> Haskel... at haskell.org <javascript:>
>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>
>>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140225/dd782f03/attachment.html>

From ky3 at atamo.com  Tue Feb 25 14:37:25 2014
From: ky3 at atamo.com (Kim-Ee Yeoh)
Date: Tue, 25 Feb 2014 21:37:25 +0700
Subject: [Haskell-cafe] Q: haskell type inference algorithm paper
In-Reply-To: <CAMocUqQ=uhVncsW5+q8YUWN_kTznf515Prg7=gx-XxiaM9ajTQ@mail.gmail.com>
References: <CAMocUqQ=uhVncsW5+q8YUWN_kTznf515Prg7=gx-XxiaM9ajTQ@mail.gmail.com>
Message-ID: <CAPY+ZdSh-EUfBmrnNhfsXAXtCZNYM+DXL_HnkaVTw6mBoqwPHw@mail.gmail.com>

On Tue, Feb 25, 2014 at 8:38 PM, Di Xu <xudifsd at gmail.com> wrote:

> I'm interested in its type inference algorithm, could you give me some
> paper or material reference that describe the haskell type inference
> algorithm? I want to port it to typed clojure.


Haskell type inference is still a developing research area. Suffice to say,
not even SPJ knows all about what it _should be_.

Here's a reasonable plan:

1) Start with so-called "Unification" [1]. Try manually inferring the types
of some Haskell fragments to get a sense of how it applies. The connection
should emerge as clear as day.

2) Next, study Damas-Hindley-Milner. Gain a sense of what motivates
'principal types', why they're useful, as opposed to a situation where they
are impossible to infer.

3) Finally, there's type classes. I don't know if typed clojure has them or
not, but this is really what separates Haskell from, say, Lazy ML (LML). Be
warned, this is where it gets gnarly.

[1] http://en.wikipedia.org/wiki/Unification_%28computer_science%29

-- Kim-Ee
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140225/bfa514cc/attachment.html>

From simon at banquise.net  Tue Feb 25 15:05:57 2014
From: simon at banquise.net (Simon Marechal)
Date: Tue, 25 Feb 2014 16:05:57 +0100
Subject: [Haskell-cafe] Haskell minimal (portable) development
	environment
In-Reply-To: <CAO0Ooq0p7nOyZ6fv+x53umXrjCd_Mpbu5fVW7_ezT+daBZvT1w@mail.gmail.com>
References: <e8b56cb7-9d99-4d5a-9878-b3969db8c548@googlegroups.com>
 <loom.20140224T135653-417@post.gmane.org>
 <514ee771-6fca-4988-97e7-09c446ccdc2c@googlegroups.com>
 <3d0191a1-c22c-4d98-b752-08edfb099eb9@googlegroups.com>
 <CAO0Ooq0p7nOyZ6fv+x53umXrjCd_Mpbu5fVW7_ezT+daBZvT1w@mail.gmail.com>
Message-ID: <530CB155.2010007@banquise.net>

On 02/25/2014 04:12 AM, Alexander Solla wrote:
> I'm doing something similar.  I'm using Vagrant with SaltStack to do my
> configuration management.  I would recommend you do the same (or
> similar, with puppet/chef/etc).  I went through quite a bit of pain at
> one point when I lost track of a machine's configuration, and I don't
> want to repeat that experience.  Also, SaltStack has a nice provisioning
> system.

That might not be relevant to your interests, and this is definitely
self promotion. If you were to use Puppet, you would find that you have
a large toolkit in Haskell here :

http://hackage.haskell.org/package/language-puppet

Among other things, you might like lenses that might be used to refactor
your manifests, and a (currently under development) testing system built
upon hspec. This still requires a ruby library on your system though.

From alex.solla at gmail.com  Tue Feb 25 15:10:44 2014
From: alex.solla at gmail.com (Alexander Solla)
Date: Tue, 25 Feb 2014 07:10:44 -0800
Subject: [Haskell-cafe] Haskell minimal (portable) development
	environment
In-Reply-To: <d1e69ada-d6bf-4d0b-a33b-bf9e0bbb411e@googlegroups.com>
References: <e8b56cb7-9d99-4d5a-9878-b3969db8c548@googlegroups.com>
 <loom.20140224T135653-417@post.gmane.org>
 <514ee771-6fca-4988-97e7-09c446ccdc2c@googlegroups.com>
 <3d0191a1-c22c-4d98-b752-08edfb099eb9@googlegroups.com>
 <CAO0Ooq0p7nOyZ6fv+x53umXrjCd_Mpbu5fVW7_ezT+daBZvT1w@mail.gmail.com>
 <d1e69ada-d6bf-4d0b-a33b-bf9e0bbb411e@googlegroups.com>
Message-ID: <CAO0Ooq1PgcDULAn2cJAZ=n4h1-8QvMeRHDqaZG0Qc8DmvySiug@mail.gmail.com>

On Tue, Feb 25, 2014 at 6:36 AM, dabd <dario.rehman at gmail.com> wrote:

> I read here a comparison of salt vs ansible. It looks like ansible is
> simpler, especially when dealing with execution order and dependencies.
>

That's nice and good.  Use the tool you want.  I'm just saying
configuration management is too important to not automate and backup. :)
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140225/58c8d87d/attachment.html>

From xudifsd at gmail.com  Tue Feb 25 15:23:31 2014
From: xudifsd at gmail.com (Di Xu)
Date: Tue, 25 Feb 2014 23:23:31 +0800
Subject: [Haskell-cafe] Q: haskell type inference algorithm paper
In-Reply-To: <CAPY+ZdSh-EUfBmrnNhfsXAXtCZNYM+DXL_HnkaVTw6mBoqwPHw@mail.gmail.com>
References: <CAMocUqQ=uhVncsW5+q8YUWN_kTznf515Prg7=gx-XxiaM9ajTQ@mail.gmail.com>
 <CAPY+ZdSh-EUfBmrnNhfsXAXtCZNYM+DXL_HnkaVTw6mBoqwPHw@mail.gmail.com>
Message-ID: <CAMocUqTtHRppvvD08iC+2X-rfa63AW5WEK=1y5dVDHirkMH2+A@mail.gmail.com>

Thanks a lot for these paper reference and detailed explanation. I have a
lot to read now ;)


> Here's a reasonable plan:
>
> 1) Start with so-called "Unification" [1]. Try manually inferring the
> types of some Haskell fragments to get a sense of how it applies. The
> connection should emerge as clear as day.
>
> 2) Next, study Damas-Hindley-Milner. Gain a sense of what motivates
> 'principal types', why they're useful, as opposed to a situation where they
> are impossible to infer.
>
> 3) Finally, there's type classes. I don't know if typed clojure has them
> or not, but this is really what separates Haskell from, say, Lazy ML (LML).
> Be warned, this is where it gets gnarly.
>
> [1] http://en.wikipedia.org/wiki/Unification_%28computer_science%29
>

Wow, thanks for this such a detailed plan, I'm also new to type system, it
seems that all the later type inference algorithm is base on
Damas-Hindley-Milner, I must start from here.

The feature that typed clojure misses is some ability to do fully automatic
type inference, here are some example:

map is a polymorphic function with type `(a -> b) -> [a] -> [b]`, and so
does identity function of type `a -> a`, here are invocation: `map identity
[1,2,3]`, haskell could successfully inference its type, but typed clojure
is unable to do this fully automatically, we had to instantiate either map
or identity manually.

The author of typed clojure given me this
paper<http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.39.7265>,
and to quote from paper:

When a polymorphic function is given an anonymous function as argument, we
have a situation where either one of these techniques can be used to infer
some type annotations, but not both at the same time. For example, in the
term map (fun x -> x) [1,2,3], we cannot infer both the type arguments to
map and the annotation on the function parameter x for the following
reason. We take the simple approach that all the the arguments' types must
be determined before calculation of any missing type arguments. This means
that the type of the anonymous function must be synthesized with the
concrete type of its parameter not available from the context. This
synthesis immediately fails, since the parameter is not annotated with its
type.


So, I'd like to know how haskell solved this problem?

Thanks
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140225/a41cecbd/attachment.html>

From chriswarbo at googlemail.com  Tue Feb 25 17:02:16 2014
From: chriswarbo at googlemail.com (Chris Warburton)
Date: Tue, 25 Feb 2014 17:02:16 +0000
Subject: [Haskell-cafe] Q: haskell type inference algorithm paper
In-Reply-To: <CAMocUqTtHRppvvD08iC+2X-rfa63AW5WEK=1y5dVDHirkMH2+A@mail.gmail.com>
 (Di Xu's message of "Tue, 25 Feb 2014 23:23:31 +0800")
References: <CAMocUqQ=uhVncsW5+q8YUWN_kTznf515Prg7=gx-XxiaM9ajTQ@mail.gmail.com>
 <CAPY+ZdSh-EUfBmrnNhfsXAXtCZNYM+DXL_HnkaVTw6mBoqwPHw@mail.gmail.com>
 <CAMocUqTtHRppvvD08iC+2X-rfa63AW5WEK=1y5dVDHirkMH2+A@mail.gmail.com>
Message-ID: <86ppmbdt2f.fsf@gmail.com>


Let's try explicitly unifying the types in your map example. We'll
assume that map already has the following explicit type:

data List a = Nil | Cons a (List a)

type Function a b = a -> b

map :: Function (Function a b) (Function (List a) (List b))

I've defined new "List" and "Function" types since the "[]" and "->" may
cause confusion.

The "a" and "b" are placeholders; they give us *constraints* by telling
us which types must be the same, but they don't tell us what those types
actually are. These placeholders can be re-used in different type
declarations, but I'll use different letters to prevent any confusion.

Now let's look at the arguments given to map in your example. First the
identity function, written like this in Haskell, with some unknown type:

(\x -> x) :: ?

The simple placeholder "?" is my way of saying 'we don't know yet'. In
fact, we already know that the value is a function, so we can write that
down:

(\x -> x) :: Function ? ?

Now we can calculate the output type by *assuming* that the input type
holds. In other words, to calculate the type of the output value we need
to assume that we've been given an input value. Here we will assume that
we've been given a value of some type "c":

x :: c

Now we can calculate the type of the output expression:

x :: ?

Since we assumed that x :: c, we can immediately write down the type of
the output, since it's the same:

x :: c

Hence we've found that the output type happens to be the same as the
input type:

(\x -> x) :: Function c c

Now let's look at the other argument:

(Cons 1 (Cons 2 (Cons 3 Nil))) :: ?

This is [1,2,3] written using my List type. We know that Cons gives us a
List, so we can write that down:

(Cons 1 (Cons 2 (Cons 3 Nil))) :: List ?

Now we need to know the types of "1", "2" and "3". Haskell treats
numbers in a special way, using the "Num" typeclass, but that will just
complicate things, so I'll pretend that they're Ints:

(Cons 1 (Cons 2 (Cons 3 Nil))) :: List Int

Notice that this type has no placeholders, it is 'concrete'.

Now let's look at the full example:

map (\x -> x) (Cons 1 (Cons 2 (Cons 3 Nil)))

We can only apply a function to arguments of the correct type, which
means that the following equations must be satisfied:

     Function a b = Function c c
           List a = List Int

We can see that the 'top level' constraints are OK: we have a Function
type equal to a Function type and a List type equal to a List type. Next
we need to check their arguments (known as "type arguments"):

           a = c
           b = c
           a = Int

This looks OK, since we don't have any nonsense like Int = Bool or
anything. However, we still haven't worked out what the types actually
are. It looks like this is where typed clojure gives up:

> We take the simple approach that all the the arguments' types must be
> determined before calculation of any missing type arguments.

In Haskell we can go a bit further by rearranging these equations using
substitution. We can see that the first and third equations both use
"a", hence we can substitute one for the other:

         Int = c

This uses "c" and so does the middle equation, so we can do another
substitution:

           b = Int

Now we have concrete types for all of our placeholders, specifically:

           a = Int
           b = Int
           c = Int

Hence we can substitute these back into the type of our map expression:

Function (Function Int Int) (Function (List Int) (List Int))

Or, with the conventional notation for types:

(Int -> Int) -> [Int] -> [Int]

The extra step of solving simultaneous equations to get the type
arguments is the reason Haskell can infer this type and typed clojure
cannot.

Regards,
Chris

From m at jaspervdj.be  Tue Feb 25 18:00:00 2014
From: m at jaspervdj.be (Jasper Van der Jeugt)
Date: Tue, 25 Feb 2014 19:00:00 +0100
Subject: [Haskell-cafe] [ANN] profiteur: a tool to visualise GHC .prof files
Message-ID: <20140225180000.GB6241@jasper.local>

Hey all,

I just released the tool profiteur [1]. You can use it to visualise GHC
`.prof` files in a tree map -- I think this makes looking at huge
`.prof` files a lot less unwieldy. More information can be found in this
blogpost [2].

[1]: http://hackage.haskell.org/package/profiteur
[2]: http://jaspervdj.be/posts/2014-02-25-profiteur-ghc-prof-visualiser.html

Peace,
Jasper

From fuuzetsu at fuuzetsu.co.uk  Tue Feb 25 18:29:13 2014
From: fuuzetsu at fuuzetsu.co.uk (Mateusz Kowalczyk)
Date: Tue, 25 Feb 2014 18:29:13 +0000
Subject: [Haskell-cafe] [ANN] profiteur: a tool to visualise GHC .prof
 files
In-Reply-To: <20140225180000.GB6241@jasper.local>
References: <20140225180000.GB6241@jasper.local>
Message-ID: <530CE0F9.1040408@fuuzetsu.co.uk>

On 25/02/14 18:00, Jasper Van der Jeugt wrote:
> Hey all,
> 
> I just released the tool profiteur [1]. You can use it to visualise GHC
> `.prof` files in a tree map -- I think this makes looking at huge
> `.prof` files a lot less unwieldy. More information can be found in this
> blogpost [2].
> 
> [1]: http://hackage.haskell.org/package/profiteur
> [2]: http://jaspervdj.be/posts/2014-02-25-profiteur-ghc-prof-visualiser.html
> 
> Peace,
> Jasper
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
> 

Hi,

Great! The way profiling output analysis is now is a huge pain in the
ass. I'm very glad to see that something new is up.

I did want to try it but I can't get it to run: on ghc-20140225, aeson
fails to compile so that doesn't work. I did manage to compile it with
7.6.3 but after trying to run it on a profiling output I had lying
around, it failed with:

/home/shana/programming/yi/yi/yi.prof: Failed reading: takeWith

You can find the file in question at [1] (~1.4MB). I'm most eager to try
this out so it'd be great if you could have a look.

Are there plans to support on-line rendering? I find it very useful to
be able to see the profiling output as the program is running.
Previously I ended up having to periodically (~5 sec) generate the
postscript file and then have the postscript viewer watch it for
changes. It was very cumbersome but it sometimes worked. It'd be great
if your software could do something like this!

Are flags other than -p supported? I know that it's possible to get
different profiling output, such as on size of allocated structures &c.

[1]: http://fuuzetsu.co.uk/misc/yi.prof

-- 
Mateusz K.

From m at jaspervdj.be  Tue Feb 25 19:01:08 2014
From: m at jaspervdj.be (Jasper Van der Jeugt)
Date: Tue, 25 Feb 2014 20:01:08 +0100
Subject: [Haskell-cafe] [ANN] profiteur: a tool to visualise GHC .prof
	files
In-Reply-To: <20140225180000.GB6241@jasper.local>
References: <20140225180000.GB6241@jasper.local>
Message-ID: <20140225190108.GA1204@jasper.local>

I uploaded a new version (0.1.1.0) which works with the `yi.prof` file
you provided.

Hope this helps,
Peace,
Jasper

> Hi,
>
> Great! The way profiling output analysis is now is a huge pain in the
> ass. I'm very glad to see that something new is up.
>
> I did want to try it but I can't get it to run: on ghc-20140225, aeson
> fails to compile so that doesn't work. I did manage to compile it with
> 7.6.3 but after trying to run it on a profiling output I had lying
> around, it failed with:
>
> /home/shana/programming/yi/yi/yi.prof: Failed reading: takeWith
>
> You can find the file in question at [1] (~1.4MB). I'm most eager to try
> this out so it'd be great if you could have a look.
>
> Are there plans to support on-line rendering? I find it very useful to
> be able to see the profiling output as the program is running.
> Previously I ended up having to periodically (~5 sec) generate the
> postscript file and then have the postscript viewer watch it for
> changes. It was very cumbersome but it sometimes worked. It'd be great
> if your software could do something like this!
>
> Are flags other than -p supported? I know that it's possible to get
> different profiling output, such as on size of allocated structures &c.
>
> [1]: http://fuuzetsu.co.uk/misc/yi.prof
>
> -- 
> Mateusz K.

From fuuzetsu at fuuzetsu.co.uk  Tue Feb 25 19:08:45 2014
From: fuuzetsu at fuuzetsu.co.uk (Mateusz Kowalczyk)
Date: Tue, 25 Feb 2014 19:08:45 +0000
Subject: [Haskell-cafe] [ANN] profiteur: a tool to visualise GHC .prof
	files
In-Reply-To: <20140225190108.GA1204@jasper.local>
References: <20140225180000.GB6241@jasper.local>
 <20140225190108.GA1204@jasper.local>
Message-ID: <530CEA3D.3000104@fuuzetsu.co.uk>

On 25/02/14 19:01, Jasper Van der Jeugt wrote:
> I uploaded a new version (0.1.1.0) which works with the `yi.prof` file
> you provided.
> 
> Hope this helps,
> Peace,
> Jasper
> 
>> Hi,
>>
>> Great! The way profiling output analysis is now is a huge pain in the
>> ass. I'm very glad to see that something new is up.
>>
>> I did want to try it but I can't get it to run: on ghc-20140225, aeson
>> fails to compile so that doesn't work. I did manage to compile it with
>> 7.6.3 but after trying to run it on a profiling output I had lying
>> around, it failed with:
>>
>> /home/shana/programming/yi/yi/yi.prof: Failed reading: takeWith
>>
>> You can find the file in question at [1] (~1.4MB). I'm most eager to try
>> this out so it'd be great if you could have a look.
>>
>> Are there plans to support on-line rendering? I find it very useful to
>> be able to see the profiling output as the program is running.
>> Previously I ended up having to periodically (~5 sec) generate the
>> postscript file and then have the postscript viewer watch it for
>> changes. It was very cumbersome but it sometimes worked. It'd be great
>> if your software could do something like this!
>>
>> Are flags other than -p supported? I know that it's possible to get
>> different profiling output, such as on size of allocated structures &c.
>>
>> [1]: http://fuuzetsu.co.uk/misc/yi.prof
>>
>> -- 
>> Mateusz K.

That indeed lets me load up the file. Now I notice a problem with the
rendering itself. When I open the generated file, the rendering on of
the whole thing keeps twitching: what's happening is that your model
realises there's some space still left so it tries to resize to maximum
space available _but_ it resizes too much and scrollbars appear (making
the whole thing ?jump? slightly). It then notices that it in fact
doesn't fit inside the window and goes a bit smaller. Scrollbars
disappear (so it jumps again) but then it notices that there's some
space left and so on and so on? It's the same behaviour in Firefox and
Chromium and resizing my browser window doesn't seem to affect it, it
keeps toggling between slightly-too-small and slightly-too-big.

-- 
Mateusz K.

From sykora at lucentbeing.com  Tue Feb 25 19:14:40 2014
From: sykora at lucentbeing.com (sykora)
Date: Tue, 25 Feb 2014 14:14:40 -0500
Subject: [Haskell-cafe] [ANN] profiteur: a tool to visualise GHC .prof
	files
In-Reply-To: <530CEA3D.3000104@fuuzetsu.co.uk>
References: <20140225180000.GB6241@jasper.local>
 <20140225190108.GA1204@jasper.local>
 <530CEA3D.3000104@fuuzetsu.co.uk>
Message-ID: <CAB-Kqtf_-DH18PkVC+ioUWSwLb94qp-D-KWWBQC1D11ECA-vVQ@mail.gmail.com>

I can confirm this "twitching" behavior. I ran profiteur on a ~4.1M
profile, and the tree browser works fine, except for the constant
resizing.

Great work, I've been looking for this kind of tool for a while.

On Tue, Feb 25, 2014 at 2:08 PM, Mateusz Kowalczyk
<fuuzetsu at fuuzetsu.co.uk> wrote:
> On 25/02/14 19:01, Jasper Van der Jeugt wrote:
>> I uploaded a new version (0.1.1.0) which works with the `yi.prof` file
>> you provided.
>>
>> Hope this helps,
>> Peace,
>> Jasper
>>
>>> Hi,
>>>
>>> Great! The way profiling output analysis is now is a huge pain in the
>>> ass. I'm very glad to see that something new is up.
>>>
>>> I did want to try it but I can't get it to run: on ghc-20140225, aeson
>>> fails to compile so that doesn't work. I did manage to compile it with
>>> 7.6.3 but after trying to run it on a profiling output I had lying
>>> around, it failed with:
>>>
>>> /home/shana/programming/yi/yi/yi.prof: Failed reading: takeWith
>>>
>>> You can find the file in question at [1] (~1.4MB). I'm most eager to try
>>> this out so it'd be great if you could have a look.
>>>
>>> Are there plans to support on-line rendering? I find it very useful to
>>> be able to see the profiling output as the program is running.
>>> Previously I ended up having to periodically (~5 sec) generate the
>>> postscript file and then have the postscript viewer watch it for
>>> changes. It was very cumbersome but it sometimes worked. It'd be great
>>> if your software could do something like this!
>>>
>>> Are flags other than -p supported? I know that it's possible to get
>>> different profiling output, such as on size of allocated structures &c.
>>>
>>> [1]: http://fuuzetsu.co.uk/misc/yi.prof
>>>
>>> --
>>> Mateusz K.
>
> That indeed lets me load up the file. Now I notice a problem with the
> rendering itself. When I open the generated file, the rendering on of
> the whole thing keeps twitching: what's happening is that your model
> realises there's some space still left so it tries to resize to maximum
> space available _but_ it resizes too much and scrollbars appear (making
> the whole thing 'jump' slightly). It then notices that it in fact
> doesn't fit inside the window and goes a bit smaller. Scrollbars
> disappear (so it jumps again) but then it notices that there's some
> space left and so on and so on... It's the same behaviour in Firefox and
> Chromium and resizing my browser window doesn't seem to affect it, it
> keeps toggling between slightly-too-small and slightly-too-big.
>
> --
> Mateusz K.
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe

From m at jaspervdj.be  Tue Feb 25 19:20:10 2014
From: m at jaspervdj.be (Jasper Van der Jeugt)
Date: Tue, 25 Feb 2014 20:20:10 +0100
Subject: [Haskell-cafe] [ANN] profiteur: a tool to visualise GHC .prof
	files
In-Reply-To: <CAB-Kqtf_-DH18PkVC+ioUWSwLb94qp-D-KWWBQC1D11ECA-vVQ@mail.gmail.com>
References: <20140225180000.GB6241@jasper.local>
 <20140225190108.GA1204@jasper.local>
 <530CEA3D.3000104@fuuzetsu.co.uk>
 <CAB-Kqtf_-DH18PkVC+ioUWSwLb94qp-D-KWWBQC1D11ECA-vVQ@mail.gmail.com>
Message-ID: <CAAJvgDDs4AZdFSYFJExcAa0tuywmzLcSfJ5K6tmBR7fBLPsnhg@mail.gmail.com>

The twitching should be fixed in version 0.1.2.0. Thanks for the comments!

Peace,
Jasper

On Tue, Feb 25, 2014 at 8:14 PM, sykora <sykora at lucentbeing.com> wrote:
> I can confirm this "twitching" behavior. I ran profiteur on a ~4.1M
> profile, and the tree browser works fine, except for the constant
> resizing.
>
> Great work, I've been looking for this kind of tool for a while.
>
> On Tue, Feb 25, 2014 at 2:08 PM, Mateusz Kowalczyk
> <fuuzetsu at fuuzetsu.co.uk> wrote:
>> On 25/02/14 19:01, Jasper Van der Jeugt wrote:
>>> I uploaded a new version (0.1.1.0) which works with the `yi.prof` file
>>> you provided.
>>>
>>> Hope this helps,
>>> Peace,
>>> Jasper
>>>
>>>> Hi,
>>>>
>>>> Great! The way profiling output analysis is now is a huge pain in the
>>>> ass. I'm very glad to see that something new is up.
>>>>
>>>> I did want to try it but I can't get it to run: on ghc-20140225, aeson
>>>> fails to compile so that doesn't work. I did manage to compile it with
>>>> 7.6.3 but after trying to run it on a profiling output I had lying
>>>> around, it failed with:
>>>>
>>>> /home/shana/programming/yi/yi/yi.prof: Failed reading: takeWith
>>>>
>>>> You can find the file in question at [1] (~1.4MB). I'm most eager to try
>>>> this out so it'd be great if you could have a look.
>>>>
>>>> Are there plans to support on-line rendering? I find it very useful to
>>>> be able to see the profiling output as the program is running.
>>>> Previously I ended up having to periodically (~5 sec) generate the
>>>> postscript file and then have the postscript viewer watch it for
>>>> changes. It was very cumbersome but it sometimes worked. It'd be great
>>>> if your software could do something like this!
>>>>
>>>> Are flags other than -p supported? I know that it's possible to get
>>>> different profiling output, such as on size of allocated structures &c.
>>>>
>>>> [1]: http://fuuzetsu.co.uk/misc/yi.prof
>>>>
>>>> --
>>>> Mateusz K.
>>
>> That indeed lets me load up the file. Now I notice a problem with the
>> rendering itself. When I open the generated file, the rendering on of
>> the whole thing keeps twitching: what's happening is that your model
>> realises there's some space still left so it tries to resize to maximum
>> space available _but_ it resizes too much and scrollbars appear (making
>> the whole thing 'jump' slightly). It then notices that it in fact
>> doesn't fit inside the window and goes a bit smaller. Scrollbars
>> disappear (so it jumps again) but then it notices that there's some
>> space left and so on and so on... It's the same behaviour in Firefox and
>> Chromium and resizing my browser window doesn't seem to affect it, it
>> keeps toggling between slightly-too-small and slightly-too-big.
>>
>> --
>> Mateusz K.
>> _______________________________________________
>> Haskell-Cafe mailing list
>> Haskell-Cafe at haskell.org
>> http://www.haskell.org/mailman/listinfo/haskell-cafe
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe

From fuuzetsu at fuuzetsu.co.uk  Tue Feb 25 19:24:00 2014
From: fuuzetsu at fuuzetsu.co.uk (Mateusz Kowalczyk)
Date: Tue, 25 Feb 2014 19:24:00 +0000
Subject: [Haskell-cafe] [ANN] profiteur: a tool to visualise GHC .prof
 files
In-Reply-To: <CAAJvgDDs4AZdFSYFJExcAa0tuywmzLcSfJ5K6tmBR7fBLPsnhg@mail.gmail.com>
References: <20140225180000.GB6241@jasper.local>
 <20140225190108.GA1204@jasper.local> <530CEA3D.3000104@fuuzetsu.co.uk>
 <CAB-Kqtf_-DH18PkVC+ioUWSwLb94qp-D-KWWBQC1D11ECA-vVQ@mail.gmail.com>
 <CAAJvgDDs4AZdFSYFJExcAa0tuywmzLcSfJ5K6tmBR7fBLPsnhg@mail.gmail.com>
Message-ID: <530CEDD0.7010602@fuuzetsu.co.uk>

On 25/02/14 19:20, Jasper Van der Jeugt wrote:
> The twitching should be fixed in version 0.1.2.0. Thanks for the comments!
> 
> Peace,
> Jasper
> 

It indeed does seem fixed. My last pet-peeve for now seems to be that
it's possible to get the same colour of rectangles aligned with each
other which makes it impossible to tell how big the rectangles actually
are. Perhaps some kind of algorithm to pack contrasting colours next to
each other would be in order.

It's just a suggestion.

Again, thanks a ton for this software!

-- 
Mateusz K.

From chriswarbo at googlemail.com  Wed Feb 26 10:11:58 2014
From: chriswarbo at googlemail.com (Chris Warburton)
Date: Wed, 26 Feb 2014 10:11:58 +0000
Subject: [Haskell-cafe] [ANN] profiteur: a tool to visualise GHC .prof
	files
In-Reply-To: <530CEDD0.7010602@fuuzetsu.co.uk> (Mateusz Kowalczyk's message of
 "Tue, 25 Feb 2014 19:24:00 +0000")
References: <20140225180000.GB6241@jasper.local>
 <20140225190108.GA1204@jasper.local> <530CEA3D.3000104@fuuzetsu.co.uk>
 <CAB-Kqtf_-DH18PkVC+ioUWSwLb94qp-D-KWWBQC1D11ECA-vVQ@mail.gmail.com>
 <CAAJvgDDs4AZdFSYFJExcAa0tuywmzLcSfJ5K6tmBR7fBLPsnhg@mail.gmail.com>
 <530CEDD0.7010602@fuuzetsu.co.uk>
Message-ID: <86ha7mdvyp.fsf@gmail.com>

Mateusz Kowalczyk <fuuzetsu at fuuzetsu.co.uk> writes:

> It indeed does seem fixed. My last pet-peeve for now seems to be that
> it's possible to get the same colour of rectangles aligned with each
> other which makes it impossible to tell how big the rectangles actually
> are. Perhaps some kind of algorithm to pack contrasting colours next to
> each other would be in order.
>
> It's just a suggestion.
>
> Again, thanks a ton for this software!

Or maybe put a 1px border around the rectangles? KISS and all that ;)

Cheers,
Chris

From trupill at gmail.com  Wed Feb 26 15:07:56 2014
From: trupill at gmail.com (Alejandro Serrano Mena)
Date: Wed, 26 Feb 2014 16:07:56 +0100
Subject: [Haskell-cafe] OutsideIn(X) question
Message-ID: <CAHnFXOu-v7VNNOBzS-eF-_pp_-jh9cO3J1nj7srkxtMwv32vZw@mail.gmail.com>

Dear Haskell-caf?,
I don't know if this is the best forum to ask questions about the
OutsideIn(X) paper that lies below type inference in GHC. But given that
this is the place where I know many GHC devs look at, I'll just try :)

My question related about the proof of soundness and principality,
specifically Lemma 7.2 (to be found in page 67). In that lemma, it's stated
that QQ and \phi' Q_q ||- \phi Q_w <-> \phi' Q_w'. I'm trying to recover
the proof (which is omitted in the text), but I stumble upon a wall when
trying to work out what happens in the case an axiom is applied.

In particular, I'm playing with an example where

QQ (the set of axioms) = { forall. C a => D a } (where C and D are
one-parameter type classes)
Q_q = { }
Q_w = { D Int }

Thus, if I apply the rule DINSTW (to be found in page 65), I get a new

Q_w' = { C Int }

Now, if the lemma 7.2 is true, it should be the case that

(1)  QQ ||- C Int <-> D Int

which in particular means that I have the two implications

(2)  { forall. C a => D a, C Int } ||- D Int
(3)  { forall. C a => D a, D Int } ||- C Int

(2) follows easily by applying the AXIOM rule of ||- (as shown in page 54).
However, I don't see how to make (3) work :(
I think that understanding this example will be key for my understanding of
the whole system.

Anybody could point to the error in my reasoning or to places where I could
find more information?
Thanks in advance.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140226/a1051596/attachment.html>

From allbery.b at gmail.com  Wed Feb 26 15:39:39 2014
From: allbery.b at gmail.com (Brandon Allbery)
Date: Wed, 26 Feb 2014 10:39:39 -0500
Subject: [Haskell-cafe] OutsideIn(X) question
In-Reply-To: <CAHnFXOu-v7VNNOBzS-eF-_pp_-jh9cO3J1nj7srkxtMwv32vZw@mail.gmail.com>
References: <CAHnFXOu-v7VNNOBzS-eF-_pp_-jh9cO3J1nj7srkxtMwv32vZw@mail.gmail.com>
Message-ID: <CAKFCL4W1NekGLJse-Fm-1TnCfLFTnO=RcXvjf-pLEsv=dVatBA@mail.gmail.com>

On Wed, Feb 26, 2014 at 10:07 AM, Alejandro Serrano Mena
<trupill at gmail.com>wrote:

> Dear Haskell-caf?,
> I don't know if this is the best forum to ask questions about the
> OutsideIn(X) paper that lies below type inference in GHC. But given that
> this is the place where I know many GHC devs look at, I'll just try :)
>

If you don't get an answer, consider the glasgow-haskell-users list.

-- 
brandon s allbery kf8nh                               sine nomine associates
allbery.b at gmail.com                                  ballbery at sinenomine.net
unix, openafs, kerberos, infrastructure, xmonad        http://sinenomine.net
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140226/4b55016d/attachment.html>

From sol at typeful.net  Wed Feb 26 18:36:46 2014
From: sol at typeful.net (Simon Hengel)
Date: Wed, 26 Feb 2014 19:36:46 +0100
Subject: [Haskell-cafe] Berlin HUG meeting at Tuesday, March 4th
Message-ID: <20140226183646.GA20023@x200>

Hi,
we have regular Haskell meetings in Berlin, but I think it was never
officially announced on this list.

There is a meetup page [1] and the next meeting is at

    Tuesday, March 4th

Big thanks to Adam for organizing things!

One important thing, please join on meetup if you want to come!

Cheers,
Simon

[1] http://www.meetup.com/berlinhug/

From gershomb at gmail.com  Wed Feb 26 21:29:38 2014
From: gershomb at gmail.com (Gershom B)
Date: Wed, 26 Feb 2014 16:29:38 -0500
Subject: [Haskell-cafe] Portfolio Analytics group at S&P CapitalIQ Hiring
	Summer Interns for 2014
Message-ID: <CAM8RHpFfzKorWNAiZ0++SFeOP18yEViTh0fhQWe6t_umAHmdGw@mail.gmail.com>

Our team is full of people with strong functional programming
interests, and we even have an in-house Haskell-like DSL. To get a
sense of the work we do, you can watch Edward Kmett's CUFP
presentation (http://www.youtube.com/watch?v=o3m2NkusI9k) and browse
his slides (http://cufp.org/sites/all/files/slides/2013/kmett.pdf). We
have work that directly requires FP knowledge, and other work
involving Scala, or even C# and SQL.

If you are a college junior who wants to get paid to spend a summer in
New York working in this environment, then apply by March 15 and see
where it goes. You'll need to apply at the below web link, and _also_
email us directly so we can route your resume to our team. More than
any particular experience or skills, we're interested in people who
love computer science and like building new things.

Application site:
http://careers.mhfi.com/ShowJob/Id/131214/Software-Engineer-Summer-Intern-%28S-P-Capital-IQ-Technology%29/

Additional contacts to email: smcfarland at spcapitaliq.com and
gbazerman at spcapitaliq.com

From cpa at crans.org  Thu Feb 27 10:05:48 2014
From: cpa at crans.org (Charles-Pierre Astolfi)
Date: Thu, 27 Feb 2014 11:05:48 +0100
Subject: [Haskell-cafe] OutsideIn(X) question
In-Reply-To: <CAHnFXOu-v7VNNOBzS-eF-_pp_-jh9cO3J1nj7srkxtMwv32vZw@mail.gmail.com>
References: <CAHnFXOu-v7VNNOBzS-eF-_pp_-jh9cO3J1nj7srkxtMwv32vZw@mail.gmail.com>
Message-ID: <CAB6QvNPmFVkfVBa62mnmYpK7sCZp45PJJdEzGPZhcSnMe_A4ug@mail.gmail.com>

Hi Alejandro,

This is definitely a question for the Types forum: types-list@
lists.seas.upenn.edu
This list is research oriented, low traffic, and mostly read by people
working on type theory. Threads are usually about questions in type theory
papers just like yours.

Cheers,

--
Cp


On Wed, Feb 26, 2014 at 4:07 PM, Alejandro Serrano Mena
<trupill at gmail.com>wrote:

> Dear Haskell-caf?,
> I don't know if this is the best forum to ask questions about the
> OutsideIn(X) paper that lies below type inference in GHC. But given that
> this is the place where I know many GHC devs look at, I'll just try :)
>
> My question related about the proof of soundness and principality,
> specifically Lemma 7.2 (to be found in page 67). In that lemma, it's stated
> that QQ and \phi' Q_q ||- \phi Q_w <-> \phi' Q_w'. I'm trying to recover
> the proof (which is omitted in the text), but I stumble upon a wall when
> trying to work out what happens in the case an axiom is applied.
>
> In particular, I'm playing with an example where
>
> QQ (the set of axioms) = { forall. C a => D a } (where C and D are
> one-parameter type classes)
> Q_q = { }
> Q_w = { D Int }
>
> Thus, if I apply the rule DINSTW (to be found in page 65), I get a new
>
> Q_w' = { C Int }
>
> Now, if the lemma 7.2 is true, it should be the case that
>
> (1)  QQ ||- C Int <-> D Int
>
> which in particular means that I have the two implications
>
> (2)  { forall. C a => D a, C Int } ||- D Int
> (3)  { forall. C a => D a, D Int } ||- C Int
>
> (2) follows easily by applying the AXIOM rule of ||- (as shown in page
> 54). However, I don't see how to make (3) work :(
> I think that understanding this example will be key for my understanding
> of the whole system.
>
> Anybody could point to the error in my reasoning or to places where I
> could find more information?
> Thanks in advance.
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140227/b37f0cf8/attachment.html>

From karl at karlv.net  Fri Feb 28 01:32:07 2014
From: karl at karlv.net (Karl Voelker)
Date: Thu, 27 Feb 2014 17:32:07 -0800
Subject: [Haskell-cafe] Haskell spec vs FlexibleInstances
In-Reply-To: <loom.20140218T212623-105@post.gmane.org>
References: <201402182011.s1IKBw2e003049@stowe.cs.dartmouth.edu>
 <loom.20140218T212623-105@post.gmane.org>
Message-ID: <CD122DE3-D6D5-4488-B773-2DB3DD6F0B7E@karlv.net>

The spec doesn't allow multi-parameter type classes at all, so I don't see how you could run into this problem while writing extensionless Haskell.

I guess it's still a valid question whether the MultiParamTypeClasses extension should allow repeated type parameters.

-Karl

On Feb 18, 2014, at 12:53 PM, AntC <anthony_clayden at clear.net.nz> wrote:

>> Doug McIlroy <doug <at> cs.dartmouth.edu> writes:
>> 
>> What potential evil motivates  the prohibition of repeated type
>> parameters in an instance declaration?
> 
> Hi Doug, 
> 
> I guess the first reason would be to catch accidental duplicate names of 
> typevars.
> 
> But as to "potential evils", the only point of such an instance:
> 
>    instance C a a where ...
> 
> would be to have another instance:
> 
>    instance C a b where ...
> 
> So we're into overlapping instances. (And discriminating on type equality -
> - which only works if the types are grounded. See the HList paper, section 
> 9 'By chance or design?')
> 
> Overlapping instances like that will probably need FunDeps. So the more 
> recent (and probably more blessed) approach is to use the Closed type 
> families/branched instances doo-hicky upcoming with GHC 7.8.
> http://www.haskell.org/haskellwiki/GHC/Indexed_types#Type_instance_declarat
> ions
> 
> AntC
> 
> 
> 
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe

From vincent.berthoux at gmail.com  Fri Feb 28 08:13:39 2014
From: vincent.berthoux at gmail.com (Vincent Berthoux)
Date: Fri, 28 Feb 2014 09:13:39 +0100
Subject: [Haskell-cafe] [ANN] Rasterific & FontyFruity
Message-ID: <CALCmskVSMf-mQOztjj=zP2xGOGZRFJ3Q6bRm8v19BrowwzsMEw@mail.gmail.com>

Hello Haskellers,

  I'm pleased to announce two new packages, whom work hand in hand:
FontyFruity, a truetype file parser, and Rasterific a vector drawing
engine. This two libraries enable us to generate pictures without the need
of an external C library, and saving them to a file or directly send them
over the network.

FontyFruity:
  * hackage : http://hackage.haskell.org/package/FontyFruity
  * Github : https://github.com/Twinside/FontyFruity

Rasterific:
  * hackage : http://hackage.haskell.org/package/Rasterific
  * Github : https://github.com/Twinside/Rasterific

   Regards

       Vincent
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140228/2d104e77/attachment.html>

From hsyl20 at gmail.com  Fri Feb 28 08:49:43 2014
From: hsyl20 at gmail.com (Sylvain Henry)
Date: Fri, 28 Feb 2014 09:49:43 +0100
Subject: [Haskell-cafe] [ANN] Rasterific & FontyFruity
In-Reply-To: <CALCmskVSMf-mQOztjj=zP2xGOGZRFJ3Q6bRm8v19BrowwzsMEw@mail.gmail.com>
References: <CALCmskVSMf-mQOztjj=zP2xGOGZRFJ3Q6bRm8v19BrowwzsMEw@mail.gmail.com>
Message-ID: <CAPmptcVYdsiZ2DEqLNVRvudKAYwHT1xt7BhwFU5NiYFPEGWn1g@mail.gmail.com>

Awesome! Would it be possible to use FontyFruity to remove the limitations
of Text in Diagrams (see below)? Is there something missing in Rasterific
to render SVG?

>From http://projects.haskell.org/diagrams/doc/manual.html#text

> Text objects take up no space!

> The main reason for this is that computing the size of some text in a
given font is rather complicated, and diagrams cannot (yet) do it natively.
The cairo backend can do it (see below) but we don't want to tie diagrams
to a particular backend.
> The second reason is that font size is handled similarly to line width,
so the size of a text object cannot be known at the time of its creation
anyway! (Future versions of ``diagrams`` may include some sort of
constraint-solving engine to be able to handle this sort of situation, but
don't hold your breath.) Font size is treated similarly to line width for a
similar reason: we often want disparate text elements to be the same size,
but those text elements may be part of subdiagrams that have been
transformed in various ways. Note: I wish this were true, but currently it
isn't. At some future date when we do an overhaul of this stuff and
introduce units, perhaps users can choose which behavior they want. --
byorgey 20 Nov 2013

> Note, however, that the cairo backend includes a module
Diagrams.Backend.Cairo.Text with functions for querying font and text
extents, and creating text diagrams that take up an appropriate amount of
space. So it is possible to have automatically-sized text objects, at the
cost of being tied to the cairo backend and bringing IO into the picture
(or being at peace with some probably-justified uses of unsafePerformIO).

Cheers
Sylvain


2014-02-28 9:13 GMT+01:00 Vincent Berthoux <vincent.berthoux at gmail.com>:

> Hello Haskellers,
>
>   I'm pleased to announce two new packages, whom work hand in hand:
> FontyFruity, a truetype file parser, and Rasterific a vector drawing
> engine. This two libraries enable us to generate pictures without the need
> of an external C library, and saving them to a file or directly send them
> over the network.
>
> FontyFruity:
>   * hackage : http://hackage.haskell.org/package/FontyFruity
>   * Github : https://github.com/Twinside/FontyFruity
>
> Rasterific:
>   * hackage : http://hackage.haskell.org/package/Rasterific
>   * Github : https://github.com/Twinside/Rasterific
>
>    Regards
>
>        Vincent
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140228/6dd8e36a/attachment.html>

From vincent.berthoux at gmail.com  Fri Feb 28 09:07:03 2014
From: vincent.berthoux at gmail.com (Vincent Berthoux)
Date: Fri, 28 Feb 2014 10:07:03 +0100
Subject: [Haskell-cafe] [ANN] Rasterific & FontyFruity
In-Reply-To: <CAPmptcVYdsiZ2DEqLNVRvudKAYwHT1xt7BhwFU5NiYFPEGWn1g@mail.gmail.com>
References: <CALCmskVSMf-mQOztjj=zP2xGOGZRFJ3Q6bRm8v19BrowwzsMEw@mail.gmail.com>
 <CAPmptcVYdsiZ2DEqLNVRvudKAYwHT1xt7BhwFU5NiYFPEGWn1g@mail.gmail.com>
Message-ID: <CALCmskWzDE+1Qc-mrzz239QFxvzt+-SpA0xc2m1eZmR=akaorw@mail.gmail.com>

Hi Sylvain,

   It should be possible, but in order to get the extent of a text element,
you need the point size and the DPI of your output medium. Please, don't
hesitate to fill a ticket on the github page.

   Regards

      Vincent


2014-02-28 9:49 GMT+01:00 Sylvain Henry <hsyl20 at gmail.com>:

> Awesome! Would it be possible to use FontyFruity to remove the limitations
> of Text in Diagrams (see below)? Is there something missing in Rasterific
> to render SVG?
>
> From http://projects.haskell.org/diagrams/doc/manual.html#text
>
> > Text objects take up no space!
>
> > The main reason for this is that computing the size of some text in a
> given font is rather complicated, and diagrams cannot (yet) do it natively.
> The cairo backend can do it (see below) but we don't want to tie diagrams
> to a particular backend.
> > The second reason is that font size is handled similarly to line width,
> so the size of a text object cannot be known at the time of its creation
> anyway! (Future versions of ``diagrams`` may include some sort of
> constraint-solving engine to be able to handle this sort of situation, but
> don't hold your breath.) Font size is treated similarly to line width for a
> similar reason: we often want disparate text elements to be the same size,
> but those text elements may be part of subdiagrams that have been
> transformed in various ways. Note: I wish this were true, but currently it
> isn't. At some future date when we do an overhaul of this stuff and
> introduce units, perhaps users can choose which behavior they want. --
> byorgey 20 Nov 2013
>
> > Note, however, that the cairo backend includes a module
> Diagrams.Backend.Cairo.Text with functions for querying font and text
> extents, and creating text diagrams that take up an appropriate amount of
> space. So it is possible to have automatically-sized text objects, at the
> cost of being tied to the cairo backend and bringing IO into the picture
> (or being at peace with some probably-justified uses of unsafePerformIO).
>
> Cheers
> Sylvain
>
>
> 2014-02-28 9:13 GMT+01:00 Vincent Berthoux <vincent.berthoux at gmail.com>:
>
>> Hello Haskellers,
>>
>>   I'm pleased to announce two new packages, whom work hand in hand:
>> FontyFruity, a truetype file parser, and Rasterific a vector drawing
>> engine. This two libraries enable us to generate pictures without the need
>> of an external C library, and saving them to a file or directly send them
>> over the network.
>>
>> FontyFruity:
>>   * hackage : http://hackage.haskell.org/package/FontyFruity
>>   * Github : https://github.com/Twinside/FontyFruity
>>
>> Rasterific:
>>   * hackage : http://hackage.haskell.org/package/Rasterific
>>   * Github : https://github.com/Twinside/Rasterific
>>
>>    Regards
>>
>>        Vincent
>>
>> _______________________________________________
>> Haskell-Cafe mailing list
>> Haskell-Cafe at haskell.org
>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>
>>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140228/b370d9ab/attachment.html>

From cam at uptoisomorphism.net  Fri Feb 28 14:44:19 2014
From: cam at uptoisomorphism.net (Casey McCann)
Date: Fri, 28 Feb 2014 09:44:19 -0500
Subject: [Haskell-cafe] Haskell spec vs FlexibleInstances
In-Reply-To: <CD122DE3-D6D5-4488-B773-2DB3DD6F0B7E@karlv.net>
References: <201402182011.s1IKBw2e003049@stowe.cs.dartmouth.edu>
 <loom.20140218T212623-105@post.gmane.org>
 <CD122DE3-D6D5-4488-B773-2DB3DD6F0B7E@karlv.net>
Message-ID: <CAJ5riwKG_R4z7+8Tgh1EEFxxQ_TfrtAcEJ9S78v2AwYj-okWOw@mail.gmail.com>

On Thu, Feb 27, 2014 at 8:32 PM, Karl Voelker <karl at karlv.net> wrote:
> The spec doesn't allow multi-parameter type classes at all, so I don't see how you could run into this problem while writing extensionless Haskell.
>
> I guess it's still a valid question whether the MultiParamTypeClasses extension should allow repeated type parameters.

The restriction to distinct type variables, and the resulting issues
with unification, apply equally to instances for applied type
constructors. This disallows e.g. writing a Monoid instance for (a ->
a) directly without a newtype wrapper, not that we'd want to do that
anyway.

- C.

From dan.doel at gmail.com  Fri Feb 28 16:14:02 2014
From: dan.doel at gmail.com (Dan Doel)
Date: Fri, 28 Feb 2014 11:14:02 -0500
Subject: [Haskell-cafe] Haskell spec vs FlexibleInstances
In-Reply-To: <CAJ5riwKG_R4z7+8Tgh1EEFxxQ_TfrtAcEJ9S78v2AwYj-okWOw@mail.gmail.com>
References: <201402182011.s1IKBw2e003049@stowe.cs.dartmouth.edu>
 <loom.20140218T212623-105@post.gmane.org>
 <CD122DE3-D6D5-4488-B773-2DB3DD6F0B7E@karlv.net>
 <CAJ5riwKG_R4z7+8Tgh1EEFxxQ_TfrtAcEJ9S78v2AwYj-okWOw@mail.gmail.com>
Message-ID: <CAHEA9tOxJroDy_phc-T52s0B39vfEz5o5C8H6P-6HuvhiYh3Ew@mail.gmail.com>

On Fri, Feb 28, 2014 at 9:44 AM, Casey McCann <cam at uptoisomorphism.net>wrote:

> The restriction to distinct type variables, and the resulting issues
> with unification, apply equally to instances for applied type
> constructors. This disallows e.g. writing a Monoid instance for (a ->
> a) directly without a newtype wrapper, not that we'd want to do that
> anyway.
>

This was once the instance defined in Data.Monoid. It was changed to the
current one in GHC 6.6.

--
 Dan
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140228/0fa796d5/attachment.html>

From corentin.dupont at gmail.com  Fri Feb 28 17:28:43 2014
From: corentin.dupont at gmail.com (Corentin Dupont)
Date: Fri, 28 Feb 2014 18:28:43 +0100
Subject: [Haskell-cafe] export DataKinds
Message-ID: <CAEyhvmq+dY0fe05WRoMvgYGhuQ_bhqY57PZuefovP5yW9pD+Uw@mail.gmail.com>

Hi Cafe,
I create kinds using the DataKinds extension:

{-# LANGUAGE DataKinds #-}

module MyModule where

data Foo = Bar | Baz

The problem is that the generated Bar and Baz type constructors are not
exported!
I am obliged to put the pragma DataKinds in every package that uses
MyModule (a lot).
Is there a way to avoid that?

Thanks!
Corentin
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140228/cbb741cc/attachment.html>

From eir at cis.upenn.edu  Fri Feb 28 18:36:34 2014
From: eir at cis.upenn.edu (Richard Eisenberg)
Date: Fri, 28 Feb 2014 13:36:34 -0500
Subject: [Haskell-cafe] export DataKinds
In-Reply-To: <CAEyhvmq+dY0fe05WRoMvgYGhuQ_bhqY57PZuefovP5yW9pD+Uw@mail.gmail.com>
References: <CAEyhvmq+dY0fe05WRoMvgYGhuQ_bhqY57PZuefovP5yW9pD+Uw@mail.gmail.com>
Message-ID: <2190F448-5DE0-460E-AA9F-5C98EA42B820@cis.upenn.edu>

Promoted data constructors aren't imported/exported separately from the normal data constructors. So, to use a promoted data constructor in an importing module, you need to import the normal data constructor and then promote it, with DataKinds.

But, here is a workaround:

> {-# LANGUAGE DataKinds #-}
> data Foo = Bar | Baz
> type Bar = 'Bar
> type Baz = 'Baz

This defines (normal, not promoted) type synonyms for the promoted data constructors. Because the namespace for types and the one for data constructors are distinct, you can even reuse the same names. In a quick test, an importing module was able to use these without DataKinds specified.

I hope this helps!
Richard

On Feb 28, 2014, at 12:28 PM, Corentin Dupont wrote:

> Hi Cafe,
> I create kinds using the DataKinds extension:
> 
> {-# LANGUAGE DataKinds #-}
> 
> module MyModule where
> 
> data Foo = Bar | Baz
> 
> The problem is that the generated Bar and Baz type constructors are not exported!
> I am obliged to put the pragma DataKinds in every package that uses MyModule (a lot).
> Is there a way to avoid that?
> 
> Thanks!
> Corentin
> 
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe


From corentin.dupont at gmail.com  Fri Feb 28 18:45:47 2014
From: corentin.dupont at gmail.com (Corentin Dupont)
Date: Fri, 28 Feb 2014 19:45:47 +0100
Subject: [Haskell-cafe] export DataKinds
In-Reply-To: <2190F448-5DE0-460E-AA9F-5C98EA42B820@cis.upenn.edu>
References: <CAEyhvmq+dY0fe05WRoMvgYGhuQ_bhqY57PZuefovP5yW9pD+Uw@mail.gmail.com>
 <2190F448-5DE0-460E-AA9F-5C98EA42B820@cis.upenn.edu>
Message-ID: <CAEyhvmpx8F1VN6q_1ZM+naZqcq5AuJ2suXRfo3ca=KvT6dn_Aw@mail.gmail.com>

Thanks!


On Fri, Feb 28, 2014 at 7:36 PM, Richard Eisenberg <eir at cis.upenn.edu>wrote:

> Promoted data constructors aren't imported/exported separately from the
> normal data constructors. So, to use a promoted data constructor in an
> importing module, you need to import the normal data constructor and then
> promote it, with DataKinds.
>
> But, here is a workaround:
>
> > {-# LANGUAGE DataKinds #-}
> > data Foo = Bar | Baz
> > type Bar = 'Bar
> > type Baz = 'Baz
>
> This defines (normal, not promoted) type synonyms for the promoted data
> constructors. Because the namespace for types and the one for data
> constructors are distinct, you can even reuse the same names. In a quick
> test, an importing module was able to use these without DataKinds specified.
>
> I hope this helps!
> Richard
>
> On Feb 28, 2014, at 12:28 PM, Corentin Dupont wrote:
>
> > Hi Cafe,
> > I create kinds using the DataKinds extension:
> >
> > {-# LANGUAGE DataKinds #-}
> >
> > module MyModule where
> >
> > data Foo = Bar | Baz
> >
> > The problem is that the generated Bar and Baz type constructors are not
> exported!
> > I am obliged to put the pragma DataKinds in every package that uses
> MyModule (a lot).
> > Is there a way to avoid that?
> >
> > Thanks!
> > Corentin
> >
> > _______________________________________________
> > Haskell-Cafe mailing list
> > Haskell-Cafe at haskell.org
> > http://www.haskell.org/mailman/listinfo/haskell-cafe
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140228/4c050990/attachment.html>

From s.j.thompson at kent.ac.uk  Fri Feb 28 19:20:36 2014
From: s.j.thompson at kent.ac.uk (Simon Thompson)
Date: Fri, 28 Feb 2014 19:20:36 +0000
Subject: [Haskell-cafe] SBLP 2014 - Call for Papers
References: <032E6DC4-F39A-494C-A691-ACE9E9692659@kent.ac.uk>
Message-ID: <983E88D4-EB58-43E7-81A7-C1C1A8DB2D59@kent.ac.uk>







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.

SBLP happens on Thursday, Oct 2nd, and Friday, Oct 3rd.
CBSoft dates are September 28, 2014 to October 3, 2014

This CFP is also available at the webpage of the event:
http://www.ic.ufal.br/evento/cbsoft2014/en/call-for-papers-sblp.html

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 city in the Northeastern part of
Brazil. The conference will happen on October 2nd, 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. Accepted papers
written 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.

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
Fabrice Rastello, INRIA
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
Jeremy Singer University of Glasgow
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
Roberto Ierusalimschy PUC-Rio
Rodrigo Geraldo, Federal University of Ouro Preto
Sandro Rigo, State University of Campinas
S?rgio Medeiros, Federal University of Rio Grande do Norte
Simon Thompson, University of Kent
Varmo Vene, University of Tartu
Zongyan Qiu Peking University

Simon Thompson | Professor of Logic and Computation 
School of Computing | University of Kent | Canterbury, CT2 7NF, UK
s.j.thompson at kent.ac.uk | M +44 7986 085754 | W www.cs.kent.ac.uk/~sjt




Simon Thompson | Professor of Logic and Computation 
School of Computing | University of Kent | Canterbury, CT2 7NF, UK
s.j.thompson at kent.ac.uk | M +44 7986 085754 | W www.cs.kent.ac.uk/~sjt



From jeremy at n-heptane.com  Fri Feb 28 19:56:17 2014
From: jeremy at n-heptane.com (Jeremy Shaw)
Date: Fri, 28 Feb 2014 13:56:17 -0600
Subject: [Haskell-cafe] GHC 7.6.3 and Plugins 1.5.4.0
In-Reply-To: <CAG=SMqZprEL7HOMMrjuDQ8FrskSCkNkhyg=Q7g30Dq7PfPJDDA@mail.gmail.com>
References: <CAG=SMqZprEL7HOMMrjuDQ8FrskSCkNkhyg=Q7g30Dq7PfPJDDA@mail.gmail.com>
Message-ID: <CAGE_JKYnaQLcYE98VsQ3jz30sYi51oMVigdZuKA2uu=v3Hs3Eg@mail.gmail.com>

I honestly have no idea whatsoever. The plugins library was written by
somebody else and I am the maintainer only in the sense that I will
apply patches that people send.

That said, I really want a working, modern version of the plugins
library that uses the GHC-API and integrates with cabal and cabal
sandboxes. I have started such a library here:

https://github.com/Happstack/plugins-ng

It is pretty much only proof of concept at the moment. But there is a
working example. It desperately needs additional developers though if
it is going to be usable anytime soon.

- jeremy

On Mon, Feb 24, 2014 at 7:12 AM, Fabian Bergmark
<fabian.bergmark at gmail.com> wrote:
> Im using the plugins library and am unable get it to work with user
> defined types. I.e. evaluating the string "id :: Int -> Int" works,
> but "id :: Test -> Test" yield the runtime-error.
>
> test: /tmp/MXXXXX27601.o: unknown symbol
> `testdzm0zi0zi0_DataziTestD_zdfTypeableTestD_closure'
>
> I have created a small compiling example of the bug here
>
> https://github.com/fabianbergmark/plugins-bug
>
> I have tried to move the data-type to a separate library without success.
>
> Curiously, loading the library exposing the data-type in GHCi, and
> running eval "id :: Test -> Test" works and yields the correct result.
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe

From jmitdase at gmail.com  Fri Feb 28 20:22:59 2014
From: jmitdase at gmail.com (Joey Eremondi)
Date: Fri, 28 Feb 2014 14:22:59 -0600
Subject: [Haskell-cafe] Scaling Haskell/Yesod on OpenShift
Message-ID: <CAA_J3fHPJCchYrUptGWAA8xeAj+JLZKdCqtjJgXG4OvLceX+0w@mail.gmail.com>

I was wondering, does anyone have experience with using Haskell/Yesod on
the OpenShift PaaS? I've seen the Haskell and Yesod cartridges, but I'm
wondering if there's any way to get Haskell playing nice with their
load-balancing and automatic scaling capabilities? Would CloudHaskell be
useful at all in this?

I'm reasonably experienced with Haskell but very new to Cloud computing and
Web stuff, so any advice, even if basic, is helpful. Thanks!
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20140228/f1dd097c/attachment.html>