rendere la funzione con 'se' point-free

Question

Ho un compito in Haskell (no, non sono i miei compiti, sto imparando per l'esame).

Il compito è:

Write funzione senza punto numocc che conta le occorrenze di elemento in determinati liste. Ad esempio: numocc 1 [[1, 2], [2, 3, 2, 1, 1], [3]] = [1, 2, 0]

Questo è il mio codice:

addif :: Eq a => a -> Int -> a -> Int 
addif x acc y = if x == y then acc+1 else acc 

count :: Eq a => a -> [a] -> Int 
count = flip foldl 0 . addif 

numocc :: Eq a => a -> [[a]] -> [Int] 
numocc = map . count 

numocc e count sono 'point-libera', ma stanno usando la funzione addif che non è.

Non ho idea di come posso fare la funzione addif senza punti. C'è un modo per fare l'istruzione if senza punti? Forse c'è un trucco che non usa if?

Answer 1

userei il fatto che è possibile convertire facilmente un Bool a un Int utilizzando fromEnum:

addif x acc y = acc + fromEnum (x == y) 

Ora è possibile iniziare ad applicare i soliti trucchi per renderlo punto-libera

-- Go prefix and use $ 
addif x acc y = (+) acc $ fromEnum $ (==) x y 
-- Swap $ for . when dropping the last argument 
addif x acc = (+) acc . fromEnum . (==) x 

E così via. Non toglierò tutto il divertimento di renderlo punto libero, specialmente quando ci sono strumenti per farlo per te.

In alternativa, si potrebbe scrivere una funzione come

count x = sum . map (fromEnum . (==) x) 

che è quasi Point gratuito, e ci sono trucchi che ci si avvicina, anche se ottengono piuttosto brutta in fretta:

count = fmap fmap fmap sum map . fmap fmap fmap fromEnum (==) 

Here I pensa che in realtà sembra più bello usare fmap anziché (.), anche se è possibile sostituire ogni fmap con (.) e sarebbe lo stesso codice esatto.In sostanza, il (fmap fmap fmap) compone un singolo argomento e una funzione a due argomenti insieme, se invece dà il nome .: si potrebbe scrivere questo come

count = (sum .: map) . (fromEnum .: (==)) 

Ripartiti:

> :t fmap fmap fmap sum map 
Num a => (a -> b) -> [a] -> b 

quindi ci vuole una funzione da b a un numero a, un elenco di b s e restituisce un a, non troppo male.

> :t fmap fmap fmap fromEnum (==) 
Eq a => a -> a -> Int 

E questo tipo può essere scritto come Eq a => a -> (a -> Int), che è una cosa importante da notare. Questo rende il tipo di ritorno di questa funzione corrispondente all'ingresso a fmap fmap fmap sum map con b ~ Int, quindi possiamo comporli per ottenere una funzione di tipo Eq a => a -> [a] -> Int.

Answer 2

Un trucco sarebbe quello di importare uno dei molti if functions, ad es. Data.Bool.bool 1 0 (disponibile anche in Data.Bool.Extras).

Un trucco più arcano sarebbe quello di utilizzare Foreign.Marshal.Utils.fromBool, che fa esattamente quello che ti serve qui. O la stessa cosa, meno arcano: fromEnum (grazie @bheklilr).

Ma penso che il trucco più semplice sarebbe semplicemente quello di evitare di contare te stesso, e basta applicare la funzione standarddopo il numero filter per il numero.

Answer 3

perché non

numocc x 
    = map (length . filter (== x)) 
    = map ((length .) (filter (== x))) 
    = map (((length .) . filter) (== x)) 
    = map (((length .) . filter) ((==) x)) 
    = map (((length .) . filter . (==)) x) 
    = (map . ((length .) . filter . (==))) x 
    = (map . (length .) . filter . (==)) x 

e poi il banale eta-contrazione.

Answer 4

Utilizzando l'istanza Enum per Bool, è possibile costruire una sostituzione pointfree per se che può essere utilizzato nei casi più generali:

chk :: Bool -> (a,a) -> a 
chk = ([snd,fst]!!) . fromEnum 

Uso chk possiamo definire una versione diversa di addIf:

addIf' :: Eq a => a -> a -> Int -> Int 
addIf' = curry (flip chk ((+1),id) . uncurry (==)) 

Ora possiamo semplicemente sostituire chk in addIf':

addIf :: Eq a => a -> a -> Int -> Int 
addIf = curry (flip (([snd,fst]!!) . fromEnum) ((+1),id) . uncurry (==)) 

Answer 5

Penso che stiate cercando Data.Bool 's bool, che esiste dal 4.7.0.0 (2014-04-08).

incif :: (Eq a, Enum counter) => a -> a -> counter -> counter 
incif = ((bool id succ) .) . (==) 

L'ulteriore . permette == prendere due parametri, prima di passare l'espressione bool.

Dal momento che l'ordine dei parametri è diverso, è necessario utilizzare incif come questo:

(flip . incif) 

(Integrazione che inincif è lasciato come esercizio per il lettore [Traduzione:. Non è banale, e non so ancora come;;)