खज़ाने की फैक्ट्री

फैंटम टाइप

Elm के टाइप जेनेरिक टाइप की अनुमति देते हैं, जो आम तौर पर किसी इंटरफेस में लचीलापन जोड़ते हैं। उदाहरण के लिए, Maybe a टाइप किसी भी टाइप की वैल्यू रख सकता है।

type Maybe a = Nothing | Just a

ध्यान दीजिए कि ऊपर के उदाहरण में टाइप पैरामीटर a बराबर के चिह्न = के दोनों ओर इस्तेमाल होता है। हम कहते हैं कि a टाइप की परिभाषा के अंदर किसी डेटा से बँधा हुआ है।

फैंटम टाइप की तकनीक

लेकिन कुछ मामलों में टाइप पैरामीटर सिर्फ समीकरण के बाईं ओर ही दिखाई देता है।

type Distance unit = Distance Float

ऊपर दी गई Distance की परिभाषा में unit एक मुक्त टाइप पैरामीटर है, जो टाइप के किसी भी डेटा से बँधा नहीं है। ऐसे टाइप को हम फैंटम टाइप भी कहते हैं।

यह तब बहुत उपयोगी साबित होता है जब हमें कंपाइल टाइम पर ही बंधन लागू करने हों। उदाहरण के लिए, हम यह पक्का करना चाहते हैं कि हम सिर्फ एक ही यूनिट की दूरियाँ जोड़ें।

-- Distance is an opaque type, since the module does not expose its variants.
-- This means that users may only use the functions meter, foot and add to manipulate distances.
module Distance exposing (Distance, Meter, Foot, meter, foot, add)

-- The Distance type has a phantom type 'unit'.
type Distance unit = Distance Float

-- We define two types that will be used in place
-- of the phantom type 'unit' in our constructor functions.
type Meter = Meter
type Foot = Foot

-- Constructor for Meter
meter : Distance Meter
meter = Distance 1.0

-- Constructor for Foot
foot : Distance Foot
foot = Distance 0.3048

-- The add function cannot take two parameters of different types.
-- So we cannot add meters and feet by mistake.
add : Distance unit -> Distance unit -> Distance unit
add (Distance d1) (Distance d2) = Distance (d1 + d2)

उस मॉड्यूल के बाहर का कोड Distance टाइप के भीतरी हिस्से तक नहीं पहुँच सकता। उपयोगकर्ता दो Distance Meter जोड़ सकते हैं, लेकिन एक Distance Meter के साथ एक Distance Foot नहीं जोड़ सकते।

import Distance exposing (Distance)

-- Compiles
twoMeters = Distance.add Distance.meter Distance.meter

-- Does not compile
errDist = Distance.add Distance.meter Distance.foot

फैंटम टाइप के रूप में एक्सटेंसिबल रिकॉर्ड

इस पर कोई रोक नहीं है कि कौन से टाइप फैंटम बन सकते हैं, और रिकॉर्ड टाइप भी इसके लिए इस्तेमाल किए जा सकते हैं। फैंटम टाइप के रूप में इस्तेमाल होने पर रिकॉर्ड ऐसे जटिल बंधन व्यक्त कर सकते हैं जो फंक्शन के ज़रिए आगे बदल सकते हैं।

चलिए Distance मॉड्यूल के अंदर LegoBlock नाम की एक नई दूरी की यूनिट जोड़ते हैं। भौतिक ब्लॉक नियमन के अधीन वस्तुएँ होती हैं, इसलिए उनमें हमेशा दो प्रॉपर्टी होती हैं: उनकी दूरियाँ भिन्नात्मक नहीं होतीं और ऋणात्मक भी नहीं होतीं।

type LegoBlock = LegoBlock

fourStuds : Distance { properties | unit: LegoBlock, nonFractional : (), nonNegative: () }
fourStuds = Distance 4.0

