Haskell operatore vs funzione precedenza

Question

Sto provando a verificare qualcosa sull'operatore e sulla precedenza delle funzioni in Haskell. Per esempio, il codice seguente

list = map foo $ xs 

può essere riscritta come

list = (map foo) $ (xs) 

e alla fine sarà

list = map foo xs 

La mia domanda di una volta, perché la prima formulazione non sarebbe essere riscritta come

list = (map foo $) xs 

poiché la precedenza della funzione è sempre superiore alla precedenza dell'operatore, ma penso di aver trovato la risposta: gli operatori non possono semplicemente essere argomenti di funzioni (eccetto ovviamente, se li circondano con parentesi). È giusto? Se è così, trovo strano che non ci sia menzione di questa meccanica/regola in RWH o Learn you a Haskell, o in nessuno degli altri posti che ho cercato. Quindi, se conosci un luogo, dove viene dichiarata la regola, ti preghiamo di collegarti ad esso.

- modifica: Grazie per le risposte rapide. Penso che la mia confusione sia venuta dal pensare che un operatore letterale avrebbe in qualche modo valutato qualcosa, che potrebbe essere consumato da una funzione come argomento. Mi ha aiutato a ricordare che un operatore infisso può essere tradotto meccanicamente in funzioni prefissate. In questo modo le prime rese formulazione

($) (map foo) (xs) 

in cui v'è alcun dubbio che ($) è la funzione che consumano, e dal momento che le due formulazioni sono equivalenti, quindi il $ letterale nella prima formulazione non può essere consumato da mappa.

Answer 1

Sei corretto. Questa regola fa parte della sintassi Haskell definita da Haskell Report. In particolare, si noti nella Sezione 3, Espressioni, che l'argomento per l'applicazione della funzione (uno fexp) deve essere un aexp. Un aexp consente agli operatori come parte di sezioni e anche all'interno di un'espressione tra parentesi, ma non di operatori nudi.

In map foo $ xs, la sintassi Haskell indica che questo viene analizzato come due espressioni che vengono applicate all'operatore binario $. Come osserva sepp2k, la sintassi (map foo $) è una sezione sinistra e ha un significato diverso.

Devo confessare che non ho mai pensato molto a questo e in realtà ho dovuto cercare nel rapporto per vedere perché gli operatori hanno il comportamento che fanno.

Answer 2

Gli operatori possono essere passati come argomenti di funzione se li si circonda con parentesi (ad esempio map foo ($) xs, che sarebbe effettivamente passato come (map foo ($)) xs). Tuttavia, se non li circondi con parentesi, hai ragione che non possono essere passati come argomento (o assegnati a variabili).

noti inoltre che la sintassi (someValue $) (dove $ potrebbe essere qualsiasi operatore) significa in realtà qualcosa di diverso: è equivalente a \x -> someValue $ x, cioè vale parzialmente l'operatore alla operando sinistro (che nel caso di $ è un noop naturalmente). Analogamente, ($ x) applica parzialmente l'operatore all'operando di destra. Quindi map ($ x) [f, g, h] valuterebbe a [f x, g x, h x].

Answer 3

In primo luogo, l'applicazione (spazio bianco) è il "gestore" con la precedenza più alta.

In secondo luogo, in Haskell, non c'è davvero alcuna distinzione tra operatori e funzioni, a parte il fatto che gli operatori sono predefiniti per impostazione predefinita, mentre le funzioni no. È possibile convertire le funzioni di infisso con apici inversi

2 `f` x 

e convertire operatori di prefisso con parentesi:

(+) 2 3 

Quindi, la sua domanda è un po 'confuso.

Ora, funzioni e operatori specifici avranno dichiarato la precedenza, che si può trovare in GHCi con ": info":

Prelude> :info ($) 
($) :: (a -> b) -> a -> b -- Defined in GHC.Base 

infixr 0 $ 

class (Eq a, Show a) => Num a where 
    (+) :: a -> a -> a 

infixl 6 + 

mostra sia la precedenza e l'associatività.

Answer 4

La differenza è che operatori infissi vengono posizionati tra loro argomenti, quindi questo

list = map foo $ xs 

possono essere riscritte in forma prefisso

list = ($) (map foo) xs 

che, per la definizione di operatore $, è semplicemente

list = (map foo) xs 

Answer 5

In aggiunta alle informazioni fornite da altre risposte già, si noti che operatori diversi possono avere precedenti diversi rispetto ad altri operatori, nonché essere di sinistra/destra o non associativa. È possibile trovare queste proprietà per gli operatori Prelude nello Haskell 98 Report fixity section.

 
+--------+----------------------+-----------------------+-------------------+ 
| Prec- | Left associative | Non-associative | Right associative | 
| edence |  operators  |  operators  | operators  | 
+--------+----------------------+-----------------------+-------------------+ 
| 9  | !!     |      | .     | 
| 8  |      |      | ^, ^^, **   | 
| 7  | *, /, `div`,   |      |     | 
|  | `mod`, `rem`, `quot` |      |     | 
| 6  | +, -     |      |     | 
| 5  |      |      | :, ++    | 
| 4  |      | ==, /=, <, <=, >, >=, |     | 
|  |      | `elem`, `notElem`  |     | 
| 3  |      |      | &&    | 
| 2  |      |      | ||    | 
| 1  | >>, >>=    |      |     | 
| 0  |      |      | $, $!, `seq`  | 
+--------+----------------------+-----------------------+-------------------+ 

Qualsiasi operatore privo dichiarazione fixity si presume essere associativo fianco con precedenza 9.

Ricordate, l'applicazione ha la funzione precedenza più alta (si pensi di precedenza 10 rispetto alle altre precedenze nella tabella) [1].