def f(a):
        print a
        print a+1
        {999: int}.get(a,f)(a+2)

    f(1)

Basically, the concept is to call f recursively, until you get to 999 (and had printed 999 and 1000), at which time you call some non-recursive function (I call "int").

At 999, the inner-called f function terminates, leading to the unwinding of the stack (each previous f function terminating), and then the program ends.

This statement is the hard one to understand:

        {999: int}.get(a,f)(a+2)

    f() -> f(1).
    f(1001) -> ok;
    f(N) -> io:fwrite("~p~n", [N]), f(N + 1).

    MAX = 1000

    def execute_if_not_equals(value, other, &block)
      noop = lambda {}
      [block, noop][value / other].call
    end

    def print(i)
      execute_if_not_equals(i, MAX) do
        puts(i + 1)
        print(i + 1)
      end
    end

    print(0)

  var items = [];
  var rec = function(item) {
      var func = [];
      func[true] = function(item) { items.push(item); [item-1].map(rec); };
      func[false] = function(item) {};
      return func[Boolean(item)](item);
  };
  var item = [1000];
  item.map(rec);
  console.log(items.reverse().join(','));

    print str(range(1,1001)).strip('[]').replace(', ','\n')

    print "\n".join(map(str, range(1,1001)))

    print "\n".join(str(i) for i in range(1,1001))

Or else you could just:

    for i in range(1,1000):
        print i

    z="0123456789"
    print map(lambda x:int("".join(x))+1,zip(sorted(zip(*z)[0]*100),
              sorted(zip(*z)[0]*10)*10,
              zip(*z)[0]*100))

    from __future__ import print_function 
    z="0123456789"
    map(print,map(lambda x: int("".join(x))+1,zip(sorted(z*100),
                      sorted(z*10)*10, z*100)))

    sorted(z*100)

    sorted(z*10)*10.

    z*100.

    map(lambda x:  int("".join(x))+1,zip(sorted(z*100),
                              sorted(z*10)*10, z*100)))

Then I map it to the new print function that is available in Python 3.0, or with the import statement.

A simpler version would use range, but that seems a little too simple:

    from __future__ import print_function 
    map(print,range(1,1000))

  ('\n').join(map(str, [1,2,3]))

   $,="\n"; print 1..1000

    mapM_ (putStrLn . show) [1..1000]

mapM_ print [1..1000]

but yeah, ...haskell +1 for that :D

  (map (lambda (n)
       (displayln n))
     (cdr (build-list 1001 values)))

  #define NOT_A_LOOP(x) while(x)

#include someone_else_did_it_so_we_dont_know(x)

Just as those other answers in C relied on GOTOs somewhere.

Which, of course, is passing the buck to Range#to_a

No stinking loops!