nonFractional और nonNegative ऐसे रिकॉर्ड के फील्ड हैं जो टाइप आर्गुमेंट के बाहर कहीं मौजूद ही नहीं होता। इसलिए इन्हें () टाइप देना ही ठीक है, जिसे यूनिट टाइप कहते हैं। इस टाइप में इस बात के अलावा कोई जानकारी नहीं होती कि यह वहाँ मौजूद है।

मनमानी LegoBlock दूरियाँ हासिल करना निश्चित रूप से मुमकिन है, जैसे दूरियों के अंतर या अनुपात निकालने के बाद।

negativeStud : Distance { properties | unit: LegoBlock, nonFractional : () }
negativeStud = Distance -1.0

threeFiddyStud : Distance { properties | unit: LegoBlock, nonNegative : () }
threeFiddyStud = Distance 3.50

crazyStud : Distance { properties | unit: LegoBlock }
crazyStud = Distance -13.37

ऊपर दी गई सभी वैल्यू मान्य हैं और कंपाइल हो जाएँगी। लेकिन हमारी खास दिलचस्पी fourStuds जैसी वैल्यू में है, जिनमें nonFractional और nonNegative दोनों प्रॉपर्टी होती हैं, क्योंकि ये ऐसे भौतिक ब्लॉक दर्शाती हैं जिन्हें जोड़ा जा सकता है

combineLegoBlocks
  :  Distance { properties | unit: LegoBlock, nonFractional : (), nonNegative: () }
  -> Distance { properties | unit: LegoBlock, nonFractional : (), nonNegative: () }
  -> Distance { properties | unit: LegoBlock, nonFractional : (), nonNegative: () }
combineLegoBlocks = add

चलिए अब कुछ फंक्शन जोड़ते हैं, ताकि उपयोगकर्ता LegoBlock दूरियाँ बना सकें और उन्हें परिष्कृत कर सकें।

newLegoBlock : Float -> Distance { properties | unit: LegoBlock }
newLegoBlock dist = Distance dist

floorDistance : Distance properties -> Distance { properties | nonFractional : () }
floorDistance (Distance dist) = Distance (toFloat (floor dist))

ceilingDistance : Distance properties -> Distance { properties | nonFractional : () }
ceilingDistance (Distance dist) = Distance (toFloat (ceiling dist))

absDistance : Distance properties -> Distance { properties | nonNegative : () }
absDistance (Distance dist) = Distance (abs dist)

ध्यान दीजिए कि floorDistance, ceilingDistance और absDistance LegoBlock के अलावा दूसरी यूनिट के साथ भी काम कर सकते हैं। ये इनपुट प्रॉपर्टी के बारे में कोई अनुमान नहीं लगाते, बल्कि सिर्फ यह गारंटी देते हैं कि आउटपुट में एक तय प्रॉपर्टी ज़रूर होगी, चाहे nonFractional हो या nonNegative।

चलिए कुछ परिणाम देखते हैं।

import Distance exposing (Distance)

-- Compiles
distance1 = combineLegoBlocks fourStuds fourStuds

-- Does not compile
distance2 = combineLegoBlocks fourStuds threeFiddyStud

-- Compiles
distance3 = combineLegoBlocks fourStuds (floorDistance threeFiddyStud)

-- Does not compile
distance4 = combineLegoBlocks fourStuds negativeStud

-- Compiles
distance5 = combineLegoBlocks fourStuds (absDistance negativeStud)

-- Does not compile
distance6 = combineLegoBlocks fourStuds crazyStud

-- Compiles
distance7 = combineLegoBlocks fourStuds (floorDistance (absDistance crazyStud))

-- Compiles
distance8 = combineLegoBlocks fourStuds (ceilingDistance (absDistance crazyStud))

आम तौर पर floorDistance और ceilingDistance अलग-अलग परिणाम देते हैं, लेकिन गारंटी वही रहती है। यही फैंटम टाइप की तकनीक की शक्ति है: उपयोगकर्ताओं को लचीले विकल्प देना और साथ ही मज़बूत गारंटी बनाए रखना।