March 2010 - Beginners

Addable function combinators
by Edgar Klerks 01 Apr '10

01 Apr '10

(I am sorry for the spam, but my browser seems to chopoff the reply-to field. I have changed mailclient so I can manually add it. Hopefully the issue is resolved) Hi Brent, I already solved it myself. I wanted to find an systematic way to produce composition operators which composes functions with different arity together. I stated it a bit vague. For example <*||> is (c -> d) -> (a -> b -> c) -> a -> b -> d I can add this types with the composition operator to create a new operator which combines functions with different arity. In this case a function with arity 1 with a function with arity 4: <*||>.<*||> = <*||||> But I couldn't find an systematic way to level the arity of the function on the left side. I wanted to find an operator what did this, like so: <*|> `op` <*|> = <**|> But I found another way already, which can be found in the followup. So I guess this question is closed. But thanks anyway for your response. I really appreciate the way the people on this list react to new haskellers. Your are really helpful, which sometimes on other lists is quitte the oposite. Greets, Edgar

1 0

Addable function combinators
by Edgar Klerks 01 Apr '10

01 Apr '10

Hi Brent, I already solved it myself. I wanted to find an systematic way to produce composition operators which composes functions with different arity together. I stated it a bit vague. For example <*||> is (c -> d) -> (a -> b -> c) -> a -> b -> d I can add this types with the composition operator to create a new operator which combines functions with different arity. In this case a function with arity 1 with a function with arity 4: <*||>.<*||> = <*||||> But I couldn't find an systematic way to level the arity of the function on the left side. I wanted to find an operator what did this, like so: <*|> `op` <*|> = <**|> But I found another way already, which can be found in the followup. So I guess this question is closed. But thanks anyway for your response. I really appreciate the way the people on this list react to new haskellers. Your are really helpful, which sometimes on other lists is quitte the oposite. Greets, Edgar

1 0

hiding documentation for non-exposed modules
by Ashish Agarwal 31 Mar '10

31 Mar '10

I'm using cabal to build and install a new library I'm writing. In the .cabal file I've exposed only a single module. However, the haddock generated documentation includes even the non-exposed modules, which is not what I want since end-users should not see these. Is there a way to tell cabal to build documentation only for exposed modules?

2 2

What should I use (the equivalent of Windows schtasks) to schedule a task to run?
by Hong Yang 31 Mar '10

31 Mar '10

I searched "schedul" on hayoo!, but had no clue. It seems that I can use scheduleEventAt from Control.Monad.Event.Classes. But what is type "e"? It seems like an event. How do I define an event? I have not learned Monad yet. Can some one give me a simple example? Suppose I want to run an external program "pg" which in Haskell's language has the type of String -> IO (). Thanks, Hong

2 2

Addable function combinators
by edgar klerks 31 Mar '10

31 Mar '10

He All, I was toying a bit around and found a function, which combines an function of arity 1 with 2. Then I produced a whole sequence of these function, the number of * stands for the arity of the left function and the number of | stands for arity the right function. so <*|||> :: (b -> c -> d) -> (a -> c) -> a -> b -> d: (<*****|>) = flip (<*|||||>) (<****|>) = flip (<*||||>) (<***|>) = flip (<*|||>) (<**|>) = flip (<*||>) (<*|>) = (.) (<*||>) = (<*|>).(<*|>) (<*|||>) =(<*||>).(<*|>) (<*||||>) = (<*||>).(<*||>) (<*|||||>) = (<*||||>).(<*|>) con = (flip.) .(.) (<**||>) = (<*||>).flip (<**|||>) = (<*|>).(<**||>) (<**||||>) = (<*|>).(<**|||>) (<***||>) = (<*||>).(con flip) (<***|||>) = (<*|>).(<***||>) (<****||>) = (<*||>).(con.con $ flip) I found it interesting, but now I am stuck. is it possible to make the stars addable instead of the | or both? Greets, Edgar Edgar

2 2

Rewriting traversal over trees
by Darryn Reid 31 Mar '10

31 Mar '10

