Գնահատել նախագիծը
← Բոլոր հրապարակումները

Ինչ կարող են Java ծրագրավորողները շահել Scala-ից

Տեսեք, թե ինչպես է Scala-ն գնում ավելի հեռու՝ բերելով հզոր հնարավորություններ, ինչպիսիք են տիպային անվտանգությունը, implicit պարամետրերը և compile-time տեղեկատվությունը, որոնք փոխում են JVM-ի վրա մշակման եղանակը։

16 րոպե
ScalaJavaՏիպային անվտանգություն

JVM-ը հայտնվեց 1994 թվականին՝ Java ծրագրեր գործարկելու համար, բայց վաղուց դադարել է լինել միայն Java-ի հարթակ։ Բազմաթիվ այլ լեզուներ օգտագործում են նրա հնարավորությունները, այդ թվում՝ Scala-ն։ Եթե դուք Java ծրագրավորող եք և Scala-ի մասին մի քիչ լսել կամ կարդացել եք, գուցե կարծեք, որ այն միայն որոշ syntactic sugar է բերում։ Այս հոդվածում կփորձեմ համոզել ձեզ, որ այն շատ ավելին է առաջարկում։

Այնտեղ կա նաև որոշակի syntactic sugar, ի թիվս այլ բաների, բայց հոդվածը դրա մասին չէ։ Կկենտրոնանամ 3 հնարավորության վրա, որոնք Java-ում չկան և որոնք, իմ կարծիքով (IMHO), ամենահզորն են և ամենամեծ տարբերությունն են ապահովում։ Դրանք են տիպային անվտանգությունը, implicit պարամետրերն ու դասերը, և compile-time-ում հասանելի տեղեկատվությունը։

Տիպային անվտանգություն

Java-ն տիպային անվտանգ է՞։ Իհարկե։ Բայց ի՞նչ է դա իրականում նշանակում։ Տիպային անվտանգությունը «այո կամ ոչ» հարց է, թե՞ ավելի շատ սպեկտր է։ Այլ կերպ ասած՝ կարո՞ղ են երկու լեզուներն էլ տիպային անվտանգ լինել, բայց մեկը լինի «ավելի տիպային անվտանգ», քան մյուսը։ IMHO՝ այո, կարող է, և Scala-ն «ավելի տիպային անվտանգ» է, քան Java-ն։ Պատճառը generic տիպերի համար իրագործված «կովարիանտության» (covariance) և «կոնտրավարիանտության» (contravariance) մեխանիզմներն են։ Դրանք տալիս են տիպերի միջև ժառանգման հարաբերություններ սահմանելու միջոց՝ հիմնվելով նրանց generic տիպի վրա։ Լավագույնս բացատրում է օրինակը՝

Java-ում Integers-ների List-ը Objects-ների List չէ, թեև ամեն Integer Object է։ Հետևյալ կոդը չի կոմպիլացվում՝

List<Integer> listOfInts = new List();
List<Object> listOfObjects = listOfInts // compile time error

Scala-ում, ընդհակառակը, այս կոդը կոմպիլացվում է՝

val listOfInts: List[Int] = List()
val listOfObjects: List[Object] = listOfInts

Ինչպե՞ս է դա լինում։ Աշխատում է, որովհետև Scala-ի List-ը կովարիանտ է իր տարրի (generic) տիպով։ Նայեք, թե ինչպես է List-ը հայտարարված Scala-ում՝

sealed abstract class List[+A] extends AbstractSeq[A]

Տեսնո՞ւմ եք + նշանը generic տիպի կողքին։ Այն ցույց է տալիս, որ List-ը կովարիանտ է իր generic տիպով, այսինքն՝ List, որի տարրերը A-ի ենթատիպ են, ինքը A տիպի տարրերով List-ի ենթատիպ է։ Սա դեռ կարող է անորոշ հնչել, բայց համբերեք։ Օրինակները օգնության են գալիս՝

Խնձորների List-ը պտուղների List-ի ենթատիպ է՝

val listOfApples: List[Apple] = List(grannySmith, goldenDelicious, gala)
val listOfFruits: List[Fruit] = listOfApples

