Ausführen eine Transformation mit dem Eingang, bevor die Funktion Monade

Question

Anwendung Ich bin mir bewusst, dass ich die Funktion Monade verwenden kann, um ein Konstrukt wie die unten zu erreichen (wo ich das Argument in mehr Anrufen wiederverwenden, ohne es explizit Referenzierung):

compute_v0 :: String -> String 
compute_v0 = do 
    x <- length -- (using the argument implicitly here) 
    top <- head -- (and here) 
    return (replicate x top) 

Das Ergebnis der obigen Funktion für: compute "1234""1111"

Meine Frage wäre: Wie würde ich eine Transformation auf die ‚versteckten‘ Argument anwenden, bevor das tun Block ausgeführt wird (man stelle würde ich mag „abcd anhängen "zur Liste).

Meine erste Lösung:

compute_v1 :: String -> String 
compute_v1 = compute_v1' . (++ "abcd") 

compute_v1' ::String -> String 
compute_v1' = do 
    x <- length 
    top <- head 
    return (replicate x top) 

Das Ergebnis für compute "1234" wäre jetzt "11111111". Dies erledigt zwar den Job, aber ich würde lieber versuchen, es in einem einzigen Code-Block definiert zu halten.

Der nächstgelegene ich tatsächlich bekommen konnte umfassen die Transformation, während immer noch den Stil von Code (v0) zu halten war diese:

compute_v2 :: String -> String 
compute_v2 = (++ "abcd") >>= \r -> do 
    let x = length r 
    let top = head r 
    return $ replicate x top 

Aber ich hatte noch eine Lambda enthalten, eine Menge let Bindungen verwenden und verweisen Sie explizit auf das Lambda-Argument. Gibt es bessere Möglichkeiten, ein solches Konstrukt zu erreichen?

Answer 1

Da alle Monad Instanzen auch Functor Instanzen haben und die Funktion Instanz Functor hat fmap = (.), können Sie

compute :: String -> String 
compute = flip fmap (++ "abcd") $ do 
    x <- length 
    top <- head 
    return $ replicate x top 

Einige Pakete haben (wie microlens und lens) definieren (<&>) = flip fmap, so dass Sie

schreiben

compute :: String -> String 
compute = (++ "abcd") <&> do 
    x <- length 
    top <- head 
    return $ replicate x top 

Es gibt auch eine Category Instanz für (->), die giv es uns (>>>) = flip (.). Das mag etwas klarer, optisch:

compute :: String -> String 
compute = (++ "abcd") >>> do 
    x <- length 
    top <- head 
    return $ replicate x top 

Answer 2

Sie so etwas tun könnte:

compute_v2 :: String -> String 
compute_v2 = do 
    x <- length 
    top <- head 
    return $ replicate x top 
    <$> (++ "abcd") 

AFAIK ist die Monade in Frage der Reader Monade genannt, und es ist auch ein Functor.

*Q46393211> compute_v2 "1234" 
"11111111" 
*Q46393211> compute_v2 "71" 
"777777" 

Answer 3

MonadReader class hat die Methode local hierfür und (->) r ist eine Instanz, so

import Control.Monad.Reader (local) 

compute_v3 ::String -> String 
compute_v3 = local (++ "abcd") $ do 
    x <- length 
    top <- head 
    return (replicate x top) 

sollte funktionieren (kann im Augenblick nicht-Test).