Am I right in saying that write always flushes stdout instead of the port it's passed?

"!" looks like "." and "'" put together!

However, I wish we could say (x 1 -1) instead of (cut x 1 -1). And since x.0.0 expands to (x 0 0) then that would let us say x.1.-1 which is what languages such as Python and Ruby already allow.

    (1..4).to_a => [1,2,3,4]
    (1...4).to_a => [1,2,3]

str[a...b] is a substring from a to b, exclusive.

With negative indices:

    str[a..-b] == str[a..str.length-b]
    "abcde"[1..-1] == "abcde"[1..5-1] == "abcde"[1..4] == "bcde"

    str[a...-b] == str[a...str.length-b]
    "abcde"[1...-1] == "bcd"

  > (cut "abcde" 1)
  "bcde"

  (cut "abcde" 1 -1)
  (cut "abcde" 1)

    $ irb
    >> "abcde"[1..-1]
    => "bcde"
    >>

So, to clarify: I think arc should not do it Ruby-style, but rather have

  arc> (cut "abcde" 1 -1)
  "bcd"

  arc> (cut "abcde" 0 0)
  "a"
  arc> (cut "abcde" 0 0)
  "abcde"

How do you propose to get "bcde" from "abcde"?

  > (cut "abcde" 1)
  "bcde"

  (cut "abcde" begin end)

I like indices that are intuitive with literal numbers. Counting from 0 at one end and from 1 at the other is jarring. When -1 points to the end of string rather than before the last char (cut str 0 (- (len str))) returns the first char instead of the empty string.

With -1 -> before last char:

  (def chop ((o str "abcdef"))
    (pr "Chop how many chars off the end of \"" str "\"? ")
    (= n (coerce (cut (readline) 1) 'int)) ; bug in readline prepends #\newline
    (prn "Chopped: \"" (if (is n 0) str (cut str 0 (- n))) "\"")) ; handle corner case

  (def chop ((o str "abcdef"))
    (pr "Chop how many chars off the end of \"" str "\"? ")
    (= n (coerce (cut (readline) 1) 'int)) ; bug in readline prepends #\newline
    (prn "Chopped: \"" (cut str 0 (- -1 n)) "\"")) ; no corner case, but there's this -1 there

    $ irb
    >> "abcde"[1...-1]
    => "bcd"

  arc> +.3.3
  6

  arc> isa!x!sym
  t

  arc> cdr!(1 2 3)
  Error: "Can't take cdr of #<eof>"

  arc> (= x '(1 2 3))
  (1 2 3)
  arc> cdr.cdr.x
  Error: "procedure ...rcode/arc/ac.scm:561:11: expects 1 argument, given 2: #<procedure:...rcode/arc/ac.scm:561:11> (1 2 3 . nil)"

  arc> (def foo (x) [+ 10 _])
  #<procedure: foo>
  arc> foo.3
  #<procedure>
  arc> (+:foo.3 5)
  15

  arc> (= x [+ 10 _])
  #<procedure: x>
  arc> (prn:prn.x 5)
  #<procedure: x>
  15
  15
  arc> (prn:prn.x 5)
  #<procedure: x>
  15
  15
  arc> (prn (prn.x 5))
  #<procedure: x>
  15
  15
  arc> (prn ((prn x) 5))
  #<procedure: x>
  15
  15

  arc> (def add (x) [+ x _])
  #<procedure: add>
  arc> (map [prn:add.40:idfn _] (range 1 5))
  41
  42
  43
  44
  45
  (41 42 43 44 45)

  arc> (= s "abc")
  "abc"
  arc> s.1
  #\b

If a.b expands to (a b) then (f v w).(g x y) would just expand to ((f x y) (g x y)). At first glance, that definitely appears to be a cool way to grab just one of the results from a function return (ala (f x y).2).

Hmm, on the down side, you could have statements like (or worse):

    (bst-find tree 45 f<).(if (< 10 42) (/ 4 3)
                              (> 4 2)   x
                                        'r)

A possible problem is that I can see myself wanting to use this syntax a lot for accessing hash tables with symbols as keys. But ! is a lot more annoying to type than . is.

My alternative suggestion (which I'm sure has worse problems of its own) would be

  x.y  ->  (x 'y) if y is a symbol, (x y) otherwise

  x,y  ->  (x y)   (by analogy with , inside backquote)

  x!y  ->  (x 'y)  (if there should ever be a need to quote a non-symbol?)

  a!ex

  a.ex

I noticed chaining doesn't work for .:

    arc> (= l '(1 2 (3 4) 5))
    (1 2 (3 4) 5)
    arc> l.2
    (3 4)
    arc> l.2.1
    (3 4)

    arc> (= l '(1 2 3 4 5))
    (1 2 3 4 5)
    arc> l.1..4
    (2 3 4 5)

  arc> (= l '(1 2 (3 4) 5))
  (1 2 (3 4) 5)
  arc> l.2.1
  (3 4)
  arc> (l.2 1)
  4

Grepping the source, the x.y and x!y syntax doesn't seem to be used.

Is Arc turning into Perl 6 implemented using the Lisp axioms?