func_call(Name/_/ResultIndex, Args, Result) :-
    !,
    List = [Name|Args],
    nth0(ResultIndex, CallFunc, Result, List),
    C=.. CallFunc,
    call(C).


func_call(Name/ArgsAmount, Args, Result):-
    !,
    func_call(Name/ArgsAmount/ArgsAmount, Args, Result).

func_call(F, X ,R) :-
    current_predicate(F/N),
    func_call(F/N/N , X ,R).

:- op(500, xfx, <#).
:- op(450, xfy, #).

:- op(400, fx, #).

parse_args_chain(Head # Tail, [Head|TailArgs]) :-
    !,
    parse_args_chain(Tail, TailArgs).

parse_args_chain(Head, [Head]).

%Result <# Name # ArgsChain :-
 %   parse_args_chain(ArgsChain, Args),
  %  func_call(Name, Args, Result).

curry_call(function(Fun/NArgs, PrevArgs), Arg, Result) :-
    append(PrevArgs, [Arg], AccuArgs),
    N is NArgs - 1,
    (
        length(AccuArgs, N) ->
            func_call(Fun, AccuArgs, Result) ;
            Result = function(Fun/NArgs, AccuArgs)
    ).

%Result <# Function # ArgsChain :-
 %   initial_function(Function, IF),
  %  curry(IF, ArgsChain, Result).

curry(F, A # T, Result) :-
    !,
    curry_unpack(A, UA),
    curry_call(F, UA, Res),
    curry(Res, T, Result).

curry(F, A, Result) :-
    curry_unpack(A, UA),
    curry_call(F, UA, Result).

Result <# Function # ArgsChain :-
    initial_function(Function, IF),
    curry(IF, ArgsChain, Result), !.

initial_function(function(F, A), function(F, A)) :- !.
initial_function(F, function(F, [])).

%curry(F, A # T, Result) :-
 %   !, (
  %      A = # (OtherFunction # OtherArgs) ->
   %     Sub <# OtherFunction # OtherArgs, curry(F, Sub # T, Result) ;
    %    curry(F, A, SubResult), curry(SubResult, T, Result)
     %   ).

%curry(F, A, Result) :-
 %   (
  %      A = # (OtherFunction # OtherArgs) ->
   %     Sub <# OtherFunction # OtherArgs, curry(F, Sub, Result) ;
    %    curry_call(F, A, Result)
    %).

curry_unpack(#(F # Args), AU) :-
    !,
    initial_function(F, IF),
    curry(IF, Args, AU).
curry_unpack(A, A).