Redux: उदाहरण - एक्शन टाइप नेमस्पेसिंग को कैसे लागू किया जाए?

कार्यों में खाता टाइप करें? यह भी देखें कि आप एक रिड्यूसर फैक्ट्री कैसे लिख सकते हैं और एक ही कोड का उपयोग करने के लिए examples/real-world/reducers कई बार रिड्यूसर का उत्पादन करते हैं जो विभिन्न क्रियाओं का जवाब देते हैं।

इसी तरह से मत भूलो कि एक्शन क्रिएटर्स सिर्फ फ़ंक्शन हैं, और आप ऐसे फ़ंक्शंस बना सकते हैं जो अन्य फ़ंक्शंस का एक गुच्छा लौटाते हैं।

मुझे लगता है कि यह वास्तव में मदद करेगा यदि आप समस्या का एक विशिष्ट छोटा उदाहरण प्रदान करते हैं जो आप कहते हैं कि मौजूदा उदाहरणों में अनदेखा किया गया है।

फिर हम आपको उस विशिष्ट उदाहरण को सरल बनाने के तरीके खोजने में मदद कर सकते हैं। बिना कोड के किसी प्रश्न के उत्तर में कुछ विशेष सुझाना बहुत कठिन है।

@gaearon मुझे पता है कि आप इसके साथ कहाँ जा रहे हैं, लेकिन मैं पुन: प्रयोज्य reducers, एक्शन क्रिएटर या DRY चीजों को बनाने की कोशिश नहीं कर रहा हूँ, बिल्कुल विपरीत।

मैं एक-दूसरे से कार्यों के समूहों को अलग करने की कोशिश कर रहा हूं, ताकि मेरे पास सिस्टम के दो अलग-अलग वर्गों पर काम करने वाले 2 लोग हो सकें और सुनिश्चित करें कि वे एक्शन टाइप नामों में नाम स्थान की कमी के कारण गलती से एक-दूसरे के रीड्यूसर को ट्रिगर करना शुरू नहीं करेंगे।

आशा है कि यह इसे और अधिक स्पष्ट करता है।

मैंने https://www.npmjs.com/package/flux-constant का उपयोग करके एक सुपर सरल सहायक फ़ंक्शन के साथ संयोजन में createActionTypes नामक इस समस्या को हल किया है।

अनिवार्य रूप से, मेरा कोड समाप्त हो रहा है:

// create-action-types.js
var fluxConstant = require('flux-constant');
module.exports = function (types) {
    return fluxConstant.set(types);
};

// in foo-action-types.js
module.exports = createAtionTypes([
    'ADD_FOO',
    'REMOVE_FOO'
]);

// in some-store.js
var fooActionTypes = require('foo-action-types');
function (state, action) {
    switch(action.type) {
        case fooActionTypes.ADD_FOO: 

        case fooActionTypes.REMOVE_FOO:
   }
}

सभी क्रिया प्रकारों को एक स्थान पर स्थिरांक के रूप में क्यों नहीं रखा जाता है?
फिर वे निश्चित रूप से संघर्ष नहीं कर सकते क्योंकि आप एक ही नाम को दो बार निर्यात नहीं कर सकते।

इसे बेहतर ढंग से देखने के लिए, मान लें कि यह स्टोर की प्रारंभिक स्थिति है:

let initialState = {
  "testerAccount": {
    "videoUploads": [],
    "messages": []
  },
  "customerAccount": {
    "videoUploads": [],
    "messages": []
  },
  "systemUserAccount": {
    "videoUploads": [],
    "messages": []
  }
};

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

@ आप जो भी सुझाव दे रहे हैं वह समस्या के मूल को हल नहीं करता है, यह डक्ट टेप दृष्टिकोण से अधिक है क्योंकि समय के साथ आप एक विशाल प्रकार की फ़ाइल के साथ समाप्त हो जाएंगे जिससे बहुत सारी समस्याएं हो जाएंगी।

यह कोड मर्ज के दौरान सीधे समस्याओं का कारण होगा जो बाद में नामकरण हैक के साथ हल करने की आवश्यकता होगी, उदाहरण के लिए:

