Informazioni sugli errori di restrizione del valore F #

Question

Non capisco come funzioni la restrizione del valore in F #. Ho letto la spiegazione nello wiki e nello MSDN documentation. Quello che non capisco è:

1. Perché, ad esempio, questo mi dà un errore di valore di restrizione (Tratto da this domanda):

   let toleq (e:float<_>) a b = (abs (a - b)) < e 
   

   Ma THS non lo fa:

   let toleq e (a:float<_>) b = (abs (a - b)) < e 
   

2. Questo è generalizzata tutto bene ...

   let is_bigger a b = a < b 
   

   ma questo non è (si precisa come int):

   let add a b = a + b 
   

3. Perché funzioni con parametri impliciti generare valore Limitazione:

   questo:

   let item_count = List.fold (fun acc _ -> 1 + acc) 0 
   

   vs questo:

   let item_count l = List.fold (fun acc _ -> 1 + acc) 0 l 
   

   (attenzione, se lo faccio utilizzare questa funzione in un frammento di codice l'errore VR sarà andato, ma poi la funzione sarà specificato il tipo ho usato per, e voglio che sia generalizzata)

Come funziona?

(sto usando l'ultima F #, v1.9.6.16)

Answer 1

EDIT

Meglio/recente Info è qui: Keeping partially applied function generic

(originale sotto)

penso una cosa pragmatica qui non è cercare di capire questo troppo profondamente, ma piuttosto conoscere un paio di strategie generali per superare la VR e andare avanti con il tuo lavoro. È una risposta un po 'fuoriuscita, ma non sono sicuro che abbia senso dedicare del tempo a comprendere le intrecci del sistema di tipo F # (che continua a cambiare in modi minori da versione a versione) qui.

Le due strategie principali che vorrei sostenere sono queste. In primo luogo, se si sta definendo un valore con un tipo di funzione (tipo con una freccia '->'), quindi assicurarsi che sia una funzione sintattica facendo eta-conversion:

// function that looks like a value, problem 
let tupleList = List.map (fun x -> x,x) 
// make it a syntactic function by adding argument to both sides 
let tupleList l = List.map (fun x -> x,x) l 

In secondo luogo, se si incontrano ancora VR/generalizzando problemi, quindi specificare l'intero firma tipo di dire ciò che si vuole (e poi 'marcia indietro', come F # permette):

// below has a problem... 
let toleq (e:float<_>) a b = (abs (a - b)) < e 
// so be fully explicit, get it working... 
let toleq<[<Measure>]'u> (e:float<'u>) (a:float<'u>) (b:float<'u>) : bool = 
    (abs (a - b)) < e 
// then can experiment with removing annotations one-by-one... 
let toleq<[<Measure>]'u> e (a:float<'u>) b = (abs (a - b)) < e 

Penso che queste due strategie sono il miglior consiglio pragmatico. Detto questo, ecco il mio tentativo di rispondere alle tue domande specifiche.

1. Non so.

2. '>' è una funzione completamente generica ('a ->' a -> bool) che funziona per tutti i tipi, e quindi is_bigger generalizza. D'altra parte, '+' è una funzione 'in linea' che funziona su una manciata di tipi primitivi e una certa classe di altri tipi; può essere generalizzato solo all'interno di altre funzioni 'inline', altrimenti deve essere bloccato a un tipo specifico (o verrà impostato su 'int'). (Il metodo "in linea" del polimorfismo ad-hoc è il modo in cui gli operatori matematici in F # superano la mancanza di "classi di tipi".)

3. Questo è il problema della "funzione sintattica" di cui sopra; 'compiliamo in campi/proprietà che, a differenza delle funzioni, non possono essere generici. Quindi, se vuoi che sia generico, rendilo una funzione. (Vedi anche this question per un'altra eccezione a questa regola.)

Answer 2

Nessuno, comprese le persone in # team di F, conosce la risposta a questa domanda in modo significativo.

Il sistema di inferenza di tipo F # è esattamente come la grammatica VB6 nel senso che il compilatore definisce la verità.

Sfortunato, ma vero.

Answer 3

La limitazione del valore è stata introdotta per risolvere alcuni problemi con il polimorfismo in presenza di effetti collaterali. F # eredita questo da OCaml, e credo che la restrizione del valore esista in tutte le varianti ML. Ecco uno morelinks da leggere, oltre ai link che hai citato. Poiché Haskell è puro, non è soggetto a questa restrizione.

Per quanto riguarda le vostre domande, penso che la domanda 3 sia veramente correlata alla restrizione del valore, mentre i primi due non lo sono.