Terminology of Optionals in Swift or other languages

Question

In Swift the elements we manipulates all have types.

When we use theses types, we can add a '!', '?' or nothing to express their nullability.

1. What shall I call the '?' or '!' used to express this trait ?

A type decorator ? A decorator ? Operator ? Something else ?

2. What shall I call the type created when using this character ?

Is it a new type ? Is it a decorated type ? A type variation ?

The swift compiler, seems to consider them as new types, However my question is not implementation or language dependent and therefor I tagged it as language agnostic.

Edit: I'm looking for a language agnostic name. I understand with pranjalsatija's comment optionals are defined as compound type. However, this is a language implementation detail. I could rephrase my questions as:

What do you call a character with a special meaning when used it a type definition, and how to call the derived type.

This term should probably apply to capital casing constants in ruby as the concept is similar.

Answer 1

? on the end of the type isn’t a decorator or operator. It’s hardcoded syntactic sugar in Swift that allows you to shorten Optional<Thing> to Thing?.

The ? doesn’t really have a name (at least I’ve never heard anyone on the Swift team use one), in the language reference it’s just described as “the postfix ?”. The language grammar doesn’t put it in a syntactic category.

Similarly, [Thing] is shorthand for Array<Thing>, but there isn’t a name for the square brackets in this context.

Describing Option<Int> as “derived from” Int would be to misuse the term “derived”. You can if you want describe it as “Optional specialized for Int”.

In fact you may be looking for the language-agnostic term for how Swift allows you to build types (like Optional<T> or Array<T>) that apply to any kind of type T without having to care what T actually is. In which case the term would probably be generics.

! is a little different. When applied to a type name as in Thing!, it’s shorthand for ImplicitlyUnwrappedOptional<Thing>, in the same manner as ?.

! when applied to a variable of type Thing? is equivalent to a postfix operator that tests the optional and if it is nil, terminates your program, something like this:

postfix operator !<T>(value: T?) -> T {
    if let unwrapped = value {
        return unwrapped
    }
    else {
       fatalError("unexpectedly found nil while unwrapping an Optional value")
    }
}

so in this context, ! can be described as an operator. But not in the first context.

For the terminology a given language uses to describe optionals, see the Option type wikipedia page.