ADD_VIDEO_UPLOAD, ADD_TESTER_VIDEO_UPLOAD, ADD_VIDEO_UPLOAD_IN_SOME_SECTION, आदि

जो फिर से एक बड़ा सिरदर्द है।

@koulmomo यह वही है

@gaearon मुझे लगता है कि हमारे पास कम से कम एक उदाहरण होना चाहिए जो या तो इस पैकेज का उपयोग करता है या एक नया पैकेज जिसे रेडक्स-स्थिरांक नाम दिया जा सकता है?

मेरी राय में डॉक्स / उदाहरणों में दृष्टिकोण को बढ़ावा देना, जो नाम बदलने की समस्या को हल करता है, नया डिफ़ॉल्ट होना चाहिए।

इसए लिए तुम्हारी मदद के लिए धन्यवाद :)

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

मुझे नहीं लगता कि flux-constant यहां एक महान समाधान है। यह instanceof चेक पर निर्भर करता है। इसका मतलब है कि आप अपने कार्यों को क्रमबद्ध नहीं कर सकते हैं और बाद में उन्हें फिर से दोहरा सकते हैं क्योंकि - bam! - deserialized प्रकार उत्पन्न लोगों से मेल नहीं खाएंगे।

लोग अक्सर फ्लक्स को "सरल" बनाने की कोशिश करते हैं, बिना यह महसूस किए कि वे इसकी आवश्यक विशेषताओं को

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

मैं आपके उदाहरण में स्पष्ट समरूपता से गुमराह था। मैं अब समझ गया हूं कि आपका मतलब यहां कोई DRY नहीं है, और सुविधाओं में समरूपता केवल स्पष्ट है, जैसा कि आपने https://github.com/rackt/redux/issues/786#issuecomment -142649749 में कहा है।

मुझे नहीं लगता कि यहां लाइब्रेरी की जरूरत है। एक सम्मेलन की स्थापना! उदाहरण के लिए, यदि आपके उपप्रोजेक्ट या सुविधाएँ इतनी अलग हैं, तो इसे क्रिया प्रकार feature/ACTION_TYPE कॉल करने का नियम बनाएं, जैसे testers/UPLOAD_VIDEO या customers/UPLOAD_VIDEO । यह विशेष रूप से अच्छा है अगर ये "समूह" वास्तव में डिस्क पर वास्तविक फ़ोल्डर (या बेहतर-पैकेज) के अनुरूप हैं।

कोड समीक्षाओं में उल्लंघन को पकड़ना आसान होगा। यदि आप _really_ चाहते हैं, तो आप इसे स्वचालित कर सकते हैं, लेकिन मैं यह नहीं देख सकता कि यह मैन्युअल नाम स्थान पर क्या लाता है। प्रत्येक मॉड्यूल के अंदर, आप अभी भी सुविधाओं पर आसानी से नियंत्रण के लिए एक फ़ाइल में सभी स्थिरांक घोषित करना चाहते हैं, जिससे प्रयास के आकस्मिक दोहराव को रोका जा सके, और एक दस्तावेज के रूप में।

मैं कोड बंटवारे के साथ huge-apps उदाहरण जोड़ने के लिए हूं, नामांकित क्रिया प्रकार आदि, हालांकि यह एक अलग मुद्दा होगा।

नाम स्थान के लिए स्ट्रिंग्स स्वाभाविक रूप से खराब नहीं हैं। URL स्ट्रिंग्स हैं, और वे ठीक काम करने लगते हैं।

@gaearon आप सही हैं, मैं फ्लक्स-स्थिरांक पर आधारित समाधान के साथ क्रमांकन की समस्या के बारे में भूल गया।

मुझे स्ट्रिंग आधारित नेमस्पेसिंग में कोई समस्या नहीं है जब तक कि हम स्वयं के नाम में मॉड्यूल / नेमस्पेस को आसानी से अलग कर सकते हैं।

नामकरण सम्मेलन आधारित समाधान कुछ मैंने पहले देखा है:

https://github.com/erikras/ducks-modular-redux

