Single quote denotes a symbol in scheme. But this snippest is not strictly scheme. Perhaps it is SXML but I am not familiar with it.

A single quote is actually shorthand for the quote special form

  'foo
  (quote foo)
  '(1 2 3)
  (quote (1 2 3))

It basically does not evaluate its arguments but returns whatever it is. So instead of the value of foo, it the symbol foo. The list example does not evaluate it either, it would normally try to apply the first element as a function, but instead we get the list of numbers.

This is just Scheme. It's nothing to do with SXML.

#:foo is a keyword argument and '(apache httpd) is a quoted list containing the symbols apache and httpd.

Angled brackets have no special meaning, they are just part of the identifier.

While I don't write Scheme, I believe it is Scheme -- one of the goals of the GNU project is to have every GNU tool be configurable with Scheme (which is why GNU has a Scheme implementation as opposed to a Common LISP implementation).

Not only does GNU have a Common Lisp implementation, in fact there are two:

GCL: https://www.gnu.org/software/gcl/

CLISP: http://clisp.org/

I've installed CLISP before, why didn't I know it was a GNU project? Fair enough, I stand corrected. :D

Well, they have GCL and CLisp too!

Template Haskell (and Rust) gets this from Lisp, ultimately.

Rust's usage of single quotes comes from CS language theory (lifetimes are denoted using quotes) which I believe comes from the normal usage of quotes in possessive words (James', Amanda's). I don't think LISP's usage comes from the same place (it means something very different semantically).

OCaml's usually what I see cited as the reason for Rust adopting the syntax.

... where it's a type variable.

I think we can blame the use for lifetimes entirely on the Rusties.

Lifetimes are also types, or more specifically, generic type parameters.

I believe the community name is Rustacean[1].

[1]: http://www.rustaceans.org/

Lisp's quote (or ') comes from the word quote and the context:

  (quote something)

Meaning: take whatever follows and leave it alone. Do not interpret it. If it's a list it stays a list (one of the main uses for this). The single quote ' is shorthand for that. It's meant to be an easier way to create a literal list (and other things) without escaping all the parts of a list that might be misinterpreted as symbols to evaluate (to values or functions).