Escreva uma função f,, que obtenha um número inteiro positivo e retorne uma função.

A nova função retornada deve ser idêntica a f. No entanto, quando a "chamada de encerramento" ocorrer, fdeve retornar a soma de todos os números inteiros passados.

Por exemplo, g=f(4)(se fé a primeira função) deve ser definida gpara outra função. h=g(3)fará o mesmo. No entanto, quando você chama hsem argumentos (veja os detalhes abaixo), ele deve gerar 7, pois é a soma dos argumentos da função anterior. Dito de outra maneira f(3)(4)() == 7.

Observe que isso não é o mesmo que f(3,4)().

"Chamada de encerramento" é uma das seguintes opções (sua escolha):

• chamar sem argumentos
• nulo como argumento
• qualquer valor não positivo

A quantidade arbitrária de chamadas de função deve ser suportada, não há limite predefinido.

É garantido que a soma total não será maior que 1'000.

Podemos assumir que existe pelo menos uma chamada antes da "chamada de encerramento".

Seu código não deve usar variáveis ​​estáticas por programa, portanto, deve ser possível executar o experimento várias vezes no mesmo tempo de execução e observar exatamente o mesmo comportamento.

Exemplos:

f(1)() == 1
f(4)(2)(7)() == 13
f(4)(2)(7)(5)(2)() == 20

JavaScript (ES6), 18 bytes

f=n=>m=>m?f(m+n):n

Passe um valor falso para recuperar a soma. Zeros podem ser permitidos por um custo de 2 bytes.

Experimente online

Ungolfed:

f = function(n) {
    return function(m) {
        if (m) {
            return f(m+n);
        } else {
            return n;
        }
    }
}

Haskell (GHC), 118 bytes

São 98 bytes para o código e 20 bytes para o sinalizador do compilador GHC -XFlexibleInstances, o que permite uma extensão do sistema de tipos.

class F a where f::Int->a
instance F(()->Int)where f n()=n
instance F a=>F(Int->a)where f=(f.).(+)

Isso define uma "função" f, que pode ser chamada com um número arbitrário de números inteiros seguido pela unidade (), após o qual retorna um número inteiro. As anotações de tipo são obrigatórias. Experimente online!

Explicação

Forçar o sistema de tipo estrito de Haskell a permitir isso requer alguma mágica, a saber, habilitar a extensão GHC para instâncias flexíveis de classe de tipo. Como isso funciona é que fé uma função parametricamente polimórfica restrita por uma restrição de classe de tipo: seu tipo é F a => Int -> a. Isso significa que frecebe um número inteiro e retorna um valor do tipo a, para qualquer tipo aque pertença à classe de tipo F. Fé apenas o nome da classe de tipo que fornece a função f; é declarado na primeira linha.

As próximas duas linhas são duas instâncias de Ftipos diferentes a. A segunda linha indica que o tipo de funções de ()para inteiros pertence F(onde ()é o tipo de unidade cujo único membro é o valor ()) e a implementação é f n () = n; a função retorna seu primeiro argumento. A última linha afirma que, se apertencer F, o mesmo ocorre com o tipo de funções de números inteiros para a: de uma função f :: Int -> a, podemos gerar outra função f :: Int -> Int -> a. A implementação é f m n = f (m+n)(o código usa combinadores para torná-lo mais curto), onde o fda esquerda é o novo e o fda direita é o antigo. Isso essencialmente dáfum novo argumento inteiro, que é adicionado ao próximo. Vários argumentos são somados como este:

  f  a1   a2   a3   a4   a5  ()
= f (a1 + a2)  a3   a4   a5  ()
= f (a1 + a2 + a3)  a4   a5  ()
= f (a1 + a2 + a3 + a4)  a5  ()
= f (a1 + a2 + a3 + a4 + a5) ()
=    a1 + a2 + a3 + a4 + a5

O fem cada linha tem um tipo diferente.

As funções Haskell são alteradas automaticamente, portanto, se você fornecer fapenas números inteiros, obterá uma função.

Python 2, 42 41 36 bytes

Essa solução nunca terá um estouro, pois o Python suporta números inteiros de precisão arbitrária. Zero é o "valor especial".

f=lambda n:lambda m:m and f(m+n)or n

Experimente online

Ungolfed:

def f(n):
    def g(m=''):
        return f(m+n)if m<''else n
    return g

C, 62 58 bytes, borderline competindo