लेकिन मुझे उम्मीद थी कि ऐसा करने का एक बेहतर या "सही" तरीका हो सकता है जो आपके अनुभव पर आधारित होगा।

मुझे लगता है कि मैं फ्लक्स-कॉन्स्टैंट एप्रोच को किसी ऐसी चीज में बदलने की कोशिश करूंगा जिसे आप वास्तव में किसी तरह से सीरियस कर सकें।

यदि आप इसके लिए समय पाते हैं तो कृपया "विशाल-ऐप्स" उदाहरण जोड़ें क्योंकि इससे अन्य लोगों का बहुत समय बचेगा और हो सकता है कि यह किसी प्रकार के सम्मेलन को स्थापित करने का मार्ग प्रशस्त करे, जिसका हम बाद में आसानी से पालन कर सकते हैं।

फिर से धन्यवाद :)

हाँ, क्षमा करें, दुर्भाग्य से मैं कुछ समय के लिए एक बड़े ऐप पर काम नहीं कर रहा था, और जब मैंने किया, तब भी मुझे वास्तव में पसंद आया कि हमारे पास एक विशालकाय फ़ाइल है जिसमें कॉन्स्टेंट को खंडों में बांटा गया है क्योंकि यह हो सकता है कि एक अच्छा अवलोकन प्रदान करता है। ऐप में।

@pbc की जाँच करें

मैं डॉक्स में इस "समस्या" को और अधिक विस्तार से देखना चाहूंगा। मेरे पास @pbc जैसे ही प्रश्न हैं। मुझे नहीं लगता कि "सभी कार्रवाई प्रकारों को एक स्थान पर स्थिरांक के रूप में क्यों नहीं रखा जाता है?" यदि आप परियोजनाओं में कई मॉड्यूलों का उपयोग करते हैं और अनुशंसा करते हैं तो "एक सम्मेलन की स्थापना करें"! सीएसएस भूमि में BEM की तरह बहुत कुछ लगता है। हालाँकि हम BEM से CSS मॉड्यूल की ओर बढ़ते हैं और मुझे लगता है कि CSS मॉड्यूल के समान कुछ है जो कि बड़े प्रोजेक्ट्स में कार्रवाई प्रकारों के लिए हैश वर्ग के नामों की भी आवश्यकता है।

जहां तक ​​मैं बता सकता हूं, क्रमबद्धता और संघर्षों की अनुपस्थिति दोनों को प्राप्त करने का कोई तरीका नहीं है।

पुन: प्रयोज्य मॉड्यूल के लिए एक अच्छा सम्मेलन पहले से ही मौजूद "अद्वितीयता प्रदाता" का उपयोग कर सकता है, जैसे रिवर्स डोमेन नाम, या जीथब पर उपयोगकर्ता नाम / रेपो, या एनपीएम पर पंजीकृत मॉड्यूल नाम।

संपादित करें: सीएसएस मॉड्यूल सीएसएस के शीर्ष पर एक कस्टम भाषा को परिभाषित करके और प्रीप्रोसेसिंग के दौरान क्लासनेम को प्रीफ़िक्स करता है (वैसे भी कन्वेंशन के लिए फोड़े, लेकिन एक उत्पन्न होता है)।

प्रश्न और चर्चा के लिए +1। मैंने @pbc के रूप में इस सटीक समस्या के साथ बहुत संघर्ष किया। मेरे लिए भ्रम यह है कि हमारे पास reducers के लिए CombReducers हैं, जो एक अच्छा राज्य वृक्ष बनाता है, लेकिन दूसरी तरफ कार्रवाई वैश्विक रूप से कम या ज्यादा महसूस होती है। इसके द्वारा, किसी भी प्रकार के नाम स्थान को मैन्युअल रूप से करना होगा।

मुझे लगता है कि मैंने क्रमबद्ध स्ट्रिंग एक्शन प्रकारों के लिए एक समाधान ढूंढ लिया है। मुझे लगता है कि यह उन परिस्थितियों में से एक है जहां हमारे दिमाग में किसी चीज पर कृत्रिम सीमाएं लाद दी जाती हैं।

