Mancanti operatori '$' come in Haskell

Question

Mancanti operatori '$' come in Haskell

#1 da (4 voti)
#2 da (2 voti)

0

Di seguito ho prodotto quello che ritengo sia un riassunto dello standard $ come operatori per varie classi in Haskell. Tuttavia ci sono alcune lacune. Seguendo lo schema applicativo, penseresti che quegli operatori sarebbero $$ e <$$> ma non ho visto operatori come quello su Hoogle o Hayoo. Qualcuno potrebbe colmare le lacune con gli operatori più comunemente usati per tali spazi?

              | Function first           | Op   | Function second          | Op   |
----------------------------------------------------------------------------------
| Plain       | (a -> b)   -> a   -> b   | $    | a   -> (a -> b)   -> b   |      |
| Functor     | (a -> b)   -> f a -> f b | <$>  | f a -> (a -> b)   -> f b |      |
| Applicative | f (a -> b) -> f a -> f b | <*>  | f a -> f (a -> b) -> f b | <**> |
| Monad       | (a -> m b) -> m a -> m b | =<<  | m a -> (a -> m b) -> m b | >>=  |
-----------------------------------------------------------------------------------

operators haskell

posta Clinton 12.12.2014 - 03:27

fonte

2 risposte

Leggi altre domande sui tag operators haskell

perché è un set ordinato naturalmente generato a 9 ma non a 10 cifre Alternativa alla stampa delle informazioni di debug su stdout \ stderr [duplicato]

score 4 · Answer 1

Non ce n'è uno tristemente. Le persone di solito usano la colonna di sinistra con . invece di operatori separati. A volte vedo le persone usare

|> :: a -> (a -> b) -> b

come un operatore della linea di tubazioni F # e OCaml. Generalmente, tuttavia, le persone usano . invece di

 a |> f |> g

è scritto come

 g . f $ a

Questo vale anche per <$>

 a |$> f |$> g

potrebbe essere scritto come

 g . f <$> a

Questo è effettivamente più veloce (di un fattore di 2x) poiché <$> può essere piuttosto costoso per le raccolte di grandi dimensioni.

score 2 · Answer 2

Il pacchetto lens fornisce questi operatori:

(&) :: a -> (a -> b) -> b

(<&>) :: Functor f => f a -> (a -> b) -> f b

Dalla documentazione dell'obiettivo su (&) :

This is the flipped version of ($), which is more common in languages like F# as (|>) where it is needed for inference. Here it is supplied for notational convenience and given a precedence that allows it to be nested inside uses of ($).

Poiché il 7,8% di(&) può essere trovato in Data.Function troppo.