We Hate Lisp(wiki.c2.com)

    Dim sum
    
    For Each thing In Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
        sum = sum + thing
    Next

    sum(range(10))

    Vec![1..10].iter().reduce(|x,y| x+y)

    ;;; -*- LISP -*-
    ;;; IOTA: Macros for doing I/O correctly.
    ;;; Bugs/suggestions/complaints to KMP@MC

    ;;; IOTA
    ;;;
    ;;; Mnemonic Basis: A form of Lambda for doing I/O binding.
    ;;;
    ;;; This is a LAMBDA binding macro that will open a lisp file object
    ;;; in such a way that it is automatically closed when the lambda binding
    ;;; range is exited.

    The following is some sample code (complete with documentation) that I found in my notes and thought might be helpful:

    ;;; Notes about CLI interrupts:
    ;;;
    ;;; A CLI interrupt is what happens when another job sends to yours. It is
    ;;; normally the case that other jobs will send directly to a user's HACTRN.
    ;;; If, however, Lisp is interrupted by a CLI message, it can elect to handle
    ;;; handle the interrupt in an arbitrary way.
    ;;;
    ;;; To define a handler, two things must be done:
    ;;;  [1] Place the name of the handler function (function of one arg)
    ;;;  in the variable CLI-MESSAGE.
    ;;;  [2] Enable CLI handling with (SSTATUS CLI T)
    ;;;
    ;;; The handler should take a single argument which it probably should ignore
    ;;; since I have no idea what it is likely to be.
    ;;;
    ;;; The handler should open the file "CLA:" in (CLA BLOCK) mode and immediately
    ;;; discard the first 8 characters which will be garbage.
    ;;;
    ;;; The remainder of the stream, until a control-C or an eof, will be the text
    ;;; of the message sent. It may be read with TYI, READ, etc. and handled 
    ;;; however.

    (eval-when (eval compile)
      (cond ((not (get 'iota 'version))
             (load "liblsp;iota"))))

    (defun handle-cli-msg (ignore)
      (iota ((stream '((cla)) '(cla block)))
        (do ((i 0 (1+ i))) ((= i 8)) (tyi stream))
        (do ((c (tyi stream -1) (tyi stream -1)))
            ((or (= c -1) (= c 3)))
          (format t "~&~3,'0O ~@:C~%" c c)))) ;print out chars seen

    (setq cli-message 'handle-cli-msg)

    (sstatus cli t)

    ; --------

    (defun eval-cli-msg (ignore) ;alternate handler
      (iota ((stream '((cla)) '(block cla)))
        (do ((i 0 (1+ i))) ((= i 8)) (tyi stream))
        (do ((f (read stream nil) (read stream nil)))
            ((null f))
          (errset (eval f) nil)))) ;Quietly evaluate forms...

    ;; Assumes the other lisp will have EVAL-CLI-MSG as value of CLI-MESSAGE

    (defun eval-in-other-lisp (uname jname s-expression)
      (iota ((stream `((cli) ,uname ,jname) '(out ascii block)))
        (print s-expression stream)))

   from(177).to(448).do(i -> { ... })