Շների List-ը կենդանիների List-ի ենթատիպ է՝

val listOfDogs: List[Dog] = List(
  frenchBulldog, 
  goldenRetriever, 
  germanShepherd
)
val listOfAnimals: List[Animal] = listOfDogs

Ցանկացած A տիպի List-ը A-ի գերտիպի List-ի ենթատիպ է։ Այս վերագրումների բոլորն էլ աշխատում են, և կոմպիլյատորը առարկություն չի ունենում։ Բնականաբար, գերտիպը չի կարելի վերագրել ենթատիպին. val listOfDogs = listOfAnimals-ը չի կոմպիլացվի։

Այս պարզ մեխանիզմի շնորհիվ ենթատիպերի ցանկը գերտիպերի ցանկ տիպով val-ին վերագրելուց առաջ փոխակերպելու կարիք չկա։

ենթատիպերի ցանկ

Կոնտրավարիանտությունը «հակադարձ» կանոնն է։ Այն հայտարարվում է մինուս նշանով (-), և ParamType[-T]-ն ասում է, որ ParamType-ը կոնտրավարիանտ է իր generic T տիպով։ Այլ կերպ ասած՝ ParamType[A]-ը ParamType[B]-ի ենթատիպ է, երբ B-ն A-ի գերտիպ է։ Սա կարող է անիմաստ թվալ, բայց ունի նաև լավ կիրառման դեպքեր։

Ֆունկցիայի ընդունած տիպը (ֆունկցիայի պարամետրի տիպը) կոնտրավարիանտ տիպի օրինակ է։ Մեկ պարամետր ընդունող և արժեք վերադարձնող ֆունկցիան կոնտրավարիանտ է իր պարամետրի տիպով և կովարիանտ՝ վերադարձվող տիպով։ Այո, տիպը (այստեղ՝ Function1) կարող է կովարիանտ լինել մեկ տիպի պարամետրով և կոնտրավարիանտ՝ մյուսով։ Մեկ պարամետրանի ֆունկցիան իրագործում է Scala-ի Function1 trait-ը (այստեղ ցույց է տրված պարզեցված ձևով)՝

trait Function1[-T1, +R]

Այն ակնհայտորեն կոնտրավարիանտ է մի տիպով և կովարիանտ՝ մյուսով։ Կոնտրավարիանտը (-T1) ֆունկցիայի ընդունած պարամետրի տիպն է, իսկ կովարիանտը (+R)՝ ֆունկցիայի վերադարձրած տիպը։ Ինչո՞ւ է մեկը կովարիանտ, մյուսը՝ կոնտրավարիանտ։ Ամեն ինչ հանգում է իրար։

Վերցնենք Apple դասը, որը ժառանգում է Fruit-ը, և Horse-ը, որը ժառանգում է Animal-ը։ Այժմ վերցնենք Animal => Apple ստորագրությամբ ֆունկցիա (այն ընդունում է Animal տիպի 1 պարամետր և վերադարձնում Apple), օրինակ՝ whatItLikes(animal: Animal): Apple, որը վերադարձնում է կենդանու սիրած խնձորի տեսակը։

Այնուհետև պատկերացրեք HorseService, սերվիսը, որի կոնստրուկտորը պահանջում է Horse => Fruit տիպի ֆունկցիա։ Տիպերի վարիանտության շնորհիվ մենք դեռ կարող ենք փոխանցել whatItLikes ֆունկցիան։ Այն կոնտրավարիանտ է պարամետրի տիպով՝ Animal-ը Horse-ի գերտիպ է, և կովարիանտ՝ վերադարձվող տիպով՝ Apple-ը Fruit-ի ենթատիպ է, ուստի այն համապատասխանում է։ Այլ կերպ՝ Function1[Animal, Apple] ֆունկցիայի տիպը Function1[Horse, Fruit]-ի ենթատիպ է, քանի որ Animal-ը Horse-ի գերտիպ է, իսկ Apple-ը Fruit-ի ենթատիպ։ Դա պարզ է դառնում, երբ դիտարկում ենք, թե որտեղ կարելի է այն օգտագործել։ Ինչպես վերևի օրինակում, երբ պահանջվում է Horse ընդունող և Fruit վերադարձնող ֆունկցիա, մենք դեռ կարող ենք տրամադրել ցանկացած Animal ընդունող ֆունկցիա (քանի որ այն ընդունում է նաև ցանկացած Horse) և Apple վերադարձնող (քանի որ Apple-ը միշտ ընդունելի է այնտեղ, որտեղ Fruit է ակնկալվում)։

