Opaque Type: Swift میں some اور any کیا ہے

مصنف: IT Sectr اشاعت: 2026-06-18 مطالعے کا وقت: 11 منٹ

Opaque Type (نیم شفاف نوع) Swift کا ایک ایسا طریقہ کار ہے جو کسی فنکشن کو کسی خاص قسم کی قدر واپس کرنے کی اجازت دیتا ہے، بغیر کال کرنے والے کوڈ کو حقیقی قسم ظاہر کیے۔ واپسی کی قسم میں کلیدی لفظ some سب سے مشہور مثال ہے: SwiftUI میں some View کا مطلب ہے "کوئی ایسی قسم واپس آتی ہے جو View سے مطابقت رکھتی ہے، لیکن بالکل کون سی — یہ نفاذ کی تفصیل ہے"۔ Opaque type قسم کی شناخت برقرار رکھتا ہے (پروٹوکول کو قسم کے طور پر استعمال کرنے کے برعکس)، جس سے کمپائلر کوڈ کو بہتر بنا سکتا ہے اور واپسی کی قسم کی مستقل مزاجی کو یقینی بناتا ہے۔ Swift Book, 2025 کے مطابق، opaque types ایسوسی ایٹڈ ٹائپس والے پروٹوکولز کا مسئلہ حل کرتے ہیں، جس سے ایسے پروٹوکولز کی اقدار کو فنکشنز سے واپس کرنا ممکن ہوتا ہے۔

اہم نکات

  • Opaque Type — واپسی کی قسم جو حقیقی نفاذ کو کال کرنے والے کوڈ سے چھپاتی ہے
  • some — واپسی کی پوزیشن میں opaque type اعلان کرنے کے لیے کلیدی لفظ
  • قسم کی شناخت برقرار رہتی ہے: کمپائلر حقیقی قسم جانتا ہے، any کے برعکس
  • SwiftUI body اعلان کرنے کے معیاری طریقے کے طور پر some View استعمال کرتا ہے
  • محدودیت: some والے فنکشن کو تمام شاخوں سے ایک ہی حقیقی قسم واپس کرنی چاہیے

Swift میں Opaque Type کیا ہے؟

Opaque Type — یہ ایک واپسی کی قسم ہے جسے کلیدی لفظ some کے ساتھ اعلان کیا جاتا ہے، اور یہ حقیقی نفاذ کو کال کرنے والے کوڈ سے چھپاتی ہے۔ کال کرنے والی طرف صرف یہ جانتی ہے کہ واپس آنے والی قدر کسی خاص پروٹوکول سے مطابقت رکھتی ہے، لیکن یہ نہیں جانتی کہ some کے پیچھے بالکل کون سی قسم ہے۔ اس کے ساتھ ہی کمپائلر حقیقی قسم جانتا ہے اور اسے جامد تقسیم (static dispatch) اور اصلاح کے لیے استعمال کرتا ہے۔

وہ مسئلہ جو Opaque Type حل کرتا ہے

Swift 5.1 (SE-0244) میں opaque types کے آنے سے پہلے، ایسوسی ایٹڈ ٹائپس والے پروٹوکول کو فنکشن سے واپس کرنا boxing-ریپر کے بغیر ناممکن تھا۔ مثلاً، Equatable پروٹوکول میں ایسوسی ایٹڈ ٹائپ ہے، اور فنکشن صرف Equatable واپس نہیں کر سکتا تھا — کمپائلر غلطی دیتا تھا "protocol can only be used as a generic constraint"۔ Opaque type نے یہ مسئلہ حل کر دیا۔

swift
func makeInt() -> some Equatable {
    return 42
}

func makeString() -> some Equatable {
    return "Hello"
}

// کمپائلر جانتا ہے کہ makeInt Int واپس کرتا ہے
// makeInt() == makeString() — ❌ غلطی، مختلف قسمیں

دونوں فنکشن some Equatable واپس کرتے ہیں، لیکن حقیقی قسمیں مختلف ہیں: Int اور String۔ انہیں == کے ذریعے موازنہ کرنے کی کوشش کمپائل کی غلطی کا سبب بنے گی، کیونکہ opaque type اس بات کی ضمانت دیتا ہے کہ کسی ایک کال سے ایک ہی قسم واپس آتی ہے، لیکن مختلف فنکشنز کے درمیان نہیں۔ یہ ایک خصوصیت ہے، بگ نہیں: opaque type قسم کی شناخت وہاں برقرار رکھتا ہے جہاں پروٹوکول بطور قسم (any Equatable) اسے کھو دیتا ہے۔

