(def cp () (map eval (readall:clipboard)))

  ;Now I redefine a couple of functions (e.g. to add or remove printlining)
  ; and copy the new definitions, then use (cp) at the REPL.
  arc> (cp)
  *** redefining int-nthroot
  *** redefining cint-nthroot
  *** redefining cint-omega
  (#<procedure: int-nthroot> #<procedure: cint-nthroot> #<procedure: cint-omega>)

Function: (clipboard) : Returns the clipboard as a string. Useful when you want to give your program a string from somewhere (maybe capture it with (= x (clipboard)) and then use it), and your alternatives are a) pasting it in literally (which requires escaping), b) pasting to a file and reading it in, and c) trying to call (readline) a bunch of times or something. Also useful in implementing (cp).

(clipboard) probably takes a platform-specific system call. On Mac OS X, the shell command "pbpaste" prints out the clipboard, so I have it defined as:

  (def clipboard () (tostring:system "pbpaste"))

Function: (pbcopy x) : Coerces x to a string and sets the clipboard to that string. Named after the MacOSX utility. Useful mainly so I can add two spaces to each line when pasting code into this forum:

  arc> (pbcopy:tostring:map [prn "  " _] (lines:pbpaste))
  nil

  (def pbcopy (s)
    (let f (tmpfile)
      (w/outfile gf f (disp s gf))
      (system:string "cat " f " | pbcopy")
      rmfile.f))

  (def tmpfile ()
    (let u (string "/tmp/arctmp" (rand-string 10))
      (if (file-exists u)
          (tmpfile)
          u)))

I remember seeing tricks for cons counting, profiling (http://arclanguage.org/item?id=11556, another story about forgetting the existence of a key tool), tracing, visualizing macroexpansion.. the list goes on. Lots of stuff in the arc2 branches never made it to arc3. I'm certain there's gems there.

-

I posted a few at http://arclanguage.org/item?id=11111

REPL tricks at http://arclanguage.org/item?id=11103

Then there's defgeneric/defmethod. I'm still proud of the writeup on how I rediscovered defgeneric for myself: http://arclanguage.org/item?id=11779

And serialize/unserialize/persisted: http://arclanguage.org/item?id=11865

I like these one-liners:

  (= be is)
  (= neither nor)
  (= redef =)

  (= const =)

I don't want to use init (http://arclanguage.org/item?id=11103) because I do want the value to be updated when I reload the file. init is for global state in data structures which shouldn't be reset when I reload the file, and const is for global parameters that influence the behavior of my app. Those I often do want to update on reload.

-

Another recent macro encapsulates a common pattern for initialization code:

  (mac firsttime(place . body)
    `(unless ,place
       ,@body
       (set ,place)))

A workhorse of readwarp: pick a random feed from a set and check if it satisfies certain properties (e.g. has an unread item, is recent, is well-cleaned, etc., etc.)

  (mac findg(generator test)
    (w/uniq (ans count)
      `(ret ,ans ,generator
         (let ,count 0
           (until (or (,test ,ans) (> (++ ,count) 10))
              (= ,ans ,generator))
           (unless (,test ,ans)
             (= ,ans nil))))))

  (def randpos(l)
    (when l
      (l (rand:len l))))

cons counting

http://arclanguage.org/item?id=11135

tracing

http://arclanguage.org/item?id=10372

visualizing macroexpansion

http://arclanguage.org/item?id=11806

the list goes on

http://arclanguage.org/submitted?id=fallintothis

(Okay, that last one was excessive, but I thought it was funny. I'm just glad anyone likes things I write. :P)

To be honest, this is what I think people should be using the 'lib section of Anarki for; posting code that they think is useful. That way it's available for anyone that wants it. If you post code on the forum, post it somewhere else so that people can find it again.

'fromfile executes body in a context where stdin is an input-port that reads the contents of the file described by the string f; it closes the port afterwards. 'tofile is similar, but instead binds stdout so that it writes to the file f. 'ontofile is similar to 'tofile, except that output is appended to the file f.

These macros, while not strictly necessary given the existence of 'w/infile, 'w/outfile, and 'w/appendfile (which are implemented almost identically), make it nicer to read from and write to files. There are several macros in Arc that come in pairs, one binding a variable and the other supplying a usually anaphoric default variable name. Examples: 'rfn and 'afn, 'each and 'on, 'iflet and 'aif (although these aren't quite identical). I think this is a good pattern.