Դա իմաստ ունի, որովհետև ընդհանրապես պարամետրը կարելի է փոխանցել իր գերտիպն ընդունող ֆունկցիային, իսկ ֆունկցիայի վերադարձրած արժեքն ընդունվում է, եթե այն ակնկալվող տիպի ենթատիպ է։

Horse => Fruit

Որպես Scala ծրագրավորողներ՝ մենք հազվադեպ ենք օրավուր աշխատանքում գործ ունենում տիպերի վարիանտության հետ, բայց մեր օգտագործած գրադարանները օգտագործում են այն, ինչը դրանց դարձնում է ավելի օգտակար և ավելի անվտանգ (տիպային անվտանգության իմաստով) և մեզ հեռու պահում runtime սխալներից։

Implicit-ներ

Implicit-ը արժեք, պարամետր կամ ֆունկցիա է, որը կոմպիլյատորը ավտոմատ (implicit) կիրառում է ամենուր, որտեղ անհրաժեշտ է, առանց կոդում բացահայտ երևալու։ Օրինակ՝ հետևյալ կերպ հայտարարված մեթոդը կանչելու համար

def encode[A](a: A)(using enc: Encoder[A])

բավական է գրել encode(a), եթե a-ի տիպի համար implicit encoder գոյություն ունի և scope-ում է։ Կոմպիլյատորը enc պարամետրը կլրացնի մեր փոխարեն։

Առաջին հայացքից implicit-ները թվում են syntactic sugar – ծրագրավորողները կարող են բաց թողնել որոշ պարամետրեր, քանի որ կոմպիլյատորը դրանք տրամադրում է ավտոմատ։ Սակայն implicit ֆունկցիաների շնորհիվ (մի պարամետրի ավտոմատ փոխակերպում մյուսի) դրանք շատ ավելի հզոր են, քան թվում է։

Scala 3-ում implicit-ների մի քանի տեսակ կա՝ implicit պարամետրեր, փոխակերպումներ, extension-ներ և այլն։ Արագ կդիտարկենք յուրաքանչյուրը, ապա կփորձենք ինչ-որ օգտակար բան կառուցել՝ համադրելով Scala 3-ի տարբեր implicit-ները։

Implicit պարամետր

Սա թույլ է տալիս չգրել փոփոխականի անունը ամեն անգամ, երբ այն պետք է։ Այն հարմար է այն պարամետրերի համար, որոնք փոխանցվում են բարձր մակարդակի ֆունկցիայից ցածրինին, հետո մեկ այլ ցածրինի և այսպես շարունակ։ Այնպիսի բաներ, ինչպիսիք են context-ը, լռելյայն արժեքները, timeout-ները և այլն, սովորաբար ծագում են վերևում, բայց պետք են մի քանի մակարդակ ներքևում։ Այն ձեռքով փոխանցելու փոխարեն կարող եք այն դարձնել implicit, որպեսզի փոխանցվի ավտոմատ՝

@main
def main(): Unit = {
 given timeout: Timeout = Timeout(3)

 val value = doSomething
 println(value)
}

def doSomething(using Timeout) = {
 doSomethingDeeper
}

def doSomethingDeeper(using timeout: Timeout): String = {
 s"done in less than ${timeout.seconds} seconds"
}

