Funzioni al curry f #

Question

Ho una domanda riguardante due tipi int -> (int -> int) e (int -> int) -> int.Qual è la differenza tra questi due?

Ho letto qui da qualche parte che la prima potrebbe essere interpretata come una funzione che prende un int e restituisce una funzione che prende e int e restituisce un int, che è uguale a int -> int -> int.È giusto?

Answer 1

La differenza tra int -> (int -> int) e int -> int -> int è trascurabile (ti interesserebbe davvero solo se dovessi interagire con un'altra lingua).Queste sono funzioni curry che effettivamente prendono due interi e restituiscono un intero (ad esempio, l'operatore di addizione incorporato ha un tipo lungo queste linee).

Tuttavia, entrambi sono molto diversi da (int -> int) -> int, che prende una funzione da numeri interi a numeri interi e restituisce un numero intero.Come altri hanno già detto, l'unico semplice esempio di tale funzione applicherebbe la funzione data a un valore specifico (ad esempio fun (f:int->int) -> f 13).

Answer 2

Bella domanda, sospetto che funzionalmente non ci sia molta differenza.Ho passato un po 'a giocherellare cercando di capire come ottenere anche quelle due firme.(Il let fun1 i = fun j -> i + j di John Palmer mi fornisce solo int -> int -> int)

let add a b = a + b       // int -> int -> int
let inc a = add a         // int -> (int -> int)

Non riuscivo a pensare a un esempio non artificioso per la seconda firma:

let foo fn : int -> fn 1  // (int -> int) -> int

(Questo non risponde direttamente alla tua domanda, ma potrebbe dare a qualcun altro qualcosa su cui masticare)

Answer 3

Non so veramente F #, ma sembra abbastanza intuitivo (molti altri linguaggi hanno le stesse nozioni).

1. È una funzione che accetta un int e restituisce una funzione che accetta un int e restituisce un int
2. È una funzione che accetta una funzione che accetta un int e restituisce un int e restituisce un int

La prima sarebbe una specie di funzione al curry.

Answer 4

Quindi vediamo come sarebbero le implementazioni:

prima

let func1 i = fun j -> i+j

questo ha una firma di int -> (int -> int)

nota che func1 2 3 non dovrebbe funzionare

MODIFICA: risulta che, a causa del modo in cui funziona l'associatività, in realtà va bene

ma questo è diverso da

let func2 i j= i+j

che ha un tipo di int -> int -> int

qui func2 1 2 va bene

l'altro esempio che possiamo creare in questo modo:

let func4 a = a 1

questo avrà una firma di ('t->int) -> u, scegliere un a concreto funzionerà.Nota che func4 1 2 sicuramente non verrà compilato