'tofile and 'ontofile are especially useful when you want to write to a file using 'pr, 'prn, 'prs, etc., none of which take an optional output-port argument; alternatives would be rebinding stdout using 'w/stdout, or collecting output with 'tostring and 'disp-ing it all at once (which may not work as a substitute if it's important that output be generated incrementally).

Credit for these names goes to fallintothis: http://arclanguage.org/item?id=12272

  (mac fromfile (f . body)
    (w/uniq gf
      `(w/infile ,gf ,f
         (w/stdin ,gf
           ,@body))))
  (mac tofile (f . body)
    (w/uniq gf
      `(w/outfile ,gf ,f
         (w/stdout ,gf
           ,@body))))
  (mac ontofile (f . body)
    (w/uniq gf
      `(w/appendfile ,gf ,f
         (w/stdout ,gf
           ,@body))))

  (map f xs) = (rev:accumulate cons f:car xs nil cdr no)
  (factorial n) = (accumulate * idfn 1 1 inc [> _ n])
  (rev xs) = (accumulate cons car xs nil cdr no)
  (range a b) = (rev:accumulate cons idfn a nil inc [> _ b])
  (len xs) = (accumulate + [idfn 1] xs 0 cdr no)
  (sum f a b) = (accumulate + f a 0 inc [> _ b])
  (sumlist f xs) = (accumulate + f:car xs 0 cdr no)
  (mapn f a b) = (rev:accumulate cons f a nil inc [> _ b])

  (def accumulate (comb f xs init next done)
    ((afn (xs total)
       (if (done xs)
           total
           (self (next xs) (comb (f xs) total))))
     xs init))

  (as string
      (big long
           (hairy gigantic)
           (immense and complicated (function))))

  (coerce (big long
               (hairy gigantic
               (immense and complicated (function)))
          'string)

  (mac as (type x)
    `(coerce ,x ',type))

  (string:big long
    (hairy gigantic)
    (immense and complicated (function)))

  (as:string:big long
    (hairy gigantic)
    (immense and complicated (function)))

(Note from the future: What follows doesn't really continue that response. I just started randomly considering a few more angles. ^_^ )

Most of the time, [coerce _ 'string], [coerce _ 'sym], and so forth just end up being more verbose ways of saying things like [string _] and [sym _]. Almost all the uses of 'coerce in Arc 3.1 and Anarki are like that, where they hard code the target type, so that it's just like the name is coerce-cons or coerce-string but without any synergy with ssyntax. There are two exceptions:

  (def sort (test seq)
    (if (alist seq)
        (mergesort test (copy seq))
        (coerce (mergesort test (coerce seq 'cons)) (type seq))))

  (def inc (x (o n 1))
    (coerce (+ (coerce x 'int) n) (type x)))

Now that I think about this, my position has softened even more, but I'm still a bit stubborn. Even if 'coerce is only used as a way to convert something back from the type a calculation needs to manipulate it in, there's still an arbitrary choice being made between multiple behaviors. If some generic string utility wants to convert '(#\[ #\1 #\]) to "[1]" and back, but some JSON utility wants to convert '(1) to "[1]" and back, then (coerce "[1]" 'cons) needs to have two meanings at once.

Of course, if it comes to that, it's easy to just make the JSON utility convert from '(1) to (annotate 'json-encoded "[1]") and back instead. I think I have no escape from that. XD Any corner case I come up with is going to be at least as you're-not-gonna-need-it as 'coerce is. ^_-

Nevertheless, while I was arguing with myself, I came up with an experimental type-independent (and therefore 'coerce free) way to model back-and-forth transformations. It's a pretty obvious design, but I somehow managed to make it complicated and arbitrary in certain ways. :-p Here it is in case anyone's interested:

  (def encode-int (unencoded)
    (list `(type ,type.unencoded) int.unencoded))
  
  (def decode-int (recovery-notes encoded)
    (let fail (fn () (err "Unexpected 'decode-int case!"))
      (case do.recovery-notes.0 type
        (case do.recovery-notes.1
          string  string.encoded
          int     encoded
                  (do.fail))
        (do.fail))))
  
  (= encoding-int (annotate 'encoding
                    ; This is more hackable than
                    ; (list encode-int decode-int).
                    (list (fn args (apply encode-int args))
                          (fn args (apply decode-int args))))
  
  (def fn-through (encoding unencoded body)
    (withs ((encode decode) rep.encoding
            (recovery-notes encoded) do.encode.unencoded)
      (do.decode recovery-notes do.body.encoded)))
  
  (mac through (encoding var . body)
    `(fn-through ,encoding ,var (fn (,var) ,body)))
  
  (def inc (x (o n 1))
    (through encoding-int x
      (+ x n)))

Ah, now I follow. But often there's one kind that applies far more often than alternatives. And it's good for coerce to give it. For other type combinations it's good to know that coerce is complete, and that it'll give some sort of conversion. But you're right, I don't know if this ever makes code shorter. Perhaps this is yet another example of programmer's OCD, that insidious need to have things be aesthetic even when they don't matter.

I just started randomly considering a few more angles. ^_^

I'm starting to realize that's the reason I have a hard time following what you write :) If I may make a suggestion, make a list. I find your long comments are often too terse. Often they contain enough stuff for three or four distinct postings or comments. But the transitions are abrupt, perhaps because you're trying not to be even more long-winded. If you gave each idea its own post or comment it would have more room to breathe, and I'd be able to return to each one at my leisure. Feel free to post new submissions with substantial ideas. We hardly have enough submissions here.

Like your code idea at the end of the comment, and the suggestion that it's like monad transformers. I'd love to see a post elaborating on it. I'd love even more to see a yegge-sized elaboration of all your thoughts on coerce and what 'synergy with ssyntax' means. Perhaps they haven't settled down yet, but keep it in mind when they do :)

Sometimes I feel I would spend an hour with any one of your ideas if you'd spent just a few extra minutes with it.

Thanks for telling me that. ^^;

My usual process is that I'll take a few hours to write a comment, then I'll run out of time and decide to come back later to finish it up, and then I'll never go back to that draft (but I might start from scratch on the same topic). Occasionally I'll finish something in time to post it.

Recently, I have less time than I'm used to, so I've been posting things even if they're rough, in case someone gets value out of it anyway. I guess this makes my posts into scatterings of half-ideas, based on things I've been thinking to myself but only now had a reasonable excuse to mention. (Usually I shoot for a few organized, mostly full ideas, which also have very good excuses to be mentioned. :-p )

  (xloop (i 1 total 1)
    (if (> i n)
        total
        (next (+ i 1) (* total i)))))

  ((rfn next (i total)
     (if (> i n)
         total
         (next (+ i 1) (* total i))))
   1 1)

  $ grep -c xloop a general-poly.arc
  a:38
  general-poly.arc:18

  (mac xloop (var-vals . body)
    (let w (pair var-vals)
      `((rfn next ,(map car w) ,@body) ,@(map cadr w))))

  (xloop i 1 total 1
    (if (> i n)
      total
      (next (+ i 1) (* total i))))

  (def mapn (f a b . xs)
    (if no.xs
        (map f (range a b))
        (mapn [apply mapn (fn args (apply f _ args))
                     xs]
              a b)))

  arc> (mapn square 1 10)
  (1 4 9 16 25 36 49 64 81 100)
  arc> (mapn list 1 3 20 22)
  (((1 20) (1 21) (1 22)) ((2 20) (2 21) (2 22)) ((3 20) (3 21) (3 22)))

  arc> (grid:mapn * 1 7 1 7)
  1  2  3  4  5  6  7
  2  4  6  8 10 12 14
  3  6  9 12 15 18 21
  4  8 12 16 20 24 28
  5 10 15 20 25 30 35
  6 12 18 24 30 36 42
  7 14 21 28 35 42 49
  nil
  arc> (grid:mapn choose 0 7 0 7)
  1 0  0  0  0  0 0 0
  1 1  0  0  0  0 0 0
  1 2  1  0  0  0 0 0
  1 3  3  1  0  0 0 0
  1 4  6  4  1  0 0 0
  1 5 10 10  5  1 0 0
  1 6 15 20 15  6 1 0
  1 7 21 35 35 21 7 1
  nil

Function: (prsn . args) : Prints the elements of args separated by spaces, then prints a newline. Extremely handy for debugging: add in (prsn a b c) when you want to see the state of a,b,c. Equivalent to the built-in prs, except this also prints a newline.

  (def prsn args (apply prs args) (prn))

Very handy for printing out a table of data, especially in conjunction with prsn. Also good for, e.g., printing out dates which you want to be constant-length. Look at this beautiful table:

  arc> (for i 6 15 (prsn (pad i 2) (pad fib.i 3) (pad (fib:* 2 i) 6)))
   6   8    144
   7  13    377
   8  21    987
   9  34   2584
  10  55   6765
  11  89  17711
  12 144  46368
  13 233 121393
  14 377 317811
  15 610 832040
  nil

  (def pad (x wanted-len (o side 'left) (o pad-char #\space))
    (zap string x)
    (let padding (newstring (- wanted-len len.x) pad-char)
      (case side
        left (string padding x)
        right (string x padding))))

Function: (grid xses (o strict nil)) : Prints out xses, which should be a list of lists, in a grid; that is, it pads each element enough that all elements in each column are the same width. If strict is t, then all columns will be the same width. Works even if lists are different length. Note that my definition uses 'pad and 'prsn. Illustration with Pascal's triangle, first without strict, then with:

  arc> (grid:accum a (for n 0 10 (a:accum b (for k 0 n (b:choose n k)))))
  1
  1  1
  1  2  1
  1  3  3   1
  1  4  6   4   1
  1  5 10  10   5   1
  1  6 15  20  15   6   1
  1  7 21  35  35  21   7   1
  1  8 28  56  70  56  28   8  1
  1  9 36  84 126 126  84  36  9  1
  1 10 45 120 210 252 210 120 45 10 1
  nil
  arc> (grid (accum a (for n 0 10 (a:accum b (for k 0 n (b:choose n k))))) t)
    1
    1   1
    1   2   1
    1   3   3   1
    1   4   6   4   1
    1   5  10  10   5   1
    1   6  15  20  15   6   1
    1   7  21  35  35  21   7   1
    1   8  28  56  70  56  28   8   1
    1   9  36  84 126 126  84  36   9   1
    1  10  45 120 210 252 210 120  45  10   1
  nil

  (def grid (xses (o strict nil)) ;dense lines of code for brevity
    (let lens (map [best > (map (fn (xs) (len:string:car:nthcdr _ xs)) xses)]
                   (range 0 (dec:best > (map len xses))))
      (when strict (let u (best > lens) (= lens (n-of len.lens u))))
      (each xs xses (apply prsn (map pad xs lens)))))

  (fn () (err "Ack! You called me!"))
  (thunk:err "Ack! You called me!")

A side effect of making all function arguments optional [1] is that the square bracket syntax can then cover zero-argument functions too, so we get this additional (shorter) way to express your thunk example:

  [err "Ack! You called me!"]

  (thunk 34)

Incidentally, it actually does save parens in that case:

  thunk.34

  arc> aps.map
  (deep-map map map-chooses map-more map-subperms map1 mapn mappend maptable s-map s-map1)

  (def arc-namespace ()
    (map [sym:cut string._ 1]
         (keep [is string._.0 #\_]
               ($.namespace-mapped-symbols))))
  (def apropos-fn (x)
    (sort < (map sym (keep [findsubseq x _]
                           (map string (arc-namespace))))))
  (mac aps (x) `(apropos-fn (string ',x)))

Though it's more limited, you might even just use sig in vanilla Arc.

  (mac apropos (name)
    (list 'quote
           (sort (compare < string)
                 (keep [findsubseq (string name) (string _)] (keys sig)))))

  arc> (count-up "banana")
  ((#\a 3) (#\n 2) (#\b 1))
  arc> (factor 720)
  (2 2 2 2 3 3 5)
  arc> count-up.that
  ((2 4) (3 2) (5 1))

  (def count-up (xs)
    (let u (table)
      (each x xs
        (++ (u x 0)))
      (sort (compare > cadr) (tablist u))))

  (def counts (seq (o c (table)))
    (if (no seq)
        c
        (do (++ (c (car seq) 0))
            (counts (cdr seq) c))))

  (def sortable (ht (o f >))
    (let res nil
      (maptable (fn kv
                  (insort (compare f cadr) kv res))
                ht)
      res))

  (= count-up (compose sortable counts [coerce _ 'cons]))

  (= count-up sortable:counts)

  (mac erp (x)
    (w/uniq (gx)
      `(let ,gx ,x
         (w/stdout (stderr)
           (write ',x)
           (disp ": ")
           (write ,gx)
           (disp #\newline))
         ,gx)))

  arc> (+ 3 (erp (/ 4 2)) 5)
  (/ 4 2): 2
  10