- Haskell-Cafe - Haskell.org

Re: [Haskell-cafe] [TYPES] OutsideIn(X) question
by Dimitrios Vytiniotis 03 Mar '14

03 Mar '14

Dear Alejandro, thanks for your notice! You are right, the entailment relation in the JFP paper is too weak for type classes. As we formulated it, the simplifier can take a type class reduction step but there is no way to show that the new set of constraints is equivalent to the original class constraint. There is nothing very deep going on, it's an oversight in the definition of entailment. The fix -- at least in the case of non-overlapping instances and vanilla multi-parameter type classes -- is to ensure that all axioms for type class instances form bi-implications. In fact in the constraint handling rules formulation of type classes, class instances always gave rise to such bi-implications. I will post the correction to the article on my web page in the next couple of weeks and let you know, but I thought I should send an update. Best regards, Dimitrios -----Original Message----- From: Types-list [mailto:types-list-bounces@lists.seas.upenn.edu] On Behalf Of Alejandro Serrano Mena Sent: Thursday, February 27, 2014 10:18 AM To: types-list(a)lists.seas.upenn.edu Subject: [TYPES] OutsideIn(X) question [ The Types Forum, http://lists.seas.upenn.edu/mailman/listinfo/types-list ] Dear Types List, I have a small question related to the "OutsideIn(X): Modular type inference with local assumptions" and was hoping that you could help me a bit. My question related about the proof of soundness and principality, specifically Lemma 7.2 (to be found in page 67). In that lemma, it's stated that QQ and \phi' Q_q ||- \phi Q_w <-> \phi' Q_w'. I'm trying to recover the proof (which is omitted in the text), but I stumble upon a wall when trying to work out what happens in the case an axiom is applied. In particular, I'm playing with an example where QQ (the set of axioms) = { forall. C a => D a } (where C and D are one-parameter type classes) Q_q = { } Q_w = { D Int } Thus, if I apply the rule DINSTW (to be found in page 65), I get a new Q_w' = { C Int } Now, if the lemma 7.2 is true, it should be the case that (1) QQ ||- C Int <-> D Int which in particular means that I have the two implications (2) { forall. C a => D a, C Int } ||- D Int (3) { forall. C a => D a, D Int } ||- C Int (2) follows easily by applying the AXIOM rule of ||- (as shown in page 54). However, I don't see how to make (3) work :( I think that understanding this example will be key for my understanding of the whole system. Anybody could point to the error in my reasoning or to places where I could find more information? Thanks in advance.

1 0

I'm trying to design a GUI library -- a design question
by Ömer Sinan Ağacan 03 Mar '14

03 Mar '14