Պետք չէ timeout-ը փոխանցել doSomething-ին կամ doSomethingDeeper-ին. այն փոխանցվում է ավտոմատ։ Եթե implicit պարամետրը scope-ում բացահայտ չի օգտագործվում, անուն պետք չէ. նայեք, թե ինչպես է հայտարարված doSomething-ը. այն ունի using Timeout առանց պարամետրի անվան՝ պարզապես ցույց տալու համար, որ implicit պարամետրը պահանջվում է՝ առանց այն անվանելու։ Որոշ իմաստով սա նման է Java-ի ScopedValue-ին, միայն թե այն պետք է հայտարարվի կանչերի ուղու յուրաքանչյուր մեթոդում. վերևի օրինակում doSomething-ը նույնպես հայտարարում է implicit Timeout պարամետրը, թեև չի օգտագործում այն։ Մյուս կողմից, implicit-ները չեն սահմանափակվում պարամետրերով. կան նաև implicit դասեր և մեթոդներ, ուստի շարունակեք կարդալ։

Implicit փոխակերպում

Երբեմն արժեքը պետք է փոխակերպել այլ տիպի։ Ենթադրենք, պետք է Meters-ը վերածել Yards-ի։ Scope-ում implicit փոխակերպմամբ դա կարող է կատարվել ավտոմատ. Meters-ը կարելի է օգտագործել ամենուր, որտեղ Yards է ակնկալվում, և դրանք կփոխակերպվեն թռիչքի ժամանակ։

case class Meters(value: Double)
case class Yards(value: Double)

given Conversion[Meters, Yards] = m => Yards(m.value * 1.094)

@main
def main2(): Unit = {
 val distance = Meters(10)

 go(distance)
}

def go(distance: Yards): Unit = {
 println(s"Going ${distance.value} yards")
}

Թեև go-ն ընդունում է Yards, այլ ոչ թե Meters, այն աշխատում է implicit փոխակերպման շնորհիվ։ Որպես արգումենտ փոխանցված Meters-ը փոխակերպվում է Yards-ի։

Extension մեթոդներ

Extension մեթոդները Scala 3-ում implicit-ների երրորդ տեսակն են։ Դրանց կարելի է նայել որպես «փոխակերպում այնպիսի տիպի, որտեղ մեթոդը իրագործված է»։ Ասենք՝ ինչ-որ տեղ Double-ներ են օգտագործվում, բայց մենք ուզում ենք ավելի ճշգրիտ և տիպային անվտանգ լինել՝ ապահովելով, որ տրված double արժեքը ներկայացնում է հեռավորություն Meters-ով։ Կարող ենք Double տիպին ավելացնել .asMeters extension մեթոդը։

extension(distanceInMeters: Double) def asMeters(): Meters = 
  Meters(distanceInMeters)

@main
def main3(): Unit = {
 val distance = 10

 go(distance.asMeters())
}

Սա հնարավոր է դարձնում ընդլայնել (մեթոդներ ավելացնել) այնպիսի տիպի վարքագիծը, որը ծրագրավորողը չի վերահսկում, օրինակ՝ գրադարանից եկած տիպի։ Սրան հասնելու այլ եղանակներ էլ կան, օրինակ՝ տիպը ValueObject-ով փաթաթելը, բայց ես կպնդեի, որ extension մեթոդներն ավելի լավ ընտրություն են։ Նրանց առավելությունն այն է, որ տիպը կարող է ունենալ բազմաթիվ extension մեթոդներ (հնարավոր է՝ տարբեր գրադարաններից), մինչդեռ մեկ տիպի համար բազմաթիվ ValueObject ունենալը անհարմար է։ Մեկ VO-ով փաթաթված տիպը չի կարող միաժամանակ փաթաթված լինել մեկ այլ VO-ով։ Պահանջվում է այն բացել և նորից փաթաթել մեկ այլ VO-ով, ինչը անհարմար է։

Compile-time-ում հասանելի տեղեկատվություն

Java-ն runtime-ում բացահայտում է շատ տեղեկատվություն դասերի, նրանց դաշտերի, մեթոդների և այլնի մասին։ Դա հնարավորություն է տալիս ունենալ generic encoder-ներ, սերիալիզատորներ և այլն, բայց եթե ինչ-որ բան սխալ է՝ ասենք, դաշտ է ակնկալվում, բայց դասը այն չունի, – ձախողվում է runtime-ում։ Scala 3-ը compile-time-ում հասանելի է դարձնում շատ ավելի շատ տեղեկատվություն, ուստի եթե որոշ ենթադրություններ չեն բավարարվում, կոդը պարզապես չի կոմպիլացվի։