Opaque Type بمقابلہ Generic: فرق کیا ہے

Generic اور Opaque Type ایک ہی سکے کے دو رخ ہیں۔ Generic کال کرنے والے کوڈ کو قسم منتخب کرنے کی اجازت دیتا ہے، جبکہ opaque type فنکشن کو قسم کو کال کرنے والے کوڈ سے چھپانے کی اجازت دیتا ہے۔ فرق کنٹرول کی سمت میں ہے۔

خصوصیتGeneric Opaque some
قسم کون منتخب کرتا ہےکال کرنے والا کوڈفنکشن/طریقہ
قسم کی شناختبرقرار رہتی ہے (مستحکم)برقرار رہتی ہے (مستحکم)
return کی شاخوں کی تعدادایک (generic کے ذریعے)تمام شاخوں میں ایک ہی قسم
استعمالالگورتھم، ڈیٹا ڈھانچےSwiftUI، فیکٹری طریقے

Generic — انتخاب باہر سے

generic-فنکشن میں caller فیصلہ کرتا ہے کہ کون سی قسم استعمال کرنی ہے۔ فنکشن کو کسی بھی T کے ساتھ کام کرنا چاہیے جو پابندیوں کو پورا کرتا ہو۔ opaque type کے لیے caller حقیقی قسم نہیں جانتا — فیصلہ نفاذ کرتا ہے۔

swift
// Generic: caller قسم منتخب کرتا ہے
func identity<T>(_ value: T) -> T { value }
let x: Int = identity(42)

// Opaque: فنکشن قسم چھپاتا ہے
func makeSomeEquatable() -> some Equatable { 42 }
let y = makeSomeEquatable()

generic اور opaque type کے درمیان انتخاب نیت پر منحصر ہے۔ اگر کال کرنے والے کوڈ کو قسم منتخب کرنی ہے — تو generic استعمال کریں۔ اگر فنکشن کو نفاذ کی تفصیلات چھپانی ہیں — تو some استعمال کریں۔ SwiftUI نے some View کا انتخاب اس لیے کیا کیونکہ body اندر سے لچکدار، لیکن باہر سے مستحکم ہونا چاہیے۔

کلیدی لفظ some اور اس کا استعمال

some Swift کا کلیدی لفظ ہے، جو Swift 5.1 (SE-0244) میں متعارف ہوا۔ یہ واپسی کی پوزیشن میں opaque type اعلان کرنے کے لیے استعمال ہوتا ہے، نیز پیرامیٹرز (SE-0341) اور پراپرٹیز میں بھی۔ some اس بات کی ضمانت دیتا ہے کہ حقیقی قسم مستحکم ہے اور کمپائلر کو معلوم ہے، لیکن بیرونی کوڈ سے چھپی ہوئی ہے۔

فنکشن کے پیرامیٹرز میں some

Swift 5.7 سے، some کو نہ صرف واپسی کی پوزیشن بلکہ پیرامیٹرز میں بھی استعمال کیا جا سکتا ہے۔ پیرامیٹر میں some Equatable کا مطلب ہے "یہ فنکشن کوئی بھی Equatable قسم قبول کرتا ہے، لیکن کسی ایک جسم کے اندر تمام کالز ایک ہی قسم دیکھتی ہیں"۔

swift
func areEqual(_ a: some Equatable, _ b: some Equatable) -> Bool {
    // a اور b — ممکنہ طور پر مختلف قسمیں، == براہ راست کام نہیں کرے گا
    return isEqual(a, b)
}

func isEqual<T: Equatable>(_ a: T, _ b: T) -> Bool {
    return a == b
}

پیرامیٹرز میں some کا استعمال کے مقابلے میں زیادہ مختصر نحو دیتا ہے۔ یہ پروٹوکول اور پروٹوکول-مرکوز ڈیزائن میں خاص طور پر مفید ہے، جہاں پروٹوکول کے ہر استعمال کے لیے علیحدہ generic-پیرامیٹر کی ضرورت نہیں ہوتی۔ کمپائلر پردے کے پیچھے some-پیرامیٹرز کو generic میں تبدیل کرتا ہے، لہٰذا کارکردگی یکساں ہے۔

کلیدی لفظ any اور existential-قسمیں