Hi all, I'm designing a ncurses based GUI library. I'm calling smallest GUI elements "widgets". A widget can have internal state of any type. Let's call this type `s`. I want to be able to have something like this: > data Widget s = Widget > { handleKey :: Key -> s -> s > , draw :: Int -> Int -> Int -> Int -> IO () > , getFocus :: s -> s > , loseFocus :: s -> s > -- more methods may be added in the future > } I also want to be able to have container types like this: > data Container = Container [Widget s] but obviously this does not work because widgets may have different types of states. So problem I'm trying to solve here is that I should somehow abstract internal state used in a Widget but still be able to keep track of that state so that I can pass it to methods in sequential invocations of that methods. Also, once I have a container like this, updating widget states would become a problem. I'd have to somehow keep all those states like: > data Container = Container [Widget] [WidgetState] or > data Container = Container [(Widget, WidgetState)] and then manually pass state to widgets when calling methods, and update the list using return values of methods. In a sense I'm like trying to emulate something like closures with mutable closed-over data in impure languages. I think one way to have a similar effect is to use closures with closed-over IORefs. Then I could modify that state but then I'd need to have methods with types `IO ()`. I want to have more "precise" types. i.e. IO is a lot more general than what I'd like to have as my widget methods. (side effect of a widget should be limited with changes in it's internal state) Sorry for badly organized post, I'm a bit tired right now and I hope my points are clear. I'm trying to figure out Haskell way of doing something like this, without going into IO world. Ideas/suggestions would be appreciated. Thanks, --- Ömer Sinan Ağacan http://osa1.net

4 10

New Functional Programming Job Opportunities
by Functional Jobs 03 Mar '14

03 Mar '14

Here are some functional programming job opportunities that were posted recently: NixOS/Haskell DevOps Engineer at Zalora http://functionaljobs.com/jobs/8687-nixos-haskell-devops-engineer-at-zalora functional software developer at OpinionLab http://functionaljobs.com/jobs/8685-functional-software-developer-at-opinio… Platform Engineer at Signal Vine LLC http://functionaljobs.com/jobs/8684-platform-engineer-at-signal-vine-llc Cheers, Sean Murphy FunctionalJobs.com

1 0

ANN: tasty-0.8
by Roman Cheplyaka 03 Mar '14

03 Mar '14

I'm glad to announce the 0.8 release of tasty, a modern Haskell testing framework. http://hackage.haskell.org/package/tasty-0.8 Among the important user-visible changes are: - New running modes `--hide-successes` and `--quiet` - Short flags for some existing options (`-p` for `--pattern`, `-j` for `--num-threads`) - Timeout support - Possibility to pass options via environment variables - Fix of a resources-related bug For details, see the CHANGELOG and README: https://github.com/feuerbach/tasty/blob/master/CHANGES.md http://documentup.com/feuerbach/tasty tasty now has a mailing list[ml] and an IRC channel #tasty at FreeNode. The IRC channel is logged at ircbrowse.net[logs] (thanks to Chris Done). [ml]: https://groups.google.com/forum/#!forum/haskell-tasty [logs]: http://ircbrowse.net/tasty Read more: http://ro-che.info/articles/2014-03-03-tasty-0.8.html Roman

1 0

ANN: poppler-0.12.3 is released.
by Ian-Woo Kim 02 Mar '14

02 Mar '14

Hi, Haskellers! A new version of haskell poppler library is now released. Poppler is a pdf rendering library, based on xpdf code base. It's being developed and has quite complete features. Haskell poppler library is a binding to the native poppler library. Recently, gtk2hs-0.12.5 was released and we now have support to gtk3. We also have a great advance of Cabal-1.18, but the previous version of poppler was not buildable with the new Cabal. So this version (0.12.3) of poppler is to support gtk2hs-0.12.5 and Cabal-1.18. By default, poppler is compiled against gtk version 2, but with -fgtk3 option, one can build poppler with gtk3. The new version of poppler is available on hackage. Enjoy! Ian-Woo Kim

1 0

Scaling Haskell/Yesod on OpenShift
by Joey Eremondi 02 Mar '14

02 Mar '14

I was wondering, does anyone have experience with using Haskell/Yesod on the OpenShift PaaS? I've seen the Haskell and Yesod cartridges, but I'm wondering if there's any way to get Haskell playing nice with their load-balancing and automatic scaling capabilities? Would CloudHaskell be useful at all in this? I'm reasonably experienced with Haskell but very new to Cloud computing and Web stuff, so any advice, even if basic, is helpful. Thanks!

2 1

ICFP 2014 deadline discrepancy: UTC -11 /= anywhere in the world
by Philip Dexter 02 Mar '14

02 Mar '14

ICFP 2014's website [1] (and all notices) list the deadline as Saturday, 1 March 2014, 23:59 UTC-11 (anywhere in the world) Anywhere in the world time, also known as Anywhere on Earth (AoE), is UTC-12, not UTC-11. Is there anybody that can confirm that this is intentional? EasyChair does not list a deadline. -- [1] http://www.icfpconference.org/icfp2014/index.html

2 2

questions about ghc-clang-wrapper
by Richard Cobbe 02 Mar '14

02 Mar '14

I've just run the ghc-clang-wrapper script (from https://gist.github.com/tibbe/8448715) to try to get GHC 7.6.3 (part of Haskell Platform 2013-2.0.0) working with XCode 5.0.2 on a MacOS 10.8.5 machine. Things look good, but I have two questions: Question 1: How do I know this worked? I tested it by modifying a package that I'm writing so that it requires CPP to build correctly, and successfully built it with "cabal clean; cabal configure; cabal build". (More details available on request.) Does that mean I'm in good shape? (I'm asking because I was never entirely clear on what the incompatibility was; all I know is that it has something to do with cpp.) Question 2: Is there any harm in adding -Wno-return-type to extraClangArgs in ghc-clang-wrapper? This silences an annoying but apparently harmless warning I get from "cabal configure". Thanks, Richard

