You can do something like this (pseudocode-ish; link to buildable code is provided below):

// wrap std::optional for chaining
template <class T> class Maybe {
  std::optional<T> t;

  // ... constructors etc

  // Maybe chaining 
  // If A has a member named m of type M, 
  // then Maybe<A>.fetch(&A::m) returns a Maybe<M>

  template <class M>
  Maybe<M> fetch(M T::*mem_ptr) {
     return (bool(t)) ? Maybe<M>((*t).*mem_ptr) : Maybe<M>() ;
  }

  // Maybe chaining special case 
  // If A has a member named m, which is itself a Maybe<M>,
  // then return it without wrapping it in an additional Maybe

  template <class M>
  Maybe<M> fetch(Maybe<M> T::*mem_ptr) {
     return (bool(t)) ? ((*t).*mem_ptr) : Maybe<M>() ;
  }

};

Now if you have this:

 struct C { int d ; }
 struct B { C c; }
 struct A { B b; }
 A a;
 Maybe<A> ma;

and you can do this

 int d = a.b.c.d;

you cannot do the same with ma, but you can use the next best thing, namely:

 Maybe<int> md = ma.fetch(&A::b).fetch(&B::c).fetch(&C::d);

And you can still use this if you Maybe-ify any or all struct members above:

 struct C { Maybe<int> d ; }
 struct B { Maybe<C> c; }
 struct A { Maybe<B> b; }

Live example (not production quality but it builds).

The safe navigation operator still returns null if a null is in the path, so you have to check for that:

if(c?.Status__c?.Contains('Released') == true){ // get the Error on this line
        System.debug('Contains');
}

Or, in an even modern alternative, you can use the null-coalescing operator:

if(c?.Status__c?.contains('Released') ?? false) {
    System.debug('Contains');
}

The main point is that ?. can return null, but a condition always expects true or false. The null-coalescing operator can help in these situations.

C++23 introduced Monadic operations for optional, so you can use std::optional::transform

#include <optional>

using Bar = int;
struct Foo { Bar x; };

std::optional<Bar> f()
{
    std::optional<Foo> obj {};
    return obj.transform([](auto&& o) { return o.x;});
}

for lower C++ versions you could use C++11 optional library which has a similar operation (map), or write your own version of transform (not recommended).

godbolt demo

I don't recommend you write you own transform because to make it chainable you need to inherit from std::optional, and it is likely UB to inherit from the standard library objects.

A shorter version would define the lambda as a struct externally, if you are using it everywhere and need to reduce the number of letters per use. (with the exact same assembly)

template <typename Member>
struct grab
{
    Member member;
    auto operator()(auto& obj) const 
    { return obj.*member; }
};

std::optional<Bar> f()
{
    std::optional<Foo> obj {};
    return obj.transform(grab{&Foo::x});
}

I agree that these tags should be synonymised. There is also a null-propagation-operator tag which should be included in this.

I think safe-navigation-operator shouldn't be the canonical one. It has the fewest tagged questions, and it doesn't include null in its name. I also think "navigation" could be misleading to people who aren't already familiar with this usage of it (normally I would say property access, array access, etc., not property navigation or array navigation). I would favour null-conditional-operator or null-propagation-operator being the canonical one, since the word null appearing in the tag name makes the tag more useful when it appears on the main page or in searches.

You need to put a . after the ? to use optional chaining:

myArray.filter(x => x.testKey === myTestKey)?.[0]

Playground link

Using just the ? alone makes the compiler think you're trying to use the conditional operator (and then it throws an error since it doesn't see a : later)

Optional chaining isn't just a TypeScript thing - it is a finished proposal in plain JavaScript too.

It can be used with bracket notation like above, but it can also be used with dot notation property access:

const obj = {
  prop2: {
    nested2: 'val2'
  }
};

console.log(
  obj.prop1?.nested1,
  obj.prop2?.nested2
);

And with function calls:

const obj = {
  fn2: () => console.log('fn2 running')
};

obj.fn1?.();
obj.fn2?.();