any Swift 5.6+ کا کلیدی لفظ ہے جو existential-قسمیں (پروٹوکول بطور قسم) واضح طور پر اعلان کرنے کے لیے استعمال ہوتا ہے۔ some کے برعکس، any قسم کی شناخت مٹا دیتا ہے: کمپائلر نہیں جانتا کہ پروٹوکول کے پیچھے کون سی حقیقی قسم ہے۔ یہ لچک دیتا ہے (ایک صف میں مختلف قسمیں ذخیرہ کی جا سکتی ہیں)، لیکن کارکردگی کی قیمت پر۔

some بمقابلہ any: تقابلی تجزیہ

some — جامد پولی مورفزم: کمپائلر حقیقی قسم جانتا ہے، براہ راست تقسیم استعمال کرتا ہے اور کوڈ کو inline کر سکتا ہے۔ any — متحرک پولی مورفزم: ورچوئل طریقوں کی جدول (existential container) استعمال کی جاتی ہے، جو بالواسطگی کا اضافہ کرتی ہے۔

swift
protocol Drawable {
    func draw()
}

// some: جامد قسم معلوم ہے
func makeDrawable() -> some Drawable {
    return Circle() // ایک ہی واپسی کی قسم
}

// any: متحرک، مختلف قسمیں ذخیرہ کر سکتا ہے
var shapes: [any Drawable] = [Circle(), Square()]
shapes.append(Triangle())

some اور any کے درمیان انتخاب کارکردگی اور لچک کے درمیان سمجھوتہ ہے۔ Some تیز ہے، لیکن ایک نفاذ تک محدود کرتا ہے۔ Any زیادہ لچکدار ہے (قسمیں ملا سکتے ہیں)، لیکن متحرک تقسیم کی وجہ سے سست ہے۔ SwiftUI میں body کے لیے ہمیشہ some View استعمال ہوتا ہے، کیونکہ ہر View کا body ایک ہی حقیقی قسم ہے۔

ایسوسی ایٹڈ ٹائپس والے پروٹوکولز میں Opaque Type

Opaque Type Swift کا بنیادی مسئلہ حل کرتا ہے: ایسوسی ایٹڈ ٹائپس والے پروٹوکول (PAT) کو قسم کے طور پر براہ راست استعمال نہیں کیا جا سکتا۔ فنکشن صرف Collection واپس نہیں کر سکتا — کمپائلر کو Element بتانے کی ضرورت ہوتی ہے۔ some Collection اسے حل کرتا ہے، ایسوسی ایٹڈ ٹائپ کو چھپا کر۔

PAT کو some کے ذریعے واپس کرنا

opaque type کے بغیر Collection واپس کرنے کے لیے حقیقی قسم (Array<Int>) یا قسم کو مٹانا (AnyCollection<Int>) استعمال کرنا پڑتا۔ some Collection سنہری وسط دیتا ہے: کمپائلر حقیقی نفاذ جانتا ہے، کال کرنے والا کوڈ — نہیں۔

swift
func makeReversedCollection<T>(
    of array: [T]
) -> some Collection {
    return array.reversed()
}

let result = makeReversedCollection(of: [1, 2, 3])
// result — ReversedCollection>, hidden from caller
for item in result {
    print(item)
}

result پر iteration ممکن ہے، لیکن ReversedCollection کی خصوصیات تک براہ راست رسائی نہیں ہے۔ یہ encapsulation کی حفاظت کرتا ہے: اگر بعد میں reversed() کو کسی دوسرے طریقے سے بدل دیا جائے، کال کرنے والا کوڈ نہیں ٹوٹے گا۔ opaque type API کو تبدیل کیے بغیر نفاذ کو تبدیل کرنے کی آزادی دیتا ہے۔

SwiftUI میں some View کی عملی مثالیں

some View opaque type کا سب سے مشہور استعمال ہے۔ SwiftUI میں ہر View اپنے body کو some View کے طور پر اعلان کرتا ہے۔ اس کا مطلب ہے کہ body کچھ حقیقی View قسم واپس کرتا ہے، لیکن ڈویلپر کو یہ سوچنے کی ضرورت نہیں کہ وہ بالکل کیا ہے — TupleView، Group، ModifiedContent یا فریکوئنسی کی کوئی اور قسم۔

SwiftUI some View کیسے استعمال کرتا ہے

opaque type کے بغیر body کو حقیقی قسم واپس کرنی پڑتی، مثلاً ModifiedContent<Button<Text>, Padding>، جو غیر عملی ہے۔ some View یہ پیچیدگی چھپاتا ہے۔ کمپائلر body کی حقیقی قسم کمپائل کے وقت خود بخود نکالتا ہے۔

