ಅಭಿವೃದ್ಧಿಪಡಿಸಿದ ಜೆನೆರಿಕ್ ನಿರ್ಬಂಧಗಳು: ಸಂಕೀರ್ಣ ಟೈಪ್ ಸಂಬಂಧಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವುದು

ಜೆನೆರಿಕ್ಸ್ ಅನೇಕ ಆಧುನಿಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ ಒಂದು ಶಕ್ತಿಶಾಲಿ ವೈಶಿಷ್ಟ್ಯವಾಗಿದೆ, ಇದು ಡೆವಲಪರ್‌ಗಳಿಗೆ ಟೈಪ್ ಸುರಕ್ಷತೆಯನ್ನು ತ್ಯಾಗ ಮಾಡದೆ ವಿವಿಧ ಪ್ರಕಾರಗಳೊಂದಿಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಕೋಡ್ ಬರೆಯಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಮೂಲ ಜೆನೆರಿಕ್ಸ್ ತುಲನಾತ್ಮಕವಾಗಿ ನೇರವಾಗಿರWhile, ಅಭಿವೃದ್ಧಿಪಡಿಸಿದ ಜೆನೆರಿಕ್ ನಿರ್ಬಂಧಗಳು ಸಂಕೀರ್ಣ ಟೈಪ್ ಸಂಬಂಧಗಳ ರಚನೆಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತವೆ, ಇದು ಹೆಚ್ಚು ಬಲವಾದ, ಹೊಂದಿಕೊಳ್ಳುವ ಮತ್ತು ನಿರ್ವಹಿಸಬಹುದಾದ ಕೋಡ್‌ಗೆ ಕಾರಣವಾಗುತ್ತದೆ. ಈ ಲೇಖನವು ಅಭಿವೃದ್ಧಿಪಡಿಸಿದ ಜೆನೆರಿಕ್ ನಿರ್ಬಂಧಗಳ ಜಗತ್ತಿನಲ್ಲಿ ಆಳವಾಗಿ ಧುಮುಕುತ್ತದೆ, ವಿಭಿನ್ನ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿನ ಉದಾಹರಣೆಗಳೊಂದಿಗೆ ಅವುಗಳ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಮತ್ತು ಪ್ರಯೋಜನಗಳನ್ನು ಅನ್ವೇಷಿಸುತ್ತದೆ.

ಜೆನೆರಿಕ್ ನಿರ್ಬಂಧಗಳು ಎಂದರೇನು?

ಜೆನೆರಿಕ್ ನಿರ್ಬಂಧಗಳು ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್ ಪೂರೈಸಬೇಕಾದ ಅವಶ್ಯಕತೆಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತವೆ. ಈ ನಿರ್ಬಂಧಗಳನ್ನು ಹೇರುವುದರ ಮೂಲಕ, ನೀವು ಜೆನೆರಿಕ್ ಕ್ಲಾಸ್, ಇಂಟರ್‌ಫೇಸ್ ಅಥವಾ ಮೆಥಡ್‌ನೊಂದಿಗೆ ಬಳಸಬಹುದಾದ ಪ್ರಕಾರಗಳನ್ನು ನಿರ್ಬಂಧಿಸಬಹುದು. ಇದು ನಿಮಗೆ ಹೆಚ್ಚು ವಿಶೇಷ ಮತ್ತು ಟೈಪ್-ಸೇಫ್ ಕೋಡ್ ಬರೆಯಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

ಸರಳ ಪದಗಳಲ್ಲಿ, ವಸ್ತುಗಳನ್ನು ವಿಂಗಡಿಸುವ ಸಾಧನವನ್ನು ನೀವು ರಚಿಸುತ್ತಿದ್ದೀರಿ ಎಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. ವಿಂಗಡಿಸಲಾದ ವಸ್ತುಗಳು ಹೋಲಿಸಬಹುದಾದವು ಎಂದು ನೀವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಬಯಸಬಹುದು, ಅಂದರೆ ಅವುಗಳು ಪರಸ್ಪರ ಸಂಬಂಧದಲ್ಲಿ ಆದೇಶವನ್ನು ಹೊಂದಿರುವ ಮಾರ್ಗವನ್ನು ಹೊಂದಿರುತ್ತವೆ. ಜೆನೆರಿಕ್ ನಿರ್ಬಂಧವು ಈ ಅವಶ್ಯಕತೆಯನ್ನು ಜಾರಿಗೊಳಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ, ಕೇವಲ ಹೋಲಿಸಬಹುದಾದ ಪ್ರಕಾರಗಳು ನಿಮ್ಮ ವಿಂಗಡಣೆ ಸಾಧನದೊಂದಿಗೆ ಬಳಸಲ್ಪಡುತ್ತವೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಮೂಲ ಜೆನೆರಿಕ್ ನಿರ್ಬಂಧಗಳು

ಅಭಿವೃದ್ಧಿಪಡಿಸಿದ ನಿರ್ಬಂಧಗಳಲ್ಲಿ ಮುಳುಗುವ ಮೊದಲು, ಮೂಲಭೂತ ವಿಷಯಗಳನ್ನು ತ್ವರಿತವಾಗಿ ಪರಿಶೀಲಿಸೋಣ. ಸಾಮಾನ್ಯ ನಿರ್ಬಂಧಗಳು ಒಳಗೊಂಡಿರುತ್ತವೆ:

• ಇಂಟರ್‌ಫೇಸ್ ನಿರ್ಬಂಧಗಳು: ಒಂದು ನಿರ್ದಿಷ್ಟ ಇಂಟರ್‌ಫೇಸ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗೆ ಅಗತ್ಯವಿದೆ.
• ಕ್ಲಾಸ್ ನಿರ್ಬಂಧಗಳು: ಒಂದು ನಿರ್ದಿಷ್ಟ ಕ್ಲಾಸ್ ಅನ್ನು ಆನುವಂಶಿಕವಾಗಿ ಪಡೆಯಲು ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗೆ ಅಗತ್ಯವಿದೆ.
• 'new()' ನಿರ್ಬಂಧಗಳು: ಪ್ಯಾರಾಮೀಟರ್‌ಲೆಸ್ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಹೊಂದಲು ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗೆ ಅಗತ್ಯವಿದೆ.
• 'struct' ಅಥವಾ 'class' ನಿರ್ಬಂಧಗಳು: (C# ನಿರ್ದಿಷ್ಟ) ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಮೌಲ್ಯ ಪ್ರಕಾರಗಳಿಗೆ (struct) ಅಥವಾ ಉಲ್ಲೇಖ ಪ್ರಕಾರಗಳಿಗೆ (class) ನಿರ್ಬಂಧಿಸುತ್ತದೆ.

ಉದಾಹರಣೆಗೆ, C# ನಲ್ಲಿ:

            public interface IStorable
{
 string Serialize();
 void Deserialize(string data);
}

public class DataRepository<T> where T : IStorable, new()
{
 public void Save(T item)
 {
 string data = item.Serialize();
 // Save data to storage
 }

 public T Load(string data)
 {
 T item = new T();
 item.Deserialize(data);
 return item;
 }
}

            

              
                Copy
              
            
          

ಇಲ್ಲಿ, `DataRepository` ಕ್ಲಾಸ್ ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್ `T` ನೊಂದಿಗೆ ಜೆನೆರಿಕ್ ಆಗಿದೆ. `where T : IStorable, new()` ನಿರ್ಬಂಧವು `T` `IStorable` ಇಂಟರ್‌ಫೇಸ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕು ಮತ್ತು ಪ್ಯಾರಾಮೀಟರ್‌ಲೆಸ್ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಹೊಂದಿರಬೇಕು ಎಂದು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ. ಇದು `DataRepository` ರಿಗೆ `T` ಪ್ರಕಾರದ ವಸ್ತುಗಳನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ಸೀರಿಯಲೈಸ್ ಮಾಡಲು, ಡೀಸೀರಿಯಲೈಸ್ ಮಾಡಲು ಮತ್ತು ಇನ್‌ಸ್ಟ್ಯಾನ್ಶಿಯೇಟ್ ಮಾಡಲು ಅನುಮತಿಸುತ್ತದೆ.

ಅಭಿವೃದ್ಧಿಪಡಿಸಿದ ಜೆನೆರಿಕ್ ನಿರ್ಬಂಧಗಳು: ಮೂಲಭೂತಗಳಾಚೆಗೆ

ಅಭಿವೃದ್ಧಿಪಡಿಸಿದ ಜೆನೆರಿಕ್ ನಿರ್ಬಂಧಗಳು ಸರಳ ಇಂಟರ್‌ಫೇಸ್ ಅಥವಾ ಕ್ಲಾಸ್ ಇನ್ಹೆರಿಟೆನ್ಸ್‌ಗಿಂತ ಆಚೆಗೆ ಹೋಗುತ್ತವೆ. ಅವು ಪ್ರಕಾರಗಳ ನಡುವಿನ ಸಂಕೀರ್ಣ ಸಂಬಂಧಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತವೆ, ಇದು ಶಕ್ತಿಶಾಲಿ ಟೈಪ್-ಲೆವೆಲ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ತಂತ್ರಗಳಿಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

1. ಅವಲಂಬಿತ ಪ್ರಕಾರಗಳು ಮತ್ತು ಟೈಪ್ ಸಂಬಂಧಗಳು

ಅವಲಂಬಿತ ಪ್ರಕಾರಗಳು ಮೌಲ್ಯಗಳ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿರುವ ಪ್ರಕಾರಗಳು. ಮುಖ್ಯವಾಹಿನಿಯ ಭಾಷೆಗಳಲ್ಲಿ ಸಂಪೂರ್ಣ ಅವಲಂಬಿತ ಟೈಪ್ ಸಿಸ್ಟಮ್‌ಗಳು ತುಲನಾತ್ಮಕವಾಗಿ ಅಪರೂಪವಾಗಿದ್ದರೂ, ಅಭಿವೃದ್ಧಿಪಡಿಸಿದ ಜೆನೆರಿಕ್ ನಿರ್ಬಂಧಗಳು ಅವಲಂಬಿತ ಟೈಪಿಂಗ್‌ನ ಕೆಲವು ಅಂಶಗಳನ್ನು ಅನುಕರಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ಒಂದು ಮೆಥಡ್‌ನ ರಿಟರ್ನ್ ಟೈಪ್ ಇನ್‌ಪುಟ್ ಪ್ರಕಾರವನ್ನು ಅವಲಂಬಿಸಿರುವುದನ್ನು ನೀವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಬಯಸಬಹುದು.

ಉದಾಹರಣೆ: ಡೇಟಾಬೇಸ್ ಪ್ರಶ್ನೆಗಳನ್ನು ರಚಿಸುವ ಫಂಕ್ಷನ್ ಅನ್ನು ಪರಿಗಣಿಸಿ. ರಚಿಸಲಾದ ನಿರ್ದಿಷ್ಟ ಪ್ರಶ್ನೆ ವಸ್ತುವವು ಇನ್‌ಪುಟ್ ಡೇಟಾದ ಪ್ರಕಾರವನ್ನು ಅವಲಂಬಿಸಿರಬೇಕು. ವಿಭಿನ್ನ ಪ್ರಶ್ನೆ ಪ್ರಕಾರಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಲು ನಾವು ಇಂಟರ್‌ಫೇಸ್ ಅನ್ನು ಬಳಸಬಹುದು, ಮತ್ತು ಸರಿಯಾದ ಪ್ರಶ್ನೆ ವಸ್ತುವನ್ನು ಹಿಂತಿರುಗಿಸಲಾಗಿದೆಯೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಟೈಪ್ ನಿರ್ಬಂಧಗಳನ್ನು ಬಳಸಬಹುದು.

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ:

            interface BaseQuery {}

interface UserQuery extends BaseQuery {
 //User specific properties
}

interface ProductQuery extends BaseQuery {
 //Product specific properties
}

function createQuery<T extends { type: 'user' | 'product' }>(config: T): 
 T extends { type: 'user' } ? UserQuery : ProductQuery {
 if (config.type === 'user') {
 return {} as UserQuery; // In real implementation, build the query
 } else {
 return {} as ProductQuery; // In real implementation, build the query
 }
}

const userQuery = createQuery({ type: 'user' }); // type of userQuery is UserQuery
const productQuery = createQuery({ type: 'product' }); // type of productQuery is ProductQuery

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯು ಇನ್‌ಪುಟ್ ಕಾನ್ಫಿಗರೇಶನ್‌ನ `type` ಗುಣಲಕ್ಷಣದ ಆಧಾರದ ಮೇಲೆ ರಿಟರ್ನ್ ಟೈಪ್ ಅನ್ನು ನಿರ್ಧರಿಸಲು ಷರತ್ತುಬದ್ಧ ಪ್ರಕಾರವನ್ನು (`T extends { type: 'user' } ? UserQuery : ProductQuery`) ಬಳಸುತ್ತದೆ. ಇದು ಕಂಪೈಲರ್‌ಗೆ ಹಿಂತಿರುಗಿಸಲಾದ ಪ್ರಶ್ನೆ ವಸ್ತುವಿನ ನಿಖರವಾದ ಪ್ರಕಾರವನ್ನು ತಿಳಿದಿರುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.

2. ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳ ಆಧಾರದ ಮೇಲೆ ನಿರ್ಬಂಧಗಳು

ಒಂದು ಶಕ್ತಿಶಾಲಿ ತಂತ್ರವೆಂದರೆ ಇತರ ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಅವಲಂಬಿಸಿರುವ ನಿರ್ಬಂಧಗಳನ್ನು ರಚಿಸುವುದು. ಇದು ಜೆನೆರಿಕ್ ಕ್ಲಾಸ್ ಅಥವಾ ಮೆಥಡ್‌ನಲ್ಲಿ ಬಳಸುವ ವಿಭಿನ್ನ ಪ್ರಕಾರಗಳ ನಡುವಿನ ಸಂಬಂಧಗಳನ್ನು ವ್ಯಕ್ತಪಡಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ: ಡೇಟಾವನ್ನು ಒಂದು ಸ್ವರೂಪದಿಂದ ಇನ್ನೊಂದಕ್ಕೆ ಪರಿವರ್ತಿಸುವ ಡೇಟಾ ಮ್ಯಾಪರ್ ಅನ್ನು ನೀವು ನಿರ್ಮಿಸುತ್ತಿದ್ದೀರಿ ಎಂದು ಹೇಳೋಣ. ನೀವು `TInput` ಎಂಬ ಇನ್‌ಪುಟ್ ಟೈಪ್ ಮತ್ತು `TOutput` ಎಂಬ ಔಟ್‌ಪುಟ್ ಟೈಪ್ ಅನ್ನು ಹೊಂದಿರಬಹುದು. `TInput` ನಿಂದ `TOutput` ಗೆ ಪರಿವರ್ತಿಸಬಹುದಾದ ಮ್ಯಾಪರ್ ಫಂಕ್ಷನ್ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ಎಂದು ನೀವು ಜಾರಿಗೊಳಿಸಬಹುದು.

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ:

            interface Mapper<TInput, TOutput> {
 map(input: TInput): TOutput;
}

function transform<TInput, TOutput, TMapper extends Mapper<TInput, TOutput>>(
 input: TInput,
 mapper: TMapper
): TOutput {
 return mapper.map(input);
}

class User {
 name: string;
 age: number;
}

class UserDTO {
 fullName: string;
 years: number;
}

class UserToUserDTOMapper implements Mapper<User, UserDTO> {
 map(user: User): UserDTO {
 return { fullName: user.name, years: user.age };
 }
}

const user = { name: 'John Doe', age: 30 };
const mapper = new UserToUserDTOMapper();
const userDTO = transform(user, mapper); // type of userDTO is UserDTO

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, `transform` ಎಂಬುದು `TInput` ಪ್ರಕಾರದ ಇನ್‌ಪುಟ್ ಮತ್ತು `TMapper` ಪ್ರಕಾರದ ಮ್ಯಾಪರ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುವ ಜೆನೆರಿಕ್ ಫಂಕ್ಷನ್ ಆಗಿದೆ. `TMapper extends Mapper<TInput, TOutput>` ನಿರ್ಬಂಧವು ಮ್ಯಾಪರ್ `TInput` ನಿಂದ `TOutput` ಗೆ ಸರಿಯಾಗಿ ಪರಿವರ್ತಿಸಬಹುದು ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಇದು ಪರಿವರ್ತನೆ ಪ್ರಕ್ರಿಯೆಯ ಸಮಯದಲ್ಲಿ ಟೈಪ್ ಸುರಕ್ಷತೆಯನ್ನು ಜಾರಿಗೊಳಿಸುತ್ತದೆ.

3. ಜೆನೆರಿಕ್ ಮೆಥಡ್‌ಗಳ ಆಧಾರದ ಮೇಲೆ ನಿರ್ಬಂಧಗಳು

ಜೆನೆರಿಕ್ ಮೆಥಡ್‌ಗಳು ಮೆಥಡ್‌ನಲ್ಲಿ ಬಳಸುವ ಪ್ರಕಾರಗಳನ್ನು ಅವಲಂಬಿಸಿರುವ ನಿರ್ಬಂಧಗಳನ್ನು ಸಹ ಹೊಂದಬಹುದು. ಇದು ವಿಭಿನ್ನ ಟೈಪ್ ಸನ್ನಿವೇಶಗಳಿಗೆ ಹೆಚ್ಚು ವಿಶೇಷ ಮತ್ತು ಅಳವಡಿಸಿಕೊಳ್ಳಬಹುದಾದ ಮೆಥಡ್‌ಗಳನ್ನು ರಚಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ: ವಿಭಿನ್ನ ಪ್ರಕಾರಗಳ ಎರಡು ಸಂಗ್ರಹಗಳನ್ನು ಒಂದೇ ಸಂಗ್ರಹವಾಗಿ ಸಂಯೋಜಿಸುವ ಮೆಥಡ್ ಅನ್ನು ಪರಿಗಣಿಸಿ. ನೀವು ಎರಡೂ ಇನ್‌ಪುಟ್ ಪ್ರಕಾರಗಳು ಕೆಲವು ರೀತಿಯಲ್ಲಿ ಹೊಂದಾಣಿಕೆಯಾಗುತ್ತವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಬಯಸಬಹುದು.

C# ನಲ್ಲಿ:

            public interface ICombinable<T>
{
 T Combine(T other);
}

public static class CollectionExtensions
{
 public static IEnumerable<TResult> CombineCollections<T1, T2, TResult>(
 this IEnumerable<T1> collection1,
 IEnumerable<T2> collection2,
 Func<T1, T2, TResult> combiner) 
 {
 foreach (var item1 in collection1)
 {
 foreach (var item2 in collection2)
 {
 yield return combiner(item1, item2);
 }
 }
 }
}

// Example usage
List<int> numbers = new List<int> { 1, 2, 3 };
List<string> strings = new List<string> { "a", "b", "c" };

var combined = numbers.CombineCollections(strings, (number, str) => number.ToString() + str);

// combined will be IEnumerable<string> containing: "1a", "1b", "1c", "2a", "2b", "2c", "3a", "3b", "3c"

            

              
                Copy
              
            
          

ಇಲ್ಲಿ, ನೇರ ನಿರ್ಬಂಧವಿಲ್ಲದಿದ್ದರೂ, `Func<T1, T2, TResult> combiner` ಪ್ಯಾರಾಮೀಟರ್ ನಿರ್ಬಂಧದಂತೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಇದು `T1` ಮತ್ತು `T2` ಅನ್ನು ತೆಗೆದುಕೊಂಡು `TResult` ಅನ್ನು ಉತ್ಪಾದಿಸುವ ಫಂಕ್ಷನ್ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ಎಂದು ನಿರ್ದೇಶಿಸುತ್ತದೆ. ಇದು ಸಂಯೋಜನೆ ಕಾರ್ಯಾಚರಣೆಯು ಉತ್ತಮವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಲ್ಪಟ್ಟಿದೆ ಮತ್ತು ಟೈಪ್-ಸೇಫ್ ಆಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

4. ಹೈಯರ್-ಕೈಂಡೆಡ್ ಟೈಪ್ಸ್ (ಮತ್ತು ಅವುಗಳ ಸಿಮ್ಯುಲೇಶನ್)

ಹೈಯರ್-ಕೈಂಡೆಡ್ ಟೈಪ್ಸ್ (HKTs) ಎಂದರೆ ಇತರ ಪ್ರಕಾರಗಳನ್ನು ಪ್ಯಾರಾಮೀಟರ್‌ಗಳಾಗಿ ತೆಗೆದುಕೊಳ್ಳುವ ಪ್ರಕಾರಗಳು. ಜಾವಾ ಅಥವಾ ಸಿ# ನಂತಹ ಭಾಷೆಗಳಲ್ಲಿ ನೇರವಾಗಿ ಬೆಂಬಲಿಸದಿದ್ದರೂ, ಜೆನೆರಿಕ್ಸ್ ಬಳಸಿ ಇದೇ ರೀತಿಯ ಪರಿಣಾಮಗಳನ್ನು ಸಾಧಿಸಲು ಮಾದರಿಗಳನ್ನು ಬಳಸಬಹುದು. ಇದು ಪಟ್ಟಿಗಳು, ಆಯ್ಕೆಗಳು ಅಥವಾ ಫ್ಯೂಚರ್‌ಗಳಂತಹ ವಿಭಿನ್ನ ಕಂಟೈನರ್ ಪ್ರಕಾರಗಳ ಮೇಲೆ ಅಬ್‌ಸ್ಟ್ರಾಕ್ಟಿಂಗ್ ಮಾಡಲು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ.

ಉದಾಹರಣೆ: ಕಂಟೈನರ್‌ನ ಪ್ರತಿ ಅಂಶಕ್ಕೆ ಫಂಕ್ಷನ್ ಅನ್ನು ಅನ್ವಯಿಸುವ `traverse` ಫಂಕ್ಷನ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು ಮತ್ತು ಫಲಿತಾಂಶಗಳನ್ನು ಅದೇ ಪ್ರಕಾರದ ಹೊಸ ಕಂಟೈನರ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸುವುದು.

ಜಾವಾದಲ್ಲಿ (ಇಂಟರ್‌ಫೇಸ್‌ಗಳೊಂದಿಗೆ HKT ಗಳನ್ನು ಸಿಮ್ಯುಲೇಟ್ ಮಾಡುವುದು):

            interface Container<T, C extends Container<T, C>> {
 <R> C map(Function<T, R> f);
}

class ListContainer<T> implements Container<T, ListContainer<T>> {
 private final List<T> list;

 public ListContainer(List<T> list) {
 this.list = list;
 }

 @Override
 public <R> ListContainer<R> map(Function<T, R> f) {
 List<R> newList = new ArrayList<>();
 for (T element : list) {
 newList.add(f.apply(element));
 }
 return new ListContainer<>(newList);
 }
}

interface Function<T, R> {
 R apply(T t);
}

// Usage
List<Integer> numbers = Arrays.asList(1, 2, 3);
ListContainer<Integer> numberContainer = new ListContainer<>(numbers);
ListContainer<String> stringContainer = numberContainer.map(i -> "Number: " + i);

            

              
                Copy
              
            
          

`Container` ಇಂಟರ್‌ಫೇಸ್ ಜೆನೆರಿಕ್ ಕಂಟೈನರ್ ಪ್ರಕಾರವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಸ್ವಯಂ-ಉಲ್ಲೇಖಿತ ಜೆನೆರಿಕ್ ಪ್ರಕಾರ `C extends Container<T, C>` ಹೈಯರ್-ಕೈಂಡೆಡ್ ಪ್ರಕಾರವನ್ನು ಸಿಮ್ಯುಲೇಟ್ ಮಾಡುತ್ತದೆ, `map` ಮೆಥಡ್ ಅದೇ ಪ್ರಕಾರದ ಕಂಟೈನರ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಈ ವಿಧಾನವು ಕಂಟೈನರ್ ರಚನೆಯನ್ನು ನಿರ್ವಹಿಸಲು ಟೈಪ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ಬಳಸಿಕೊಳ್ಳುತ್ತದೆ, ಆದರೆ ಒಳಗಿನ ಅಂಶಗಳನ್ನು ಪರಿವರ್ತಿಸುತ್ತದೆ.

5. ಷರತ್ತುಬದ್ಧ ಪ್ರಕಾರಗಳು ಮತ್ತು ಮ್ಯಾಪ್ಡ್ ಪ್ರಕಾರಗಳು

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಂತಹ ಭಾಷೆಗಳು ಷರತ್ತುಬದ್ಧ ಪ್ರಕಾರಗಳು ಮತ್ತು ಮ್ಯಾಪ್ಡ್ ಪ್ರಕಾರಗಳಂತಹ ಹೆಚ್ಚು ಅತ್ಯಾಧುನಿಕ ಟೈಪ್ ಮ್ಯಾನಿಪ್ಯುಲೇಶನ್ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ನೀಡುತ್ತವೆ. ಈ ವೈಶಿಷ್ಟ್ಯಗಳು ಜೆನೆರಿಕ್ ನಿರ್ಬಂಧಗಳ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಹೆಚ್ಚಿಸುತ್ತವೆ.

ಉದಾಹರಣೆ: ನಿರ್ದಿಷ್ಟ ಪ್ರಕಾರದ ಆಧಾರದ ಮೇಲೆ ವಸ್ತುವಿನ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಹೊರತೆಗೆಯುವ ಫಂಕ್ಷನ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು.

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ:

            type PickByType<T, ValueType> = {
 [Key in keyof T as T[Key] extends ValueType ? Key : never]: T[Key];
};

interface Person {
 name: string;
 age: number;
 address: string;
 isEmployed: boolean;
}

type StringProperties = PickByType<Person, string>; // { name: string; address: string; }

const person: Person = {
 name: "Alice",
 age: 30,
 address: "123 Main St",
 isEmployed: true,
};

const stringProps: StringProperties = {
 name: person.name,
 address: person.address,
};

            

              
                Copy
              
            
          

ಇಲ್ಲಿ, `PickByType` ಎಂಬುದು `T` ಪ್ರಕಾರದ ಗುಣಲಕ್ಷಣಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸುವ ಮ್ಯಾಪ್ಡ್ ಪ್ರಕಾರವಾಗಿದೆ. ಪ್ರತಿ ಗುಣಲಕ್ಷಣಕ್ಕೆ, ಅದು ಗುಣಲಕ್ಷಣದ ಪ್ರಕಾರ `ValueType` ಅನ್ನು ವಿಸ್ತರಿಸುತ್ತದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಹಾಗಿದ್ದರೆ, ಗುಣಲಕ್ಷಣವನ್ನು ಫಲಿತಾಂಶದ ಪ್ರಕಾರದಲ್ಲಿ ಸೇರಿಸಲಾಗುತ್ತದೆ; ಇಲ್ಲದಿದ್ದರೆ, `never` ಬಳಸಿ ಅದನ್ನು ಹೊರಗಿಡಲಾಗುತ್ತದೆ. ಇದು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಪ್ರಕಾರಗಳ ಗುಣಲಕ್ಷಣಗಳ ಆಧಾರದ ಮೇಲೆ ಹೊಸ ಪ್ರಕಾರಗಳನ್ನು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ರಚಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಅಭಿವೃದ್ಧಿಪಡಿಸಿದ ಜೆನೆರಿಕ್ ನಿರ್ಬಂಧಗಳ ಪ್ರಯೋಜನಗಳು

ಅಭಿವೃದ್ಧಿಪಡಿಸಿದ ಜೆನೆರಿಕ್ ನಿರ್ಬಂಧಗಳನ್ನು ಬಳಸುವುದರಿಂದ ಹಲವಾರು ಪ್ರಯೋಜನಗಳಿವೆ:

• ವರ್ಧಿತ ಟೈಪ್ ಸುರಕ್ಷತೆ: ಟೈಪ್ ಸಂಬಂಧಗಳನ್ನು ನಿಖರವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸುವ ಮೂಲಕ, ರನ್‌ಟೈಮ್‌ನಲ್ಲಿ ಮಾತ್ರ ಕಂಡುಬರುವ ದೋಷಗಳನ್ನು ಕಂಪೈಲ್ ಸಮಯದಲ್ಲಿ ನೀವು ಹಿಡಿಯಬಹುದು.
• ಸುಧಾರಿತ ಕೋಡ್ ಪುನರ್ಬಳಕೆ: ಜೆನೆರಿಕ್ಸ್ ಟೈಪ್ ಸುರಕ್ಷತೆಯನ್ನು ತ್ಯಾಗ ಮಾಡದೆ ವಿವಿಧ ಪ್ರಕಾರಗಳೊಂದಿಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಕೋಡ್ ಬರೆಯಲು ಅನುಮತಿಸುವ ಮೂಲಕ ಕೋಡ್ ಪುನರ್ಬಳಕೆಯನ್ನು ಉತ್ತೇಜಿಸುತ್ತದೆ.
• ವರ್ಧಿತ ಕೋಡ್ ನಮ್ಯತೆ: ಅಭಿವೃದ್ಧಿಪಡಿಸಿದ ನಿರ್ಬಂಧಗಳು ಹೆಚ್ಚು ಹೊಂದಿಕೊಳ್ಳುವ ಮತ್ತು ಅಳವಡಿಸಿಕೊಳ್ಳಬಹುದಾದ ಕೋಡ್ ಅನ್ನು ರಚಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತವೆ, ಇದು ವ್ಯಾಪಕ ಶ್ರೇಣಿಯ ಸನ್ನಿವೇಶಗಳನ್ನು ನಿರ್ವಹಿಸಬಹುದು.
• ಉತ್ತಮ ಕೋಡ್ ನಿರ್ವಹಣೆ: ಟೈಪ್-ಸೇಫ್ ಕೋಡ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ಮರುರೂಪಿಸಲು ಮತ್ತು ಕಾಲಾನಂತರದಲ್ಲಿ ನಿರ್ವಹಿಸಲು ಸುಲಭವಾಗಿದೆ.
• ವ್ಯಕ್ತಪಡಿಸುವ ಶಕ್ತಿ: ಅವುಗಳಿಲ್ಲದಿದ್ದರೆ ಅಸಾಧ್ಯವಾದ (ಅಥವಾ ಕನಿಷ್ಠ ಬಹಳ ಕ್ಲಿಷ್ಟಕರವಾದ) ಸಂಕೀರ್ಣ ಟೈಪ್ ಸಂಬಂಧಗಳನ್ನು ವಿವರಿಸುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಅವು ಅನ್‌ಲಾಕ್ ಮಾಡುತ್ತವೆ.

ಸವಾಲುಗಳು ಮತ್ತು ಪರಿಗಣನೆಗಳು

ಶಕ್ತಿಶಾಲಿಯಾಗಿದ್ದರೂ, ಅಭಿವೃದ್ಧಿಪಡಿಸಿದ ಜೆನೆರಿಕ್ ನಿರ್ಬಂಧಗಳು ಸವಾಲುಗಳನ್ನು ಸಹ ಪರಿಚಯಿಸಬಹುದು:

• ವರ್ಧಿತ ಸಂಕೀರ್ಣತೆ: ಅಭಿವೃದ್ಧಿಪಡಿಸಿದ ನಿರ್ಬಂಧಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಟೈಪ್ ಸಿಸ್ಟಮ್ ಬಗ್ಗೆ ಆಳವಾದ ತಿಳುವಳಿಕೆ ಅಗತ್ಯವಿದೆ.
• ಕಠಿಣ ಕಲಿಕೆ ಬಲ: ಈ ತಂತ್ರಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳಲು ಸಮಯ ಮತ್ತು ಶ್ರಮ ಬೇಕಾಗಬಹುದು.
• ಅತಿಯಾದ ಎಂಜಿನಿಯರಿಂಗ್ ಸಂಭವನೀಯತೆ: ಈ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ವಿವೇಚನೆಯಿಂದ ಬಳಸುವುದು ಮತ್ತು ಅನಗತ್ಯ ಸಂಕೀರ್ಣತೆಯನ್ನು ತಪ್ಪಿಸುವುದು ಮುಖ್ಯವಾಗಿದೆ.
• ಕಂಪೈಲರ್ ಕಾರ್ಯಕ್ಷಮತೆ: ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ, ಸಂಕೀರ್ಣ ಟೈಪ್ ನಿರ್ಬಂಧಗಳು ಕಂಪೈಲರ್ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಪರಿಣಾಮ ಬೀರಬಹುದು.

ವಾಸ್ತವ ಪ್ರಪಂಚದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು

ಅಭಿವೃದ್ಧಿಪಡಿಸಿದ ಜೆನೆರಿಕ್ ನಿರ್ಬಂಧಗಳು ವಿವಿಧ ವಾಸ್ತವ ಪ್ರಪಂಚದ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಉಪಯುಕ್ತವಾಗಿವೆ:

• ಡೇಟಾ ಆಕ್ಸೆಸ್ ಲೇಯರ್‌ಗಳು (DALs): ಟೈಪ್-ಸೇಫ್ ಡೇಟಾ ಆಕ್ಸೆಸ್‌ನೊಂದಿಗೆ ಜೆನೆರಿಕ್ ರೆಪೋಸಿಟರಿಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು.
• ಆಬ್ಜೆಕ್ಟ್-ರಿಲೇಶನಲ್ ಮ್ಯಾಪರ್‌ಗಳು (ORMs): ಡೇಟಾಬೇಸ್ ಟೇಬಲ್‌ಗಳು ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ ವಸ್ತುಗಳ ನಡುವಿನ ಟೈಪ್ ಮ್ಯಾಪಿಂಗ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು.
• ಡೊಮೈನ್-ಡ್ರಿವಿನ್ ಡಿಸೈನ್ (DDD): ಡೊಮೈನ್ ಮಾದರಿಗಳ ಸಮಗ್ರತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಟೈಪ್ ನಿರ್ಬಂಧಗಳನ್ನು ಜಾರಿಗೊಳಿಸುವುದು.
• ಫ್ರೇಮ್‌ವರ್ಕ್ ಅಭಿವೃದ್ಧಿ: ಸಂಕೀರ್ಣ ಟೈಪ್ ಸಂಬಂಧಗಳೊಂದಿಗೆ ಪುನರ್ಬಳಕೆ ಮಾಡಬಹುದಾದ ಘಟಕಗಳನ್ನು ನಿರ್ಮಿಸುವುದು.
• UI ಲೈಬ್ರರಿಗಳು: ವಿಭಿನ್ನ ಡೇಟಾ ಪ್ರಕಾರಗಳೊಂದಿಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಅಳವಡಿಸಿಕೊಳ್ಳಬಹುದಾದ UI ಘಟಕಗಳನ್ನು ರಚಿಸುವುದು.
• API ವಿನ್ಯಾಸ: ವಿಭಿನ್ನ ಸೇವಾ ಇಂಟರ್‌ಫೇಸ್‌ಗಳ ನಡುವೆ ಡೇಟಾ ಸ್ಥಿರತೆಯನ್ನು ಖಾತರಿಪಡಿಸುವುದು, IDL (ಇಂಟರ್‌ಫೇಸ್ ಡೆಫಿನಿಷನ್ ಲ್ಯಾಂಗ್ವೇಜ್) ಪರಿಕರಗಳನ್ನು ಬಳಸಿಕೊಂಡು, ಭಾಷೆಗಳ ಅಡೆತಡೆಗಳನ್ನು ದಾಟುವ ಸಾಧ್ಯತೆ, ಇದು ಟೈಪ್ ಮಾಹಿತಿಯನ್ನು ಬಳಸಿಕೊಳ್ಳುತ್ತದೆ.

ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

ಅಭಿವೃದ್ಧಿಪಡಿಸಿದ ಜೆನೆರಿಕ್ ನಿರ್ಬಂಧಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬಳಸಲು ಇಲ್ಲಿ ಕೆಲವು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು:

• ಸರಳವಾಗಿ ಪ್ರಾರಂಭಿಸಿ: ಮೂಲ ನಿರ್ಬಂಧಗಳೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಿ ಮತ್ತು ಅಗತ್ಯವಿರುವಂತೆ ಹೆಚ್ಚು ಸಂಕೀರ್ಣ ನಿರ್ಬಂಧಗಳನ್ನು ಕ್ರಮೇಣ ಪರಿಚಯಿಸಿ.
• ಸಂಪೂರ್ಣವಾಗಿ ದಾಖಲಿಸಿ: ನಿಮ್ಮ ನಿರ್ಬಂಧಗಳ ಉದ್ದೇಶ ಮತ್ತು ಬಳಕೆಯನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ದಾಖಲಿಸಿ.
• ಕಟ್ಟುನಿಟ್ಟಾಗಿ ಪರೀಕ್ಷಿಸಿ: ನಿಮ್ಮ ನಿರ್ಬಂಧಗಳು ನಿರೀಕ್ಷಿತವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಸಮಗ್ರ ಪರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯಿರಿ.
• ಓದುವಿಕೆಯನ್ನು ಪರಿಗಣಿಸಿ: ಕೋಡ್ ಓದುವಿಕೆಗೆ ಆದ್ಯತೆ ನೀಡಿ ಮತ್ತು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಕಷ್ಟಕರವಾದ ಅತಿಯಾದ ಸಂಕೀರ್ಣ ನಿರ್ಬಂಧಗಳನ್ನು ತಪ್ಪಿಸಿ.
• ನಮ್ಯತೆ ಮತ್ತು ನಿರ್ದಿಷ್ಟತೆಯನ್ನು ಸಮತೋಲನಗೊಳಿಸಿ: ಹೊಂದಿಕೊಳ್ಳುವ ಕೋಡ್ ರಚಿಸುವಿಕೆ ಮತ್ತು ನಿರ್ದಿಷ್ಟ ಟೈಪ್ ಅವಶ್ಯಕತೆಗಳನ್ನು ಜಾರಿಗೊಳಿಸುವ ನಡುವೆ ಸಮತೋಲನವನ್ನು ಸಾಧಿಸಲು ಪ್ರಯತ್ನಿಸಿ.
• ಸೂಕ್ತವಾದ ಸಾಧನಗಳನ್ನು ಬಳಸಿ: ಸ್ಟಾಟಿಕ್ ವಿಶ್ಲೇಷಣಾ ಸಾಧನಗಳು ಮತ್ತು ಲೀಂಟರ್‌ಗಳು ಸಂಕೀರ್ಣ ಜೆನೆರಿಕ್ ನಿರ್ಬಂಧಗಳೊಂದಿಗೆ ಸಂಭವನೀಯ ಸಮಸ್ಯೆಗಳನ್ನು ಗುರುತಿಸುವಲ್ಲಿ ಸಹಾಯ ಮಾಡಬಹುದು.

ತೀರ್ಮಾನ

ಅಭಿವೃದ್ಧಿಪಡಿಸಿದ ಜೆನೆರಿಕ್ ನಿರ್ಬಂಧಗಳು ಬಲವಾದ, ಹೊಂದಿಕೊಳ್ಳುವ ಮತ್ತು ನಿರ್ವಹಿಸಬಹುದಾದ ಕೋಡ್ ನಿರ್ಮಿಸಲು ಒಂದು ಶಕ್ತಿಶಾಲಿ ಸಾಧನವಾಗಿದೆ. ಈ ತಂತ್ರಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮತ್ತು ಅನ್ವಯಿಸುವ ಮೂಲಕ, ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯ ಟೈಪ್ ಸಿಸ್ಟಮ್‌ನ ಪೂರ್ಣ ಸಾಮರ್ಥ್ಯವನ್ನು ನೀವು ಅನ್‌ಲಾಕ್ ಮಾಡಬಹುದು. ಅವು ಸಂಕೀರ್ಣತೆಯನ್ನು ಪರಿಚಯಿಸಬಹುದಾದರೂ, ವರ್ಧಿತ ಟೈಪ್ ಸುರಕ್ಷತೆ, ಸುಧಾರಿತ ಕೋಡ್ ಪುನರ್ಬಳಕೆ ಮತ್ತು ಹೆಚ್ಚಿದ ನಮ್ಯತೆಯ ಪ್ರಯೋಜನಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಸವಾಲುಗಳನ್ನು ಮೀರಿಸುತ್ತವೆ. ನೀವು ಜೆನೆರಿಕ್ಸ್ ಅನ್ನು ಅನ್ವೇಷಿಸುವುದನ್ನು ಮತ್ತು ಪ್ರಯೋಗಿಸುವುದನ್ನು ಮುಂದುವರಿಸುವಾಗ, ಈ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸಂಕೀರ್ಣ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಲು ಹೊಸ ಮತ್ತು ಸೃಜನಾತ್ಮಕ ಮಾರ್ಗಗಳನ್ನು ನೀವು ಕಂಡುಕೊಳ್ಳುತ್ತೀರಿ.

ಸವಾಲನ್ನು ಸ್ವೀಕರಿಸಿ, ಉದಾಹರಣೆಗಳಿಂದ ಕಲಿಯಿರಿ ಮತ್ತು ಅಭಿವೃದ್ಧಿಪಡಿಸಿದ ಜೆನೆರಿಕ್ ನಿರ್ಬಂಧಗಳ ಬಗ್ಗೆ ನಿಮ್ಮ ತಿಳುವಳಿಕೆಯನ್ನು ನಿರಂತರವಾಗಿ ಪರಿಷ್ಕರಿಸಿ. ನಿಮ್ಮ ಕೋಡ್ ಅದಕ್ಕಾಗಿ ನಿಮಗೆ ಧನ್ಯವಾದ ಹೇಳುತ್ತದೆ!