Guardado 4 bytes graças a Kevin! (Ainda não removemos o typedef porque é algo necessário para ser chamado.)

typedef(*(*B)(_))(_);q;f(x,o,_){x=x?(q+=x,f):(x=q,q=0,x);}

A função a chamar é f; você para de chamá-lo e obtém o resultado chamando-o com um número não positivo como 0. Experimente um equipamento de teste online!

Portanto, até onde eu sei, a única maneira de "curry" funções que possuem vários tipos de retorno é fazer um dos seguintes:

1. Converta o resultado em uma função para informar ao compilador que deseja chamar o resultado novamente;
2. ou crie um tipo union/ structque tenha um intsubtipo e function / auto-referencial.

Eu tentei fazer (2), mas parecia um pouco contra o espírito da pergunta e, francamente, quase desfazível. Assim, de acordo com o espírito do desafio, optei pela opção (1). Isso requer converter cada função retornada em uma função, para que possa ser usada.

Essa sintaxe "currying" parece um pouco estranha, mas é bastante semelhante. Para imitar f(21)(1), seria preciso escrever ((B)((B)f(21))(1))(0). Eu defini o Btipo como uma função que usa um número inteiro e retorna um ponteiro para uma função que usa um número inteiro. Expandido, parece com:

   ( (B)( (B) f(21) )(1) )(0)
//            f(21)            - call f with 21
//        (B)                  - cast to B, a function pointer
//      (           )(1)       - call with 1
//   (B)                       - cast to a function pointer
// (                     )(0)  - call with 0

Mathematica, 25 bytes

f[x_]@y_=f[x+y]
f[x_][]=x

Experimente online! (Usando matemática.)

É possível fazer três bytes a menos, portando a resposta JavaScript, mas eu queria apresentar uma solução Mathematica mais idiomática. O @açúcar é apenas um pouco sintático, o que torna a solução equivalente a:

f[x_][y_]=f[x+y]
f[x_][]=x

Então, sim, a ideia é que, no Mathematica, você não pode apenas definir uma função, f[x_]mas pode anexar diretamente um valor a uma expressão mais complicada que contenha f, por exemplo, f[x_]receber outro argumento. Configurando duas definições para isso, podemos obter o comportamento desejado:

• A primeira definição recolhe uma f[x][y]chamada f[x+y], consumindo uma "chamada" e adicionando os argumentos internos. Esta regra se aplica até que fiquemos f[sum][].
• A segunda definição descompacta este caso final, definindo a coisa toda para a qual avaliar sum.

C ++, 72 bytes

#define O(P)operator()(P){return{P+a};}int
struct F{F O(int(m))O()a;}f;

Isso define um tipo Fque atua como a função solicitada e uma variável fdesse tipo a ser invocada. É válido a partir do C ++ 11 e funciona com versões online do GCC, clang, icc e VC ++.

Uso:

int main() {
  return f(1)(2)(3)(); // returns 6
}

Explicação:

Após o pré-processamento e reformatação, ele se parece com:

struct F {
  F operator()(int(m)) { return{int(m)+a}; }
  int operator()() { return {+a}; }
  int a;
} f;

Isso normalmente seria escrito:

struct F {
  F operator()(int m) { return {m+a}; }
  int operator()() { return a; }
  int a;
} f;

return a;e return {+a};faça o mesmo, como unário +não altera o valor, e chaves redundantes em torno do valor de retorno são permitidas. int me int(m)faça o mesmo, pois parênteses redundantes em torno de um nome de variável são permitidos, incluindo parâmetros de função. return {m+a};e return {int(m)+a};faça a mesma coisa, pois o lançamento de mfrom intpara intnão altera seu valor. Essas alterações aproximam as duas operator()sobrecargas na sintaxe, permitindo que uma única definição de macro seja chamada duas vezes. Escolher a ordem correta para os três membros permite que a primeira palavra da próxima linha ( int) seja incluída também na definição da macro.

Ruby, 23 bytes

f=->n{->m{m ?f[n+m]:n}}

Uso:

f[1][2][3][nil]
=> 6

C, 104 96 bytes

#define a(i)s(i)|b
#define b(i)u(i)|c
#define c(i)u(i)|b
b,c,d;s(i){b=c=i;i=d;}u(i){c=b+=i;i=d;}

Usa o método no link que @JulianWolf compartilhou. O último argumento deve ser 0.