Mirror

Տեղեկատվությունը case class-ի (case class-ը նման է Java-ի record-ին) և նրա դաշտերի տիպերի մասին տրամադրում է Mirror.Of[A]-ն՝ compile-time-ում կառուցվող տիպ, որը այս տեղեկատվությունը պահում է այլ տիպերի տեսքով։ Այստեղ ամեն ինչ գտնվում է տիպերի, այլ ոչ թե արժեքների մակարդակում, և հասանելի է compile-time-ում։ Այն թույլ է տալիս ստանալ case class-ի տիպի անունը, դաշտերի տիպերը, label-ները և այլն։

constValue

constValue-ն scala.compiletime փաթեթի մեթոդ է, որը վերադարձնում է հաստատուն տիպի արժեքը։ Ի՞նչ է հաստատուն տիպը։ Դա տիպ է, որն ունի ընդամենը մեկ հնարավոր արժեք։ Իրականում, երբ Scala 3-ում ստեղծում եք արժեք, ինչպիսին է

val a = 1

a-ի տիպը Int է, բայց նաև 1 է։ Այո, 1-ը այստեղ տիպ է. այն ակնհայտորեն ժառանգում է Int-ը, և սովորաբար մեզ դա պետք չէ և պարզապես օգտագործում ենք Int, բայց դա, այնուամենայնիվ, առանձին տիպ է։ Դա հաստատուն տիպ է մեկ հնարավոր արժեքով՝ 1։ Այսպիսով, constValue-ն մեթոդ է, որը վերադարձնում է այդպիսի տիպի արժեքը, այսինքն՝ (միակ) օրինակը։

constValue-ն աշխատում է միայն inlined համատեքստում, քանի որ փոխանցվող տիպը պետք է հայտնի լինի compile-time-ում։ inline-ին կվերադառնանք ավելի ուշ։

erasedValue

erasedValue-ն նույնպես գտնվում է scala.compiletime-ում և compile-time-ում ստեղծում է տիպի «վիրտուալ օրինակ»։ Այն օգտակար է, երբ տեղեկատվություն է պետք այնպիսի տիպի մասին, որի արժեքը runtime-ում նույնիսկ գոյություն չունի. erasedValue-ն ստեղծում է այդպիսի վիրտուալ արժեք։ Մենք այն կօգտագործենք Mirror.Of-ից վերցված case class-ի անդամների տիպերի վրա pattern matching անելու համար։

inline

Inline մեթոդը այն մեթոդն է, որի կանչը կոմպիլյատորը փոխարինում է մեթոդի մարմնով։ Մեր օրինակում կօգտագործենք inline match, որը compile-time-ում հանգեցվում է pattern-match-ի միայն մեկ ճյուղի։ Օրինակ՝

inline b match {
 case true => "matches!"
 case false => "no match, sorry"
}

compile-time-ում կփոխարինվի պարզապես "matches!"-ով կամ "no match, sorry"-ով։ Բնականաբար, որպեսզի սա աշխատի, b-ի արժեքը նույնպես պետք է հայտնի լինի compile-time-ում. հակառակ դեպքում կոմպիլյատորը սխալ կբարձրացնի։

Կառուցենք ինչ-որ օգտակար բան

