- Haskell-Cafe - Haskell.org

ANN: data-textual: Human-friendly textual representations
by Mikhail Vorozhtsov 24 Apr '13

24 Apr '13

Hello lists, I'm pleased to announce the first release of data-textual[1], a library that provides human-friendly counterparts (called Printable/Textual) of the compiler-friendly Show/Read type classes. The library is intended to be used for printing and parsing of non-compound and non-polymorphic compound data (e.g. numbers, network and hardware addresses, date/time, etc). A quick example (vs network-ip[2] library): λ> import Data.Maybe (fromJust) λ> import Data.Textual λ> import Network.IP.Addr λ> let x = fromString "[dead::b:e:e:f]:123" :: Maybe Inet6Addr λ> x Just (InetAddr {inetHost = ip6FromWords 0xdead 0x0 0x0 0x0 0xb 0xe 0xe 0xf, inetPort = 123}) λ> toString (fromJust x) "[dead::b:e:e:f]:123" λ> let y = fromStringAs aNet4Addr "192.168.100.1/24" λ> y Just (netAddr (ip4FromOctets 192 168 100 1) 24) λ> toText (netPrefix $ fromJust y) "192.168.100.0" [1] http://hackage.haskell.org/package/data-textual [2] http://hackage.haskell.org/package/network-ip

1 0

[ANN] New releases of crypto-api, DRBG, commsec, commsec-keyexchange, and cipher-aes128
by Thomas DuBuisson 24 Apr '13

24 Apr '13

All, I have recently released new versions of: - crypto-api[1]: An interface for cryptographic algorithms such as block ciphers, hashes, and secure random number generators. This version includes Klondike's cbcMac and SIV modes of operation - much thanks to his numerous patches. - DRBG[2]: A set of deterministic random bit generators (aka CPRNGs) based on NIST 800-90. - commsec[3]: A communications security package that provides data in transit security using AES-128 GCM without any external, C library, dependencies. - commsec-keyexchange[4]: A key exchange tool that leverages RSA keys to establish connection's for use with the commsec package. - cipher-aes128[5]: A re-packaging of Vincent Hanquez's excellent AES routines. ==Crypto API== Crypto-API was first released in 2010 with an aim of providing an interface useful to consumers of cryptographic algorithms and providers of those algorithms. It includes classes for block, stream, and asymmetric ciphers as well as for random number generators, hashes, and signature algorithms. Recent changes include: - Added SIV and cbcMac thanks to Klondike. NOTE: Some of this code is only conditionally included via a compile time flag due to GHC's slow compilation of the CPoly module. - Moved block cipher modes into the type classes, allowing use of high-speed C or ASM mode implementations. - More generator query methods in the CryptoRandomGen class. - Updated build dependencies - Move operations and expose them from Crypto.Util ==DRBG== DRBG implements the Hash and HMAC based generators specified in NIST SP 800-90. A generator using block ciphers in CTR mode is also provided, but is not based on the special publication. ==CommSec and CommSec-KeyExchange== Together, these packages provide a way to start from shared RSA keys and obtain a thread-safe secure communications channel. A pull-request is currently out to crypto-pubkey-openssh that would allow the reading and use of RSA keys generated by ssh-keygen. These packages aim to be "morally correct" in that they perform the correct operations at an equivalent computational cost of a properly vetted system, but are not themselves vetted for critical use. For small messages, commsec performs faster than the non-threadsafe secure-sockets counterpart. For larger messages the performance is not as competitive due to the GCM routine not being fully optimized. ==cipher-aes128== This package has performance benefits (vs cipher-aes) due to function-pointer rewriting that allows us to avoid excessive checking of the CPU info [6]. This package is hopefully going to be short-lived with the optimizations getting folded into Vincent's 'cipher-aes' once things are mature enough. A windows tester would help. Comments and patches are welcome. Sorry if I forgot to thank anyone who contributed, many of these projects have been neglected and I lose context in the interim. Cheers, Thomas M. DuBuisson [1] http://hackage.haskell.org/package/crypto-api [2] http://hackage.haskell.org/package/DRBG [3] http://hackage.haskell.org/package/commsec [4] http://hackage.haskell.org/package/commsec-keyexchange [5] http://hackage.haskell.org/package/cipher-aes128 [6] https://github.com/vincenthz/hs-cipher-aes/issues/8 - Up to 40% faster for small operations.

1 0

what happened to alexAndPred?
by Johannes Waldmann 24 Apr '13

24 Apr '13

Hi. I have ghc-7.6.3 and alex-3.0.5. When I build https://github.com/jwaldmann/smt-lib it breaks with Language/SMTLIB/Lexer.x:6:5: Not in scope: `alexAndPred'. It was working with alex-2.3.5. I was going t add "Can I constrain the alex version in the cabal file (I recall this is difficult for executables since they're not registered with ghc)" but it wouldn't help since alex-2.3.5 cannot be built with a recent ghc-7.6 because Module `System.IO.Error' does not export `try'. Also, not with ghc-7.4.2 because of dist/build/alex/alex-tmp/Scan.hs:344:17: Illegal bang-pattern (use -XBangPatterns): And not with <= ghc-7.2 because of Linking /tmp/alex-2.3.5-20331/alex-2.3.5/dist/setup/setup ... unrecognized option `--disable-benchmarks'

1 0

Re: [Haskell-cafe] Haskell compilation errors break the complexity encapsulation on DSLs
by Stephen Tetley 23 Apr '13

23 Apr '13

Helium - Utrecht University's simplified Haskell - had scriptable "Type inference directives" so the creator of an EDSL was able to augment the type checker to provide better error messages, see: Scripting the Type Inference Process Bastiaan Heeren Jurriaan Hage S. Doaitse Swierstra

2 1

ANN: network-simple 0.1.0.1
by Renzo Carbonara 23 Apr '13

23 Apr '13

Since the release of `pipes-network`, I've been encouraged to move the non-pipes-related TCP utilities to their own package, so I've done that, and `network-simple` is the result. This package builds on top of the great `network` package available in The Haskell Platform, and aims to simplify the usage of some common networking patterns, such as binding a TCP socket to a port and immediately start listening and accepting incoming connections to it, handling each connection in a different thread. Managing the lifetime of the obtained socket resources is also automated. Currently, only utilities for dealing with TCP connections are available, but I look forward to add support for UDP and Unix Domain Sockets, as well as TLS. Hackage hasn't rendered the documentation yet, so I uploaded the documentation here: http://monoid.k0001.org/haskell/network-simple/doc/index.html The code can be found at: https://github.com/k0001/network-simple I've only tried this package on the current Haskell Platform 2012.4.0.0 on Linux, let me know if something does not work in a different environment. By the way, `pipes-network-0.1.1.0` now depends on this package. Regards, Renzo Carbonara.

1 0

Yi Google summer of code project
by Bastien Jacot-Guillarmod 23 Apr '13

23 Apr '13

Hello, I'm interested in doing some improvments on the Yi editor for my Google summer of code by implementing a completion pop up list for any buffer and a smart completion for haskell. But I don't really know if this kind of project could be acceptable, for the following reason: 1) Should a GSoC project be mostly a working experience or also a learning one? I am not the most seasoned haskell programmer, but I really which to dive into a real-life project in this language. 2) Is it too long, too small? I don't have too many years of programmation in haskell behind me even if I have done some functionnal programming in other languages (Scala most of the time), hence I don't want to take something that will be overwhelming. 3) is Yi associated with haskell.org or it is not possible to have a project on Yi while being mentored by haskell? Thanks for your insight! Regards, Bastien Jacot-Guillarmod, 3rd CS bachelor student at EPFL (Lausanne) -- View this message in context: http://haskell.1045720.n5.nabble.com/Yi-Google-summer-of-code-project-tp572… Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

3 2

Re: [Haskell-cafe] Implementing an embedded language that threads a global structure.
by Ian Bloom 23 Apr '13

23 Apr '13

