- Haskell-Cafe - Haskell.org

Sugestion for a Haskell mascot
by Maurício 13 Mar '09

13 Mar '09

Hi, Here in Brazil we have a forest animal we name 'preguiça' -- literally, lazyness. What better mascot we could have for Haskell? It lives (and sleeps) in trees, and if you see the main picture in wikipedia articles you can easily imagine the tree branch beeing replaced by a lambda: http://en.wikipedia.org/wiki/Sloth http://pt.wikipedia.org/wiki/Bicho-pregui%C3%A7a Best, Maurício

26 33

Against cuteness
by Gregg Reynolds 13 Mar '09

13 Mar '09

Regarding logos/mascots: nothing personal folks, but I would like to cast a loud firm vote against all forms of cuteness, especially small furry animal cuteness. It's been done half to death, and we are not O'Reilly. Of all the billions of images from all the cultures in the world available to us we can surely find something that is witty or charming without being cute. -g

9 15

Re: [Haskell-cafe] DSLs with {in,}equalities
by Alberto G. Corona 13 Mar '09

13 Mar '09

even at the level of expressions you can be sure that inequalities hold. So you can create an instance of Ord. for example: (Sum x z) < y | x== y && z>0 = True | .... here x and y can be expressions and == can have its own rules with this you can compute symbolically, because you don´t need to reduce the expression to a numerical value. It´s a matter of finding rules. 2009/3/13 Alberto G. Corona <agocorona(a)gmail.com> > >(<) :: (Ord a) => a -> a -> Bool > > what´s the problem? > > make your Expr an instance of Ord. > > By the way > > > instance Num Expr where > > fromInterger = Const > > (+) = Plus > > (*) = Times > > does not work. you have not defined (+) and (*) for Const Integer. > > (+) (Const a) (Const b)= Const (a+b) > > With this you have an evaluator. > > In the same way: > > (Const a) < (Const b) = Const (a < b) > > > > > 2009/3/12 Adam Vogt <vogt.adam(a)gmail.com> > > This seems to be in ghc for those reasons: >> http://www.haskell.org/haskellwiki/Quasiquotation >> >> * On Monday, March 02 2009, Andrew Hunter wrote: >> >> >Several times now I've had to define an EDSL for working with >> >(vaguely) numeric expressions. For stuff like 2*X+Y, this is easy, >> >looking pretty much like: >> > >> >> data Expr = Const Integer | Plus Expr Expr | Times Expr Expr >> >> >> >> instance Num Expr where >> >> fromInterger = Const >> >> (+) = Plus >> >> (*) = Times >> > >> >&c. This lets me get a perfectly nice AST, which is what I want. >> >When I want to be able to express and work with inequalities and >> >equalities, this breaks. Suppose I want to write 2*X + Y < 3. I >> >either have to: >> > >> >a) Hide Prelude.(<) and define a simple < that builds the AST term I >> want. >> >b) Come up with a new symbol for it that doesn't look totally awful. >> > >> >Neither of these work decently well. Hiding Eq and Ord operators, >> >which is what I effectively have to do for a), is pretty much a >> >nonstarter--we'll have to use them too much for that to be practical. >> > >> >On the other hand, b) works...but is about as ugly as it gets. We >> >have lots and lots of symbols that are already taken for important >> >purposes that are syntactically "near" <,<=,==, and the like: << and >> >>> and >>= for monads, >>> for arrows, etc. There...are not good >> >choices that I know of for the symbols that don't defeat the purpose >> >of making a nice clean EDSL for expressions; I might as well use 3*X + >> >Y `lessthan` 3, which is just not cool. >> > >> >Does anyone know of a good solution, here? Are there good >> >substitutions for all the six operators that are important >> >(<,>,>=,<=,==,/=), that are close enough to be pretty-looking but not >> >used for other important modules? >> > >> >Better yet, though a little harder, is there a nice type trick I'm not >> >thinking of? This works for Num methods but not for Ord methods >> >because: >> > >> >(+) :: (Num a) => a -> a -> a >> >(<) :: (Ord a) => a -> a -> Bool >> > >> >i.e. the return type of comparisons is totally fixed. I don't suppose >> >there's a good way to...well, I don't know what the *right* answer is, >> >but maybe define a new typeclass with a more flexible type for < that >> >lets both standard types return Bool and my expressions return Expr? >> >Any good solution would be appreciated. >> > >> >Thanks, >> >AHH >> >_______________________________________________ >> >Haskell-Cafe mailing list >> >Haskell-Cafe(a)haskell.org >> >http://www.haskell.org/mailman/listinfo/haskell-cafe >> _______________________________________________ >> Haskell-Cafe mailing list >> Haskell-Cafe(a)haskell.org >> http://www.haskell.org/mailman/listinfo/haskell-cafe >> > >

