(Note, this explanation is for the standard Arc 3.1, not Anarki.)
They're not defined in Arc itself. They're handled by ac.scm, the Arc "compiler" written in Scheme. Specifically, the top-level function ac takes an Arc expression and transforms it into equivalent Scheme code. The function takes the form of a big cond, like:
(define (ac s env)
(cond ((string? s) (ac-string s env))
((literal? s) s)
((eqv? s 'nil) (list 'quote 'nil))
((ssyntax? s) (ac (expand-ssyntax s) env))
...))
The ! and . operators are part of what's called ssyntax, which you can see is involved in the last clause I included in the cond snippet above. I've always thought it's ambiguous what the first "s" stands for: probably "special" or "symbol". At any rate, we can see further down that ssyntax? is defined like so:
(define (ssyntax? x)
(and (symbol? x)
(not (or (eqv? x '+) (eqv? x '++) (eqv? x '_)))
(let ((name (symbol->string x)))
(has-ssyntax-char? name (- (string-length name) 1)))))
(define (has-ssyntax-char? string i)
(and (>= i 0)
(or (let ((c (string-ref string i)))
(or (eqv? c #\:) (eqv? c #\~)
(eqv? c #\&)
;(eqv? c #\_)
(eqv? c #\.) (eqv? c #\!)))
(has-ssyntax-char? string (- i 1)))))
First, note that + and ++ never get interpreted as ssyntax. This has to do with an earlier version of Arc that used + as a ssyntax operator (it got changed later to &). Also, _ is an exclusion; it's the special variable used by the bracket function syntax, where [+ _ 1] = (fn (_) (+ _ 1)). _ is not currently used as an ssyntax operator, but there's a lingering idea for stuff like +_1 to expand into [+ _ 1].
Otherwise, a symbol is considered to have ssyntax if it has any of the special characters: :, ~, &, ., or !.
The actual meaning of each ssyntax operator is a little bit complicated. It all goes through expand-ssyntax, defined by
As you can see, this dispatches to the different functions expand-compose, expand-sexpr, expand-and, and experimentally to expand-curry. Each of these functions will actually recursively call expand-ssyntax, so it turns out that you can have multiple ssyntax operators in the same symbol. This also means that the order of the cond clauses here is important, as they establish the precedence of each operator: : and ~ have higher precedence than . and !, which have higher precedence than &.
You can peruse the Scheme code further to find out how specifically each ssyntax operator works. But, you can also just use the ssexpand function in Arc, which will give you the result of calling the Scheme function expand-ssyntax, because ac.scm has the line
