OnComplete<T1, T2, T3, T4> Method

[kyubuns]

I want to achieve zero allocations while passing more than 2 arguments in OnComplete.
I think this can be accomplished this way, can you add it?

// Sequence
        public Tween OnComplete<T1, T2>([NotNull] T1 target1, [NotNull] T2 target2, Action<T1, T2> onComplete, bool warnIfTargetDestroyed = true) where T1 : class where T2 : class {
            if (validateIsAlive()) {
                tween.OnComplete(target1, target2, onComplete, warnIfTargetDestroyed);
            }
            return this;
        }

        public Tween OnComplete<T1, T2, T3>([NotNull] T1 target1, [NotNull] T2 target2, [NotNull] T3 target3, Action<T1, T2, T3> onComplete, bool warnIfTargetDestroyed = true) where T1 : class where T2 : class where T3 : class {
            if (validateIsAlive()) {
                tween.OnComplete(target1, target2, target3, onComplete, warnIfTargetDestroyed);
            }
            return this;
        }

        public Tween OnComplete<T1, T2, T3, T4>([NotNull] T1 target1, [NotNull] T2 target2, [NotNull] T3 target3, [NotNull] T4 target4, Action<T1, T2, T3, T4> onComplete, bool warnIfTargetDestroyed = true) where T1 : class where T2 : class where T3 : class where T4 : class {
            if (validateIsAlive()) {
                tween.OnComplete(target1, target2, target3, target4, onComplete, warnIfTargetDestroyed);
            }
            return this;
        }

// Tween
        public Tween OnComplete<T1, T2>([NotNull] T1 target1, [NotNull] T2 target2, Action<T1, T2> onComplete, bool warnIfTargetDestroyed = true) where T1 : class where T2 : class {
            if (validateIsAlive()) {
                tween.OnComplete(target1, target2, onComplete, warnIfTargetDestroyed);
            }
            return this;
        }

        public Tween OnComplete<T1, T2, T3>([NotNull] T1 target1, [NotNull] T2 target2, [NotNull] T3 target3, Action<T1, T2, T3> onComplete, bool warnIfTargetDestroyed = true) where T1 : class where T2 : class where T3 : class {
            if (validateIsAlive()) {
                tween.OnComplete(target1, target2, target3, onComplete, warnIfTargetDestroyed);
            }
            return this;
        }

        public Tween OnComplete<T1, T2, T3, T4>([NotNull] T1 target1, [NotNull] T2 target2, [NotNull] T3 target3, [NotNull] T4 target4, Action<T1, T2, T3, T4> onComplete, bool warnIfTargetDestroyed = true) where T1 : class where T2 : class where T3 : class where T4 : class {
            if (validateIsAlive()) {
                tween.OnComplete(target1, target2, target3, target4, onComplete, warnIfTargetDestroyed);
            }
            return this;
        }