1 0

Fwd: [Haskell-cafe] DSLs with {in,}equalities
by Alberto G. Corona 13 Mar '09

13 Mar '09

---------- Forwarded message ---------- From: Alberto G. Corona <agocorona(a)gmail.com> Date: 2009/3/13 Subject: Re: [Haskell-cafe] DSLs with {in,}equalities To: Adam Vogt <vogt.adam(a)gmail.com> You need an expression evaluator: with (+) (Const a) (Const b)= Const (a+b) (*) (Const a) (Const b)= Const (a*b) eval :: Exp -> Integer eval (Const i)= i eval ( Plus e1 e2)= eval e1 + eval e2 .. eval( Mul .... and instance Ord Expr where (<) expr1 expr2 = eval expr1 < eval expr2 by the way: simplify expr= Const (eval expr) ...................................... 2009/3/13 Alberto G. Corona <agocorona(a)gmail.com> > Sorry(Const a) < (Const b) = a < b > > also > > (*) (Const a) (Const b)= Const (a*b) > > > 2009/3/13 Alberto G. Corona <agocorona(a)gmail.com> > > >(<) :: (Ord a) => a -> a -> Bool >> >> what´s the problem? >> >> make your Expr an instance of Ord. >> >> By the way >> >> > instance Num Expr where >> > fromInterger = Const >> > (+) = Plus >> > (*) = Times >> >> does not work. you have not defined (+) and (*) for Const Integer. >> >> (+) (Const a) (Const b)= Const (a+b) >> >> With this you have an evaluator. >> >> In the same way: >> >> (Const a) < (Const b) = Const (a < b) >> >> >> >> >> 2009/3/12 Adam Vogt <vogt.adam(a)gmail.com> >> >> This seems to be in ghc for those reasons: >>> http://www.haskell.org/haskellwiki/Quasiquotation >>> >>> * On Monday, March 02 2009, Andrew Hunter wrote: >>> >>> >Several times now I've had to define an EDSL for working with >>> >(vaguely) numeric expressions. For stuff like 2*X+Y, this is easy, >>> >looking pretty much like: >>> > >>> >> data Expr = Const Integer | Plus Expr Expr | Times Expr Expr >>> >> >>> >> instance Num Expr where >>> >> fromInterger = Const >>> >> (+) = Plus >>> >> (*) = Times >>> > >>> >&c. This lets me get a perfectly nice AST, which is what I want. >>> >When I want to be able to express and work with inequalities and >>> >equalities, this breaks. Suppose I want to write 2*X + Y < 3. I >>> >either have to: >>> > >>> >a) Hide Prelude.(<) and define a simple < that builds the AST term I >>> want. >>> >b) Come up with a new symbol for it that doesn't look totally awful. >>> > >>> >Neither of these work decently well. Hiding Eq and Ord operators, >>> >which is what I effectively have to do for a), is pretty much a >>> >nonstarter--we'll have to use them too much for that to be practical. >>> > >>> >On the other hand, b) works...but is about as ugly as it gets. We >>> >have lots and lots of symbols that are already taken for important >>> >purposes that are syntactically "near" <,<=,==, and the like: << and >>> >>> and >>= for monads, >>> for arrows, etc. There...are not good >>> >choices that I know of for the symbols that don't defeat the purpose >>> >of making a nice clean EDSL for expressions; I might as well use 3*X + >>> >Y `lessthan` 3, which is just not cool. >>> > >>> >Does anyone know of a good solution, here? Are there good >>> >substitutions for all the six operators that are important >>> >(<,>,>=,<=,==,/=), that are close enough to be pretty-looking but not >>> >used for other important modules? >>> > >>> >Better yet, though a little harder, is there a nice type trick I'm not >>> >thinking of? This works for Num methods but not for Ord methods >>> >because: >>> > >>> >(+) :: (Num a) => a -> a -> a >>> >(<) :: (Ord a) => a -> a -> Bool >>> > >>> >i.e. the return type of comparisons is totally fixed. I don't suppose >>> >there's a good way to...well, I don't know what the *right* answer is, >>> >but maybe define a new typeclass with a more flexible type for < that >>> >lets both standard types return Bool and my expressions return Expr? >>> >Any good solution would be appreciated. >>> > >>> >Thanks, >>> >AHH >>> >_______________________________________________ >>> >Haskell-Cafe mailing list >>> >Haskell-Cafe(a)haskell.org >>> >http://www.haskell.org/mailman/listinfo/haskell-cafe >>> _______________________________________________ >>> Haskell-Cafe mailing list >>> Haskell-Cafe(a)haskell.org >>> http://www.haskell.org/mailman/listinfo/haskell-cafe >>> >> >> >

1 0

Typing Dynamic Typing [Was: Dynamically typing TH.Exp at runtime]
by oleg＠okmij.org 13 Mar '09

13 Mar '09

Martin Hofmann asked: > Is there a Haskell implementation of the paper "Typing Dynamic Typing" > by Baars and Swierstra There is a different implementation but in the same spirit http://okmij.org/ftp/tagless-final/IncopeTypecheck.hs http://okmij.org/ftp/Computation/tagless-typed.html#tc-final The first difference between IncopeTypecheck and Baars and Swierstra's one is in the type representation and safe coercions. IncopeTypecheck uses Typeable, and so it needs to define reflection from a type rep to a value of that type. The projection function of Typeable requires a value of a specific type rather than a typerep. The main difference is treating environments and weakening. Baars and Swierstra treat an Identifier, at compile time, as a projection function \env->t. Here env is the run-time env represented as a nested tuple. `Closing the Stage' paper relies on the same idea. To be able to collect those projection functions into a regular list, they wrap them into a Dynamic. IncopeTypecheck, in contrast, represents compile-time variables as functions \x->x, which are weakened as they are embedded into a reacher environment. The functions are wrapped into Dynamic, as this is the result of typechecking. The type environment Gamma in IncopeTypecheck contains only TypeRep but no Dynamics! Here a few examples to illustrate the difference between Baars and Swierstra and IncopeTypecheck: Source expression: Add (Int 2) (Int 3) Baars and Swierstra: \env -> (\_ -> 2) env + (_ -> 3) env IncopeTypecheck: add (int 1) (int 2) Source expression: (Lam "x" Int (x + (Int 1))) Baars and Swierstra: \env -> \x -> (\env -> (\(x,_) ->x) env + (\_ -> 1) env) (x,env) IncopeTypecheck: \x -> (\x -> x) x `add` (\_ -> int 1) x (of course, in IncopeTypecheck, instead of (\x -> ...) there should be lam (\x -> ...) and instead of meta-language application there should be app. I drop them for clarity). For deeply nested functions, IncopeTypecheck probably has to do more redices as it repeatedly applies coercions. Since the environment is known, I could have built the weakening in one step rather than as a sequence of weakening into a progressively richer environment. Each step into this sequence includes an administrative redex. The sequential weakening was easier to implement though.

2 1

Re: [Haskell-cafe] Natural Numbers: Best implementation?
by Sebastian Fischer 13 Mar '09

13 Mar '09

Hi Mark, On Mar 13, 2009, at 3:54 AM, Mark Spezzano wrote: > I was wondering what the best way to implement Natural number would > be. Is there a package which already does this? there are two packages on Hackage that implement natural numbers using algebraic datatypes: 'numbers' has a module Data.Number.Natural that implements them in "unary" notation (zero and successor), 'nat' has Data.Number.Nat that uses a binary encoding. Cheers, Sebastian

1 0

Combining haddock documentation from multiple packages
by Heikki Aitakangas 13 Mar '09

13 Mar '09

Is it possible to generate a "unified" documentation tree similar to http://www.haskell.org/ghc/docs/latest/html/libraries/index.html from packages installed via cabal from hackage? And if so, how does one go about doing it? -- Heikki Aitakangas

2 1

How to compare PortNumbers or Bug in Network.Socket?
by Stefan Schmidt 13 Mar '09

13 Mar '09

Hello, I want to compare two PortNumber-Values from the Network.Socket module and I think I've experienced some unexpected behavior of the derived ordering methods. I'm using the ghc-6.10.1 and the network library 2.2.0.1 on a x86 32-Bit machine. The following program creates two pairs of PortNumber values and compares them with each other. module Main(main) where import Network.Socket -- Block A p1 :: PortNumber p1 = fromIntegral 9000 p2 :: PortNumber p2 = fromIntegral 10000 -- Block B pp1 :: PortNumber pp1 = PortNum 9000 pp2 :: PortNumber pp2 = PortNum 10000 main :: IO () main = do putStrLn $ "A - " ++ (show $ p1 > p2) putStrLn $ "B - " ++ (show $ pp1 > pp2) On my machine, I get the result: A - True A - False At the first glance, it seemed to me, that there is a bug in the fromIntegral Implementation. But after I looked into the code, I saw that fromIntegral calls the system function "htons" to change the byte order from my machine to the network byte order, which on my machine is different. Because of this the values 9000 and 10000 are transferred, so that their ordering changes. Block B preservers this ordering, because the Constructor PortNum does not call htons, but since the byte order is wrong, I cannot use pp1 and pp2 to address port 9000 and 10000. As a work around, I could convert two PortNumbers back to Int-Values before comparing them, but I think the ordering functions for the PortNumber-Type do not work as expected. Or am I wrong? Stefan Schmidt

4 5

Re: [Haskell-cafe] Using a monad to decompose a function into functions
by Marcin Kosiba 13 Mar '09

13 Mar '09

On Thursday 12 March 2009, you wrote: > 2009/3/12 Marcin Kosiba <marcin.kosiba(a)gmail.com>: > > Hi, > > I'm doing a bit of research into mobility models and I'm currently > > exploring implementation language choices for the simulator > > (*snip*) > > The simulation algorithm requires expressing > > the node's mobility so that it is "stateless". The mobility model > > algorithm's type should be something like: > > mobility_model :: WorldState -> NodeState -> OtherInput -> (Action, > > NodeState) > > > > where Action can alter WorldState and the second NodeState is an altered > > input NodeState. I perform a form of speculative execution on > > mobility_model so sometimes I need to backtrack to a previous world and > > node state. This is all fairly simple stuff, and was just an > > introduction. What I do now is store an enum in NodeState and implement > > mobility_model as one big case statement. Yes, this is very imperative of > > me, I know. What I'd like to do is to express mobility_model, so that the > > code would look like: > > > > mobility_model world node input = do > > do_calculus > > emit_action > > if something > > then emit_action > > else emit_action > > do_calculus > > emit_action > > mobility_model world node input > > Hi, > > It seems you can use > http://hackage.haskell.org/packages/archive/mtl/latest/doc/html/Control-Mon >ad-State-Lazy.html Just have a look at the exemple : > > tick :: State Int Int > tick = do n <- get > put (n+1) > return n > > your code would become something like > mobility_model :: OtherInput -> State (WorldState,NodeState) () > mobility_model input = do > world <- gets fst > node <- gets snd > .... > let (world',node') = ... > put (world',node') ok, that solves part of the problem. what this doesn't solve is that somewhere between these lines (which corespond to emit_action in my example) > let (world',node') = ... > put (world',node') I need to return a value and an Action and NodeState to the simulation algorithm. and then, after the simulation algorithm calculates a new WorldState it will want the mobility_model to where it left off, but with a new WorldState. I hope I'm clear about what I wish to achieve: each emit_action should return a value (Action, NodeState) and maybe a function mobility_model_cont which I then could call with the new WorldState to continue from where emit_action returned. Thanks, Marcin Kosiba

2 1

ANNOUNCE: Vintage BASIC 1.0
by Lyle Kopnicky 13 Mar '09

13 Mar '09

I am pleased to announce the initial release of Vintage BASIC, an interpreter for microcomputer-era BASIC. Fully unit-tested, it faithfully implements the common elements of the language. On the web site, you can find 102 games from the classic book BASIC Computer Games, all of which run flawlessly. Have fun! This is a standalone interpreter, operating on text files. Although not an embedding, like Lennart Augustsson's clever implementation, it does use a custom BASIC monad in order to execute the code. A unique feature of this implementation is that control structures such as FOR are implemented using resumable exceptions: FOR is a handler and NEXT throws an exception. A Developer's Guide is included with the source. This is my first public release of open source software. I have been working on this project since 2003. Home page: http://www.vintage-basic.net Also available on Hackage<http://hackage.haskell.org/cgi-bin/hackage-scripts/package/vintage-basic>and patch-tag.com <http://patch-tag.com/repo/vintage-basic/home>. Please e-mail me at lyle(a)vintage-basic.net with any questions/comments. - Lyle

2 1