You can rarely successfully generalize about languages in the Lisp family. :)

TXR Lisp: (relevant to this article) there is an iff function that takes functional arguments.

Square the odd values in 0 to 9:

  1> (mapcar [iff oddp square use] 0..10)
  (0 1 2 9 4 25 6 49 8 81)

The use function is a synonym of identity: i.e. just use the incoming value as-is

Square the even ones instead by inverting oddp with notf:

  2> (mapcar [iff [notf oddp] square use] 0..10)
  (0 1 4 3 16 5 36 7 64 9)

Get rid of use with iffi: a two-argument iff with an implicit identity else:

  3> (mapcar [iffi oddp square] 0..10)
  (0 1 2 9 4 25 6 49 8 81)

Now about the point about Lisps and if: the regular if operator with value and expression arguments has a companion if function:

  4> (special-operator-p 'if)
  t
  5> (fboundp 'if)
  t

Unlike in some other dialects like Common Lisp, a symbol can have a binding in the macro or operator space, and in the function space at the same time.

But this if is not useful control. It's useful for things like being able to map over a function-like facsimile of the if operator. E.g. take an element of the (a b c d) or (x y z w) list depending on whether the leftmost list has a nil or t:

  6> [mapcar if '(nil t nil t) '(a b c d) '(x y z w)]
  (x b z d)

In the reverse direction, being able to write a macro for a function function exists, allows for ordinary macros to be "compiler macros" in the Common Lisp sense: provide optimizations for certain invocations of a function.

This dialect is not even "weird"; overall it is Common-Lisp-like. Right down to the multiple namespaces, which is why the [...] syntax exists for referring to functions and variables in a combined virtual namespace.

What's the benefit of being implemented as lisp-2 but acting like lisp-1 with [ ]? Why not just be a lisp-1?

> TXR is an original notation for matching entire text documents or streams, inspired by the unification that underlies logic programming systems

This has me hooked.

while there are certain simplicities and economies in a Lisp-1, it's a bad idea on the whole, and has irksome disadvantages.

Lisp-2 also has irksome disadvantages, like the verbosity in code working with functional arguments.

I want to give myself and my users the advantages of Lisp-1 and Lisp-2, as well as ways to avoid their respective disadvantages, so there is no way to get around having some kind of combination that lets us work in different styles.