टाइप-स्तरीय कंप्यूटेशंस का उपयोग करते समय अनुमान/प्रकार की जांच विफलता टाइप करें

Question

Units.scala फ़ाइल में परिभाषित metascala में मापन कार्यक्षमता इकाइयों के साथ काम करते समय मैंने एक समस्या आई है।

इस प्रश्न के शेष के लिए, मैं केवल एक इकाई प्रकार, लंबाई के साथ एक सरलीकृत योजना का उपयोग करूंगा।

तो जहां वास्तव में एक प्रकार लग रहा है

तरह

Quantity[_1, _0, _0, _0, _0, _0, _0] 
     ^^^^^^^
      | | | | | | | 
      | Mass | Crncy.| Mol | 
     Length Time Temp. Lum.Intensity 

इस समस्या को प्रदर्शन करने के लिए पर्याप्त होगा:

Quantity[_1] 
     ^
      | 
     Length 

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

इस उदाहरण पर विचार (भी UnitsTest.scala से कोड पर एक नजर है):

val length: Quantity[_1] = m(5) 
val area: Quantity[_2] = length * length // (1) Works 
val dist: Quantity[_1] = area/length // (2) Doesn't work! 

मैं कह अंतिम पंक्ति में कोई त्रुटि मिलती है:

type mismatch; 
    found : 
    scalax.units.Units.Quantity[ 
     scalax.units.Subtractables.-[ 
     scalax.units.Integers._2, 
     scalax.units.Integers._1 
     ] 
    ] 

    required: 
    scalax.units.Units.Quantity[ 
     scalax.units.Integers._1 
    ] 

यह संकलक की तरह दिखता है सकते हैं ' टी यह समझते हैं कि हाथ पर प्रकार Quantity[_1] के बराबर है जब "आयाम को घटाकर", ई। जी। क्षेत्र से जा रहा (1) में की तरह जिले के लिए:

Quantity[_2 - _1] <<not equal to>> Quantity[_1] 

भ्रामक बात यह है कि यह काम करता है जब ई "एक आयाम जोड़ने" है। जी। (2) में की तरह क्षेत्र के लिए लंबाई से जा रहा:।

Quantity[_1 + _1] <<equal to>> Quantity[_2] 

(क्षमा करें यहाँ पूरे कोड पेस्ट नहीं के लिए, यह सिर्फ बहुत ज्यादा है मैं अपने उदाहरण को कम से कम करने की कोशिश की, लेकिन मैं विफल रहा है यही कारण है कि मैं सिर्फ जोड़ने हूँ। इसके लिए।)

Answer 1

MInt विशेषता में अनुपलब्ध है। इसे बनाने के लिए एक सरल परिभाषा एक नकारात्मक जोड़ करना होगा जब आप MSucc और MNeg में किसी प्रकार को घटाना चाहते हैं।

sealed trait MInt extends Visitable[IntVisitor] with Addable with Subtractable { 
    type AddType = MInt 
    type SubType = MInt 
    type Add[I <: MInt] <: MInt 
    type Sub[I <: MInt] <: MInt 
    type Neg <: MInt 
    type Succ <: MInt 
    type Pre <: MInt 
} 

final class _0 extends Nat { 
    type Add[I <: MInt] = I 
    type Sub[I <: MInt] = I#Neg 
    type AcceptNatVisitor[V <: NatVisitor] = V#Visit0 
    type Neg = _0 
    type Succ = MSucc[_0] 
    type Pre = Succ#Neg 
} 

final class MSucc[P <: Nat] extends Pos { 
    type This = MSucc[P] 
    type Add[N <: MInt] = P#Add[N]#Succ 
    type Sub[N <: MInt] = Add[N#Neg] 
    type AcceptNatVisitor[V <: NatVisitor] = V#VisitSucc[P] 
    type Neg = MNeg[This] 
    type Pre = P 
    type Succ = MSucc[This] 
} 

final class MNeg[P <: Pos] extends MInt { 
    type Add[N <: MInt] = P#Add[N#Neg]#Neg 
    type Sub[N <: MInt] = Add[N#Neg] 
    type Accept[V <: IntVisitor] = V#VisitNeg[P] 
    type Neg = P 
    type Succ = P#Pre#Neg 
    type Pre = P#Succ#Neg 
} 

एक और बात, Quantity में / विधि अपने मानकों को विभाजित करना चाहिए और उन्हें गुणा नहीं!