What operators can be used with function-typed type parameters in generics?

  if callback?
    // function is assigned and ready to call

  if handler?
    result <- handler(inputData)

defines module qa.genericsdeep.functioningeneric

  defines function

    <?-
      A simple function type that can be used as a type parameter.
    -?>
    formatter() as open
      -> item as String
      <- rtn as String: item

  defines class

    <?-
      Generic class that stores a value of type T.
      When T is a function type, only ? operator works.
      This example uses T with standard types, showing
      the ? operator that works for all types including functions.
    -?>
    Holder of type T
      stored as T?

      //A generic that may hold a FUNCTION cannot give its field an unset 'T()' (you cannot construct a
      //function - E06110), so the no-arg default is 'default private': you cannot externally create an
      //empty one, you must use the inferred constructor with a value.
      default private Holder() as pure

      Holder() as pure
        -> initialItem as T
        stored :=? initialItem

      isPresent() as pure
        <- rtn as Boolean: stored?

      default operator ?

  defines program

    FunctionInGenericDemo()
      stdout <- Stdout()

      // === STANDARD TYPE: all operators work ===

      intHolder <- Holder(42)
      stdout.println(`Int holder present: ${intHolder.isPresent()}`)

      strHolder <- Holder("hello")
      stdout.println(`String holder present: ${strHolder.isPresent()}`)

      // === FUNCTION TYPE: only ? works ===

      upperFormatter <- () is formatter as function
        rtn: item.upperCase()

      funcHolder <- Holder(upperFormatter)
      stdout.println(`Function holder present: ${funcHolder.isPresent()}`)

      // === LIMIT: a function-holding generic cannot be empty-constructed ===
      // 'Holder() of Integer' is NOT available: the no-arg default is private because 'T()' is unavailable
      // for a generic that may hold a function. Construct with a value via the inferred constructor instead.

combine() as pure
        -> other as T
        <- rtn as T: stored + other

isPresent() as pure
        <- rtn as Boolean: stored?