Experimente online!

Math.JS, 38 bytes

f(x)=i(x,0)
i(x,y)=x<0?y:j(z)=i(z,y+x)

Ligue com f(number_a)(number_b)(...)(negative_number)

Se for permitido especificar a chamada inicial, 12 bytes ( f(x)=i(x,0)\n) podem ser eliminados e podem ser chamados comi(number_one,0)(number_two)(...)(negative_number)

Tente!

Explicação

Como mostrado no LaTex acima, f(x)simplesmente chama i(x,0), então, i(x,y)retorna o valor de yse xfor menor que 0, ou a função j(z)=i(z,x+y), que aceita um argumento, que executa um loop. Adicionando ao valor de y.

C, 232 206 bytes

#include<string.h>
#include<stdlib.h>
#define f(X)s(""#X)?0:g
#define g(X)u(""#X)?0:h
#define h(X)u(""#X)?0:g
g=0,h=0;s(char*s){g=h=atoi(s);return 0;}u(char*s){char*a=strlen(s)?s:"0";g=h+=atoi(a);return 0;}

Provavelmente, isso pode ser muito importante, mas deve servir como prova de conceito de que C pode ser usado, sem nenhuma extensão de idioma *, para resolver esse problema chamando sem argumentos e não com um valor mágico.

* O @hvd observou que, embora isso funcione imediatamente usando o gcc, parte do comportamento não está definido no padrão C, o que significa que isso pode não ser portátil. Use por sua conta e risco!