// ReusableTween
// (Only T4 because it is long.)
        internal void OnComplete<T1, T2, T3, T4>([CanBeNull] T1 _target1, [NotNull] T2 _target2, [NotNull] T3 _target3, [NotNull] T4 _target4, [NotNull] Action<T1, T2, T3, T4> _onComplete, bool warnIfTargetDestroyed) where T1 : class where T2 : class where T3 : class where T4 : class {
            if (_target1 == null || isDestroyedUnityObject(_target1)) {
                Debug.LogError($"{nameof(_target1)} is null or has been destroyed. {Constants.onCompleteCallbackIgnored}");
                return;
            }
            if (_target2 == null || isDestroyedUnityObject(_target2)) {
                Debug.LogError($"{nameof(_target2)} is null or has been destroyed. {Constants.onCompleteCallbackIgnored}");
                return;
            }
            if (_target3 == null || isDestroyedUnityObject(_target3)) {
                Debug.LogError($"{nameof(_target3)} is null or has been destroyed. {Constants.onCompleteCallbackIgnored}");
                return;
            }
            if (_target4 == null || isDestroyedUnityObject(_target4)) {
                Debug.LogError($"{nameof(_target4)} is null or has been destroyed. {Constants.onCompleteCallbackIgnored}");
                return;
            }
            Assert.IsNotNull(_onComplete);
            validateOnCompleteAssignment();
            warnIgnoredOnCompleteIfTargetDestroyed = warnIfTargetDestroyed;
            onCompleteTarget = _target1;
            onCompleteTarget2 = _target2;
            onCompleteTarget3 = _target3;
            onCompleteTarget4 = _target4;
            onCompleteCallback = _onComplete;
            onComplete = tween => {
                var callback = tween.onCompleteCallback as Action<T1, T2, T3, T4>;
                Assert.IsNotNull(callback);
                var _onCompleteTarget1 = tween.onCompleteTarget as T1;
                var _onCompleteTarget2 = tween.onCompleteTarget2 as T2;
                var _onCompleteTarget3 = tween.onCompleteTarget3 as T3;
                var _onCompleteTarget4 = tween.onCompleteTarget4 as T4;
                if (isDestroyedUnityObject(_onCompleteTarget1) || isDestroyedUnityObject(_onCompleteTarget2) || isDestroyedUnityObject(_onCompleteTarget3) || isDestroyedUnityObject(_onCompleteTarget4)) {
                    tween.warnOnCompleteIgnored(true);
                    return;
                }
                try {
                    callback(_onCompleteTarget1, _onCompleteTarget2, _onCompleteTarget3, _onCompleteTarget4);
                } catch (Exception e) {
                    tween.handleOnCompleteException(e);
                }
            };
        }

[KyryloKuzyk]

Hey, good idea, let me think about it. Do you have a real-world example where this can be useful?

One concern I have is that it would still not be possible to pass value types as targets because doing so will cause value boxing, resulting in GC allocation.

[kyubuns]

Rent a GameObject from objectPool(class) and return it when the animation is finished.
The objectPool itself is a class, no boxing occurs.
I want to write this in such a way that the capture does not occur.
The objectPool itself has a long enough lifetime, so we don't need to worry about GC. It will be created during loading.

var target = objectPool.Take();
Sequence.Create()
    .Group(Tween.Position(~~~~))
    .Group(Tween.Scale(~~~~))
    .OnComplete(target, objectPool, static (t, p) => p.Return(t));

[KyryloKuzyk]

That's a good example, thank you! So OnComplete() with two targets will be sufficient for you, right?

Also, have you considered making the ObjectPool a singleton? Then you'll be able to return objects to it with no allocations, like this: ObjectPool.Instance.Return(t).

You can even create an extension method for that:

public static Sequence ReturnToPoolOnComplete<T>(this Sequence sequence, T target) where T : class {
    sequence.OnComplete(target, t => ObjectPool.Instance.Return(t));
    return sequence;
}

[kyubuns]

Sure, two targets is enough!

As you said, making ObjectPool a singleton will solve the problem.
I realize that this is a matter of personal preference.

[floky]

Just chiming in here with maybe a more generic solution.
Would it possibly be better to optionally allow sending a bunch of custom params to the OnComplete callbacks (or other framework callbacks) to more easily avoid GC allocs and closures but without having multiple generic variants <T1, T2, T3, etc.>?

Maybe have a method with this signature OnComplete(target, targetParams, System.Action<T,TParams> onComplete) ? (where TParams would be an immutable constrained generic type ": struct")

So a potential PrimetTween API shape for this would be:

Tween OnComplete<TTarget, TParams>(
    TTarget target,
    TParams targetParams,
    System.Action<TTarget, TParams> onComplete
)
where TParams : struct

Where "targetParams" would be stored internally (without any boxing) as an immutable generic type and just be passed back to the callback when the time comes.
This would also allow someone to just pass in a tuple as params for the target object and more easily avoid GC allocs and closures:
So a full usage example would look like:

Tween.Delay(duration)
.OnComplete<MyTarget, (int count, float delay)>(myTarget,  (count: 42, delay: 3.5f),
    (target, params) => target.DoSomething(params.count, params.delay)
);

@KyryloKuzyk what do you think? 🤔

[KyryloKuzyk]

@floky Great idea!
Can you please elaborate on how to store the value type or struct without boxing? As I understand it, because I don't know the exact type of the value type passed to the OnComplete(), I should store the value in an object field. Which will inevitably introduce boxing.