code: public static <O> Function<? super Publisher<O>, ? extends Publisher<O>> lift(
  			Predicate<Scannable> filter,
  			BiFunction<Scannable, ? super CoreSubscriber<? super O>, ? extends CoreSubscriber<? super O>> lifter) {
  		return LiftFunction.liftScannable(filter, lifter);
  	}
docs: Create a function that can be used to support a custom operator via
  {@link CoreSubscriber} decoration. The function is compatible with
  {@link Flux#transform(Function)}, {@link Mono#transform(Function)},
  {@link Hooks#onEachOperator(Function)} and {@link Hooks#onLastOperator(Function)},
  but requires that the original {@link Publisher} be {@link Scannable}.
  <p>
  This variant attempts to expose the {@link Publisher} as a {@link Scannable} for
  convenience of introspection. You should however avoid instanceof checks or any
  other processing that depends on identity of the {@link Publisher}, as it might
  get hidden if {@link Scannable#isScanAvailable()} returns {@code false}.
  Use {@link #liftPublisher(Predicate, BiFunction)} instead for that kind of use case.
  
  <p>
  The function will be invoked only if the passed {@link Predicate} matches.
  Therefore the transformed type O must be the same than the input type since
  unmatched predicate will return the applied {@link Publisher}.
  
  @param filter the predicate to match taking {@link Scannable} from the applied
  publisher to operate on. Assumes original is scan-compatible.
  @param lifter the bifunction taking {@link Scannable} from the enclosing
  publisher and consuming {@link CoreSubscriber}. It must return a receiving
  {@link CoreSubscriber} that will immediately subscribe to the applied
  {@link Publisher}. Assumes the original is scan-compatible.
  
  @param <O> the input and output type
  
  @return a new {@link Function}
  @see #liftPublisher(Predicate, BiFunction)