I spent some time trying to figure this out, and the answer is yes! Quite a nice learning experience… although it came with a surprise at the end.

Originally I thought, let’s do it via impromptu’s ObjC bridge. I don’t know much about ObjC but after a bit of googling it seemed evident that the quickest way to accomplish this is by writing ObjC code that, in turns, runs a simple applescript command that opens a window:

So I translated the bottom part of the code above into impromptu/scheme:

That is a generic script-running function, that is, you can pass any script and it’ll run it, eg:

Now, back to the original problem: in order to open a Finder’s window at a specified location we need to pass the location variable to our function run_applescript; also, we want to be able to pass unix path expressions (eg ‘/Users/mike/music/’), so we’ve got to transform that path syntax into the semicolon-delimited macintosh syntax (“Macintosh HD:Users:mike:music”) needed by the applescript function we’re using. That’s easily done with string-replace, so here we go:

That’s pretty much it really… now we can easily open OsX Finder’s windows from within Impromptu.

But as I said above, there’s a surprise: after getting this far I thought I’d search impromptu’s mailing list for more examples of obj:call …. and guess what, there’s already a system function that runs applescripts, it’s called sys:run-applescript !

Too bad, it’s been a rewarding learning experience anyways…

So, since I recently found online a succinct table that sums up the differences, I thought I’d pass it on to posterity here too.

By the way, on the same site the authors report of a small scheme library (initdr.scm) that implements a few very common Lisp functions. Including [dotimes dolist intersection, union set-difference copy-list subset every some copy-tree subst sublis nconc nreverse]… Quite useful too!

UPDATE 28/11/10:

I realized that most of these lisp functions are already available in Impromptu, under the cl: namespace (check out the common-lisp library functions section on the wiki). Below are just a couple of additions to that, based on the initdr.scm library I was mentioning.. apologies for the confusion!

;;;;;;;;;;;;;;;;
;;; LISP ADDITIONS 
;; the rest of this is in the cl: impromptu library
;;;;;;;;;;;;;;;;


(define cl:first car)
(define cl:rest cdr)
(define cl:count length)

;; reverse of cons: (cons 'b '(a))
(define cl:l-put
   (lambda (obj lst)
      (reverse (cons obj (reverse lst)))))

;; dont know why but I like it reversed..
(define cl:nth (lambda (x lst)
               (list-ref lst x)))


(define (1+ n) (+ n 1))
(define (1- n) (- n 1))


;; (subst 9 7 '(5 (5 6 7(6 7))))    =>  (5 (5 6 9 (6 9)))      
(define (cl:subst new old tree)
  (if (pair? tree)
      (let ((left (subst new old (car tree)))
            (right (subst new old (cdr tree))))
        (if (and (eq? left (car tree))
                 (eq? right (cdr tree)))
            tree
            (cons left right)))
      (if (eqv? old tree)
          new
          tree)))



;; (sublis '((6 . 9) (7 . 10)) '(5 (5 6 7 (6 7)))))  => (5 (5 9 10 (9 10)))
(define (cl:sublis alist tree)
  (if (pair? tree)
      (let ((left (sublis alist (car tree)))
            (right (sublis alist (cdr tree))))
        (if (and (eq? left (car tree))
                 (eq? right (cdr tree)))
            tree
            (cons left right)))
      (let ((new (assv tree alist)))
        (if new
            (cdr new)
            tree) ) ) )


