Random Hacks comments

"Why Hygienic Macros Rock" by Scott

Tue, 15 Jul 2008 22:30:03 -0400

Daniel: Ok, thanks.

I’m acquainted with Forth. I read both Starting Forth and Thinking Forth a few days after posting the above comment, actually; I love the concatenative approach, though I find Forth a bit too low-level for my taste. (My favorite language is currently OCaml, so you can guess how I feel about working without any type system whatsover.) I’ve also looked a little at Factor, but not in depth.

That said, the source to a Forth interpreter in i386 assembly and Forth was one of the single most mind-blowing programming things I’ve ever read. When I saw that the interpreter had a bit for whether the code was being compiled or evaluated, and immediate functions could toggle it at runtime, everything suddenly made sense. So much flexibility emerging from so few constructs!

http://www.annexia.org/_file/jonesforth.s.txt

"Why Hygienic Macros Rock" by Daniel

Sun, 22 Jun 2008 21:47:00 -0400

I have actually read a lot about hygienic vs non-hygienic macros. I just cannot recall what blogs and sites I read them.

You might try smuglispweeny and lambda-the-ultimate blogs, though. And wikipedia.

The thing is, gensyms handles some of the stuff hygienic macros handle, but not all of the stuff. There are some complex cases which would require heroic efforts in LISP, and very prone to errors at that.

On the other hand, hygienic macros can access the runtime context, in a more verbose way.

So, really, they each can be used for the same things, with varied levels of complexity depending on the task. But let me advocate hygienic macros a bit here.

There once was a language called Forth. Forth was interesting in that not only it was written in itself, but all the internals were available to any programs written in it, and, furthermore, it could be changed at will. You could change the parser, for instance, or you could change how it performed compilation.

Needless to say, it was powerful in the way such languages are. The thing is… Forth lacked abstraction. Yes, you could change the compiler. But, of course, you’d have to know how the specific compiler you were changing worked—and I don’t mean simply dialect differences. The most famous Forth generated indirectly threaded code, quite a few generated directly threaded code, some generated subrouting threaded code, others generated bytecode, and others compiled directly to machine code.

So it was very powerful stuff, which had very little portability. Well, let’s be honest. It had no portability at all.

And here is the thing with non-hygienic macros… the programmers using someone’s macro also have to know how that macro works. Either that, or you add stuff to your macro until it is, effectively, hygienic.

So, by using hygienic macros, you guarantee a level of portability to them similar to library functions.

"Why Hygienic Macros Rock" by Eric

Fri, 20 Jun 2008 07:40:30 -0400

Scott: That’s a good question, and I don’t actually know the answer.

Most Scheme implementations take a distantly-related approach. They generally have two different hygenic macro systems:

A “low-level” macro system, which works roughly like LISP, but which provides hygiene by default, but also provides the ability to violate hygiene selectively. This tends to be a bit fiddly to use.
A “high-level” macro system, which is based on hygienic rewrite rules. This is very easy to use, and will work for nearly all common macros.

Of course, using the low-level macro system, you can easily implement Lisp-style non-hygienic macros.

The PLT people have recently added another very slick feature to the standard Scheme toolkit: The ability the selectively violate hygiene from inside rewrite rules, in a carefully controlled fashion. This is a really nice feature, and we’ve been using it at work with great success.

"Why Hygienic Macros Rock" by Scott

Thu, 19 Jun 2008 20:15:42 -0400

To what extent can hygienic macros be implemented in non- and vice versa? I’m more familiar with Emacs Lisp-style macros than CL or Scheme macros, but it seems like the hygiene involves automatically writing code with gensyms to avoid variable capture and other compile-time analysis. If one is implemented in terms of the other, it would probably make the most sense to have two different forms, e.g. hmacro for declaring hygienic macros, and macro for when you deliberately want to do things like variable capture.

"Monads in 15 minutes: Backtracking and Maybe" by Doug Auclair

Wed, 14 May 2008 01:39:52 -0400

Linking this article on an introductory post about Maybe, List and Either monads and their uses for nondeterministic programming.

Coincidentally, I wrote a same-game-like puzzle solver (cf. comp.lang.haskell), where I needed to flatten a list of lists. I didn’t see `flatten` in the Prelude or List, so I wrote it out. I then realized that `msum` is flatten for lists of depth 1 … then I reread this article where join :: m (m a) → m a does the same thing. Applied that in my code and noticed I had this pattern: join $ map f x … and replaced that with x >>= f.

Sigh! Months later and I’m still not recognizing when to use a simple bind!

"Monads in 15 minutes: Backtracking and Maybe" by Joel Hough

Thu, 10 Apr 2008 03:29:26 -0400

Great article! A few things clicked for me while reading. I found that writing out the choice monad example step by step helped me to understand. Like so:

choose [1,2,3] >>= (\x ->
choose [4,5,6] >>= (\y ->
guard (x*y==8) >>= (\ignored ->
return (x,y))))

is equivalent to…

step1 = concat $ map step2 [1,2,3]
step2 x = concat $ map (step3 x) [4,5,6]
step3 x y = concat $ map (step4 x y) (if x*y == 8 then [()] else [])
step4 x y _ = [(x, y)]

Thanks for the epiphanies!

"Refactoring probability distributions, part 1: PerhapsT" by Robert

Fri, 04 Apr 2008 10:37:48 -0400

With regards to what Dan P said, there is a quantum IO monad:

http://www.cs.nott.ac.uk/~txa/talks/qnet06.pdf

"Map fusion: Making Haskell 225% faster" by Lemming

Fri, 04 Apr 2008 02:42:12 -0400

I encountered the following problem which will hurt us in case of generalized monads as sketched in http://www.randomhacks.net/articles/2007/03/15/data-set-monad-haskell-macros and of data structure like StorableVector http://code.haskell.org/~sjanssen/storablevector that requires a constraint on the element types. There it makes a difference if you separately map and fold or if you do it in one go. In the first case you need a Storable constraint for intermediate result type, too. That is, these constraints make implementation issues observable via the type signature.

"Jim Hefferon's Linear Algebra: A free textbook with fascinating applications" by Arun J. C.

Wed, 05 Mar 2008 08:48:55 -0500

i am 2 semester Btech student in NIT Calicut

"Jim Hefferon's Linear Algebra: A free textbook with fascinating applications" by Arun J. C.

Wed, 05 Mar 2008 08:47:23 -0500

I just searched linear agebra and this came up wonderful , really benifical better than any other book. thanks ….