मूल विचार यह है कि प्रकार स्थिरांक को स्ट्रिंग मान के लिए किसी भी तरह से संबंधित होने की आवश्यकता नहीं है। तो आप बेतरतीब ढंग से उत्पन्न मानों का उपयोग कर सकते हैं, हैश फाइल पथ, या किसी अन्य प्रकार के निरंतर स्ट्रिंग मान के लिए अद्वितीय। अपने reducer में, आप नाम से निरंतर प्रकार आयात करते हैं, और नाम से इसकी तुलना करते हैं। वह नाम अन्य कार्यों और अन्य reducers में उपयोग किया जा सकता है, लेकिन यह कोई फर्क नहीं पड़ता, क्योंकि मूल्य समान नहीं होगा।

यहाँ उदाहरण: https://gist.github.com/samsch/63a54e868d7fa2b6023a

यह समझदार है। आप अभी भी कार्रवाई के नाम पर कुछ मानव पठनीय भाग को बनाए रखना चाहते हैं, लेकिन अद्वितीय उपसर्ग पूरी तरह से काम करते हैं।

यदि आप साबित कर सकते हैं कि वे अद्वितीय हैं, तो निश्चित रूप से।
सबसे अच्छा तरीका अभी भी पहले से मौजूद विशिष्ट प्रदाताओं का उपयोग करना है: रिवर्स डोमेन नाम या एनपीएम मॉड्यूल नाम।

जब आप मॉड्यूल लिख रहे होते हैं, तो कन्वेंशन के साथ नाम रखने से आपके नियंत्रण से बाहर होने वाले विभिन्न स्थानों में उपयोग किए जा सकते हैं।

मान लें कि आपके पास "क्षेत्र" के ActionType के साथ एक मॉड्यूल "ज्यामिति" है। इस मॉड्यूल का उपयोग दो स्थानों पर किया जाता है:

1. अप्पा-> ड्राइंग-> ज्यामिति (नाम स्थान = "ड्राइंग / ज्यामिति / क्षेत्र")
2. AppB-> त्रिकोणमिति-> आकृति-> ज्यामिति (नाम स्थान = "त्रिकोणमिति / आकार / क्षेत्र")

अब आपके पास दो परस्पर विरोधी नाम स्थान हैं, जो इस बात पर निर्भर करता है कि आपका मॉड्यूल कहां उपयोग किया जाता है।

• ActionType "क्षेत्र" के लिए अपने ज्यामिति मॉड्यूल में इस पूर्ण पथ को हार्डकोड करना एक अच्छा विचार नहीं है।
• बल्कि, नाम को सरल रखें: "क्षेत्र"।
• रचना को फिर से बनाने के लिए इसी तरह से, एक उपसर्ग जोड़ने के लिए प्रत्येक युक्त माता-पिता के द्वारा नाम स्थान की रचना करें।

मैं निम्नलिखित पैटर्न के साथ प्रयोग कर रहा हूं:

प्रत्येक प्रकार के संग्रह के लिए dir बनाएं जिसमें शामिल हैं:

• consts
• कम करने
• अवयव
• कहानियों

निम्नलिखित प्रारूप में बाधाएं बनाएं:

// song-store/song-store-consts.js
export const ADD = 'SONG_STORE.ADD'
export const REMOVE = 'SONG_STORE.REMOVE'

Reducers, गाथा या कार्यों में स्थिरांक का उपयोग करते समय import उन सभी के साथ * :

// song-store/song-store-actions.js
import * as SONG_STORE from './song-store-consts'

export function addSongStore(name) {
  return {
    type: SONG_STORE.ADD,
    name
  }
}

export function removeSongStore(songStoreId) {
  return {
    type: SONG_STORE.REMOVE,
    songStoreId
  }
}

पेड़ के झटकों के लिए दुख की बात नहीं है। अच्छा होगा यदि ES6 की अनुमति हो:

import { ADD, REMOVE } as SONG_STORE from './song-store-actions'

किसी को भी पता है कि अगर वेबपैक 2 समझदारी से पेड़ को import * हिला सकता है, तो यह निर्यात के लिए कोड को बंडल नहीं करता है जो कि * साथ आयात होने पर भी उपयोग नहीं किया जाता है?