Hi, I hope that this is an appropriate place to post this question; I'm an experienced computer scientist and mathematician but am new to Haskell (I love it, I might add, but have much to learn). I've coded a (fairly) general rewriting traversal - I suspect the approach might be generalisable to all tree-like types, but this doesn't concern me much right now. My purpose is for building theorem provers for a number of logics, separating the overall control mechanism from the specific rules for each logic. The beauty of Haskell here is in being able to abstract the traversal away from the specific reduction rules and languages of the different logics. I have paired down the code here to numbers rather than modal formulas for the sake of clarity and simplicity. My question is two-fold: 1. Does my representation of the traversal seem good or would it be better expressed differently? If so, I'd appreciate the thoughts of more experienced Haskell users. 2. I cannot really see how to easily extend this to a queue-based breadth-first traversal. I'm sure others must have a good idea of how to do what I'm doing here except in breadth-first order; I'd appreciate it very much if someone could show me how to make a second breadth-first version. Thanks in advance for any help! Darryn. start of code. ------------------------------------------------------------------------- import Control.Monad import Control.Monad.Identity -- Tableau is a tree containing formulas of type a, in -- Fork (disjunctive) nodes and Single (conjunctive) nodes. -- Paths from root to Nil each represent an interpretation. data Tableau a = Nil -- End of a path | Single a (Tableau a) -- Conjunction | Fork (Tableau a) (Tableau a) -- Disjunction deriving (Eq, Show) -- 'Cut' directs the traversal to move back up the tree rather than into -- the current subtree, while 'Next' directs the traversal to proceed -- into the subtree. data Action = Cut | Next deriving (Eq, Show) -- The type of the rewrite function to perform at each node in -- the traversal of the tree. The Rewriter returns the new -- subtree to replace the existing subtree rooted at the -- traversal node, and a direction controlling the traversal -- to the next node. type Rewriter m a = Tableau a -> m (Tableau a, Action) -- The traversal function, depth-first order. rewrite :: (Monad m) => Rewriter m a -> Tableau a -> m (Tableau a) rewrite rf t = do (t', d) <- rf t rewrite' rf d t' -- Worker function for traversal, really its main body. rewrite' :: (Monad m) => Rewriter m a -> Action -> Tableau a -> m (Tableau a) rewrite' rf Cut t = return t rewrite' rf Next Nil = return Nil rewrite' rf Next (Single x t1) = do t1' <- rewrite rf t1 return (Single x t1') rewrite' rf Next (Fork t1 t2) = do t1' <- rewrite rf t1 t2' <- rewrite rf t2 return (Fork t1' t2') -- Some examples to test the code with: -- ghci> let t0 = (Single 2 (Single 3 Nil)) -- ghci> let t1 = (Single 1 (Fork t0 (Fork (Single 4 Nil) (Single 5 Nil)))) -- ghci> let t2 = (Fork (Single 10 Nil) (Single 11 Nil)) -- ghci> let t3 = (Fork (Single 3 Nil) (Single 3 Nil)) -- Running "test4 t1 t2" produces the expected result; running -- "test4 t1 t3" does not terminate, because this endlessly -- generates new patterns that match the substitution condition: test4 :: (Num t) => Tableau t -> Tableau t -> Tableau t test4 tab tab' = runIdentity (rewrite rf tab) where rf (Single 3 Nil) = return (tab', Next) rf t = return (t, Next) -- Running "test5 t1 t3", however, does terminate because the "Cut" -- prevents the traversal from entering the newly spliced subtrees -- that match the pattern. test5 :: (Num t) => Tableau t -> Tableau t -> Tableau t test5 tab tab' = runIdentity (rewrite rf tab) where rf (Single 3 Nil) = return (tab', Cut) rf t = return (t, Next) ------------------------------------------------------------------------- end of code.

2 1

overflow safe Word types
by Ashish Agarwal 31 Mar '10

31 Mar '10

Is there an alternative implementation of the types Word8, Word16, etc. that disallow overflow? For example, currently: Prelude Word> (fromInteger 256) :: Word8 0 I'd like a type whose constructors disallow this.

3 3

[OT] To the Google Group 'fa.haskell' admin.
by aditya siram 30 Mar '10

30 Mar '10

I noticed that my posts to the 'fa.haskell' Google group don't make it to the Haskell-Cafe archives and I suspect they are invisible to the Haskell-Cafe readers. They seem to be visible to only those who are subscribe to the Google Group. Conversely some of the other people's posts to Haskell-Cafe don't appear in the Google group. For instance I posted to this thread: http://www.haskell.org/pipermail/haskell-cafe/2010-March/075250.html and it is not in the Haskell-Cafe archives. And this response by Jeff Wheeler: http://www.haskell.org/pipermail/haskell-cafe/2010-March/075251.html is not visible in the Google Group. As of now I'll stop using the Google group, but I wanted to let someone know. Thanks ... -deech

2 1

Mixing monads?
by Ron Leisti 29 Mar '10

29 Mar '10

I've run into a situation where I need to 'weave' two monads together, but I can't figure out how it's done. The first monad is "Parser a" from Attoparsec, and the second is one that I've created called "CBC a", with the following relevant functions: -- Decrypts a word in cipher-block-chaining mode decryptCBC :: Word128 -> CBC Word128 -- Performs a cipher-block-chaining mode operation with the given -- key and initialization vector. cbc :: Key -> IV -> CBC a -> a I've also defined a special parser for Attoparsec, for extracting the next 128 bit word from the stream: word128 :: Parser Word128 My problem is that I would like to write a function which reads a word, decrypts it, and then uses the result to make a decision about whether to read further words or return a result. So far, I think my function would have a result type of: func :: Parser (CBC foo) but within the function, if I do something like: func = do x <- word128 let r = do y <- decryptCBC x if (predicate y) then return bar else -- somehow read more from the parser? return r But within this function I run into the situation where my types turn into something like Parser (CBC (Parser a)). I have a feeling that I'm just going about this in a wrong way. I realize that I probably don't need to use Parser here, since I'm just reading a stream of words, but I'd still like to learn how to do this in the general case. Is there anyone that could point me in a better direction? Thanks, Ron

3 3

Earth Hour 2010: Will you join me?
by Ivan Vovnenko 27 Mar '10

27 Mar '10

beginners(a)haskell.org, I just signed up to support the Earth Hour 2010 campaign and I'd like to invite you to join me. Just visit https://www.myearthhour.org/home?invite=KozdEiQpor. Earth Hour was conceived by the World Wildlife Fund, and represents the global call to action on climate change. The more people that pledge to turn off their lights for Earth Hour, the more influence we will have. Nearly one billion people around the world turned off their lights for Earth Hour 2009 and we can help make the next one even bigger. Through the flick of a light switch on March 27 at 8:30 pm local time, we'll be casting our vote for action on one of the most pressing issues facing our planet, sending a message to our local, national, and global leaders that the time to act is now. Follow this link to learn more and sign-up yourself. https://www.myearthhour.org/home?invite=KozdEiQpor ---------------- -Ivan Vovnenko ----------------

1 0