ઉકેલાયેલ: ફંક્ટર

કાર્યાત્મક પ્રોગ્રામિંગની દુનિયામાં, ખ્યાલો અલગ રીતે વિકસિત થાય છે. તેમાંથી, આજે આપણે જેને અસ્પષ્ટ કરવા જઈ રહ્યા છીએ તેટલા થોડા જ અમૂર્ત અને સમજવામાં મુશ્કેલ લાગે છે - ફંક્ટર. પરંતુ એકવાર તમે તેની શક્તિ અને લવચીકતાને સમજી લો, ફંક્ટર જટિલ પ્રોગ્રામિંગ પડકારોના તમારા ઉકેલોને ભારે સરળ બનાવી શકે છે.

હાસ્કેલમાં ફંક્ટર્સને સમજવું

ફંક્ટર, હાસ્કેલમાં, એક પ્રકાર છે જે અમલીકરણ કરે છે ફંક્ટર પ્રકાર વર્ગ. તે અનિવાર્યપણે કંઈક છે જે ઉપર મેપ કરી શકાય છે. ફંક્ટર બે પ્રાથમિક તત્વો, 'fmap' ફંક્શન અને કેટલાક કાયદાઓને મૂર્ત બનાવે છે જે સુસંગત વર્તનને સુનિશ્ચિત કરે છે.

'fmap' નો ઉપયોગ સ્ટ્રક્ચરમાં ફેરફાર કર્યા વિના સ્ટ્રક્ચરની અંદરની કિંમત પર ફંક્શન લાગુ કરવા માટે થાય છે. આનો અર્થ એ છે કે, ફંકટર્સ સંદર્ભને અપ્રભાવિત છોડીને સંદર્ભ અમલીકરણ કામગીરીને સમાવે છે. તે અમને સંદર્ભને હેન્ડલ કરવામાં ફસાયા વિના સમસ્યા-નિરાકરણ પર ધ્યાન કેન્દ્રિત કરવાની મંજૂરી આપે છે.

instance Functor Maybe where
    fmap func (Just x) = Just (func x)
    fmap func Nothing = Nothing

ફંક્ટર કાયદા

ફંક્ટર તરીકે લાયક બનવા માટેના પ્રકાર માટે, તે તરીકે ઓળખાતા બે કાયદાઓને સંતોષવા આવશ્યક છે ફંક્ટર કાયદા. આ કાયદાઓ અમે જે માળખા પર કામ કરી રહ્યા છીએ તેની અખંડિતતાનું રક્ષણ કરે છે.

કાયદો 1: ફંક્ટર પર ઓળખ કાર્યને મેપ કરવાથી મૂળ ફંક્ટર પરત આવવું જોઈએ - fmap id == id

fmap id (Just 3)  -- Returns: Just 3
fmap id Nothing  -- Returns: Nothing

કાયદો 2: બે ફંક્શન કંપોઝ કરવું અને પછી પરિણામી ફંક્શનને ફંક્ટર પર મેપ કરવું એ પહેલા એક ફંક્શનને મેપિંગ અને પછી બીજાને મેપ કરવા જેવું જ હોવું જોઈએ - fmap (f. g) == fmap f . એફએમએપી જી

fmap (abs . negate) (Just 5)  -- Returns: Just 5
(fmap abs . fmap negate) (Just 5)  -- Returns: Just 5

સમસ્યાઓ ઉકેલવા માટે ફંક્ટર લાગુ કરવું

હવે, ચાલો સમજાવીએ કે ફંક્ટર કેવી રીતે કાર્યક્ષમ રીતે સમસ્યાઓ હલ કરી શકે છે. ઉદાહરણ તરીકે, કહો કે અમારી પાસે સંભવિત મૂલ્યોની સૂચિ તરીકે સંભવિત પરિણામોની સૂચિ છે. જો આપણે દરેકને એક-એક વધારવું હોય તો, સામાન્ય રીતે, આપણે ઘણા બધા બોઈલરપ્લેટ કોડ લખવા પડશે. ફંક્ટર દાખલ કરો.

'fmap' સૂચિ પર સરળતાથી પુનરાવર્તિત થઈ શકે છે, કંઈપણ મૂલ્યોને બાયપાસ કરીને અને ફક્ત માત્ર મૂલ્યો પર ઑપરેશન લાગુ કરી શકે છે. મૂળ માળખું જાળવી રાખતી વખતે.

let maybes = [Just 1, Nothing, Just 3]
fmap (+1) <$> maybes  -- Returns: [Just 2, Nothing, Just 4]

આમ, ફંકટર્સ સંદર્ભમાં ગણતરીઓનું સંચાલન કરવા માટે સુવ્યવસ્થિત, બુદ્ધિશાળી રીત પ્રદાન કરે છે. તેઓ સરળ, ભવ્ય કોડ સાથે જટિલ કાર્યોને હેન્ડલ કરવાની હાસ્કેલની ક્ષમતાનો એક અભિન્ન ભાગ બનાવે છે.

સંબંધિત પોસ્ટ્સ:

પ્રતિક્રિયા આપો