यह एक बहुत ही आम मुद्दा लगता है और यह हमारे कार्यालय के आसपास अक्सर, या तो:

• नाम संघर्ष अवांछनीय व्यवहार का कारण बनता है।
• अनूठी कार्रवाई प्रकार बनाने से संबंधित बॉयलरप्लेट के बारे में शिकायत करना।

हमने कुछ अलग समाधानों की कोशिश की लेकिन कुछ भी नहीं लगा:

1. सभी क्रिया प्रकारों को एक स्थान पर स्थिर रखने के कारण निश्चित रूप से इसे प्रबंधित करना आसान हो जाता है, लेकिन मैंने पाया कि ऐप के बढ़ने पर यह थोड़ा कमतर हो जाता है।
2. @Samsch द्वारा बताए गए बेतरतीब ढंग से उत्पन्न मूल्यों ने वास्तव में मेरा ध्यान आकर्षित किया और यह निश्चित रूप से काम करता है, लेकिन हां, मानव पठनीय भाग को खोना उसके साथ रहना अधिक कठिन बनाता है।
3. @Philholden द्वारा उपरोक्त टिप्पणी ने वास्तव में मुझसे अपील की, क्योंकि हम आम तौर पर एक सुविधा संचालित वास्तुकला का उपयोग करते हैं और निर्देशिका संरचना काफी वर्णनात्मक है।

पिछले कुछ महीनों के लिए प्रयोग करने के बाद, हमने अपने एक्शन प्रकारों के नामकरण के लिए निर्देशिका संरचना का उपयोग करने का निर्णय लिया। इनको टाइप करने से मैन्युअल रूप से पुराना तेजी से पुराना हो जाता है, इसलिए मैंने __filename साथ कुछ करने का प्रयास किया, लेकिन यह कोड बंडलिंग आदि के कारण काम नहीं करता है। तब मैंने अपना पहला बैबेल प्लगइन बनाया, जो कीवर्ड __filenamespace एक स्थिर स्ट्रिंग में

उदाहरण

App/testerAccount/index.js :

// Something like this
const ADD_VIDEO_UPLOAD = `${__filenamespace}/ADD_VIDEO_UPLOAD`;
const ADD_COMMENT = `${__filenamespace}/ADD_COMMENT`;

// Will be transformed into something like this
const ADD_VIDEO_UPLOAD = 'App/testerAccount/ADD_VIDEO_UPLOAD';
const ADD_COMMENT = 'App/testerAccount/ADD_COMMENT';

बेझिझक इसे एक कोशिश दे, मुझे आशा है कि यह उपयोगी है। किसी भी प्रतिक्रिया को प्राप्त करना शानदार होगा, विशेष रूप से @pbc या @gaearon से मुद्दा निर्माता और पुस्तकालय निर्माता के रूप में।

https://www.npmjs.com/package/babel-plugin-filenamespace

मैं वास्तव में उम्मीद कर रहा था कि कोई "मानक" पेश करेगा। हमें इसके लिए प्रतीकों या वस्तुओं की आवश्यकता नहीं है, हमें सिर्फ एक सम्मेलन की आवश्यकता है।

क्या हम "featureName$actionType" या "fileName/ACTION_TYPE" या "PROJECT.FEATURE.ACTION" ? अगर हम सभी कुछ पर सहमत हो सकते हैं, तो रिड्यूसर साझा करना आसान होगा।

मुझे लगता है कि अन्य उपलब्ध सम्मेलनों की कमी के साथ, बतख रक्षा मानक बन गए हैं।

const ACTION = 'app/feature/ACTION'; बहुत पर्याप्त है।

@gaearon ने हमेशा उल्लेख किया है कि 1: 1 कार्रवाई और reducers के बीच संबंध शायद एक बुरा विचार है और मैं वास्तव में सहमत हूं। लेकिन उस मामले के बारे में क्या जहां दो अलग-अलग विचार वास्तव में एक ही reducer कॉल करना चाहते हैं।
उदाहरण के लिए। एक साधारण वरीयता टॉगल को दो अलग-अलग स्थानों से सक्षम या अक्षम किया जा सकता है:
/ MyAccount / toggleNotification
/ डैशबोर्ड / toggleNotification
तो क्या हमारे पास एक ही सामग्री के साथ दो रीड्यूसर लिखे जाने चाहिए
reducers / notifications.js
cc: @ samit4me , @philholden

