示例#1
0
        protected override object TryInvoke(InvokeBinder binder, object[] arguments) {
            var argsIdx = 0;
            var left = Length;
            var combinedIdx = 0;
            var combined = new List<object>();
            var argumentsLength = Currying.Arity(arguments);

            while (combinedIdx < received.Length || argsIdx < argumentsLength) {
                object result = null;

                if (combinedIdx < received.Length && (!IsPlaceholder(received[combinedIdx]) || argsIdx >= argumentsLength)) {
                    result = received[combinedIdx];
                }
                else {
                    result = arguments[argsIdx];
                    argsIdx += 1;
                }

                combined.Insert(combinedIdx, result);

                if (!IsPlaceholder(result)) {
                    left -= 1;
                }

                combinedIdx += 1;
            }

            return left <= 0 ? Reflection.DynamicInvoke(fn, combined.ToArray()) : Currying.Arity(left, new CurryN(fn, combined.ToArray(), Length));
        }
示例#2
0
        protected override object TryInvoke(InvokeBinder binder, object[] arguments)
        {
            object arg1;
            var    length = Currying.Arity(arguments);

            switch (length)
            {
            case 0:
                return(Curry2(fn));

            case 1:
                return(IsPlaceholder(arg1 = arguments[0]) ? Curry2(fn) : Curry1(_arg2 => fn(arg1, _arg2)));

            default:
                var arg2 = arguments[1];
                var arg2IsPlaceHolder = IsPlaceholder(arg2);
                var arg1IsPlaceHolder = IsPlaceholder(arg1 = arguments[0]);

                return(arg1IsPlaceHolder && arg2IsPlaceHolder?Curry2(fn) : arg1IsPlaceHolder?Curry1(_arg1 => {
                    return fn(_arg1, arg2);
                }) : arg2IsPlaceHolder?Curry1(_arg2 => {
                    return fn(arg1, _arg2);
                }) : fn(arg1, arg2));
            }
        }
示例#3
0
        protected override object TryInvoke(InvokeBinder binder, object[] arguments)
        {
            object arg1 = null;
            object arg2 = null;
            object arg3 = null;
            var    arg1IsPlaceHolder = false;
            var    arg2IsPlaceHolder = false;
            var    arg3IsPlaceHolder = false;
            var    arity             = Currying.Arity(arguments);

            if (arity > 0)
            {
                arg1 = arguments[0];
            }

            switch (arity)
            {
            case 0:
                return(Curry3(fn));

            case 1:
                return(IsPlaceholder(arg1) ? Curry3(fn) : Curry2((_arg2, _arg3) => fn(arg1, _arg2, _arg3)));

            case 2:
                arg2 = arguments[1];
                arg1IsPlaceHolder = IsPlaceholder(arg1);
                arg2IsPlaceHolder = IsPlaceholder(arg2);

                return((arg1IsPlaceHolder = IsPlaceholder(arg1)) && (arg2IsPlaceHolder = IsPlaceholder(arg2)) ? Curry3(fn) : arg1IsPlaceHolder?Curry2((_arg1, _arg3) => {
                    return fn(_arg1, arg2, _arg3);
                }) : arg2IsPlaceHolder?Curry2((_arg2, _arg3) => {
                    return fn(arg1, _arg2, _arg3);
                }) : Curry1(_arg3 => {
                    return fn(arg1, arg2, _arg3);
                }));

            default:
                arg2 = arguments[1];
                arg3 = arguments[2];
                arg1IsPlaceHolder = IsPlaceholder(arg1);
                arg2IsPlaceHolder = IsPlaceholder(arg2);
                arg3IsPlaceHolder = IsPlaceholder(arg3);

                return(arg1IsPlaceHolder && arg2IsPlaceHolder && arg3IsPlaceHolder?Curry3(fn) : arg1IsPlaceHolder && arg2IsPlaceHolder?Curry2((_arg1, _arg2) => {
                    return fn(_arg1, _arg2, arg3);
                }) : arg1IsPlaceHolder && arg3IsPlaceHolder?Curry2((_arg1, _arg3) => {
                    return fn(_arg1, arg2, _arg3);
                }) : arg2IsPlaceHolder && arg3IsPlaceHolder?Curry2((_arg2, _arg3) => {
                    return fn(arg1, _arg2, _arg3);
                }) : arg1IsPlaceHolder?Curry1(_arg1 => {
                    return fn(_arg1, arg2, arg3);
                }) : arg2IsPlaceHolder?Curry1(_arg2 => {
                    return fn(arg1, _arg2, arg3);
                }) : arg3IsPlaceHolder?Curry1(_arg3 => {
                    return fn(arg1, arg2, _arg3);
                }) : fn(arg1, arg2, arg3));
            }
        }
示例#4
0
        protected override object TryInvoke(InvokeBinder binder, object[] arguments)
        {
            object arg1   = null;
            var    length = Currying.Arity(arguments);

            if (length == 0 || R.__.Equals(arg1 = arguments[0]))
            {
                return(Curry1(fn));
            }

            return(fn(arg1));
        }