( সুইফট ২.x )
জেনেরিক ধরণের পদ্ধতির জন্য নীল-আরপিন্ট সম্বলিত একটি প্রোটোকলের সাথে সামঞ্জস্য রাখতে আপনি অ্যারে প্রসারিত করতে পারেন, যেমন, কোনও প্রকারের সীমাবদ্ধতা অনুসারে সমস্ত জেনেরিক অ্যারে উপাদানগুলির জন্য আপনার কাস্টম ফাংশনাল ইউজযুক্ত একটি প্রোটোকল, বলুন প্রোটোকল MyTypes। এই পদ্ধতির সাহায্যে বোনাসটি হ'ল আপনি জেনেরিক অ্যারে আর্গুমেন্ট গ্রহণ করে ফাংশন লিখতে পারেন, এই সীমাবদ্ধতার সাথে এই অ্যারে আর্গুমেন্টগুলি আপনার কাস্টম ফাংশন ইউটিলিটি প্রোটোকলের সাথে খাপ খায়, প্রোটোকল বলে MyFunctionalUtils।
আপনি এই আচরণটি সুস্পষ্টভাবে পেতে পারেন, অ্যারে উপাদানগুলিকে সীমাবদ্ধ করে টাইপ করে MyTypes, বা --- যেমন আমি নীচে বর্ণিত পদ্ধতিতে দেখাব ---, খুব ঝরঝরে, স্পষ্টভাবে, আপনার জেনেরিক অ্যারে ফাংশন শিরোনামকে সরাসরি ইনপুট অ্যারে প্রদর্শন করতে দেয় অনুসারে MyFunctionalUtils।
প্রোটোকল দিয়ে MyTypesটাইপ সীমাবদ্ধতা হিসাবে ব্যবহারের জন্য আমরা শুরু করি ; এই প্রোটোকল দ্বারা ধরনের আপনি আপনার জেনেরিক্স মাপসই করতে চান প্রসারিত (উদাহরণস্বরূপ নিচের মৌলিক ধরনের প্রসারিত Intএবং Doubleসেইসাথে একটি কাস্টম টাইপ MyCustomType)
/* Used as type constraint for Generator.Element */
protocol MyTypes {
var intValue: Int { get }
init(_ value: Int)
func *(lhs: Self, rhs: Self) -> Self
func +=(inout lhs: Self, rhs: Self)
}
extension Int : MyTypes { var intValue: Int { return self } }
extension Double : MyTypes { var intValue: Int { return Int(self) } }
// ...
/* Custom type conforming to MyTypes type constraint */
struct MyCustomType : MyTypes {
var myInt : Int? = 0
var intValue: Int {
return myInt ?? 0
}
init(_ value: Int) {
myInt = value
}
}
func *(lhs: MyCustomType, rhs: MyCustomType) -> MyCustomType {
return MyCustomType(lhs.intValue * rhs.intValue)
}
func +=(inout lhs: MyCustomType, rhs: MyCustomType) {
lhs.myInt = (lhs.myInt ?? 0) + (rhs.myInt ?? 0)
}
প্রোটোকল MyFunctionalUtils(আমাদের অতিরিক্ত জেনেরিক অ্যারে ফাংশন ইউটিলিটিগুলি ব্লুপ্রিন্টগুলি ধারণ করে) এবং এরপরে, অ্যারের দ্বারা এক্সটেনশন MyFunctionalUtils; নীল-মুদ্রিত পদ্ধতির প্রয়োগ:
/* Protocol holding our function utilities, to be used as extension
o Array: blueprints for utility methods where Generator.Element
is constrained to MyTypes */
protocol MyFunctionalUtils {
func foo<T: MyTypes>(a: [T]) -> Int?
// ...
}
/* Extend array by protocol MyFunctionalUtils and implement blue-prints
therein for conformance */
extension Array : MyFunctionalUtils {
func foo<T: MyTypes>(a: [T]) -> Int? {
/* [T] is Self? proceed, otherwise return nil */
if let b = self.first {
if b is T && self.count == a.count {
var myMultSum: T = T(0)
for (i, sElem) in self.enumerate() {
myMultSum += (sElem as! T) * a[i]
}
return myMultSum.intValue
}
}
return nil
}
}
পরিশেষে, পরীক্ষাগুলি এবং দুটি উদাহরণ যথাক্রমে নিম্নলিখিত কেসগুলির সাথে জেনেরিক অ্যারে গ্রহণ করে একটি ফাংশন দেখায়
দেখানো অন্তর্নিহিত কথন যে অ্যারের পরামিতি প্রোটোকল 'MyFunctionalUtils' সাথে সামঞ্জস্য, টাইপ মাধ্যমে 'MyTypes' (ফাংশন অ্যারে উপাদানের constraining bar1)।
সুস্পষ্টভাবে দেখানো হচ্ছে যে অ্যারে প্যারামিটারগুলি 'মাই ফাংশনাল ইউটিলেস' (ফাংশন bar2) প্রোটোকলের সাথে খাপ খায় ।
পরীক্ষা এবং উদাহরণ নিম্নলিখিত:
/* Tests & examples */
let arr1d : [Double] = [1.0, 2.0, 3.0]
let arr2d : [Double] = [-3.0, -2.0, 1.0]
let arr1my : [MyCustomType] = [MyCustomType(1), MyCustomType(2), MyCustomType(3)]
let arr2my : [MyCustomType] = [MyCustomType(-3), MyCustomType(-2), MyCustomType(1)]
/* constrain array elements to MyTypes, hence _implicitly_ constraining
array parameters to protocol MyFunctionalUtils. However, this
conformance is not apparent just by looking at the function signature... */
func bar1<U: MyTypes> (arr1: [U], _ arr2: [U]) -> Int? {
return arr1.foo(arr2)
}
let myInt1d = bar1(arr1d, arr2d) // -4, OK
let myInt1my = bar1(arr1my, arr2my) // -4, OK
/* constrain the array itself to protocol MyFunctionalUtils; here, we
see directly in the function signature that conformance to
MyFunctionalUtils is given for valid array parameters */
func bar2<T: MyTypes, U: protocol<MyFunctionalUtils, _ArrayType> where U.Generator.Element == T> (arr1: U, _ arr2: U) -> Int? {
// OK, type U behaves as array type with elements T (=MyTypes)
var a = arr1
var b = arr2
a.append(T(2)) // add 2*7 to multsum
b.append(T(7))
return a.foo(Array(b))
/* Ok! */
}
let myInt2d = bar2(arr1d, arr2d) // 10, OK
let myInt2my = bar2(arr1my, arr2my) // 10, OK
extension T[]এক্সকোডে অ্যারে টাইপ করতে কমান্ড-ক্লিক করার সময় একই বিটটি দেখছেন , তবে ত্রুটি না পেয়ে এটি প্রয়োগের কোনও উপায় দেখছেন না।