3 3

parsec problem: infinite loop (possibly connected to try(lookahead ...)) but how?)
by keydana＠gmx.de 01 Mar '14

01 Mar '14

Hi, I want to parse a rather unstructured log file, skipping blocks I'm not interested in but keeping others. For that purpose, I define "markers" that flag the beginning of interesting chunks. The "skip parser" reads anything until such a marker (using manyTill parseAny (try (lookAhead parseMarker)) and then the relative content parser starts by really consuming this marker string. I have a test case demonstrating this principle which works fine, but when I execute the (seemingly!) equivalent "real" code on a piece of a (seemingly!) equivalent "real log file", ghci enters an infinite loop - and I have no idea why... I'd be very grateful for any help, as I'm completely stuck here ;-) Following are: - the test input file - the piece of "real logfile" - the complete code in one piece (Main.hs), with the test case code in the bottom These are the results when I run 1) the test case: *Main> readFile "testfile.txt" >>= parseTest parseAll ["aaa\naaa\n","aaa\naaa\n","aaa\naaa\n"] 2) the main code (endless loop interrupted, with output from debug.trace): parseUntilChunkWFG: "" parseMaybeChunk: Nothing parseWFGMarker: Global Wait-For-Graph(WFG) at ddTS[0.3] : parseUntilChunkWFG: "" parseMaybeChunk: Nothing ^CparseWFGMarker: Global Wait-For-Graph(WFG) at ddTS[0.3] : parseUntilChunkWFG: "" parseMaybeChunk: Nothing Interrupted. This is the test input file, with vi newline symbols: ########################################################################## this is just some stuff$ I wanna skip$ $ this is, too$ 12[] $ $ BEGIN_MARKER$ aaa$ aaa$ $ this here again I can skip$ $ BEGIN_MARKER$ aaa$ aaa$ $ and then it goes on till the end of the file$ ########################################################################## ... and this is the real piece (part of, what is important I have 2 chunks of "interesting content"): ########################################################################## client details:$ O/S info: user: oracle, term: pts/2, ospid: 5820$ machine: node1.skyrac.com program: sqlplus(a)node1.skyrac.com (TNS V1-V3)$ application name: sqlplus(a)node1.skyrac.com (TNS V1-V3), hash value=10026263$ current SQL:$ insert into test values(2)$ DUMP LOCAL BLOCKER: initiate state dump for DEADLOCK$ possible owner[39.5827] on resource TX-00080011-00000545$ $ *** 2014-02-22 08:43:55.554$ Submitting asynchronized dump request [28]. summary=[ges process stack dump (kjdglblkrdm1)].$ Global blockers dump end:-----------------------------------$ Global Wait-For-Graph(WFG) at ddTS[0.3] :$ BLOCKED 0x83437238 3 wq 2 cvtops x1 TX 0xc0006.0x1c5(ext 0x4,0x0)[27000-0001-00000001] inst 1 $ BLOCKER 0x83b196a8 3 wq 1 cvtops x28 TX 0xc0006.0x1c5(ext 0x4,0x0)[36000-0002-00000005] inst 2 $ BLOCKED 0x83437238 3 wq 2 cvtops x1 TX 0x80011.0x545(ext 0x2,0x0)[36000-0002-00000005] inst 2 $ BLOCKER 0x83b35b10 3 wq 1 cvtops x28 TX 0x80011.0x545(ext 0x2,0x0)[27000-0001-00000001] inst 1 $ $ *** 2014-02-22 08:43:56.292$ * Cancel deadlock victim lockp 0x83437238 $ DUMP LOCAL BLOCKER: initiate state dump for DEADLOCK$ possible owner[39.5827] on resource TX-00080011-00000545$ $ *** 2014-02-22 08:43:55.554$ Submitting asynchronized dump request [28]. summary=[ges process stack dump (kjdglblkrdm1)].$ Global blockers dump end:-----------------------------------$ Global Wait-For-Graph(WFG) at ddTS[0.3] :$ BLOCKED 0x83437238 3 wq 2 cvtops x1 TX 0xc0006.0x1c5(ext 0x4,0x0)[27000-0001-00000001] inst 1$ BLOCKER 0x83b196a8 3 wq 1 cvtops x28 TX 0xc0006.0x1c5(ext 0x4,0x0)[36000-0002-00000005] inst 2$ BLOCKED 0x83437238 3 wq 2 cvtops x1 TX 0x80011.0x545(ext 0x2,0x0)[36000-0002-00000005] inst 2$ BLOCKER 0x83b35b10 3 wq 1 cvtops x28 TX 0x80011.0x545(ext 0x2,0x0)[27000-0001-00000001] inst 1$ $ *** 2014-02-22 08:43:56.292$ ########################################################################## ... and this is the code: ########################################################################## module Main ( main ) where import System.Environment import System.Directory import Text.ParserCombinators.Parsec import Debug.Trace import Numeric import Data.Maybe import Data.Char main = do --files <- getArgs currDir <- getCurrentDirectory --let filepaths = map ((currDir ++ "/") ++) ["munip1_lmd0_5702.trc", "munip2_lmd0_5966.trc"] let filepaths = map ((currDir ++ "/") ++) ["munip1_lmd0_5702.trc"] wfgs <- mapM (\p -> parseFromFile parseChunks p) filepaths print wfgs parseChunks :: Parser [Chunk] parseChunks = do chunks <- many1 parseMaybeChunk -- trace ("parseChunks: " ++ (show chunks)) return (catMaybes chunks) return (catMaybes chunks) parseMaybeChunk :: Parser (Maybe Chunk) parseMaybeChunk = do chunk <- try (parseChunkWFG >>= return . Just) <|> try (parseUntilChunkWFG >> return Nothing) <|> (parseTillEOF >> return Nothing) trace ("parseMaybeChunk: " ++ show chunk) return chunk --return chunk parseUntilChunkWFG :: Parser [Char] parseUntilChunkWFG = do skip <- manyTill parseAny (try (lookAhead parseWFGMarker) ) trace ("parseUntilChunkWFG: " ++ show skip) return skip --return skip parseAny :: Parser Char parseAny = do anyC <- oneOf (['a'..'z'] ++ ['A'..'Z'] ++ ['0'..'9'] ++ "()[]* -:.,/_?@='\n\\") --trace ("parseAny: " ++ (show anyC)) return anyC return anyC parseWFGMarker :: Parser [Char] parseWFGMarker = do marker <- string "Global Wait-For-Graph(WFG) at ddTS[0.3] :\n" trace ("parseWFGMarker: " ++ marker) return marker --return marker parseTillEOF :: Parser [Char] parseTillEOF = do anyCs <- many1 anyChar eof --trace ("parseTillEOF: " ++ anyCs) return anyCs return anyCs parseChunkWFG :: Parser Chunk parseChunkWFG = do marker <- string "Global Wait-For-Graph(WFG) at ddTS[0.3] :\n" wfg <- manyTill parseWFGEntry newline --trace ("parseChunkWFG: " ++ (show wfg)) return $ ChunkWFG wfg return $ ChunkWFG wfg parseWFGEntry :: Parser WFGEntry parseWFGEntry = do role <- try (string "BLOCKER") <|> string "BLOCKED" skipMany1 (space >> string "0x") lockaddr <- many1 hexDigit skipMany1 (space >> (many1 digit) >> space >> string "wq" >> space >> (many1 digit) >> space >> string "cvtops" >> space >> char 'x' >> (many1 digit) >> space) restype <- manyTill upper space skipMany1 (string "0x") id1 <- manyTill hexDigit (string ".0x") id2 <- manyTill hexDigit (string "(ext ") manyTill (digit <|> oneOf ")[]x,-") (string " inst ") instid <- manyTill digit (space >> newline) let wfgEntry = WFGEntry (read role :: Role) lockaddr (ResourceId id1 id2 restype) (read instid) --trace ("parseWFGEntry: " ++ show wfgEntry) return $ wfgEntry {- trace ("parseWFGEntry: " ++ role ++ " " ++ lockaddr ++ " " ++ restype ++ " " ++ id1 ++ " " ++ id2 ++ " " ++ instid) return $ wfgEntry -} return $ wfgEntry data Chunk = ChunkWFG WFG deriving (Show, Read) data ResourceId = ResourceId { id1 :: String, id2 :: String, restype :: String } deriving (Show, Read) data WFGEntry = WFGEntry { role :: Role, lockaddr :: String, resource :: ResourceId, instid :: Int } deriving (Show, Read) type WFG = [WFGEntry] data Role = BLOCKED | BLOCKER deriving (Show, Read) ------------------- testcase code --------------------------- parseAll :: Parser [String] parseAll = do chunks <- many1 parseChunk return (catMaybes chunks) parseChunk :: Parser (Maybe [Char]) parseChunk = do chunk <- try (parseContent >>= return . Just) <|> try (parseUntilMarker >> return Nothing) <|> (parseTillEOF >> return Nothing) --trace ("parseChunk: " ++ show chunk) return chunk return chunk parseUntilMarker :: Parser [Char] parseUntilMarker = do skip <- manyTill parseAny (try (lookAhead parseMarker) ) --trace ("parseUntilMarker: " ++ show skip) return skip return skip parseMarker :: Parser [Char] parseMarker = do marker <- string "BEGIN_MARKER\n" --trace ("parseWFGMarker: " ++ marker) return marker return marker parseContent :: Parser [Char] parseContent = do marker <- string "BEGIN_MARKER\n" items <- manyTill parseItem newline --trace ("parseContent: " ++ (show items)) return $ concat items return $ concat items parseItem :: Parser [Char] parseItem = string "aaa\n" ########################################################################## Many thanks in advance for any hints what might be going on :-)! Sigrid