;; (copy-tree '(5 (5 6 7(6 7))))
(define (cl:copy-tree x)
  (if (pair? x)
      (cons (copy-tree (car x))
            (copy-tree (cdr x)))
      x))


; Convert a floating-point number to a string of sign and at most 4 characters.
; Rounds the number so that 1.999 will come out as 2.00 , very small as 0.0 .
; numstring is written assuming that num is not too large or too small,
; i.e. num must be printable in 4 digits.
(define (cl:numstring num)
  (let* ((numc (abs num)) (sign (if (< num 0) -1 1)) (exponent 0))
    (if (< numc 1.0e-6)
    "0.0"
    (begin
      (if (< numc 1.0)
          (begin (while (< numc 100)
                (set! numc (* numc 10))
                (set! exponent (1- exponent)))
             (set! numc (* (round numc) (expt 10 exponent))) )
          (set! numc (* numc 1.0001)))
      (if (< sign 0)
          (string-append "-"
                 (substring (number->string numc) 0
                   (min 4 (string-length (number->string numc)))))
          (substring (number->string numc) 0
             (min 4 (string-length (number->string numc))))) ) ) ))




;(list-flatten '(9 9 (9 9 9 ))))  = (9 9 9 9 9)

(define cl:list-flatten 
   (lambda (l)
      (cond ((null? l)
             '())
            ((atom? l)
             (list l))
            (#t (append (cl:list-flatten  (car l)) (cl:list-flatten  (cdr l)))))))

Land of Lisp, Learn to Program in Lisp, One Game at a Time! by Conrad Barski, M.D.

…

So you’ve decided to know everything about scheme and rock the world using fast-paced programming environments like Impromptu.
Well, I confess I did think that on several occasions, but still I haven’t made it even half way through the schemer pilgmim’s path. But I’ve collected quite a few useful resources in the process, and those I can certainly share!

So in what follows I’ve put together a list of learning resources about Scheme that I found useful.. First off, two links that might be useful in all situations:

Now, why don’t we start with the definition offered by the self-regulating wikipedia collective intelligence? Here we go:

Scheme is one of the two main dialects of the programming language Lisp. Unlike Common Lisp, the other main dialect, Scheme follows a minimalist design philosophy specifying a small standard core with powerful tools for language extension. Its compactness and elegance have made it popular with educators, language designers, programmers, implementors, and hobbyists, and this diverse appeal is seen as both a strength and, because of the diversity of its constituencies and the wide divergence between implementations, one of its weaknesses

If this blurb hasn’t made you proud of learning such a slick language, you’ll surely find more interesting ideas in what follows. I divided up the list in two sections, generic learning materials about scheme, and tutorials about specific topics (for now, only macros are included).
———————————-

1. Learning Resources About Scheme:

———————-

2. Specific topics:

On Macros and metaprogramming:

———————-

That’s all for now… I’ll be adding more stuff as I run into it!

Since a couple of months ago Impromptu has a wiki too – so I thought, it’d be nice to see a function’s help in a browser window, and possibly contribute to its explanation too..

So, that’s the rationale for this little script. By calling ‘wiki’ you can open up a web browser at the relevant Impromptu-wiki page.. as simple as that.

>>>

First off, we need a couple of utility functions that are not included in Impromptu by default, for better manipulating strings, lists and webpages (UPDATE 9-Nov2010: some of this symbols have been included in Improptu 2.5, so I prefixed the one below with the utils: namespace):

;;;;;;;
;; utilities
;;;;;;;

;; (utils:list-flatten '(9 9 (9 9 9 ))))  = (9 9 9 9 9)
(define utils:list-flatten
   (lambda (l)
      (cond ((null? l)
             '())
            ((atom? l)
             (list l))
            (#t (append (utils:list-flatten  (car l)) (utils:list-flatten  (cdr l)))))))

;; returns a char from a string of length 1, or a list of chars from a longer string
(define utils:char
   (lambda (string_char)
      (if (string? string_char)
          (if (> (string-length string_char) 0)
              (if (> (string-length string_char) 1)
                  (string->list string_char)
                  (car (string->list string_char))))
          (print 'please 'enter 'a 'string))))

;; matches a single character in a string, and replaces it
(define utils:string-replace
   (lambda (s match replacement)
      (let ((ll (string->list s))
            (match1 (utils:char match))
            (replacement1 (utils:char replacement)))
         (if (= (string-length match) 1)
             (let ((z (map (lambda (x)
                              (if (equal? x match1)
                                  replacement1
                                  x))
                           ll)))
                (list->string (utils:list-flatten z)))
                ;z)
             (print "i can match only single characters for now")))))

;; makes a string upper case
(define utils:string-capitalize
   (lambda (s)
      (string-append (string (char-upcase (string-ref s 0))) (substring s 1 (string-length s)))))

;; open-url: calls the default mac browser with a url argument 
;; disclaimer: I'm not an objc programmer... found an example at 
;; http://macosx.com/forums/software-programming-web-scripting/18422-how-do-i-launch-url-using-cocoa-objective-c.html
(define utils:open-url
   (lambda (urlstring)
      (let ((urlobj (objc:call "NSURL" "URLWithString:" urlstring))
            (workspace (objc:call "NSWorkspace" "sharedWorkspace")))
         (objc:call workspace "openURL:" urlobj))))

 

>>>
Finally, the functions for opening the wiki page:

;;;;;;;;;;
;; wiki url caller
;; e.g. (wiki objc:from-address) => goes to http://moso.com.au/wiki/index.php?title=Objc:from-address
;;;;;;;;;;

;; wiki-escape: composes the url so that it matches the ones of the online wiki 
(define wikiescape
   (lambda (funname)
      (for-each (lambda (x)
                   (set! funname (utils:string-replace funname (car x) (cadr x))))
                '(("+" "%2B")
                  ("=" "%3D")
                  ("<" "lessthan")
                  (">" "greaterthan")
                  ("*" "%2A")
                  ("?" "%3F")
                  ("!" "%21")
                  ))
      (utils:string-capitalize funname)))

(define wiki-inner
   (lambda (funname)
      (let* ((urlbase "http://moso.com.au/wiki/index.php?title=")
             (newname (wikiescape funname))
             (url (string-append urlbase newname)))
         (utils:open-url url))))

;; macro wrapper and main function that gets called 
(define-macro (wiki name)
   `(wiki-inner (sexpr->string (quote ,name))))

 

>>>
That’s it: load all of this code (or put it in a single file and load it at startup time) and you’ve got the wiki procedure available!

To recap.. normally with Impromptu if you want to play notes at some specific time expressed in beats with you’d have to set up a metronome first [have a look here for more info about how to use *metro*] and then check for the right beat using the modulo function.
For example, something like this will play a central C every first beat of a 4/4 measure:

(define *metro* (make-metro 100))

(define test
   (lambda (beat)
      (if (equal? (modulo beat 4) 0)
          (play dls 60 60 3))
      (callback (*metro* (+ beat (* 1/2 1/4))) 'test (+ beat 1/4))))

(test (*metro* 'get-beat 4))

Another way of doing this is by using case. Same approach, but probably faster to code, as it lets you specify ‘multiple beats’ very easily:

(define test2
   (lambda (beat)
      (case (modulo beat 4)
            ((0)
             (play dls 60 60 3))
            ((2 5/2)
             (play dls 67 60 1/2)))
      (callback (*metro* (+ beat (* 1/2 1/4))) 'test2 (+ beat 1/4))))

(test2 (*metro* 'get-beat 4))

Still quite a few parenthesis though… which, especially when playing live, might mean more chances to mess up!
So when I saw Ben’s video I realized that a macro usable to facilitate the creation of case/modulo expressions would be quite useful..
Here is how it can be done:

(define-macro (if-mod x y args)
   `(for-each (lambda (step)
                 (if (equal? (modulo beat ,x) step)
                     ,args))
              (if (list? ,y)
                  ,y
                  (list ,y))))

Now, by using the if-mod macro we’ve just created we can re-write the second example above much more concisely:

(define test2-new
   (lambda (beat)
      (if-mod 4 0 (play dls 60 60 3))
      (if-mod 4 '(2 5/2) (play dls 67 60 1/2))
      (callback (*metro* (+ beat (* 1/2 1/4))) 'test2-new (+ beat 1/4))))

(test2-new (*metro* 'get-beat 4))

That’s all! Notice also that the if-mod construct can take either a list of beats or a single one.