Առաջին հայացքից implicit-ները կարող են թվալ պարզ syntactic sugar, որը միայն խնայում է մեր մուտքագրումը։ Սակայն խելամիտ օգտագործման դեպքում դրանք կարող են հզոր գործիք լինել։ Սխալ օգտագործելու դեպքում դրանք կարող են նաև վնասել. համարեք, որ զգուշացվել եք ;) Implicit-ների օգտագործման մի (լավ) դեպք encoder-ների/decoder-ների և սերիալիզատորների/դեսերիալիզատորների գեներացումն է։ JSON encoder-ները/decoder-ները ամենատարածվածն են, բայց ցանկացած այլ ձևաչափ, ինչպիսիք են CSV-ն, Protobuf-ը և այլն, նույնպես աշխատում է։ JSON-ը լավ է համապատասխանում, քանի որ այն schema-less է և աջակցում է ներդրված օբյեկտներ, ինչը հնարավորություն է տալիս ցույց տալու, թե ինչպես են implicit-ները օգնում գեներացնել ներդրված encoder-ներ։ Այս օրինակում կկառուցենք ավելի պարզ բան, բայց նույնպես schemaless և ներդրումով, ճիշտ ինչպես JSON-ը։ Encoder-ը generic է և աշխատում է ցանկացած case class-ի համար (case class-ը նման է Java-ի record-ին, հիշո՞ւմ եք), որը պարունակում է այլ ներդրված case class-եր։ Լավ, գուցե ոչ ցանկացածի. trait-երը, կոլեկցիաները և այլն չեն աջակցվում, բայց դա բավական է ցույց տալու, թե ինչ են implicit-ները ընդունակ անել։ Վերցնենք երկու պարզ case class

case class User(name: String, age: Int, address: Address)

և

case class Address(
  country: String, 
  city: String, 
  street: String, 
  number: Int
)

Մենք runtime reflection չենք օգտագործի։ Եթե ինչ-որ բան սխալ է, և օրինակը չի կարող կոդավորվել, ուզում ենք այդ մասին իմանալ compile-time-ում։

Մեկ այլ նպատակ օգտագործման հեշտությունն է, մոտավորապես այսպես՝

val user = User(
  "Paul", 
  45, 
  Address("Germany", "Hamburg", "Lindenstrasse", 10)
)
val encoded = Encoder.encode(user)

Ակնհայտ է, որ պետք է Encoder object՝ encode մեթոդով