1 0

Safe Haskell design question - package trust
by Omari Norman 01 Mar '14

01 Mar '14

Safe Haskell has three levels of safety: Safe - pure functions won't launch missiles. Well, sort of. They might launch missiles if they apply functions from other Trustworthy modules that do launch missiles, though one can use -fpackage-trust to mitigate this issue. Unsafe - pure functions might launch missiles, watch out. Trustworthy - module author raises her hand and says "My pure functions won't launch missiles, I promise." I can use the package trust feature to say "only trust a Trustworthy package if I say so." My issue is this: why is there no easy way to trust *any* package, not just packages that are Trustworthy? I should be able to say "I trust this package." It is immaterial whether the package author has raised her hand and said "my pure functions don't launch missiles" when I can examine the code for myself and determine whether the code launches missiles. Indeed, if I use package trust, I need to either examine the code or trust the author--the author's pledge isn't determinative. I see what "Trustworthy" adds when you're not using package trust, but it's just an informational flag if you are using package trust. Despite this Safe Haskell will not recognize the trustworthiness of packages that I have deliberately marked as trusted--merely because the author has not made a pledge. I ask because Safe Haskell has been around for over two years now yet the time package, which ships with GHC, has modules that are unsafe. I have examined them; they don't launch missiles. Yet the only easy way to get them working with Safe Haskell is to get the modules marked Trustworthy. I have emailed the maintainer and the libraries mailing list and so far have heard nothing. I have seen at least one package author get annoyed because people asked him to mark his modules Trustworthy, and I think he's right. He shouldn't need to say they're Trustworthy; rather, the Safe Haskell user should be able to do this himself. (True, the Safe Haskell user can do this by recompiling--come on, it shouldn't be that hard, and I don't want to recompile a package like time, that ships with GHC.)

1 0