हास्केल - लेंस, 'टू' फ़ंक्शन का उपयोग

Question

मेरे पास निम्न कोड है। जब मैं गेम स्टेटस देता हूं तो मैं सक्रिय खिलाड़ी के जीवन को संशोधित करने में सक्षम होना चाहता हूं। मैं एक activePlayer लेंस के साथ आया था, लेकिन जब मैं कोशिश करते हैं और -= ऑपरेटर मैं निम्न त्रुटि प्राप्त के साथ संयोजन में इसका इस्तेमाल करते हैं:

> over (activePlayer.life) (+1) initialState 
<interactive>:2:7: 
    No instance for (Contravariant Mutator) 
     arising from a use of `activePlayer' 
    Possible fix: 
     add an instance declaration for (Contravariant Mutator) 
    In the first argument of `(.)', namely `activePlayer' 
    In the first argument of `over', namely `(activePlayer . life)' 
    In the expression: over (activePlayer . life) (+ 1) initialState`` 

और प्रश्न में कोड:

{-# LANGUAGE TemplateHaskell #-} 
module Scratch where 

import Control.Lens 
import Control.Monad.Trans.Class 
import Control.Monad.Trans.State 
import Data.Sequence (Seq) 
import qualified Data.Sequence as S 

data Game = Game 
    { _players :: (Int, Seq Player) -- active player, list of players 
    , _winners :: Seq Player 
    } 
    deriving (Show) 

initialState = Game 
    { _players = (0, S.fromList [player1, player2]) 
    , _winners = S.empty 
    } 

data Player = Player 
    { _life :: Integer 
    } 
    deriving (Show, Eq) 

player1 = Player 
    { _life = 10 
    } 

player2 = Player 
    { _life = 10 
    } 

makeLenses ''Game 
makeLenses ''Player 

activePlayer 
    :: (Functor f, Contravariant f) => 
     (Player -> f Player) -> Game -> f Game 
activePlayer = players.to (\(i, ps) -> S.index ps i) 

प्रत्येक खिलाड़ी ले जाता है क्रम में उनकी बारी। मुझे एक ही समय में सभी खिलाड़ियों का ट्रैक रखने की आवश्यकता है, साथ ही वर्तमान में सक्रिय है, यही कारण है कि मैंने इसे कैसे संरचित किया, हालांकि मैं अलग-अलग संरचनाओं के लिए खुला हूं क्योंकि मेरे पास अभी तक सही नहीं है।

Answer 1

जब आप (.) के साथ लेंस लाइब्रेरी में विभिन्न आइटम लिखते हैं तो वे एक प्रकार के उप प्रकार (नीचे देखें) के अनुसार क्षमताओं को खो सकते हैं। इस मामले में, आप बना दिया है एक Lens (players) एक Getter (to f कुछ समारोह f के लिए) और इस तरह संयोजन के साथ सिर्फ एक Getter जबकि over लेंस है कि दोनों हो और निर्धारित कर सकते हैं पर कार्य करता है।

activePlayer वैध लेंस बनाना चाहिए, हालांकि, आप इसे गेटर/सेटर जोड़ी के रूप में मैन्युअल रूप से लिख सकते हैं। मैं इस धारणा के तहत आंशिक रूप से नीचे लिख रहा हूं कि सूचकांक कभी भी अमान्य नहीं हो सकता है।

activePlayer :: Lens' Game Player 
activePlayer = lens get set 
    where 
    get :: Game -> Player 
    get (Game { _players = (index, seq) }) = Seq.index seq index 

    set :: Game -> Player -> Game 
    set g@(Game { _players = (index, seq) }) player = 
     g { _players = (index, Seq.update index player seq) } 

बेहतर subtyping कि lens पुस्तकालय में होने वाली है समझने के लिए हम उपयोग कर सकते हैं the Big Lattice Diagram from Hackage

जब भी आप (.) आपको लगता है कि चार्ट में अपना पहला आम वंशज के साथ अंत के साथ दो लेंस प्रकार गठबंधन । तो यदि आप Lens और Prism गठबंधन करते हैं तो आप देख सकते हैं कि उनके तीर Traversal पर एकत्रित होते हैं। यदि आप Lens और Getter (to f है) को गठबंधन करते हैं तो आपको Getter मिलते हैं क्योंकि GetterLens का प्रत्यक्ष वंशज है।