object Encoder {
   def encode[A](value: A)(using enc: Encoder[A]): String = ...

Scala-ում object-ը singleton է։ Այնտեղ են դրվում այն մեթոդները, որոնք Java-ում static կլինեին, այսինքն՝ նրանք, որոնք դասի օրինակներ չեն պահանջում։ encode մեթոդի հայտարարությունն ասում է, որ այն ընդունում է մեկ «սովորական» value պարամետր A տիպի, գումարած մեկ implicit պարամետր Encoder[A] տիպի։

Այս մեթոդի ներսում A-ն generic տիպ է։ Այն կարող է լինել ցանկացած տիպ, և հայտարարությանը այն պետք է enc պարամետրի համար։ enc-ը generic տիպով պարամետրիզացված Encoder է, որը պետք է նույն տիպը լինի, ինչ value-ն է օրինակ։ Սա այստեղ A generic տիպի միակ սահմանափակումն է և միակ պատճառը, թե ինչու է այն մեզ պետք՝ արտահայտելու համար, որ Encoder-ի generic տիպը պետք է համընկնի value-ի տիպի հետ։

enc-ը գտնվում է իր սեփական պարամետրերի ցանկում. այո, Scala-ում մեթոդը կարող է ունենալ մեկից ավելի պարամետրերի ցանկ։ using բանալի բառը այս ցանկի պարամետրերը նշում է որպես implicit, այսինքն՝ դրանք գրել պետք չէ, եթե այդ տիպի implicit պարամետր scope-ում է։

Հիմա գրենք մեթոդի մարմինը։ Երբ անհրաժեշտ encoder-ը հասանելի է, այն պարզ է երևում՝

def encode[A](a: A)(using enc: Encoder[A]): String = enc.encode(a)

Այսպես օգտագործվում են համապատասխան տիպի implicit encoder-ները, ինչը օգտակար է դառնում ներդրված տիպերը կոդավորելիս։

Այսպիսով, A տիպի implicit Encoder պետք է լինի scope-ում, բայց որտեղի՞ց է այն գալիս։ Այն տրամադրվում է implicit մեթոդով

inline implicit def makeEncoder[A](using m: Mirror.Of[A]): Encoder[A]

Այս մեթոդի մարմնի համար մեզ պետք են վերը նկարագրված գործիքներից մի քանիսը։ Այս encoder-ի գործը դասի անունը դուրս բերելն է՝ նրա բոլոր անդամների անուններով և արժեքներով միասին՝ շատ նման JSON-ին, միայն թե ավելի պարզ. մենք բաց ենք թողնում ձևավոր փակագծերը և ձևաչափման մասին չենք մտածում։ Այս ամբողջ տեղեկատվությունը ստացվում է compile-time-ում։ Տեսնենք այն մեթոդները, որոնք դա անում են՝

inline implicit def makeEncoder[A](using m: Mirror.Of[A]): Encoder[A] = 
  (a: A) => {
    val labels: Seq[String] = deconstructLabels[m.MirroredElemLabels]

   val memberEncoders: Seq[Encoder[Any]] = 
     deconstructMemberEncoders[m.MirroredElemTypes]

   val lines = a.asInstanceOf[Product].productIterator
     .zip(labels)
     .zip(memberEncoders)
     .map {
       case ((value, label), memberEncoder) =>
         s"$label: ${memberEncoder.encode(value)}"
     }

 constValue[m.MirroredLabel] + "\n" + lines.mkString("\n")
}

makeEncoder մեթոդը հենվում է մի քանի օգնական մեթոդների վրա՝ case class-ի դաշտերը, նրանց անուններն ու տիպերը և case class-ի անունը ստանալու համար, և վերջում կառուցում է գեղեցիկ ձևաչափված String, որը պարունակում է այդ ամենը։

labels-ը պահում է անդամների label-ները, այսպես, օրինակ, Address-ի համար դրանք կլինեն “country”, “city”, “street” և “number”։

memberEncoders-ը պահում է case class-ի յուրաքանչյուր անդամի encoder-ները՝ հերթականությամբ։

Այստեղ ուշագրավ մասերից մեկը a.asInstanceOf[Product]-ն է։ Scala-ի յուրաքանչյուր case class նաև Product-ի օրինակ է։ Product trait-ը տրամադրում է productIterator՝ case class-ի բոլոր դաշտերի iterator։ Այն labels-ի (դաշտերի անուններ) և memberEncoders-ի հետ zip անելուց հետո կարող ենք դաշտերը մշակել մեկ-մեկ՝ յուրաքանչյուրը իր value-ով, label-ով և memberEncoder-ով։

makeEncoder մեթոդի վերջին տողը պարզապես սկզբից ավելացնում է m.MirroredLabel-ը, որը պահում է case class-ի անունը։

Հիմա վերջին բացակայող մասերը՝ deconstructLabels և deconstructMemberEncoders մեթոդները։

inline def deconstructLabels[T <: Tuple]: List[String] =
 inline erasedValue[T] match
   case _: (head *: tail) =>
     constValue[head].asInstanceOf[String] :: deconstructLabels[tail]
   case _: EmptyTuple => List.empty

Վերևի մեթոդը ստեղծում է T տիպի «վիրտուալ» արժեք (այնպիսի, որը իրականում runtime-ում գոյություն չունի), որը այստեղ Mirror.Of-ի MirroredElemLabels-ն է։ Այնուհետև այն pattern matching է անում նրա տիպի վրա։ Տիպը Tuple է, և դրա վրա կարելի է match անել գրեթե ցանկի նման՝ head և tail (tail-ը կարող է դատարկ ցանկ լինել) կամ EmptyTuple։ Ռեկուրսիվ կերպով, երբ դա head և tail է (հիշեք, որ երկուսն էլ տիպեր են, այլ ոչ թե արժեքներ. հիշո՞ւմ եք հաստատուն տիպերը), այն head-ը կարդում է որպես String-ի օրինակ (սրանք label-ներ են, ուստի միշտ String են) և deconstruct է անում tail-ը։ Այսպես է կառուցվում բոլոր label-ների ցանկը։

Այժմ նայեք մյուս մեթոդին՝ deconstructMemberEncoders-ին։ Այն մի քիչ ավելի բարդ է, բայց համբերեք։

inline def deconstructMemberEncoders[T <: Tuple]: List[Encoder[Any]] =
 inline erasedValue[T] match
   case _: (head *: tail) =>
     val encoder = summonInline[Encoder[head]]
     encoder.asInstanceOf[Encoder[Any]] :: 
       deconstructMemberEncoders[tail]
   case _: EmptyTuple => List.empty

Ինչպես նախկինում, մեզ պետք է erasedValue՝ T տիպի վրա match անելու համար։ Կրկին, T generic տիպը միշտ tuple է, բայց այս անգամ դա դաշտերի տիպերի tuple է, այլ ոչ թե label-ների։ Ուստի դրանք բոլորը String չեն, այլ տիպեր, ինչպիսիք են Int-ը, String-ը, Address-ը և այլն։ Յուրաքանչյուր անդամի տիպի համար summon է արվում Encoder։ Summon անելը նշանակում է implicit արժեք ստանալ, եթե այն scope-ում է։ Եթե չկա, կոմպիլյացիան ձախողվում է. բոլոր implicit-ները լուծվում են compile-time-ում, այլ ոչ թե runtime-ում։ Պրիմիտիվների encoder-ները (պարզության համար օգտագործում ենք միայն String և Int) նույնպես պետք է scope-ում լինեն, և մենք դրանք ավելացնում ենք բացահայտ։ Այո… implicit-ներ, բացահայտ… Այդ երկուսի համար մեզ պետք են հետևյալ նման տողեր՝

given Encoder[String] with
   def encode(a: String): String = a

given Encoder[Int] with
   def encode(a: Int): String = a.toString

Սա սահմանում է String-ի և Int-ի encoder-ները և given բանալի բառով դրանք որպես implicit դնում scope-ում։ Address-ի Encoder-ը նույնպես implicit scope-ում է, թեև մենք երբեք այն չենք ստեղծում։ Implicit makeEncoder մեթոդը այն արտադրում է ավտոմատ։ Դա ես նկատի ունեի՝ ասելով «որոշ implicit-ներ scope են ավելացվում բացահայտ»։ Դրանցից մի քանիսը պետք է գրենք ձեռքով, իսկ Address-ինը կգեներացվի մեր կախարդական մեթոդով։

Այս բոլոր մասերը տեղում լինելով՝ ունենք գործիք, որը կոդավորում է ցանկացած case class, որի անդամները String կամ Int են, կամ այլ ներդրված case class-եր, որոնք նույնպես պարունակում են այդ տիպերի դաշտեր։ Եվ այդ ամենը compile-time-ում։ Եթե կոմպիլացվում է, Encoder.encode(x) կանչը երաշխավորված է միշտ վերադարձնել գեղեցիկ ձևաչափված տող՝ x-ի մասին ամբողջ տեղեկատվությամբ։

Ամփոփում

Scala-ն բերում է որոշ առանձնահատուկ հնարավորություններ, որոնք բացակայում են Java-ում և շատ դուրս են գալիս պարզ շարահյուսական հարմարությունից։ Դրանցից գլխավորը առաջադեմ տիպային համակարգն է, որը աջակցում է վարիանտություն generic-ներում և թույլ է տալիս ավելի հուսալի պոլիմորֆիզմ։ Implicit-ները հնարավորություն են տալիս պարամետրերի ավտոմատ փոխանցում, տիպերի փոխակերպումներ և գեներացիա, ինչը թույլ է տալիս derive անել type class-եր ներդրված տիպերի համար։ Scala-ի compile-time հնարավորությունները, ինչպիսիք են inline ֆունկցիաները, որոնք բացահայտում են տիպերի մասին տեղեկատվություն, օգնում են վաղ հայտնաբերել սխալները և բարելավել արդյունավետությունը։ Միասին վերցրած՝ այս հնարավորությունները Scala-ն դարձնում են գրավիչ տարբերակ Java ծրագրավորողների համար, ովքեր փնտրում են ծրագրավորման ավելի արտահայտիչ և հուսալի եղանակ։