swift
struct ContentView: View {
    var body: some View {
        VStack {
            Text("ہیلو")
                .font(.title)
            Button("مجھے دبائیں") {
                print("دبایا گیا")
            }
        }
        .padding()
    }
}

کمپائلر body کو ModifiedContent<VStack<TupleView<(Text, Button<Text>)>>, Padding> کے طور پر نکالتا ہے۔ ڈویلپر some View دیکھتا ہے۔ اگر layout کو VStack سے HStack میں تبدیل کریں، کمپائلر خود بخود قسم کو دوبارہ نکالے گا — کوئی دستی تصحیح نہیں۔ یہی opaque type کا جادو ہے: ڈویلپر انٹرفیس کی منطق پر توجہ دیتا ہے، ترکیب کی قسموں پر نہیں۔

اکثر پوچھے گئے سوالات

Swift میں Opaque Type کیا ہے؟

Opaque Type — یہ ایک قسم ہے جسے کلیدی لفظ some کے ساتھ اعلان کیا جاتا ہے، جو حقیقی نفاذ کو کال کرنے والے کوڈ سے چھپاتا ہے۔ کمپائلر حقیقی قسم جانتا ہے، لیکن فنکشن استعمال کرنے والا ڈویلپر صرف پروٹوکول دیکھتا ہے۔

Swift میں some اور any میں کیا فرق ہے؟

some — یہ جامد شناخت کے ساتھ opaque type ہے: کمپائلر حقیقی قسم جانتا ہے۔ any — یہ متحرک تقسیم کے ساتھ existential type ہے: قسم کی شناخت مٹ جاتی ہے۔ Some زیادہ کارگر، any زیادہ لچکدار۔

SwiftUI some View کیوں استعمال کرتا ہے؟

some View body کی پیچیدہ حقیقی قسم چھپاتا ہے، جسے کمپائلر خود بخود نکالتا ہے۔ یہ ڈویلپر کو Generic-ریپرز (VStack, Group, ModifiedContent) پر مشتمل صحیح قسم لکھنے کی ضرورت سے آزاد کرتا ہے۔

کیا some کو فنکشن کے پیرامیٹرز میں استعمال کیا جا سکتا ہے؟

ہاں، Swift 5.7 سے۔ پیرامیٹرز میں some — generic-پیرامیٹر پر نحوی شکر ہے۔ یہ فنکشنز کے اعلان کو آسان بناتا ہے، خاص طور پر پروٹوکولز کے ساتھ کام کرتے وقت، جہاں ہر some-پیرامیٹر کو علیحدہ کی ضرورت نہیں ہوتی۔

اگر some-فنکشن سے مختلف قسمیں واپس کریں تو کیا ہوگا؟

کمپائلر غلطی دے گا: opaque type کو درکار ہے کہ تمام return-شاخیں ایک ہی حقیقی قسم واپس کریں۔ یہ جان بوجھ کر قسم کی شناخت برقرار رکھنے کے لیے کیا گیا ہے۔ اگر مختلف قسمیں واپس کرنی ہیں تو any استعمال کریں۔

خلاصہ

  • Opaque Type — واپسی کی قدر کی حقیقی قسم چھپاتا ہے، کمپائلر کی سطح پر اس کی شناخت برقرار رکھتے ہوئے
  • کلیدی لفظ some واپسی کی پوزیشن اور پیرامیٹرز میں opaque type اعلان کرنے کے لیے استعمال ہوتا ہے
  • Generic بمقابلہ Opaque: caller generic کے لیے قسم منتخب کرتا ہے، opaque کے لیے — نفاذ
  • any — متحرک تقسیم کے ساتھ existential type، some — جامد پولی مورفزم
  • SwiftUI some View — بنیادی استعمال: ڈویلپر سے body کی پیچیدہ قسم چھپاتا ہے
  • Opaque type پروٹوکولز کی ایسوسی ایٹڈ ٹائپس (PAT) کے ساتھ واپسی کا مسئلہ حل کرتا ہے

ہم ایک موبائل ایپلیکیشن ٹرنکی تیار کریں گے

IT Sectr 2017 سے اسٹارٹ اپس اور کاروبار کے لیے iOS اور Android ایپلیکیشنز بناتا ہے۔ ہم آپ کو مشورہ دیں گے اور بہترین حل تجویز کریں گے۔

پروجیکٹ پر بحث کریں

مزید پڑھیں