Ungolfed:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define f(X) start("" #X) ? 0 : f0
#define f0(X) update("" #X) ? 0 : f1
#define f1(X) update("" #X) ? 0 : f0

long f0 = 0;
long f1 = 0;

int start(const char *s) {
    f0 = f1 = strtol(s, NULL, 10);

    return 0;
}

int update(const char *s) {
    const char *a = strlen(s) ? s : "0";
    f0 = f1 += strtol(a, NULL, 10);

    return 0;
}

int main() {
    printf("f(1)()          -> %ld\n", f(1)());
    printf("f(1)(2)(0)(3)() -> %ld\n", f(1)(2)(0)(3)());
    printf("f(1)(-2)(3)()   -> %ld\n", f(1)(-2)(3)());
    printf("f()             -> %ld\n", f());

    return 0;
}

Compilando e executando com gcc arbitrary-length-currying.c -o arbitrary-length-currying && ./arbitrary-length-curryingsaídas (após alguns avisos)

f(1)()          -> 1
f(1)(2)(3)(0)() -> 6
f(1)(-2)(3)()   -> 2
f()             -> 0

Código de máquina 8086, 27 bytes

00000000  bb 00 00 85 c0 74 13 01  d8 be 00 01 89 e7 47 47  |.....t........GG|
00000010  57 b9 1b 00 f3 a4 5b 89  47 01 c3                 |W.....[.G..|
0000001b

Este código de máquina deve estar no endereço 0x100 e assume o pequeno modelo de código (cs = ds = es = ss). A localização da função pode ser alterada sem custar bytes extras. Colocá-lo em deslocamento 0salvaria um byte (em xor si,sivez de mov si, 0x100)

Convenção de chamada necessária

Isso pressupõe que o chamador tenha pré-alocado pelo menos 27 bytes na pilha. Ele recebe um número axe retorna um ponteiro de função bx. Chamar esse ponteiro com ax=0termina a cadeia e retorna a soma em bx.
Então, na primeira chamada:

mov bp, sp
sub sp, 28
mov ax, number_to_add
call function
; new function pointer in bx

Em seguida, para cada chamada subsequente:

sub sp, 28
mov ax, number_to_add
call bx
; new function pointer in bx

Terminar:

mov ax, 0
call bx
; result in bx
mov sp, bp

Ungolfed (desmontagem comentada do código da máquina):

00000000  BB0000            mov bx,0x0      ; 0 is replaced after copying
00000003  85C0              test ax,ax
00000005  7413              jz 0x1a         ; if(ax==0) ret (with value in bx)
00000007  01D8              add ax,bx       ; arg += total
00000009  BE0001            mov si,0x100    ; address of the original: ds:0x100
0000000C  89E7              mov di,sp
0000000E  47                inc di
0000000F  47                inc di          ; dst = sp+2 = above return address
00000010  57                push di
00000011  B91B00            mov cx,0x1b
00000014  F3A4              rep movsb         ; copy the function code.
00000016  5B                pop bx            ; bx = start of copy destination
00000017  894701            mov [bx+0x1],ax   ; update total in the copied code
0000001A  C3                ret               ; with bx = function pointer

Depois de chamar isso com um AX diferente de zero, bx = spo buffer é preenchido com uma cópia modificada do código de máquina de function. O imediato de 16 bits na primeira instrução contém o total. (Foi escrito pela última instrução antes da ret.)

push di/ pop bxpoderia ser substituído por mov bx, di(antes rep movsb), simplificando, mas sem economia.

Exigir que o chamador passe um ponteiro para o buffer dst dieconomizaria 4 bytes vs. o cálculo relativo a sp.

Tornar o endereço de início da função igual ao tamanho da função salvaria um byte ( mov cx, si).

C #, 62 bytes

dynamic f(int n)=>(System.Func<int,dynamic>)(m=>m<0?n:f(n+m));

Para finalizar a chamada, passe em um número negativo, por exemplo

f(1)(2)(3)(-1) == 6

Scala, 58 caracteres

case class f(n:Int){def apply(m:Int)=f(n+m)
def apply()=n}

Experimente online

Ungolfed:

case class f(n:Int){
  def apply(m:Int)=f(n+m)
  def apply()=n
}

Explicação:

Este código define um case classchamado f com um construtor assumindo um int. Defina uma classe de caso que gere os métodos equals, hashcode, toString e copy e um objeto complementar com o mesmo nome para ativar a criação de objetos sem a newpalavra - chave.

Esta classe possui um método de aplicação sobrecarregado: Um leva outro número inteiro para adicionar e cria um novo objeto com a soma atualizada e um sem argumentos para obter a soma.

No Scala, qualquer objeto com um método apply pode ser chamado como um método, ou seja, o.apply(x)pode ser escrito como o(x). Isso é usado na biblioteca padrão para matrizes, listas, mapas e Function1características implementadas por funções anônimas

Pitão, 19 bytes

DhdDebR?bh+dbdR$end

Experimente online!

Estou impressionado que o Javascript vence o Pyth, mas, novamente, o Pyth não foi projetado para passar funções.

Perl 5, 36 bytes

sub f{my$n=pop;sub{@_?f($n+pop):$n}}

say f(1)->(); # 1
say f(1)->(2)->(3)->(); # 6

Flak cerebral , 6 bytes

Na verdade, acabei de perceber que, como o ToS é um formato de retorno válido, o 0 não é realmente necessário, o que economiza 2 bytes:

({{}})

Experimente online!

Submissão (s) original (s), 8 bytes

Usa 0como valor especial:

({{}}{})

Experimente online!

Explicação

Dados os argumentos a ₁ , a ₂ ,…, a _n , 0 , a pilha inicialmente se parece com isso:

                                                       a _n

                                                       ⋮

                                                       a ₂

                                                       a ₁

                                                       0 0

O código, em seguida, continua, aparece cada um _i , acumula-los, aparece a 0 adiciona-los e empurra o resultado:

(      )  -- push the following value:
 {  }     --   while ToS ≠ 0 (sums the runs):
  {}      --     pop 1 element
     {}   --   pop the remaining 0 & add it

Soluções alternativas, 8 bytes

Em vez de adicionar o 0 e adicioná-lo à soma, também podemos trocar pilhas, pois a correta está inicialmente vazia:

({{}}<>)

Experimente online!

Usando a -rbandeira, o 0 está no topo da pilha, para podermos exibi-lo primeiro:

({}{{}})

Experimente online!

{}({{}})

Experimente online!

C (GCC), 83 bytes

Meu primeiro golfe C! Existem algumas outras soluções C, mas essa é um pouco diferente. O uso do pré-processador é puramente cosmético. Essa abordagem foi discutida pela primeira vez na resposta de Conor O'Brien aqui .

#define r union r
t=0;r{int v;r(*f)();};r e;r f(a){t+=a;e.v=a?f:t;t*=a>0;return e;}

O valor do terminal é zero. O valor de retorno é uma união, portanto, para chamar o resultado, usar o campo fe acessar o valor final, use o campo v, por exemplo

f(1).f(2).f(3).f(0).v

Experimente Online

Limitações

Uma variável global mantém o total em execução. Embora isso seja explicitamente proibido, o envio suporta chamadas repetidas (o total é redefinido na chamada de terminal), o que parece ser o motivo da proibição do estado global.

Um ponteiro para fé armazenado na união retornada por meio do intmembro, portanto isso claramente não é portátil. Não tenho certeza se isso funciona no GCC em todas as plataformas ou apenas no Linux ou apenas no x86 ou apenas com o ELF ou ... Se alguém souber algum detalhe sobre isso, comente ou envie uma mensagem!

APL (Dyalog Classic) , 48 47 46 ₄₄ 32 bytes

∇r←(a f)x
r←⍎'(a+x)f'↓⍨-0=x
∇
0f

Experimente online!

Termina passando em zero. Sintaxe da chamada:((0 f 1) 2) 0

-15 bytes graças a @ngn

Requer ⎕IO←0

Quaisquer dicas de golfe são bem-vindas!

Perl 6 , 31 bytes

sub f(\n){->$m?{$m??f n+$m!!n}}

Dyvil , 34 bytes

infix int apply(i:int,j:int=0)=i+j

Uso :

0() // = 0
0(1)() // = 1
0(1)(2)() // = 3

O final ()pode ser omitido.

Explicação :

Define um operador de justaposição que leva duas polegadas e as adiciona. O parâmetro jtem o valor padrão 0para suportar a chamada sem argumentos. O 0nos exemplos acima não é o nome, mas um literal.

Julia v0.5 +, 52 bytes

type F n end
F()=0
(f::F)()=f.n
(f::F)(x)=(f.n+=x;f)

Ligar como F. Provavelmente isso poderia ser muito mais curto adotando um método menos OO, mas eu sempre gosto de ter a chance de usar esse idioma.

Se for possível supor que "pelo menos uma chamada será feita antes da chamada de término", a segunda linha poderá ser removida para salvar 6 bytes.

Julia 0,5 , 18 bytes

!n=k->k>0?!(n+k):n

Experimente online!

R, 40 bytes

f=function(x)function(y)`if`(y,f(x+y),x)

0 atua como o valor de parada aqui. Por mais dois bytes, podemos omiti-lo.

O problema é que R não possui um lambda embutido e conciso. Mas se adicionarmos um , podemos obter o código para 26 bytes :

f=x->(y->`if`(y,f(x+y),x))

(Sim, isso é R. válido. Ele só precisa de uma importação.)

PHP, 44 bytes

Uma ideia de @ user63956

Chamada de encerramento 0

function f($i){return[$_GET[0]+=$i][$i]?:f;}

Versão Online

Chamada de encerramento com NULLnecessidade [$i]de[+$i]

PHP, 47 bytes

function f($i){global$s;return$i?f.!$s+=$i:$s;}

Versão Online

PHP, 52 bytes

Chamada de encerramento NULLou qualquer outro valor falso no PHP

function f($i){global$s;$i?$s+=$i:print$s;return f;}

se o programa precisar terminar após a saída, substitua print$spor die("$s")+ 2 bytes

Versão Online

PowerShell, 86 bytes

$f={$n=$args[0];$f=(gv f).value;{if($args){&$f($args[0]+$n)}else{$n}}.getnewclosure()}

Experimente online!

Código do teste:

&(&(&(&(&(&$f 4)2)7)5)2)

Saída: 20

Python 3 , 63 bytes

f=lambda n,l=[]:n and(l.append(n)or f)or sum(l)*(l.clear()or 1)

Experimente online!

Termina com 0

Python, 69 bytes

def f(a=0,s=[]):
    if a:
        return lambda b=0:f(b,s+[a])
    return sum(s)

Oitava, 39 bytes

function r=f(n)r=@(m)merge(m,f(m+n),n);

* O argumento da chamada de encerramento é 0.

Experimente online!

* endfunctionnecessário para adicionar outros códigos.

R, 54 52 bytes

f=function(x){g=function(y='')'if'(y>'',f(x+y),x);g}

Economizou 2 bytes graças ao MickyT!

Semelhante a uma das respostas do python. Ungolfed:

f=function(x){
  g=function(y=''){
    if(y>''){
      f(y+x)
      }
      else{x}
  }
  g
}

Funciona como

> f(1)(2)(4)()
[1] 7

C ++ (gcc) , 95 91 bytes

struct f{int s;f(int t):s(t){}int operator()(){return s;}f operator()(int t){return s+t;}};

Experimente online!