I'm probably not the best person to answer your questions but here is a try: I refer to my language as a mini language because I'm only showing lamda, application and extension. You might choose to add other features like symbol definitions, fixed points, pattern matching etc. which in the more extensive versions of my code, I have. The state monad would essentially be application only, it would not include the very powerful lambda. I imagine you could implement such a language using monads but it would just be the same thing, yet more difficult to read and understand. By implementing the language embedded in Haskell you can "piggyback" on Haskell's parser and type-checker. This is the first paper I read about embedded languages. Compiling Embedded Languages - CiteSeerX<http://www.google.com/url?sa=t&rct=j&q=compiling%20embedded%20languages&sou…> You might think of embedded languages as a style or design pattern. It's purpose is to abstract an entire category of behavior and simplify the task of a person programming in the embedded language even if they are somehow limited. It seems like an embedded language would be a good option. In the code sample below, if you add a string parameter to LambdaExtension to include pieces of Perl code and make a version of the instance Pr for printing perl code into a string you might be well on your way: module Main ( main, lam, app, ext, trmA, trmB, trmC, trmD, trmE, trmF ) where data LambdaExtension f = LExtend String f int_ :: Integer -> LambdaExtension Integer int_ x = LExtend (show x) x add_ :: Num a => LambdaExtension (a -> a -> a) add_ = LExtend "+" (+) mul_ :: Num a => LambdaExtension (a -> a -> a) mul_ = LExtend "*" (*) leq_ :: Ord a => LambdaExtension (a -> a -> Bool) leq_ = LExtend "<=" (<=) not_ :: LambdaExtension (Bool -> Bool) not_ = LExtend "not" not class Calculus repr where lam :: String -> (repr gl a -> repr gl b) -> repr gl (a->b) def :: String -> repr gl a -> repr gl a app :: repr gl (a->b) -> repr gl a -> repr gl b fix :: String -> (repr gl a -> repr gl a) -> repr gl a ext :: LambdaExtension e -> repr gl e -- R is the evaluator data R gl t = R t deriving Show unR (R x) = x instance Calculus R where lam _ f = R (\z -> unR (f (R z))) def _ f = R (unR f) app e1 e2 = R ( (unR e1) (unR e2) ) fix _ f = R (fx (unR . f. R)) where fx f = f (fx f) ext (LExtend _ f) = R f -- Pr is the printer newtype Pr g a = Pr String unPr (Pr f) = f instance Calculus Pr where lam vN f = Pr(let var = Pr vN body = unPr (f var) in "\\"++ vN ++"->"++ body) def dN f = Pr (dN ++ " = " ++ unPr f) app e1 e2 = Pr(let e1b = unPr e1 e2b = unPr e2 in "(" ++ e1b ++ " " ++ e2b ++ ")") fix vN f = Pr(let var = Pr vN body = unPr (f var) in "fix\\" ++ vN ++ "->" ++ body) ext (LExtend s _) = Pr s app2 f x y = (app (app f x) y) app3 f x y z = (app (app2 f x y) z) app4 f x y z w = (app (app3 f x y z) w) -- Sample Terms trmA = lam "x" (\x -> lam "y" (\y -> app x y)) trmB = lam "y" (\y -> app trmC y) trmC = lam "c" (\c-> app2 (ext add_) c (ext (int_ 1))) trmD = (ext (int_ 3)) trmE = app trmC trmD trmF = app trmC trmE main = do putStrLn "Hello!" putStrLn $ show $ unPr (trmA) putStrLn $ show $ unPr (trmF) putStrLn "**************" Cheers, Ian On Tue, Apr 23, 2013 at 11:12 AM, Ian Bloom <ianmbloom(a)gmail.com> wrote: > I'm probably not the best person to answer your questions but here is a > try: > > I refer to my language as a mini language because I'm only showing lamda, > application and extension. You might choose to add other features like > symbol definitions, fixed points, pattern matching etc. which in the more > extensive versions of my code, I have. > > The state monad would essentially be application only, it would not > include the very powerful lambda. I imagine you could implement such a > language using monads but it would just be the same thing, yet more > difficult to read and understand. By implementing the language embedded in > Haskell you can "piggyback" on Haskell's parser and type-checker. > > This is the first paper I read about embedded languages. Compiling > Embedded Languages - CiteSeerX<http://www.google.com/url?sa=t&rct=j&q=compiling%20embedded%20languages&sou…> > You might think of embedded languages as a style or design pattern. It's > purpose is to abstract an entire category of behavior and simplify the task > of a person programming in the embedded language even if they are somehow > limited. > > It seems like an embedded language would be a good option. > In the code sample below, if you add a string parameter to LambdaExtension > to include pieces of Perl code and make a version of the instance Pr for > printing perl code into a string you might be well on your way: > > module Main ( > main, > lam, app, ext, > trmA, trmB, trmC, trmD, trmE, trmF > ) where > > data LambdaExtension f = LExtend String f > > int_ :: Integer -> LambdaExtension Integer > int_ x = LExtend (show x) x > > add_ :: Num a => LambdaExtension (a -> a -> a) > add_ = LExtend "+" (+) > > mul_ :: Num a => LambdaExtension (a -> a -> a) > mul_ = LExtend "*" (*) > > leq_ :: Ord a => LambdaExtension (a -> a -> Bool) > leq_ = LExtend "<=" (<=) > > not_ :: LambdaExtension (Bool -> Bool) > not_ = LExtend "not" not > > class Calculus repr where > lam :: String -> (repr gl a -> repr gl b) -> repr gl (a->b) > def :: String -> repr gl a -> repr gl a > app :: repr gl (a->b) -> repr gl a -> repr gl b > fix :: String -> (repr gl a -> repr gl a) -> repr gl a > ext :: LambdaExtension e -> repr gl e > > -- R is the evaluator > data R gl t = R t deriving Show > unR (R x) = x > > instance Calculus R where > lam _ f = R (\z -> unR (f (R z))) > def _ f = R (unR f) > app e1 e2 = R ( (unR e1) (unR e2) ) > fix _ f = R (fx (unR . f. R)) where fx f = f (fx f) > ext (LExtend _ f) = R f > > -- Pr is the printer > > newtype Pr g a = Pr String > unPr (Pr f) = f > > instance Calculus Pr where > lam vN f = Pr(let var = Pr vN > body = unPr (f var) > in "\\"++ vN ++"->"++ body) > def dN f = Pr (dN ++ " = " ++ unPr f) > app e1 e2 = Pr(let e1b = unPr e1 > e2b = unPr e2 > in "(" ++ e1b ++ " " ++ e2b ++ ")") > fix vN f = Pr(let var = Pr vN > body = unPr (f var) > in "fix\\" ++ vN ++ "->" ++ body) > ext (LExtend s _) = Pr s > > > app2 f x y = (app (app f x) y) > app3 f x y z = (app (app2 f x y) z) > app4 f x y z w = (app (app3 f x y z) w) > > -- Sample Terms > trmA = lam "x" (\x -> lam "y" (\y -> app x y)) > trmB = lam "y" (\y -> app trmC y) > trmC = lam "c" (\c-> app2 (ext add_) c (ext (int_ 1))) > trmD = (ext (int_ 3)) > trmE = app trmC trmD > trmF = app trmC trmE > > main = do > putStrLn "Hello!" > putStrLn $ show $ unPr (trmA) > putStrLn $ show $ unPr (trmF) > putStrLn "**************" > > Cheers, > Ian > > On Tue, Apr 23, 2013 at 12:42 AM, C K Kashyap <ckkashyap(a)gmail.com> wrote: > >> Hi Ian, >> I have a couple of questions for you - >> >> 1. Could you explain why a lambda calculus like language embedded in >> Haskell would be useful - I ask this because, the way I understand, Haskell >> is already such a language - one could easily chose to restrict oneself to >> just function definition and application. Perhaps an example problem which >> can be expressed more clearly in your described embedded language but not >> in Haskell would help me understand your point of view better. >> >> 2. Have you considered using the state monad? >> >> I am personally attempting to figure out a way to embed Perl in Haskell - >> as in, describe Perl like code (but statically checked) in Haskell and then >> generate Perl that I could use to execute on server farms which run on old >> Linux kernels where I cannot run Haskell code. >> >> I totally get that "edge of understanding" feeling :) >> >> Regards, >> Kashyap >> >> >> >> >> On Mon, Apr 22, 2013 at 3:22 AM, Ian Bloom <ianmbloom(a)gmail.com> wrote: >> >>> Hi, >>> >>> I've been working on this problem for some time and I was hoping for >>> some feedback. I'm trying to implement an embedded language that can thread >>> a global structure through the evaluation of a term. >>> >>> A mini version of this language only includes three functions, lam, app >>> and ext (lambda, apply and extension respectively). The only difference >>> between this and other embedded languages is that terms embedded in an >>> extension have access to a global variable that is invisible to the terms >>> themselves. >>> >>> The writer of a term in this language can only access the global >>> variable by applying an extension. The writer extensions insures that the >>> effect of evaluation on the global variable is commutative and insures that >>> the effect of the global variable on terms is constant regardless of the >>> order of evaluation. >>> >>> For example the global variable could be a map with some sort of lazy >>> processing. An extension that queries the map for an element might cause a >>> change in the state of the map and return some information about an >>> element, but as long as the change in state are commutative and the same >>> information is returned about elements regardless of the order of >>> evaluation then the concept is safe. >>> >>> My motivation for experimenting with such a language comes from a belief >>> that certain complicated programs would be easier to express in such a >>> language and that there might be very useful code transformations that >>> could eventually be applied to such a language that would be possible >>> because of the constraints on the behavior of extensions. >>> >>> However I have yet to properly implement a language in Haskell and so I >>> decided to post what I have and look for comments. >>> >>> Basically the language takes a common form of embedded languages; a >>> lambda expression such as >>> >>> \x y->x y >>> >>> would have the form: >>> >>> lam (\x -> lam (\y -> app x y)) >>> >>> however in order to evaluate an expression the need to also apply it to >>> a global term: >>> >>> lam (\x -> lam (\y -> app x y)) global >>> >>> Ideally the result of evaluating this would be a (global', \x y-> x y), >>> a modified version of global paired with the term. So the type of the term: >>> >>> lam (\x -> lam (\y -> app x y)) is something like g -> (g, (a -> b) -> a >>> -> b) where g is the type of global. >>> >>> From that came the first idea of the types of the evaluator functions: >>> >>> lam :: ( (g->(g,a)) -> (g->(g,b)) )-> (g->(g, a->b)) >>> app :: (g->(g,a->b)) -> (g->(g, a)) -> (g->(g,b)) >>> >>> with some additional parenthesis for sake of clarity. Each sub-term has >>> the type g->(g,t) >>> >>> any function can be included as an extension as long as the function has >>> the type: >>> (g->(g,a)) -> (g->(g,b)) >>> >>> This seems to work well except that it seems to be impossible (as far as >>> I've tried) to construct a definition for the lam function that both fits >>> this type and properly passes the global through the entire evaluation. For >>> example it's easy to define app like this: >>> >>> app :: (g->(g,a->b)) -> (g->(g,a)) -> (g->(g,b)) >>> app = (\ eA eB -> \ g0 -> let (gB, fB) = eB g0 >>> in let (gA, fA) = eA gB >>> in (gA, fA fB) ) >>> >>> but so far the definition of lam has eluded me. This is the closest I've >>> come: >>> >>> lam :: ((g->(g,a)) -> (g->(g,b))) -> (g->(g,a->b)) >>> lam = (\ f -> \ g0 -> (g0, \x -> snd $ (f (\ gv->(gv,x))) g0 )) >>> >>> This fits the type but I fear this definition does not return the >>> properly modified version of global. >>> >>> I tried some other iterations of this idea. In one effort the first >>> argument of a function is extracted into the type of a term. So a term of >>> type a->b has the type (g->a->(g,b)). And a term of type a has the type >>> (g->((g, a)) such that: >>> >>> lam2 :: ((g->(g,a)) -> (g->(g,b))) -> (g->a->(g,b)) >>> lam2 = (\ f -> \ g x -> (f (\ gv -> (gv, x))) g) >>> >>> app2 :: (g->a->(g,b)) -> (g->(g,a)) -> (g->(g,b)) >>> app2 = (\ eA eB -> \ g0 -> let (gB, fB) = eB g0 >>> in eA gB fB ) >>> >>> This seems like a step in the right direction unfortunately because the >>> return type of lam is now (g->a->(g,b)) and not (g->(g->c)) we cannot type >>> the term lam (\x -> lam (\y -> app x y)). In other words this language can >>> only express unary and nullary functions. >>> Just to help clarify this for myself I created to addition functions >>> lam2Helper and app2Helper: >>> >>> lam2Helper :: (g->a->(g,b)) -> (g->(g,a->b)) >>> lam2Helper = (\f -> \g -> (g, \a -> snd $ f g a)) >>> app2Helper :: (g->(g,a->b)) -> (g->a->(g,b)) >>> app2Helper = (\f -> \g a-> let (g1, f1) = f g >>> in (g1, f1 a)) >>> >>> these allow me to create the term: >>> lam2 (\x -> lam2Helper $ lam2 (\y -> app2 (app2Helper x) y)) >>> >>> but just like the original definition of lam from my first try, there is >>> no way to construct lam2Helper without improperly passing the global as >>> I've done in my attempt. >>> >>> Finally on my third try I attempted to make every term have type >>> (g->a->(g,b) by allowing embedded nullary functions to have the type >>> (g->()->(g,t)) >>> >>> lam3 :: ((g->()->(g,a)) -> (g->()->(g,b))) -> (g->a->(g,b)) >>> lam3 = (\ f -> \ g x -> (f (\ gv () -> (gv, x))) g () ) >>> app3 :: (g->a->(g,b)) -> (g->()->(g,a)) -> (g->()->(g,b)) >>> app3 = (\ eA eB -> \ gz () -> let (gB, fB) = eB gz () >>> in eA gB fB ) >>> >>> This allows me to construct the term: >>> lam (\x -> lam (\y -> app x y)) >>> but only by throwing out important type information... >>> >>> A compilable example of this is available here: >>> http://hpaste.org/86273 >>> >>> And with source candy here: >>> http://hpaste.org/86274 >>> >>> My goal at this point is just to understand the problem better. I feel >>> I'm at the edge of my understanding of type systems and arity and I'm >>> unsure if what I want to do is possible in Haskell. My goal would >>> eventually be to construct a working prototype of such a language and to >>> construct a proof that it maintains the types of terms and that the global >>> variable is evaluated once by every subterm. >>> >>> I appreciate any insight, interest or help. >>> >>> Thanks, >>> Ian Bloom >>> ianmbloom(a)gmail.com >>> >>> >>> >>> >>> >>> _______________________________________________ >>> Haskell-Cafe mailing list >>> Haskell-Cafe(a)haskell.org >>> http://www.haskell.org/mailman/listinfo/haskell-cafe >>> >>> >> > > > -- > 718.755.5483 > http://ianbloom.com/ > -- 718.755.5483 http://ianbloom.com/

1 0

Automated Differentiation Type Question
by Dominic Steinitz 23 Apr '13

23 Apr '13

Can anyone tell me why I get a type error with testGrad2? What are my options? Clearly I would like to be able find the gradient of my cost function for different sets of observations. Thanks, Dominic. > {-# LANGUAGE NoMonomorphismRestriction #-} > > import Numeric.AD > > default() > > costFn :: Floating a => [a] -> [[a]] -> [a] -> a > costFn ys xss thetas = (/ (2*m)) $ sum $ map (^ (2 :: Int)) $ > zipWith (\y xs -> costFnAux y xs thetas) ys xss > where > m = fromIntegral $ length xss > costFnAux :: Floating a => a -> [a] -> [a] -> a > costFnAux y xs thetas = y - head thetas - sum (zipWith (*) xs (tail thetas)) > > ys :: Floating a => [a] > ys = [1.0, 2.0, 3.0] > > xss :: Floating a => [[a]] > xss = [[1.0], [2.0], [3.0]] > > thetas :: Floating a => [a] > thetas = [0.0, 1.0] > > test :: Floating a => a > test = costFn ys xss thetas > > testGrad0 = grad (costFn ys xss) > > testGrad1 :: Floating a => [a] -> [[a]] -> [a] -> [a] > testGrad1 ys xss = grad (costFn (undefined :: Floating a => [a]) (undefined :: Floating a => [[a]])) > > testGrad2 :: Floating a => [a] -> [[a]] -> [a] -> [a] > testGrad2 ys xss = grad (costFn ys xss) > [1 of 1] Compiling Main ( /Users/dom/Dropbox/Private/Whales/ADTypePuzzle.hs, interpreted ) > > /Users/dom/Dropbox/Private/Whales/ADTypePuzzle.hs:33:33: > Could not deduce (a ~ ad-3.4:Numeric.AD.Internal.Types.AD s a) > from the context (Floating a) > bound by the type signature for > testGrad2 :: Floating a => [a] -> [[a]] -> [a] -> [a] > at /Users/dom/Dropbox/Private/Whales/ADTypePuzzle.hs:32:14-53 > or from (Numeric.AD.Internal.Classes.Mode s) > bound by a type expected by the context: > Numeric.AD.Internal.Classes.Mode s => > [ad-3.4:Numeric.AD.Internal.Types.AD s a] > -> ad-3.4:Numeric.AD.Internal.Types.AD s a > at /Users/dom/Dropbox/Private/Whales/ADTypePuzzle.hs:33:20-39 > `a' is a rigid type variable bound by > the type signature for > testGrad2 :: Floating a => [a] -> [[a]] -> [a] -> [a] > at /Users/dom/Dropbox/Private/Whales/ADTypePuzzle.hs:32:14 > Expected type: [ad-3.4:Numeric.AD.Internal.Types.AD s a] > Actual type: [a] > In the first argument of `costFn', namely `ys' > In the first argument of `grad', namely `(costFn ys xss)' > In the expression: grad (costFn ys xss) > > /Users/dom/Dropbox/Private/Whales/ADTypePuzzle.hs:33:36: > Could not deduce (a ~ ad-3.4:Numeric.AD.Internal.Types.AD s a) > from the context (Floating a) > bound by the type signature for > testGrad2 :: Floating a => [a] -> [[a]] -> [a] -> [a] > at /Users/dom/Dropbox/Private/Whales/ADTypePuzzle.hs:32:14-53 > or from (Numeric.AD.Internal.Classes.Mode s) > bound by a type expected by the context: > Numeric.AD.Internal.Classes.Mode s => > [ad-3.4:Numeric.AD.Internal.Types.AD s a] > -> ad-3.4:Numeric.AD.Internal.Types.AD s a > at /Users/dom/Dropbox/Private/Whales/ADTypePuzzle.hs:33:20-39 > `a' is a rigid type variable bound by > the type signature for > testGrad2 :: Floating a => [a] -> [[a]] -> [a] -> [a] > at /Users/dom/Dropbox/Private/Whales/ADTypePuzzle.hs:32:14 > Expected type: [[ad-3.4:Numeric.AD.Internal.Types.AD s a]] > Actual type: [[a]] > In the second argument of `costFn', namely `xss' > In the first argument of `grad', namely `(costFn ys xss)' > In the expression: grad (costFn ys xss) > Failed, modules loaded: none.

1 1

Why are QuasiQuotes allowed in SafeHaskell?
by kudah 23 Apr '13

23 Apr '13

In GHC User's Guide, the reason to disable TemplateHaskell is as follows: > TemplateHaskell — Is particularly dangerous, as it can cause side > effects even at compilation time and can be used to access > constructors of abstract data types. Doesn't the same apply to quasi-quotes?

1 0

createProcess interferes with sockets?
by Evan Laforge 23 Apr '13

23 Apr '13

I've had a strange bug that's baffled me for a long time. I finally got serious about tracking it down, and managed to reduce it to a small program that exhibits the unexpected behaviour, namely that a createProcess seems to block writing to and closing a socket. Here's the example program: --- import Control.Monad import qualified Network import qualified System.Environment as Environment import qualified System.IO as IO import qualified System.Process as Process main :: IO () main = Network.withSocketsDo $ do args <- Environment.getArgs case args of ["server"] -> server ["client"] -> client _ -> error $ show args server :: IO () server = do socket <- Network.listenOn port forever $ do putStrLn "accept" (hdl, _host, _port) <- Network.accept socket msg <- IO.hGetLine hdl putStrLn $ "from client: " ++ show msg sleep putStrLn "send response" IO.hPutStr hdl "response" IO.hClose hdl client :: IO () client = do hdl <- Network.connectTo "localhost" port IO.hPutStr hdl "hi from client\n" IO.hFlush hdl resp <- IO.hGetContents hdl print resp port = Network.UnixSocket "port" sleep = Process.createProcess (Process.proc "sleep" ["5"]) --- You can test with: % ghc --make Test.hs && rm -f port && ./Test server then on another window: % ./Test client Since the createProcess is async (it doesn't wait on the pid), I expect the response to come back to the client immediately. And the server immediately says "send response" then "accept", so it doesn't get stuck on the sleep. But the client waits 5 seconds before displaying "response", so evidently even though the handle has already been written to and closed from the server, the client waits until the subprocess (of the server!) completes before getting the response. Comment out the "sleep" line and everything is fast. Can anyone else repro this? I'm guessing it has to do with the ghc IO manager, and the fork implied by a createProcess is causing it the socket close to block, but I haven't dug any deeper yet, in case this is a know issue, or I'm just doing something wrong. This is OS X 10.8.3. thanks!

3 6

Unbound: rebind and unrebind
by Eric Dobson 23 Apr '13

23 Apr '13

I am working at reimplementing the library Unbound to understand how it works. One issue I have come up with is that an equation that I thought held true doesn't. The equation is: Forall e::Rebind a b, e `aeq` (uncurry rebind . unrebind $ e) => True. That is that spliting the binding of a rebind and then adding it back should be the identity. The issue is that Rebind does not freshen its pattern variables on unrebind, because it assumes that a higher level unbind already did that if required. But I believe this is not sufficient as there is not necesarily a higher level Bind to be ubound as shown by this program: {-# LANGUAGE TemplateHaskell, UndecidableInstances, FlexibleInstances, MultiParamTypeClasses #-} module Main where import Unbound.LocallyNameless data Exp = Var (Name Exp) deriving Show $(derive [''Exp]) instance Alpha Exp instance Subst Exp Exp where isvar (Var x) = Just (SubstName x) x :: Name Exp x = string2Name "x" y :: Name Exp y = string2Name "y" rebindPass :: Alpha a => Rebind Exp a -> Rebind Exp a rebindPass = (uncurry rebind . unrebind) main :: IO () main = do let rebound = (rebind (Var y) (Embed (Var x))) print $ rebound let substed = subst x (Var y) rebound print $ substed print $ unrebind substed print $ rebindPass substed Which outputs: <<Var y>> {Var x} <<Var y>> {Var y} (Var y,{Var y}) <<Var y>> {Var 0@0} If the equation holds true then the second and fourth lines should be identical but they are not. Can someone explain why this is the correct behavior or if the implementation is incorrect?

2 2

ANN: ipopt-hs 0.0.0.0
by adam vogt 23 Apr '13

23 Apr '13

I'm pleased to announce the first release of ipopt-hs. This package is a binding to a software package for large-scale nonlinear optimization <https://projects.coin-or.org/Ipopt>. You can get it from hackage: http://hackage.haskell.org/package/ipopt-hs Or if the documentation doesn't build (since hackage probably doesn't have ipopt), check: http://code.haskell.org/~aavogt/ipopt-hs/dist/doc/html/ipopt-hs/Ipopt.html One useful feature is that derivatives needed for the optimization can be calculated by automatic differentiation, thanks to <http://hackage.haskell.org/package/ad>. Some of the caveats with this release: - has only been tested with one problem, and only on linux, ghc-7.6.2 - derivatives are computed and stored without taking advantage of the fact that they may be sparse - advanced functions in coin/IpStdCInterface.h such as SetIntermediateCallback are not included Cheers, Adam Vogt

1 0

Dynamic collections of wires with netwire?
by Kata 23 Apr '13

23 Apr '13

I'm using netwire to make a top-down shooter; the player can spawn projectiles by clicking, and projectiles will destroy themselves and whatever they hit on collisions. So the way I'm thinking of this is as a collection of wires, one for each projectile, that I can cast input events to; however, I'm not sure how to deal with the fact that the set of wires is dynamically changing, since you can't do projectileWires <- accum (++) [] -< newProjectiles projectileState <- multicast projectileWires -< () or whatever. Do I have to write the relevant code out by hand using stepWire/stepWireP, or is there a nicer way?

1 0

Implementing an embedded language that threads a global structure.
by Ian Bloom 23 Apr '13

23 Apr '13

Hi, I've been working on this problem for some time and I was hoping for some feedback. I'm trying to implement an embedded language that can thread a global structure through the evaluation of a term. A mini version of this language only includes three functions, lam, app and ext (lambda, apply and extension respectively). The only difference between this and other embedded languages is that terms embedded in an extension have access to a global variable that is invisible to the terms themselves. The writer of a term in this language can only access the global variable by applying an extension. The writer extensions insures that the effect of evaluation on the global variable is commutative and insures that the effect of the global variable on terms is constant regardless of the order of evaluation. For example the global variable could be a map with some sort of lazy processing. An extension that queries the map for an element might cause a change in the state of the map and return some information about an element, but as long as the change in state are commutative and the same information is returned about elements regardless of the order of evaluation then the concept is safe. My motivation for experimenting with such a language comes from a belief that certain complicated programs would be easier to express in such a language and that there might be very useful code transformations that could eventually be applied to such a language that would be possible because of the constraints on the behavior of extensions. However I have yet to properly implement a language in Haskell and so I decided to post what I have and look for comments. Basically the language takes a common form of embedded languages; a lambda expression such as \x y->x y would have the form: lam (\x -> lam (\y -> app x y)) however in order to evaluate an expression the need to also apply it to a global term: lam (\x -> lam (\y -> app x y)) global Ideally the result of evaluating this would be a (global', \x y-> x y), a modified version of global paired with the term. So the type of the term: lam (\x -> lam (\y -> app x y)) is something like g -> (g, (a -> b) -> a -> b) where g is the type of global. >From that came the first idea of the types of the evaluator functions: lam :: ( (g->(g,a)) -> (g->(g,b)) )-> (g->(g, a->b)) app :: (g->(g,a->b)) -> (g->(g, a)) -> (g->(g,b)) with some additional parenthesis for sake of clarity. Each sub-term has the type g->(g,t) any function can be included as an extension as long as the function has the type: (g->(g,a)) -> (g->(g,b)) This seems to work well except that it seems to be impossible (as far as I've tried) to construct a definition for the lam function that both fits this type and properly passes the global through the entire evaluation. For example it's easy to define app like this: app :: (g->(g,a->b)) -> (g->(g,a)) -> (g->(g,b)) app = (\ eA eB -> \ g0 -> let (gB, fB) = eB g0 in let (gA, fA) = eA gB in (gA, fA fB) ) but so far the definition of lam has eluded me. This is the closest I've come: lam :: ((g->(g,a)) -> (g->(g,b))) -> (g->(g,a->b)) lam = (\ f -> \ g0 -> (g0, \x -> snd $ (f (\ gv->(gv,x))) g0 )) This fits the type but I fear this definition does not return the properly modified version of global. I tried some other iterations of this idea. In one effort the first argument of a function is extracted into the type of a term. So a term of type a->b has the type (g->a->(g,b)). And a term of type a has the type (g->((g, a)) such that: lam2 :: ((g->(g,a)) -> (g->(g,b))) -> (g->a->(g,b)) lam2 = (\ f -> \ g x -> (f (\ gv -> (gv, x))) g) app2 :: (g->a->(g,b)) -> (g->(g,a)) -> (g->(g,b)) app2 = (\ eA eB -> \ g0 -> let (gB, fB) = eB g0 in eA gB fB ) This seems like a step in the right direction unfortunately because the return type of lam is now (g->a->(g,b)) and not (g->(g->c)) we cannot type the term lam (\x -> lam (\y -> app x y)). In other words this language can only express unary and nullary functions. Just to help clarify this for myself I created to addition functions lam2Helper and app2Helper: lam2Helper :: (g->a->(g,b)) -> (g->(g,a->b)) lam2Helper = (\f -> \g -> (g, \a -> snd $ f g a)) app2Helper :: (g->(g,a->b)) -> (g->a->(g,b)) app2Helper = (\f -> \g a-> let (g1, f1) = f g in (g1, f1 a)) these allow me to create the term: lam2 (\x -> lam2Helper $ lam2 (\y -> app2 (app2Helper x) y)) but just like the original definition of lam from my first try, there is no way to construct lam2Helper without improperly passing the global as I've done in my attempt. Finally on my third try I attempted to make every term have type (g->a->(g,b) by allowing embedded nullary functions to have the type (g->()->(g,t)) lam3 :: ((g->()->(g,a)) -> (g->()->(g,b))) -> (g->a->(g,b)) lam3 = (\ f -> \ g x -> (f (\ gv () -> (gv, x))) g () ) app3 :: (g->a->(g,b)) -> (g->()->(g,a)) -> (g->()->(g,b)) app3 = (\ eA eB -> \ gz () -> let (gB, fB) = eB gz () in eA gB fB ) This allows me to construct the term: lam (\x -> lam (\y -> app x y)) but only by throwing out important type information... A compilable example of this is available here: http://hpaste.org/86273 And with source candy here: http://hpaste.org/86274 My goal at this point is just to understand the problem better. I feel I'm at the edge of my understanding of type systems and arity and I'm unsure if what I want to do is possible in Haskell. My goal would eventually be to construct a working prototype of such a language and to construct a proof that it maintains the types of terms and that the global variable is evaluated once by every subterm. I appreciate any insight, interest or help. Thanks, Ian Bloom ianmbloom(a)gmail.com

2 1

17th BRAZILIAN SYMPOSIUM ON PROGRAMMING LANGUAGES
by Simon Thompson 22 Apr '13

22 Apr '13

[Apologies if you receive multiple copies of this CFP] ======================================================= CALL FOR PAPERS 17th BRAZILIAN SYMPOSIUM ON PROGRAMMING LANGUAGES Brasília, Distrito Federal, Brazil September 29th to October 4th, 2013 http://cbsoft2013.unb.br/en/sblp-en ======================================================== IMPORTANT DATES Paper abstract submission (15 lines): May 6th, 2013 (extended deadline) Full paper submission: May 10th, 2013 (extended deadline) Notification of acceptance: June 7, 2013 Final papers due: June 28th, 2013 INVITED SPEAKERS * Tim Harris, Oracle Labs * More TBA INTRODUCTION The 17th Brazilian Symposium on Programming Languages, SBLP 2013, will be held in Brasília, Brazil, on September 29th to October 4th, 2013. 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. The symposium will be part of the 4th Brazilian Conference on Software: Theory and Practice, CBSoft 2013,http://cbsoft2013.cic.unb.br/, which will host four traditional, well-established symposia: * XXVII Brazilian Symposium on Software Engineering (SBES) * XVII Brazilian Symposium on Programming Languages (SBLP) * XVI Brazilian Symposium on Formal Methods (SBMF) * VII Brazilian Symposium on Components, Software Architecture and Software Reuse (SBCARS) SBLP 2013 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. We solicit papers that should fall into one of two different categories: full papers, with at most 15 pages, or short papers, with at most 5 pages. Full papers submitted in English will be published in a volume of Lecture Notes in Computer Science (LNCS), by Springer. For this reason, all papers must be prepared using the LNCS template, available at http://www.springer.com/computer/lncs?SGWID=0-164-6-793341-0. We encourage the submission of short papers reporting on partial results of on-going master dissertations or doctoral theses. All accepted papers will be published in the conference proceedings distributed in a digital media by the CBSOFT organizers. Submissions should be done using SBLP 2013 installation of the EasyChair conference mangement system athttp://www.easychair.org/conferences/?conf=sblp2013. As in previous editions, a journal special issue, with selected papers from accepted contributions, is anticipated. Selected papers from 2003 to 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 proceedings, are being edited as special issues of Science of Computer Programming, published by Elsevier. CBSOFT CHAIRS Genaina Nunes Rodrigues, UnB Rodrigo Bonifácio, UnB Diego Aranha, UnB PROGRAMME CHAIRS André Rauber Du Bois, UFPel Phil Trinder, Glasgow University PROGRAMME COMMITTEE Alberto Pardo, Univ. de La Republica Alex Garcia, IME Alvaro Freitas Moreira, UFRGS André Rauber Du Bois, UFPel (co-chair) Andre Santos, UFPE Carlos Camarao, UFMG Christiano Braga, UFF Edwin Brady, University of St. Andrews Fernando Castor Filho, UFPE Fernando Quintão Pereira, UFMG Francisco Heron de Carvalho Junior, UFC Hans-Wofgang Loidl, Heriot-Watt University Jeremy Singer, Glasgow University Joao Saraiva, Universidade do Minho João F. Ferreira, Teesside University Lucilia Figueiredo, UFOP Luis Soares Barbosa, Univ. do Minho Manuel António Martins, Univ. de Aveiro Marcelo A. Maia, UFU Marcello Bonsangue, Leiden Univ/CWI Marcelo d'Amorim, UFPE Marco Tulio Valente, UFMG Mariza A. S. Bigonha, UFMG Martin A. Musicante, UFRN Noemi Rodriguez, PUC-Rio Peter Mosses, Swansea University Phil Trinder, Glasgow University (co-chair) Qiu Zongyang, Beijing University Rafael Dueire Lins, UFPE Renato Cerqueira, PUC-Rio Ricardo Massa, UFPE Roberto S. Bigonha, UFMG Roberto Ierusalimschy, PUC-Rio Sandro Rigo, UNICAMP Sergio Soares, UFPE Simon Thompson, Univ. of Kent Varmo Vene, Univ. de Tartu Simon Thompson | Professor of Logic and Computation School of Computing | University of Kent | Canterbury, CT2 7NF, UK s.j.thompson(a)kent.ac.uk | M +44 7986 085754 | W www.cs.kent.ac.uk/~sjt

1 0

CFP SBLP 2013: Deadline extension
by Andre Rauber Du Bois 22 Apr '13

22 Apr '13

[Apologies if you receive multiple copies of this CFP] ======================================================= CALL FOR PAPERS 17th BRAZILIAN SYMPOSIUM ON PROGRAMMING LANGUAGES Brasília, Distrito Federal, Brazil September 29th to October 4th, 2013 http://cbsoft2013.unb.br/en/sblp-en ======================================================== IMPORTANT DATES Paper abstract submission (15 lines): May 6th, 2013 (extended deadline) Full paper submission: May 10th, 2013 (extended deadline) Notification of acceptance: June 7, 2013 Final papers due: June 28th, 2013 INVITED SPEAKERS * Tim Harris, Oracle Labs * More TBA INTRODUCTION The 17th Brazilian Symposium on Programming Languages, SBLP 2013, will be held in Brasília, Brazil, on September 29th to October 4th, 2013. 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. The symposium will be part of the 4th Brazilian Conference on Software: Theory and Practice, CBSoft 2013, http://cbsoft2013.cic.unb.br/, which will host four traditional, well-established symposia: * XXVII Brazilian Symposium on Software Engineering (SBES) * XVII Brazilian Symposium on Programming Languages (SBLP) * XVI Brazilian Symposium on Formal Methods (SBMF) * VII Brazilian Symposium on Components, Software Architecture and Software Reuse (SBCARS) SBLP 2013 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. We solicit papers that should fall into one of two different categories: full papers, with at most 15 pages, or short papers, with at most 5 pages. Full papers submitted in English will be published in a volume of Lecture Notes in Computer Science (LNCS), by Springer. For this reason, all papers must be prepared using the LNCS template, available at http://www.springer.com/computer/lncs?SGWID=0-164-6-793341-0. We encourage the submission of short papers reporting on partial results of on-going master dissertations or doctoral theses. All accepted papers will be published in the conference proceedings distributed in a digital media by the CBSOFT organizers. Submissions should be done using SBLP 2013 installation of the EasyChair conference mangement system at http://www.easychair.org/conferences/?conf=sblp2013. As in previous editions, a journal special issue, with selected papers from accepted contributions, is anticipated. Selected papers from 2003 to 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 proceedings, are being edited as special issues of Science of Computer Programming, published by Elsevier. CBSOFT CHAIRS Genaina Nunes Rodrigues, UnB Rodrigo Bonifácio, UnB Diego Aranha, UnB PROGRAMME CHAIRS André Rauber Du Bois, UFPel Phil Trinder, Glasgow University PROGRAMME COMMITTEE Alberto Pardo, Univ. de La Republica Alex Garcia, IME Alvaro Freitas Moreira, UFRGS André Rauber Du Bois, UFPel (co-chair) Andre Santos, UFPE Carlos Camarao, UFMG Christiano Braga, UFF Edwin Brady, University of St. Andrews Fernando Castor Filho, UFPE Fernando Quintão Pereira, UFMG Francisco Heron de Carvalho Junior, UFC Hans-Wofgang Loidl, Heriot-Watt University Jeremy Singer, Glasgow University Joao Saraiva, Universidade do Minho João F. Ferreira, Teesside University Lucilia Figueiredo, UFOP Luis Soares Barbosa, Univ. do Minho Manuel António Martins, Univ. de Aveiro Marcelo A. Maia, UFU Marcello Bonsangue, Leiden Univ/CWI Marcelo d'Amorim, UFPE Marco Tulio Valente, UFMG Mariza A. S. Bigonha, UFMG Martin A. Musicante, UFRN Noemi Rodriguez, PUC-Rio Peter Mosses, Swansea University Phil Trinder, Glasgow University (co-chair) Qiu Zongyang, Beijing University Rafael Dueire Lins, UFPE Renato Cerqueira, PUC-Rio Ricardo Massa, UFPE Roberto S. Bigonha, UFMG Roberto Ierusalimschy, PUC-Rio Sandro Rigo, UNICAMP Sergio Soares, UFPE Simon Thompson, Univ. of Kent Varmo Vene, Univ. de Tartu

1 0

conditional branching vs pattern matching: pwn3d by GHC
by Albert Y. C. Lai 22 Apr '13

22 Apr '13

When I was writing http://www.vex.net/~trebla/haskell/crossroad.xhtml I wanted to write: branching on predicates and then using selectors is less efficient than pattern matching, since selectors repeat the tests already done by predicates. It is only ethical to verify this claim before writing it. So here it goes, eval uses pattern matching, fval uses predicates and selectors: module E where data E = Val{fromVal::Integer} | Neg{fromNeg::E} | Add{fromAdd0, fromAdd1 :: E} isVal Val{} = True isVal _ = False isNeg Neg{} = True isNeg _ = False isAdd Add{} = True isAdd _ = False eval (Val n) = n eval (Neg e0) = - eval e0 eval (Add e0 e1) = eval e0 + eval e1 fval e | isVal e = fromVal e | isNeg e = - fval (fromNeg e) | isAdd e = fval (fromAdd0 e) + fval (fromAdd1 e) Simple and clear. What could possibly go wrong! $ ghc -O -c -ddump-simpl -dsuppress-all -dsuppress-uniques E.hs ... Rec { fval fval = \ e -> case e of _ { Val ds -> ds; Neg ds -> negateInteger (fval ds); Add ipv ipv1 -> plusInteger (fval ipv) (fval ipv1) } end Rec } Rec { eval eval = \ ds -> case ds of _ { Val n -> n; Neg e0 -> negateInteger (eval e0); Add e0 e1 -> plusInteger (eval e0) (eval e1) } end Rec } Which of the following best describes my feeling? [ ] wait, what? [ ] lol [ ] speechless [ ] oh man [ ] I am so pwn3d [ ] I can't believe it [ ] what can GHC not do?! [ ] but what am I going to say in my article?! [ ] why is GHC making my life hard?! [X] all of the above

2 1

Fwd: GSoC Project Proposal: Markdown support for Haddock
by Joe Nash 21 Apr '13

21 Apr '13

I would be interested in discussing this project with a potential mentor if one happens to be reading. I'm a second year Computer Science student at the University of Nottingham, very interested in doing a haskell.org SoC project. On Tue, Apr 9, 2013 at 8:17 PM, David Waern <david.waern(a)gmail.com> wrote: > > > > 2013/4/8 Evan Laforge <qdunkan(a)gmail.com> > >> Can't we just add some features to haddock? There are a lot of ways >> to improve haddock a lot, and no one is doing them, so my impression >> is that haddock doesn't really have active maintainers. Adding a >> whole new backend seems risky, unless it results in new maintainers >> joining. >> > > As one of the official maintainers (the other one is Simon Hengel), I > agree that Haddock can barely be called actively maintained and it has been > like that for a long time now. It's sad, but we lack of time, which is the > usual excuse of course. A more resourceful maintainer would be great, so if > someone reading this is motivated and wants to help out, we'd love to be > contacted by you. > > I don't think a SoC project for Markdown support would be risky at all > (with a sufficiently good student), however. And it wouldn't require a new > backend, the backend would still be the existing HTML backend in Haddock. > > David > > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe > >

3 2

Frankfurt Haskell User Group - Meetup on Yesod, 24.4.13
by Peter Althainz 20 Apr '13

20 Apr '13

The Frankfurt Haskell User Group meets on 24.4.13 for a presentation on Yesod. http://www.meetup.com/Frankfurt-Haskell-User-Group/. Regards: Peter

1 0

unsafeInterleaveST (and IO) is really unsafe
by oleg＠okmij.org 19 Apr '13

19 Apr '13

Timon Gehr wrote: > I am not sure that the two statements are equivalent. Above you say that > the context distinguishes x == y from y == x and below you say that it > distinguishes them in one possible run. I guess this is a terminological problem. The phrase `context distinguishes e1 and e2' is the standard phrase in theory of contextual equivalence. Here are the nice slides http://www.cl.cam.ac.uk/teaching/0910/L16/semhl-15-ann.pdf Please see adequacy on slide 17. An expression relation between two boolean expressions M1 and M2 is adequate if for all program runs (for all initial states of the program s), M1 evaluates to true just in case M2 does. If in some circumstances M1 evaluates to true but M2 (with the same initial state) evaluates to false, the expressions are not related or the expression relation is inadequate. See also the classic http://www.ccs.neu.edu/racket/pubs/scp91-felleisen.ps.gz (p11 for definition and Theorem 3.8 for an example of a distinguishing, or witnessing context). > In essence, lazy IO provides unsafe constructs that are not named > accordingly. (But IO is problematic in any case, partly because it > depends on an ideal program being run on a real machine which is based > on a less general model of computation.) I'd agree with the first sentence. As for the second sentence, all real programs are real programs executing on real machines. We may equationally prove (at time Integer) that 1 + 2^100000 == 2^100000 + 1 but we may have trouble verifying it in Haskell (or any other language). That does not mean equational reasoning is useless: we just have to precisely specify the abstraction boundaries. BTW, the equality above is still useful even in Haskell: it says that if the program managed to compute 1 + 2^100000 and it also managed to compute 2^100000 + 1, the results must be the same. (Of course in the above example, the program will probably crash in both cases). What is not adequate is when equational theory predicts one finite result, and the program gives another finite result -- even if the conditions of abstractions are satisfied (e.g., there is no IO, the expression in question has a pure type, etc). > I think this context cannot be used to reliably distinguish x == y and y > == x. Rather, the outcomes would be arbitrary/implementation > defined/undefined in both cases. My example uses the ST monad for a reason: there is a formal semantics of ST (denotational in Launchbury and Peyton-Jones and operational in Moggi and Sabry). Please look up ``State in Haskell'' by Launchbury and Peyton-Jones. The semantics is explained in Sec 6. Please see Sec 10.2 Unique supply trees -- you might see some familiar code. Although my example was derived independently, it has the same kernel of badness as the example in Launchbury and Peyton-Jones. The authors point out a subtlety in the code, admitting that they fell into the trap themselves. So, unsafeInterleaveST is really bad -- and the people who introduced it know that, all too well.

5 5

a library for abstract algebra?
by Petr Pudlák 19 Apr '13

19 Apr '13

Hi, is there a Haskell library for defining and working with algebraic structures such as groups, rings, fields, finite fields, vector spaces or modules? I found only several vector-related libraries, but they were all only over the field of real numbers (Double) and defined only vector spaces, not other algebraic structures. Thanks, Petr

5 4

ANN: Groundhog 0.3 - mysql, schemas and enhanced queries
by Boris Lykah 19 Apr '13

19 Apr '13

I am happy to announce release of Groundhog 0.3! Groundhog is a library for high-level database access. It has support for Sqlite, PostgreSQL, and a new MySQL backend. Advanced migration capabilities allow you to precisely specify the schema description, fitting it to an existing database, or creating a migration script for a new one. Groundhog is not opinionated about schema and can bind your datatypes to a relational model which may have composite keys, references across different schemas, indexes, etc. Changes: * Novel mechanism for defining your own functions, operators, or other expressions and combining them in a type-safe manner. The operators LIKE and IN, which appeared in this version, are one-liners based on it. Now you can write advanced queries compositionally without resorting to raw SQL. For example: project (upper (ZipCodeField `append` AddressField), NumberField * (NumberField + (1 :: Int))) $ lower NameField `like` "jack%" will be transformed into SQL query SELECT upper(zipcode || address), number * (number + ?) FROM tablename WHERE lower(name) like ? * PostgreSQL backend got support for arrays and geometric datatypes. * First release of MySQL backend (influenced by persistent-mysql). * New class ConnectionManager helps to extract connections from pools, application state, or other sources. Now both plain connections and pools can be run with the same function runDbConn. In particular, this class helps with integrating Groundhog into web applications. * Support for savepoints (nested transactions). * Schema qualified tables. The entities can be configured with a schema parameter. It defines schema where the table, its triggers, indexes, and other related database objects are stored. Schemas are respected both during migration and when generating queries. * Custom primary keys. A unique set of fields can be defined as a constraint, index, or primary key. Composite primary keys are supported as well. * Configuration of reference clauses ON DELETE and ON UPDATE. * New class SchemaAnalyzer exposes Groundhog functions for database introspection. In future it can be used to build more powerful migration tools, or generate datatypes from table definitions. The full description of the configuration options is available at http://hackage.haskell.org/packages/archive/groundhog-th/0.3.0/doc/html/Dat… Please see examples at http://github.com/lykahb/groundhog/tree/master/examples. If you want to integrate Groundhog into your application which is based on Snap, Yesod, or just uses another monad to store connections, see this example http://github.com/lykahb/groundhog/blob/master/examples/monadIntegration.hs. Although there are many new features in this release, Groundhog API is mature enough to minimize the breaking changes. To migrate from Groundhog 2.* replace runSqliteConn/runPostgresqlConn/runSqlitePool/runPostgresqlPool with runDbConn. Special thanks to MightyByte who suggested to generalize connections and helped to find the design, and to many others who gave their inspiring feedback. * http://github.com/lykahb/groundhog * http://hackage.haskell.org/package/groundhog * http://hackage.haskell.org/package/groundhog-th * http://hackage.haskell.org/package/groundhog-mysql * http://hackage.haskell.org/package/groundhog-postgresql * http://hackage.haskell.org/package/groundhog-sqlite Enjoy! -- Regards, Boris

2 2

Unit Testing with Control.Proxy
by Dan 19 Apr '13

19 Apr '13

Hi all, I've discovered the excellent proxy library recently and one thing strikes me. How do you unit test a proxy? Are there any specific methods or workflows for doing this cleanly and consistently? Daniel -- ~~ Whatever happens, the sun's still gonna come up tomorrow ~~

2 1

Map Reduce spec in Haskell
by John D. Ramsdell 19 Apr '13

19 Apr '13

I'm learning about the Map Reduce computation frequently used with big data. For the fun of it, I decided to write a very high-level spec of Map Reduce. Here is what I came up with. Enjoy. John > module MapReduce where > import Data.List (nub) A high-level specification of Map Reduce as a Haskell program. The program uses lists to represent multisets. As multisets have no implied ordering, the ordering implied by lists in this specification should be ignored. The database is a multiset of key-value pairs. > type Key = String > type Value = String > type Datum = (Key, Value) > type Data = [Datum] A mapper maps a datum to a finite multiset of key-value pairs. > type Mapper = Datum -> Data A reducer takes a key and a multiset of values and produces a finite multiset of values. > type Reducer = (Key, [Value]) -> [Value] A step is a mapper followed by a reducer > type Step = (Mapper, Reducer) A program is a finite sequence of steps > type Program = [Step] The semantics of a program is provided by the run function. > run :: Program -> Data -> Data > run [] d = d > run (s : p) d = > run p (step s d) The three parts of a step are mapping, shuffling, and reducing. > step :: Step -> Data -> Data > step (m, r) d = > let mapped = transform m d > shuffled = shuffle mapped in > reduce r shuffled The first part of a step is to transform the data by applying the mapper to each datum and collecting the results. > transform :: Mapper -> Data -> Data > transform m d = > [p | u <- d, p <- m u] Next, values with common keys are collected. Keys are unique after shuffling. > shuffle :: Data -> [(Key, [Value])] > shuffle d = > [(k, vs) | k <- nub (map fst d), -- nub eliminates duplicate keys > let vs = [v | (k', v) <- d, k' == k]] A reducer is applied to the data associated with one key, and always produces data with that key. > reduce :: Reducer -> [(Key, [Value])] -> Data > reduce r rs = > [(k, v) | (k, vs) <- rs, v <- r (k, vs)]

3 2

how do i get cabal to reinstall dependencies with profiling enabled?
by Anatoly Yakovenko 18 Apr '13

18 Apr '13

3 2

Contravariant applicatives, monads and arrows (was ANN: rematch, an library for composable assertions with human readable failure messages)
by Alejandro Serrano Mena 18 Apr '13

18 Apr '13

Hi, First of all, let me say that this work on matchers is really useful :) Following Roman advice, I'm trying to find a more principled approach that could be useful for this library. It seems that "Match" could easily be converted to Either and thus made into Functor, Applicative, Alternative and Monad. That would allow to write things like: User <$> runMatch (isNot isEmpty) name <*> runMatch (hasItem (is '@')) email However, I'm also thinking about the correct way to "combine" matchers to get bigger matchers. Basically, if I have matchers on every field of a record, can I get a matcher for the entire one? My first idea was to make Matcher a functor. However, what I come was a contravariant functor: given (a -> b) and Matcher b, I can easily construct a Matcher a by running the one in b over this function. So we have: contramap :: (a -> b) -> Matcher b -> Matcher a My first question is: is there any structure similar to applicative functors or monads which work on these kind of contravariant functors? This also brought into my mind to see Matcher a just as functions a -> Match and derive its properties from there. This may give better results that the above mentioned idea of looking it as a -> Either String a, because in this latter case we have a in covariant and contravariant positions and it's difficult to get anything. On the other hand, it seems very easy, from a Matcher a and a Matcher b, to get a Matcher (a,b). This reminds me a bit about arrows, but without output parameters. Does it make sense? I've always been reluctant to arrows because I don't fully understand them, but maybe this is a good moment to learn. Do any of this make sense? I would really like to contribute to this great library! :) 2013/4/16 Tom Crayford <tcrayford(a)gmail.com>: > Roman, > > Thanks for the feedback! I'd originally left the QuickCheck and HUnit > implementations in this library for convenience, thinking that there aren't > going to be many people who care about the transitive dep. But you care, so > I'm happy moving them out of core. I'll release a 0.2 with both the HUnit > and the QuickCheck runners in separate libraries soonish. > > Thanks for the haddock tip and the implementation tips. > > Re the Control namespace, these matchers aren't exclusively a testing tool. > I've been using the core api for other purposes as well (primarily for > validating forms in user interfaces in conjunction with digestive-functors). > I couldn't figure anything better to put it in apart from Control (I > definitely don't want it in Test, even though that's going to be what most > people use it for). I guess it could be in `Data`, but that doesn't sound > much better to me. > > I'm not amazingly strong at building more principled interfaces right now, > so I guess that's something I'll improve on. Are there any concrete > suggestions you have there? I'd *like* these to have an `Alternative` > instance, but making `Applicative`/`Functor` instances is beyond me right > now (I guess I'd have to change the core API for that to work out). > > Tom > > > ...

3 3

Call for Papers: Workshop on Functional Art, Music, Modeling, and Design (colocated with ICFP)
by Brent Yorgey 18 Apr '13

18 Apr '13

====================================================================== FARM 2013: Call for Papers ACM SIGPLAN Workshop on Functional Art, Music, Modeling and Design Boston, Massachusetts, USA 28th September, 2013 (directly after ICFP) http://www.cis.upenn.edu/~byorgey/farm13/ ====================================================================== Scope ----- The functional programming community is largely interested in writing beautiful programs. This workshop is intended to gather researchers and practitioners interested in writing beautiful programs that generate beautiful artifacts. Such artifacts may include visual art, music, 3D sculptures, animations, GUIs, video games, physical models, architectural models, choreographies for dance, poetry, and even physical objects such as VLSI layouts, GPU configurations, or mechanical engineering designs. The framework used need not be purely functional (“mostly functional” is fine); may be based on abstractions such as higher-order functions, monads, arrows, or streams; and may be manifested as a domain specific language or tool. Theoretical foundations, language design, implementation issues, and applications are all within the scope of the workshop. Important dates --------------- - Submissions due: Friday, 14 June 2013, 23:59 UTC-11 (American Samoa time [1]) - Author notification: Thursday, 11 July 2013 - Final papers due: Thursday, 25 July 2013 - Workshop: Saturday, 28 September 2013 (the day after ICFP) [1] http://www.timeanddate.com/worldclock/fixedtime.html?msg=FARM+submissions+d… Proceedings ----------- There will be a formal proceedings published by ACM Press. Accepted papers will be included in the ACM Digital Library; see http://authors.acm.org/main.cfm for information on the options available to authors. Authors are also encouraged to submit auxiliary material for publication along with their paper (source code, data, videos, images, etc.); authors retain all rights to the auxiliary material. Submission details ------------------ We solicit submissions in two categories: - Full papers. A full paper is limited to 12 pages, and will be evaluated according to its relevance, correctness, significance, originality, and clarity. It should explain its contributions, identify what has been accomplished, explain why it is significant, and compare it with previous work. - "Aesthetic applications". An aesthetic application paper is limited to 6 pages, and will be judged primarily on the effective and elegant use of FP to generate aesthetic artifacts (though the criteria for full papers are still relevant). Submitted papers should be in portable document format (PDF), formatted using the ACM SIGPLAN style guidelines. The text should be in a 9-point font in two columns. Submissions can be made via EasyChair at https://www.easychair.org/conferences/?conf=farm2013 Organizers ---------- Workshop Chair: Paul Hudak Program Chair: Conal Elliott Publicity Chair: Brent Yorgey Program Committee ----------------- Daniel Cukier (AgileAndArt) Conal Elliott (Tabula) (chair) Kathleen Fisher (Tufts University) Richard Gabriel (IBM Research) George Giorgidze (University of Tübingen) Paul Hudak (Yale University) José Pedro Magalhães (University of Oxford) Alex McLean (ICSRiM) John Peterson (Western State Colorado University) Michael Sperber (Active Group) Henning Thielemann (Martin-Luther-Universität Halle-Wittenberg) Brent Yorgey (University of Pennsylvania)

1 0

Re: [Haskell-cafe] Contravariant applicatives, monads and arrows (was ANN: rematch, an library for composable assertions with human readable failure messages)
by Stephen Tetley 18 Apr '13

18 Apr '13

On 16 April 2013 16:12, Alejandro Serrano Mena <trupill(a)gmail.com> wrote: > Hi, > First of all, let me say that this work on matchers is really useful :) > > Following Roman advice, I'm trying to find a more principled approach > that could be useful for this library. It seems that "Match" could > easily be converted to Either and thus made into Functor, Applicative, > Alternative and Monad. That would allow to write things like: > Have you seen Ralf Hinze, Johan Jeuring and Andreas Loeh's paper on Contracts? The found their Contract datatype formed a comonad - at the time this seemed to be one of the few (non-synthetic) uses of comonads.

2 1

ANN: algebraic-classes, conversions between algebraic classes and F-algebras
by Sjoerd Visscher 18 Apr '13

18 Apr '13

Hi all, I'd like to announce a hopefully useful new package: algebraic-classes. In short it provides conversions between algebraic classes and F-algebras, which should make generating instances of certain classes easier. Algebraic classes are classes where every method has the same result type, which is the class parameter. Examples are Num and Monoid. F-algebras are functions of the form f a -> a, with f a functor, which can be called the signature of the algebra. They are equivalent as follows: Algebraic classes are signatures, and the instances of algebraic classes are specific algebras. Take for example the Monoid class: class Monoid a where mempty :: a mappend :: a -> a -> a The equivalent signature would be: data MonoidSignature a = Op_mempty | Op_mappend a a And the list instance instance Monoid [a] where mempty = [] mappend = (++) would be equivalent to the algebra: listAlgebra :: MonoidSignature [a] -> [a] listAlgebra Op_mempty = [] listAlgebra (Op_mappend a b) = a ++ b And there is an obvious monoid algebra for any Monoid instance: evaluate :: Monoid a => MonoidSignature a -> a evaluate Op_mempty = mempty evaluate (Op_mappend a b) = mappend a b Using Template Haskell, the algebraic-classes library can generate signatures and evaluation functions from algebraic classes, and class instances from algebras. Also, for the signatures Functor and Traversable are derived using the DeriveFunctor and DeriveTraversable. That makes it possible to create algebras generically for any signature in certain cases, which together with the conversions means you can generate instances generically. Take tuples for example: if given that both components are instances of a class, then we can create the algebra as follows: algebra :: (Functor f, Class f m, Class f n) => f (m, n) -> (m, n) algebra fmn = (evaluate (fmap fst fmn), evaluate (fmap snd fmn)) And for any applicative functor we can do the same: algebra :: (Traversable f, Applicative g, Class f a) => f (g a) -> g a algebra = fmap evaluate . sequenceA Taken all together, all you have to do to get for example the Monoid instance for Either a b (based on its applicative instance) is: deriveInstance [t| Monoid b => Monoid (Either a b) |] The package lives on Hackage here: http://hackage.haskell.org/package/algebraic-classes And if you have suggestions, issues (the Template Haskell code is far from perfect at the moment) or pull-request, it is also on Github: https://github.com/sjoerdvisscher/algebraic-classes greetings, Sjoerd Visscher

1 0

Haskell missing in web benchmark
by Jeffrey Shaw 18 Apr '13

18 Apr '13

I was excited to see if Warp or Snap was included, but I was sad to see they weren't. If I find time someday, I'll add benchmarks for them, but it will be a long time. If anyone else wants to take a stab at it, that'd be awesome! http://www.techempower.com/blog/2013/03/28/framework-benchmarks/ Jeff

3 2

data types with overlapping component names (in one module)?
by Johannes Waldmann 17 Apr '13

17 Apr '13

What is the current situation: can we have two types with overlapping component names in one module? module M where data T1 = C1 { foo :: Int } data T2 = C2 { foo :: String } It seems not (ghc says: Multiple declarations of 'foo'). This comes close: http://www.haskell.org/ghc/docs/7.6.2/html/users_guide/syntax-extns.html#di… but still requires the definitions to reside in different modules? This is a major pain (it forces me to spread the source over several files), and also a show-stopper when selling Haskell to OO folks, who "naturally" assume that a class also denotes a scope. (And that you could nest them.) Are/were there plans/proposals to address this? - J.W.

4 4

Re: [Haskell-cafe] NaN as Integer value
by wren ng thornton 17 Apr '13

17 Apr '13

On 4/14/13 8:53 PM, Kim-Ee Yeoh wrote: > On Sun, Apr 14, 2013 at 3:28 PM, wren ng thornton <wren(a)freegeek.org> wrote: >> Whereas the problematic >> values due to infinities are overspecified, so no matter which answer you >> pick it's guaranteed to be the wrong answer half the time. >> >> Part of this whole problem comes from the fact that floats *do* decide to >> give a meaning to 1/0 (namely Infinity). > > I'm not sure what you mean about overspecification here, but in > setting 1/0 as +infinity (as opposed to -infinity), there's an easily > overlooked assumption that the limit is obtained "from above" as > opposed to "from below." Setting 1/0 = +inf isn't the problem, or at least not the main one. Of course, there's always the question about which completion of the reals to use--- i.e., whether we have +inf vs -inf, or whether we just have a single point infinity. Rather, the NaN problem comes from trying to resolve things like: inf - inf inf * 0 inf / inf 0 / 0 The overspecification problem I mentioned is that each of these expressions has "too many" solutions. For example, we have the following equations: x * 0 == 0 -- where x is finite inf * y == inf * signum y -- where y /= 0 inf * 0 == ?? x - inf == -inf -- where x is finite inf - y == inf -- where y is finite inf - inf == ?? x / 0 == inf * signum x -- where x /= 0 0 / y == 0 -- where y /= 0 0 / 0 == ?? -- Live well, ~wren

2 1

Derving NFData via Generics from a type that has a vector doesn't work. (was trying to understand out of memory exceptions)
by Anatoly Yakovenko 17 Apr '13

17 Apr '13

-- ok, something in deriving NFData using Generics in a type that has a Vector in it. {-# LANGUAGE DeriveGeneric #-} import Control.DeepSeq import System.IO import GHC.Generics (Generic) import qualified Data.Vector as V import qualified Data.ByteString.Lazy.Char8 as BL scanl' :: NFData a => (a -> b -> a) -> a -> [b] -> [a] scanl' f q ls = q : (case ls of [] -> [] x:xs -> let q' = f q x in q' `deepseq` scanl' f q' xs) -- this runs without blowing up -- main = print $ last $ scanl' (+) (0::Int) [0..] data Simple = Simple (V.Vector Double) deriving (Show, Generic) instance NFData Simple --this blows up main = do let initial = Simple $ V.fromList (take 100 $ repeat 0) sumvs (Simple a) (Simple b) = Simple $ V.zipWith (+) a b print $ last $ scanl' sumvs initial $ repeat $ initial

4 8

version of containers fixed by template-haskell?
by Johannes Waldmann 17 Apr '13

17 Apr '13

Is it still the case that "It just doesn't work to have multiple versions of a wired-in package" (cf. http://hackage.haskell.org/trac/ghc/ticket/5704 )? ghc-7.6.2 comes with containers-0.5.0.0 and template-haskell-2.8.0.0 . It seems I can upgrade to containers-0.5.2.1 and use it with no problems but not alongside template-haskell: ... changes: containers-0.5.0.0 -> 0.5.2.1, Warning: The following packages are likely to be broken by the reinstalls: ... ghc-7.6.2 (Isn't it somewhat bold of cabal-install to offer to break "ghc-7.6.2"? like, this will completely hose the compiler?) That's bad, because I use containers everywhere, and I assume that 0.5.2.1 has some advantages (like, speed) over 0.5.0.0. - J.W.

4 6

Announce: Blip, a bytecode compiler for Python 3 (implemented in Haskell)
by Bernie Pope 17 Apr '13

17 Apr '13

I'm pleased to announce Blip version 0.1.0, a bytecode compiler for Python 3. https://github.com/bjpop/blip Blip compiles Python 3 source files to bytecode. The output bytecode is compatible with the CPython interpreter (the "standard" Python implementation). For example, given a Python 3 source file called foo.py, the command: blip foo.py produces a bytecode file called foo.pyc. The bytecode can be executed by passing it as an argument to a CPython interpreter: python3 foo.pyc This is an early development release of Blip, so it is not ready for serious use, however it supports most of the Python 3 language already. It has been tested on OS X 10.7.5 with GHC 7.4.2. The output has been tested with Python 3.3.0. Currently implemented features: https://github.com/bjpop/blip/wiki/Currently-implemented-features Features not yet implemented (but are on the way): https://github.com/bjpop/blip/wiki/Not-yet-implemented-features Wiki for more information: https://github.com/bjpop/blip/wiki Cheers, Bernie Pope.

1 0

Yampa integral function
by felipe zapata 17 Apr '13

17 Apr '13

Hello, I'm trying to write some simulator of physical systems using Yampa. The fundamental idea is to integrate the position and velocity, using the following algorithm: 1. get the velocity using the formula, v = v0 + integral ( 0.5 * force * recip mass) where v0 is the previous velocity. 2. calculate the new position as follows, x = x0 + integral (v) and some other steps that are not relevant here. Therefore I wrote the following piece of code: type Pos = Double type Vel = Double type Mass = Double type Force = Double integralCoordSF :: Force -> Mass -> SF (Pos,Vel) (Pos,Vel) integralCoordSF force mass = proc (x0,v0) -> do v <- integralVelSF force mass -< v0 vdt2 <- integral -< v let x = x0 + vdt2 returnA -< (x,v) integralVelSF :: Force -> Mass -> SF Double Double integralVelSF force mass = proc v0 -> do t1 <- integral -< 0.5 * (force/mass) returnA -< v0 + t1 Now, let's the speed (velocity), force and the mass equal 1.0. And the initial potion equal zero. Then using the "embed" function we get that, *Main> embed (integralCoordSF 1.0 1.0) ((0.0,1.0),[(0.1,Nothing),(0.1,Nothing)]) [(0.0,1.0),(0.1,1.05),(0.20500000000000002,1.1)] According to the algorithm, if dt = 0.1 then v = 1.0 + integral (0.5 * 1.0 * recip 1.0) = 1.05 in agreement with the algorithm. But let's see about the position x = 0 + integral (v) Using the formula of step 2, the position should be equal to 0.105, but the result given by embed is 0.1. As a beginner certainly and missing a lot of concepts and details, can someone please explain me what's going on here? Thank you for your help! Felipe Z

3 3

Haskell/functional-language people in Raleigh/Durham, North Carolina, USA?
by Benjamin Redelings 17 Apr '13

17 Apr '13

Hi, I'm curious if there are any other people on this list who are interested in Haskell and functional languages in the Triangle Area, in North Carolina? thanks! -BenRI

3 2

I would like to know how to use the following events handlers : dropTargetOnData, dropTargetOnDrop, dropTargetOnEnter,
by Luc TAESCH 17 Apr '13

17 Apr '13

WxHaskell and DragAndDrop I would like to know how to use the following events handlers : dropTargetOnData, dropTargetOnDrop, dropTargetOnEnter, dropTargetOnDragOver….[1] Could you check if my current believes are corrects : From wx Widgets/ wxPython [2] / [3] / [4] it looks like they need to be used to manage DragAndDrog for non trivial examples. they are not actionable via an existing event like "on drag", etc.. I tried and create my own event. but it does not get "activated". [7] besides, from the signatures [1], these look like being activated on DropTarget, unlike other events on Reactive/ Windows/Controls . Is It Correct ? Heinrich created its own events "onText", (in reactive-Banana) but this is on a Control. [6] Could someone confirm these events effectively worked for them in WxHaskell, and maybe hint how to do that [1]: from Graphics.UI.WXCore.Events , line 1933 onwards Set an event handler that is called when the drop target can be filled with data. This function require to use 'dropTargetGetData' in your event handler to fill data. dropTargetOnData :: DropTarget a -> (Point -> DragResult -> IO DragResult) -> IO () ... -- | Set an event handler for an drop command in a drop target. dropTargetOnDrop :: DropTarget a -> (Point -> IO Bool) -> IO () -- | Set an event handler for an enter command in a drop target. dropTargetOnEnter :: DropTarget a -> (Point -> DragResult -> IO DragResult) -> IO () -- | Set an event handler for a drag over command in a drop target. dropTargetOnDragOver :: DropTarget a -> (Point -> DragResult -> IO DragResult) -> IO () -- | Set an event handler for a leave command in a drop target. dropTargetOnLeave :: DropTarget a -> (IO ()) -> IO () [2] : http://docs.wxwidgets.org/2.8/wx_wxdroptarget.html#wxdroptargetondrop [3] : http://wiki.wxpython.org/DragAndDrop [4] : http://www.blog.pythonlibrary.org/2012/06/20/wxpython-introduction-to-drag-… [5] : http://wewantarock.wordpress.com/2011/06/17/how-does-wxhaskell-event-handli… [6] : https://github.com/HeinrichApfelmus/reactive-banana/blob/master/reactive-ba… L 88 [7] : module Main where import Graphics.UI.WX hiding (empty) import Data.Maybe import Control.Monad import Graphics.UI.WX.Events import Graphics.UI.WXCore.WxcClassesMZ --import Graphics.UI.WXCore.WxcClassesAL import Graphics.UI.WXCore.DragAndDrop import Graphics.UI.WXCore.Events main = start dndtest dndtest = do f <- frame [text := "Drag And Drop test"] p <- panel f [] ok <- button p [text := "Ok"] xinput <- textEntry p [text := "here :"] --textEntry yinput <- staticText p [text := "drag me"] zinput <- staticText p [text := "result me"] set f [defaultButton := ok ,layout := container p $ margin 10 $ column 5 [boxed "coordinates" (grid 5 5 [[label "source:", hfill $ widget yinput] ,[label "target(focus first):", hfill $ widget xinput] ,[label "result:", hfill $ widget zinput] ]) ,floatBottomRight $ row 5 [widget ok]] ] set xinput [ on enter := onEnter] set yinput [ ] --------------------------------------------------------- --- meaningful stuff starts here --------------------------------------------------------- -- prepare the drop source : create a DataObject and associate it with the source textdata' <- textDataObjectCreate "text dropped" src <- dropSource textdata' yinput -- prepare the drop target: create a DataObject (placeholder here) and associate it with the target textdata <- textDataObjectCreate ".." drop <- dropTarget xinput textdata set drop [ on onMyDrop := showMeDrop ] ---- <<<< I am expecting this to get fired but no ... -- obj create a new event on drop invoking .. -- and see if it is invoked set yinput [ on drag := onDrag src ] set xinput [ ] ------ <<<< I am expecting the target to react when dropped (Its DroopedTarget i fact) set zinput [ on mouse := showMeE] set ok [ on command := close f ] return () --- this is the custom event, just a setter to fire dropTargetOnDrop. not sure at all this is the correct way. onMyDrop = newEvent "onmyDrop" (\w -> ioError (userError ("attribute '" ++ "onmyDrop" ++ "' is write-only."))) dropTargetOnDrop --dropTargetOnDrop :: DropTarget a -> (Point -> IO Bool) -> IO () --- the rest are jsut helper to see whats going on showMeEo = putStr "showMeEo" showMeDrop p = do putStr "showMeDrop" return True onDrag s p = do -- dragAndDrop :: DropSource a -> DragMode -> (DragResult -> IO ()) -> IO () dragAndDrop s Default (\r -> do {putStr "DnD handler called: "; putStrLn(show r); return ()}) putStrLn "on Drag activated:" showMeE :: EventMouse -> IO () showMeE (MouseMotion point mod) = putStr "" --- discard meaningless Motion event showMeE e = putStrLn $ show e -- onEnter p = putStrLn $ "on Enter:" ++ show p http://stackoverflow.com/questions/15911219/wxhaskell-and-draganddrop-how-t…

3 3

customizing haskeline?
by Evan Laforge 16 Apr '13

16 Apr '13

I tried to colorize a haskeline prompt by putting control characters in it, but line editing was hopelessly confused, presumably because haskeline doesn't understand control characters and thought the prompt was longer than it really was. From looking at Haskeline.promptedInput, it seems like there's no way to set the prompt to a higher level terminal operation since it's hardcoded to String, and there's no way to tell it how many displayed characters the prompt contains. So is there some way to have a fancy prompt that I'm missing? Has anyone done that successfully? This also implies it's impossible for haskeline to cooperate with cursor addressing in general. Or maybe it would be ok as long as I don't do anything fancy on the prompt line. But also seems like you can't set custom keybindings, e.g. bind a control key to a "history menu" like shells can do, which is my real goal here. I guess I'm interested if anyone has been able to use haskeline for anything more complicated than a prompt with the hardcoded default behaviour. My impression is that it's basically non-extensible, but maybe there's some hook I'm missing. By extension it seems impossible to colorize a ghci prompt, and indeed embedding control characters directly in :set prompty leads to the same problems.

2 1

trying to understand out of memory exceptions
by Anatoly Yakovenko 16 Apr '13

16 Apr '13

-- So why does this code run out of memory? import Control.DeepSeq import System.IO import qualified Data.ByteString.Char8 as BS scanl' :: NFData a => (a -> b -> a) -> a -> [b] -> [a] scanl' f q ls = q : (case ls of [] -> [] x:xs -> let q' = f q x in q' `deepseq` scanl' f q' xs) main = do file <- openBinaryFile "/dev/zero" ReadMode chars <- BS.hGetContents file let rv = drop 100000000000 $ scanl' (+) 0 $ map fromEnum $ BS.unpack chars print (head rv) -- my scanl' implementation seems to do the right thing, because main = print $ last $ scanl' (+) (0::Int) [0..] -- runs without blowing up. so am i creating a some thunk here? or is hGetContents storing values? any way to get the exception handler to print a trace of what caused the allocation?

2 2

Re: [Haskell-cafe] trying to understand out of memory exceptions
by Anatoly Yakovenko 16 Apr '13

16 Apr '13

unfortunately read file tries to get the file size readFile :: FilePath -> IO ByteStringreadFile f = bracket (openFile f ReadMode) hClose (\h -> hFileSize h >>= hGet h . fromIntegral) which wont work on a special file, like a socket. which is what i am trying to simulate here. On Tue, Apr 16, 2013 at 11:28 AM, Clark Gaebel <cg.wowus.cg(a)gmail.com>wrote: > See the comment for hGetContents: > > "This function reads chunks at a time, doubling the chunksize on each > read. The final buffer is then realloced to the appropriate size. For files > > half of available memory, this may lead to memory exhaustion. Consider > using readFile<http://hackage.haskell.org/packages/archive/bytestring/0.9.2.1/doc/html/Dat…> in > this case." > > > http://hackage.haskell.org/packages/archive/bytestring/0.9.2.1/doc/html/Dat… > > Maybe try lazy bytestrings? > > - Clark > > On Tuesday, April 16, 2013, Anatoly Yakovenko wrote: > >> -- So why does this code run out of memory? >> >> import Control.DeepSeq >> import System.IO >> import qualified Data.ByteString.Char8 as BS >> >> scanl' :: NFData a => (a -> b -> a) -> a -> [b] -> [a] >> scanl' f q ls = q : (case ls of >> [] -> [] >> x:xs -> let q' = f q x >> in q' `deepseq` scanl' f q' xs) >> >> >> main = do >> file <- openBinaryFile "/dev/zero" ReadMode >> chars <- BS.hGetContents file >> let rv = drop 100000000000 $ scanl' (+) 0 $ map fromEnum $ BS.unpack >> chars >> print (head rv) >> >> -- my scanl' implementation seems to do the right thing, because >> >> main = print $ last $ scanl' (+) (0::Int) [0..] >> >> -- runs without blowing up. so am i creating a some thunk here? or is >> hGetContents storing values? any way to get the exception handler to print >> a trace of what caused the allocation? >> >>

2 1

ANN: rematch, an library for composable assertions with human readable failure messages
by Tom Crayford 16 Apr '13

16 Apr '13

I kept on running into this thing where I was calling error in quickcheck to get good error messages about the things I was comparing. In Java land, this stuff is handled by Hamcrest: a library for composable assertions with good error messages. This library is basically a port of hamcrest's core api, but I've been very pleased with how it turned out. I've been using this in tests for production code for a month or so now, and I'm very pleased with it. Running a matcher (in this example in an hunit test) looks like this: expect [1] (is [1]) The core API is very simple: data Matcher a = Matcher { match :: a -> Bool -- ^ A function that returns True if the matcher should pass, False if it should fail , description :: String -- ^ A description of the matcher (usually of its success conditions) , describeMismatch :: a -> String -- ^ A description to be shown if the match fails. } This means you can add/write your own matchers happily, which occasionally means you can write *very* nice test code (here's an example of using a custom matcher for checking the state of an "issue" in a hypothetical issue tracking app): expect latestIssue (hasState Resolved) -- I removed the supporting code to make this assertion actually run, -- this email is already pretty long. There are numerous matchers (and functions for creating matchers) in the rematch library, including some composition functions that provide good failure messages. There are some shims to hook rematch into the common haskell test frameworks (specifically hunit and quickcheck). The two libraries are up on hackage: http://hackage.haskell.org/package/rematch http://hackage.haskell.org/package/rematch-text The code is all up on github: http://github.com/tcrayford/rematch I get rather frustrated when my tests give bad failure explanations, and using rematch goes a long way to fix that. Lastly, rematch is pretty isolated from test frameworks/etc, with a very small and easy to understand surface api. Hopefully it'll help with the thing I've seen in other languages (cough ruby cough) with every test framework reinventing this idea, and not all frameworks having all the matchers I want to use. Let me know if you have any feedback/thoughts Tom

6 8

When - O'Reilly book on Parallel and Concurrent Haskell
by amslonewolf＠gmail.com 16 Apr '13

16 Apr '13

Are there updates on when Simon Marlow's O'Reilly book on Parallel and Concurrent Haskell is going to be released?

1 1

Monad fold
by Christopher Howard 16 Apr '13

16 Apr '13

So, I'm doing something like this foldl (>>=) someA list :: Monad m => m a where list :: Monad m => [a -> m a], someA :: Monad m => m a Is there a more concise way to write this? I don't think foldM is what I want -- or is it? -- frigidcode.com

6 8

primitive operations in StateT
by Clark Gaebel 16 Apr '13

16 Apr '13

Hi list! I want to use MVectors in a StateT monad transformer. How do I do that? StateT isn't a member of 'PrimMonad', and I have no idea how to make it one. Regards, - Clark

2 4

Google Summer of Code
by Marcos Pividori 16 Apr '13

16 Apr '13

Hi, I am a Computer Science student from Argentina. I am interested in working this summer on some project related to Haskell for the Google Summer of Code. I have learned a lot about this, because in my career, we have a special approach in functional programming. So, I would like to know about recent projects and who could mentor me. I found a ticket about improving Parsec. http://hackage.haskell.org/trac/summer-of-code/ticket/1556 Is anyone working with this? Thanks, Marcos Pividori

2 1

How to design an network client with user program.
by Alexander V Vershilov 16 Apr '13

16 Apr '13

Hello. I have next problem: I have a network client that connects to server, listens for messages and generate responces. So the control flow can be represended as: server -- input -> {generate output} -> output Output can be generated using default implementation or can overriden by user. The main difficulty appeares when I need to add a user program on the top of this logic, i.e. from user-side I want to have dsl:smth like withClient $ do x <- send message waitFor x timeout 5000000 forever $ sendRandomMessage i.e. an ability to send messages, waiting for some event (message to come), waiting for timeout. The question is how to define such logic without a big overhead. I see a solution using conduit, it's possible to create 3 processes: listener, user, sender. +----> user ----+ | | -input -> listener +----------------->+---- sender -> and use TQueue or TChan to send messages between them, however there can be another possible solutions, that uses less resources, or another design. -- Alexander

3 4

Re: [Haskell-cafe] GSoC proposal: Data Visualization
by Ernesto Rodriguez 15 Apr '13

15 Apr '13

Dear All, Data visualization for hMatrix is basically my main objective, but I would like to be flexible in the following ways: * Have generic approach so other data types can be visualized with my library as long as the necessary instances are present. * Define a generic standard to represent values in multiple types of plots. This way graphics output can be easily extended for more back ends (gtk, qt, gnuplot). I am looking for alternatives. I will check GuiTV definitely, but currently I am considering the possibility of plotting data via javascript as suggested by Dough and using Haskell just to generate the values. I am using ghclive (https://github.com/shapr/ghclive) as fronted since the project looks nice and might be worth continuing it. Do you think there would be big objections if I continue working with that project since it was built for last GSoC? Best regards, Ernesto Rodriguez > > On Mon, Apr 15, 2013 at 2:10 PM, Michal J. Gajda <miga(a)nmr.mpibpc.mpg.de>wrote: > >> Dear Conal, Ernesto, Heinrich, >> >> >> On 04/15/2013 10:32 AM, Heinrich Apfelmus wrote: >> >> Ernesto Rodriguez wrote: >> >> >> For me it would already be a huge advantage if I >> could edit and re-evaluate expressions interactively (in a comfortable >> GUI, >> not ghci). Also a plot widget with sliders would also help. I was >> wondering >> if you know any reason the project has not been worked on for various >> months (as I see in the repo). Is there anyone working in this project >> and >> has a later version? I mean these are features that are even available in >> free math packages such as Sage. >> >> >> I was actually the initial mentor for this project. I'm not particularly >> happy about the result. As you can see, it hasn't been picked up by anyone >> else, including me, and I think that's because it missed the modularity >> goals I had in mind. >> >> Indeed interactive notebook functionality is missed by many :-). >> >> Is it a good time to ask about current status of GuiTV, which is possibly >> second closest to what Ernesto had in mind? >> http://www.haskell.org/haskellwiki/GuiTV >> Would be possible to ask Conal Elliot whether he is interested in >> mentoring a project that would add widget(s) for hmatrix visualisation? >> >> PS I believe Johan Malmström <http://homepage.mac.com/jmalmstrom/>'s >> HaXcel project, which may have tried to implement a similar functionality >> with a spreadsheet interface is dead: >> http://www.mrtc.mdh.se/projects/Haxcel/ >> -- >> Best regards >> Michal >> > > > > -- > Ernesto Rodriguez > > Bachelor of Computer Science - Class of 2013 > Jacobs University Bremen > > > > -- Ernesto Rodriguez Bachelor of Computer Science - Class of 2013 Jacobs University Bremen

1 0

Re: [Haskell-cafe] NaN as Integer value
by wren ng thornton 15 Apr '13

15 Apr '13

On 4/13/13 1:18 PM, Jerzy Karczmarczuk wrote: > This is not a Haskell problem. For Ints, ALL representations are valid > numbers, a NaN is a specific float object, unless I'm mistaken, so the > introduction of such an abnormal number would require some serious > modifications of the representation. Also, the necessity of NaN for floats comes from the fact that floats include values for Infinity and -Infinity, which leads to various equations which cannot be resolved sensibly. This is different than mere undefinedness. Undefined values are underspecified, but that can often be resolved by choosing some arbitrary specification (often chosen via arguing from limits or combinatorial convenience). Whereas the problematic values due to infinities are overspecified, so no matter which answer you pick it's guaranteed to be the wrong answer half the time. Part of this whole problem comes from the fact that floats *do* decide to give a meaning to 1/0 (namely Infinity). That's the gateway drug,... -- Live well, ~wren

3 2

GSoC proposal: Data Visualization
by Ernesto Rodriguez 15 Apr '13

15 Apr '13

Dear Haskell Community, During the last months I used Haskell for machine learning, particularly in the field of Echo State Neural Networks. The main drawback I encountered is that its difficult to visualize and plot data in Haskell in spite the fact there are a couple of plotting libraries. Data visualization is very important in the field of machine learning research (not so much in machine learning implementation) since humans are very efficient to analyze graphical input to figure out what is going on in order to determine possible adjustments. I was wondering if other members of the community have experienced this drawback and would be interested in improved data visualization for Haskell, especially if there is interest to use Haskell for machine learning research. I collected my ideas in the following page: https://github.com/netogallo/Visualizer . Please provide me with feedback because if the proposal is interesting for the community I would start working with it, even if it doesn't make it to this GSoC, but a project like this will need a lot of collaboration for it to be successful. Thank you very much, Best Regards, Ernesto -- Ernesto Rodriguez Bachelor of Computer Science - Class of 2013 Jacobs University Bremen

3 5