बस एक और विचार पर, मुझे लगता है कि यह एक अच्छा विचार है, एक फाइल के भीतर दो या दो से अधिक reducers होने के साथ अलग-अलग एक्शन नामों के साथ एक ही काम कर रहे हैं। यह है कि केवल reducer को देखकर हम यह समझ सकते हैं कि किसी विशेष राज्य में कितने अलग-अलग स्थानों से संशोधित किया जा रहा है।

वैसे भी, विशेषज्ञों से सुनना अच्छा लगेगा। धन्यवाद।

@ शिव : यहाँ कई विचार हैं।

सबसे पहले, आप अनुप्रयोग के भीतर कई स्थानों से एक ही कार्रवाई भेज सकते हैं।

दूसरा, आप निश्चित रूप से एक ही reducer कई क्रिया प्रकारों के लिए सुन सकते हैं, और उन्हें उसी तरह से संभाल सकते हैं।

तीसरा, "1: 1 संबंध" पहलू एक ही कार्रवाई को स्वतंत्र रूप से अपनी बिट को अपडेट करने के साथ, एक ही कार्रवाई को सुनने के लिए कई स्लाइस reducers होने में सक्षम है। हां, ज्यादातर समय केवल एक रिड्यूसर हो सकता है जो किसी दिए गए एक्शन की परवाह करता है, लेकिन कई रिड्यूसर का जवाब देना Redux के लिए एक बहुत ही इच्छित उपयोग मामला है।

@markerikson

दूसरा, आप निश्चित रूप से एक ही reducer कई क्रिया प्रकारों के लिए सुन सकते हैं, और उन्हें उसी तरह से संभाल सकते हैं।

मैं वास्तव में redux-actions का उपयोग कर रहा था, और यह नहीं जानता था कि इसकी एक उपयोगिता विधि CombAction है जो कार्य करेगी। बस यह पाया गया और आपके उपरोक्त कथन में बस उसी का उल्लेख है। (अधिक स्पष्ट होना चाहिए, क्षमा करें)
जवाब देने के लिए आपका बहुत-बहुत धन्यवाद।

मुझे नहीं लगता कि डक एक्शनटाइप्स में सही ढंग से परिभाषित होता है:

Mpm के पास Npm-मॉड्यूल-या-ऐप / reducer / ACTION_TYPE में एक्शन प्रकार हैं

कारण एक से अधिक reducers द्वारा सदस्यता ली जा सकती है। जैसा कि @mherodev ने कहा, const ACTION = 'app/feature/ACTION'; अधिक समझ में आता है, इसके अलावा मैं कार्रवाई के लिए एक स्कीमा जोड़ना चाहूंगा: const ACTION = 'action://app/feature/ACTION'; ।

कार्रवाई के प्रकारों की पहचान करने के लिए केवल एक विश्व स्तर पर स्व-वृद्धिशील पूर्णांक का उपयोग क्यों नहीं किया जाता है? जैसे

let id = 0

function generateActionType (label /* for readability */) {
  id++
  return `app/feature/${id}/${label}`
}

इस बारे में थोड़ा सोचा, यह सुनिश्चित करने के लिए कि हम अन्य डेवलपर्स के साथ नहीं टकराते, हम एक लिंट नियम लिख रहे हैं, जो एक निर्देशिका में दिखता है (जहां हमें सभी रिड्यूसर मिल गए हैं और प्रत्येक रिड्यूसर के पास कॉन्स्टेंट के रूप में अपने स्वयं के एक्शन प्रकार हैं)

हम लाइनिंग पर ऐसी योजना बना रहे हैं कि यह एक उल्लंघन की सूचना देता है यदि समान मूल्य वाले दो स्थिरांक हैं।

अगर कोई सुझाव है, तो कृपया मुझे बताएं :)