I've never messed with Clojure, but I have dabbled in Scheme some. I should really look into Clojure just so I can understand the code you post here.
Hmm... I'm guessing that the square brackets tell defn the names of the arguments of the function you're defining, and # creates a lambda whose argument is %. If that's the case, then here's a Haskell translation (it works, I tested it), using what I believe are the usual conventions in Haskell:
Code:
natural :: (Num a, Enum a) => [a]
natural = [1..]
ofNatural :: (Num a, Enum a) => (a -> b) -> [b]
ofNatural f = map f natural
multiples :: (Num a, Enum a) => a -> [a]
multiples x = ofNatural (*x)
dividedBy :: (Fractional a, Enum a) => a -> [a]
dividedBy x = ofNatural (/x)
under :: (Fractional a, Enum a) => a -> [a]
under x = ofNatural (x/)
negatives :: (Num a, Enum a) => [a]
negatives = multiples (-1)
whole :: (Num a, Enum a) => [a]
whole = ofNatural (\x -> x-1)
I don't fully understand why I had to specify the Enum typeclass thing on every function... but at least the compiler suggested adding it as a fix, which worked. And by doing so (rather than saying that natural has a type of [Int] and requiring the arguments of all the other functions to be Ints), it allows the natural list to behave as a list of integers when applied to integral functions (like + and *), or a Fractional list when / is mapped over it, or a Floating list when sqrt is mapped over, etc.
Lazy eval is a useful thing. Handy when you're trying to read a really large file (i.e. larger than your computer's available RAM) because it won't actually load a line/block until some other code requests it. And yeah, infinite lists are fun.