- 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 23 Apr '13

23 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 23 Apr '13

23 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