👂 ☠️ ✒️ स्काला में छंटनी - बिल्लियों पर एक उदाहरण 👨🏾‍🔬 🤰🏻 👨🏾‍🎨

हेलो, हेब्र! मैं आपके दरबार में मीडियम पर मेरे लेख का रूसी अनुवाद लाता हूं: स्कैला में छंटनी - एक बिल्ली की दुकान का उदाहरण । यह लेख उन पाठकों के लिए है जो स्काला भाषा के वाक्य-विन्यास को जानते हैं और मानक पुस्तकालय के बुनियादी उपकरणों के बारे में जानकार हैं।

इस तथ्य के बावजूद कि जावा और स्काला दोनों जेवीएम को एक रनटाइम प्लेटफॉर्म के रूप में उपयोग करते हैं, स्काला ने कार्यात्मक प्रोग्रामिंग अवधारणाओं और एक समृद्ध मानक पुस्तकालय के एक महत्वपूर्ण अनुकूलन के लिए बहुत अधिक अभिव्यंजक भाषा के रूप में प्रसिद्धि प्राप्त की है। इस लेख में मैं इस अभिव्यंजना के एक उदाहरण पर विचार करूंगा, यह कल्पना करने की कोशिश करूंगा कि कोड आधार का एक छोटा सा हिस्सा और इसी आवश्यकताएं समय के साथ कैसे विकसित हो सकती हैं।

समस्या का प्रारंभिक विवरण

कल्पना करें कि हमारे पास हमारे निपटान में एक बिल्ली की दुकान है (क्योंकि बिल्लियाँ स्काला पारिस्थितिकी तंत्र में सबसे लोकप्रिय जानवर हैं)। बिक्री के लिए उपलब्ध बिल्लियों के बारे में जानकारी प्राप्त करने की ख़ासियत के कारण, कुछ मामलों में जानकारी डेटाबेस से नहीं आती है और क्लाइंट को HTTP प्रतिसाद भेजने या किसी अन्य तरीके से इसे संसाधित करने से पहले इसे मैन्युअल रूप से सॉर्ट किया जाना चाहिए। विषय क्षेत्र का मुख्य उद्देश्य, निश्चित रूप से है, Catजिसमें शुरुआत में केवल तीन प्रकार के आदिम प्रकार हैं। लक्ष्य निम्न आवश्यकताओं को पूरा करने वाले बिल्ली संग्रह को छाँटने के लिए एक एपीआई विकसित करना है:

प्रत्येक फ़ील्ड के लिए क्रमबद्ध क्रम निर्धारित किया जा सकता है।
किसी भी फ़ील्ड के लिए क्रमबद्ध क्रम को परिभाषित नहीं किया जा सकता है
सॉर्ट एक अपरिभाषित सॉर्ट क्रम वाले फ़ील्ड के लिए स्थिर होना चाहिए
प्रत्येक फ़ील्ड की प्राथमिकता तब होती है जब छँटाई (यानी फ़ील्ड द्वारा छँटाई ageकरना हमेशा क्षेत्र द्वारा छँटाई करने से अधिक प्राथमिकता होगी name)

पहला पुनरावृति

case class Cat(age: Int,
               name: String,
               available: Boolean)

चूंकि समस्या का बयान अपेक्षाकृत सरल है और परियोजना के अन्य हिस्सों के बारे में कोई जानकारी नहीं है, इसलिए प्रारंभिक समाधान को सरल बनाना बेहतर है। सौभाग्य से, यह scala.Orderingपहले से ही एक सुविधाजनक विधि Tuple3को परिभाषित करता है जिसके साथ आप Orderingआयाम 3 के ट्यूपल्स के लिए उदाहरण बना सकते हैं , जिससे कक्षा की कोई भी वस्तु आसानी से कम हो जाती है Cat।

, Tuple3 , . , — Tuple1, Tuple2, Tuple3, Ordering, . 9 (3 3 ), .

, API , " " . , 3 : (), ( ) "" ( ). (ADT):

sealed trait SortOrder

object SortOrder {

  case object Keep extends SortOrder

  case object Asc extends SortOrder

  case object Desc extends SortOrder
}

Ordering. SortOrder , , , :

import common.OrderingUtil
import iteration1.SortOrder.{Asc, Desc, Keep}

object syntax {

  implicit class OrderSyntax(val order: SortOrder) extends AnyVal {

    def apply[A](ordering: Ordering[A]): Ordering[A] =
      order match {
        case Keep => OrderingUtil.identity
        case Asc => ordering
        case Desc => ordering.reverse
      }
  }
}

OrderingUtil.identity — , A, . : Ordering.by(_ => 0).

, , Ordering[Cat]. CatOrdering:

import iteration1.syntax._

object CatOrdering {

  def of(idOrder: SortOrder,
         nameOrder: SortOrder,
         availableOrder: SortOrder): Ordering[Cat] =
    Ordering
      .Tuple3(idOrder(Ordering.Int), nameOrder(Ordering.String), availableOrder(Ordering.Boolean))
      .on[Cat](cat => (cat.age, cat.name, cat.available))
}

(Ordering[Cat]) CatOrdering.of:

CatOrdering.of(SortOrder.Asc, SortOrder.Keep, SortOrder.Desc)

, ScalaTest ScalaCheck property-based . , . .

Cat .

case class Cat(age: Int,
               name: String,
               available: Boolean,
               owner: Option[String])

, — ( null!), , , , . , 4 :

, ()
,
,
, ( )

(1 4) scala.Ordering.Option, 2 . SortOrder , :

sealed trait SortOrder

object SortOrder {

  case class Asc(emptyFirst: Boolean) extends SortOrder

  case class Desc(emptyFirst: Boolean) extends SortOrder

  case object Keep extends SortOrder

  object Asc {
    def emptyFirst: Asc = Asc(emptyFirst = true)

    def emptyLast: Asc = Asc(emptyFirst = false)
  }

  object Desc {
    def emptyFirst: Desc = Desc(emptyFirst = true)

    def emptyLast: Desc = Desc(emptyFirst = false)
  }
}

SortOrder. optional Ordering[Option[A]] A, , SortOrder. , , Ordering[Option[A]] apply, Ordering[Option[A]], . , A apply Option. <:<, StackOverflow ( Dotty Not ).

import common.OrderingUtil
import iteration2.sort_order.SortOrder._

object syntax {

  private object OptionOrdering {

    def apply[A](rootOrdering: Ordering[A],
                 emptyFirst: Boolean): Ordering[Option[A]] =
      if (emptyFirst)
        OptionOrdering.emptyFirst(rootOrdering)
      else
        OptionOrdering.emptyLast(rootOrdering)

    def emptyFirst[A](rootOrdering: Ordering[A]): Ordering[Option[A]] =
      (x: Option[A], y: Option[A]) => (x, y) match {
        case (None, None) => 0
        case (None, _) => -1
        case (_, None) => 1
        case (Some(a), Some(b)) => rootOrdering.compare(a, b)
      }

    def emptyLast[A](rootOrdering: Ordering[A]): Ordering[Option[A]] =
      (x: Option[A], y: Option[A]) => (x, y) match {
        case (None, None) => 0
        case (None, _) => 1
        case (_, None) => -1
        case (Some(a), Some(b)) => rootOrdering.compare(a, b)
      }
  }

  implicit class OrderSyntax(val order: SortOrder) extends AnyVal {

    def optional[A](ordering: Ordering[A]): Ordering[Option[A]] =
      order match {
        case Keep => OrderingUtil.identity
        case Asc(emptyFirst) => OptionOrdering(ordering, emptyFirst)
        case Desc(emptyFirst) => OptionOrdering(ordering.reverse, emptyFirst)
      }

    def apply[A](ordering: Ordering[A]): Ordering[A] =
      order match {
        case Keep => OrderingUtil.identity
        case Asc(_) => ordering
        case Desc(_) => ordering.reverse
      }
  }
}

import iteration2.sort_order.SortOrder
import iteration2.sort_order.syntax._

import scala.Ordering.{Boolean => BooleanO, Int => IntO, String => StringO}

object CatOrdering {

  def toOrdering(idOrder: SortOrder,
                 nameOrder: SortOrder,
                 availableOrder: SortOrder,
                 ownerOrder: SortOrder): Ordering[Cat] = {
    Ordering
      .Tuple4(idOrder(IntO), nameOrder(StringO), availableOrder(BooleanO), ownerOrder.optional(StringO))
      .on[Cat](cat => (cat.age, cat.name, cat.available, cat.owner))
  }
}

Ordering[Cat] . , .

CatOrdering.toOrdering(
  SortOrder.Asc.emptyFirst, 
  SortOrder.Asc.emptyFirst, 
  SortOrder.Asc.emptyFirst,
  SortOrder.Asc.emptyFirst
)

, Option, . .

. , :

.
- , SortOrder.Keep.
Cat 9. Tuple10 .

- . , Cat 10 . , , . , , SortOrder . .

, , . Cat. ( №1) ( №2), ( №3). (SortOrder ):

import java.time.LocalDate

case class Cat(age: Int,
               name: String,
               available: Boolean,
               owner: Option[String],
               breed: String,
               furColor: String,
               eyeColor: String,
               registrationId: String,
               lastHealthCheck: Option[LocalDate],
               urgentSell: Boolean)

import java.time.LocalDate

import iteration3.sort_order.SortOrder
import iteration3.sort_order.syntax._

import scala.Ordering._

sealed trait CatField {
  def toOrdering(sortOrder: SortOrder): Ordering[Cat]
}

object CatField {

  case object Age extends CatField {
    override def toOrdering(sortOrder: SortOrder): Ordering[Cat] =
      sortOrder(Ordering.Int).on(_.age)
  }

  case object Name extends CatField {
    override def toOrdering(sortOrder: SortOrder): Ordering[Cat] =
      sortOrder(Ordering.String).on(_.name)
  }

  case object Available extends CatField {
    override def toOrdering(sortOrder: SortOrder): Ordering[Cat] =
      sortOrder(Ordering.Boolean).on(_.available)
  }

  case object Owner extends CatField {
    override def toOrdering(sortOrder: SortOrder): Ordering[Cat] =
      sortOrder.optional(Ordering.String).on(_.owner)
  }

  case object Breed extends CatField {
    override def toOrdering(sortOrder: SortOrder): Ordering[Cat] =
      sortOrder(Ordering.String).on(_.breed)
  }

  case object FurColor extends CatField {
    override def toOrdering(sortOrder: SortOrder): Ordering[Cat] =
      sortOrder(Ordering.String).on(_.furColor)
  }

  case object EyeColor extends CatField {
    override def toOrdering(sortOrder: SortOrder): Ordering[Cat] =
      sortOrder(Ordering.String).on(_.eyeColor)
  }

  case object RegistrationId extends CatField {
    override def toOrdering(sortOrder: SortOrder): Ordering[Cat] =
      sortOrder(Ordering.String).on(_.registrationId)
  }

  case object LastHealthCheck extends CatField {
    override def toOrdering(sortOrder: SortOrder): Ordering[Cat] =
      sortOrder.optional(Ordering.by[LocalDate, Long](_.toEpochDay)).on(_.lastHealthCheck)
  }

  case object UrgentSell extends CatField {
    override def toOrdering(sortOrder: SortOrder): Ordering[Cat] =
      sortOrder(Ordering.Boolean).on(_.urgentSell)
  }
}

import common.OrderingUtil
import iteration3.sort_order.SortOrder

object CatOrdering {

  def byFields(fields: Seq[(CatField, SortOrder)]): Ordering[Cat] =
    if (fields.isEmpty) OrderingUtil.identity[Cat]
    else {
      val (head, headOrder) = fields.head
      val (res, _) = fields.tail.foldLeft[(Ordering[Cat], Set[CatField])]((head.toOrdering(headOrder), Set())) {
        case (acc@(_, presentFields), (field, _)) if presentFields.contains(field) =>
          acc

        case ((ordering, presentFields), (field, order)) =>
          (ordering.orElse(field.toOrdering(order)), presentFields + field)
      }
      res
    }
}

orElse, , . thenComparing Comparator Java. Ordering, Comparator . , orElse Scala, orElseBy.

, , byFields , . , OrderingUtil.identity, . " ", foldLeft, .

SortOrder.Keep, , , . , , . HTTP , .

. , , , . ( ) , , . , , , , , .

यद्यपि अंतिम कार्यान्वयन अन्य प्रोग्रामिंग भाषाओं में समान दिख सकता है, लेकिन मुझे लगता है कि स्काला टाइप सुरक्षा और कोड समझ और पठनीयता के बीच एक अच्छा समझौता प्रदान करता है। मुझे उम्मीद है कि इस प्रकाशन ने बेहतर तरीके से समझने में मदद की कि कैसे स्काला में संग्रह को सॉर्ट करना है, या सुझाए गए विचारों को कोड में लागू किया जा सकता है जो सीधे संबंधित नहीं है Ordering।

इस github भंडार में सभी नमूना कोड उपलब्ध हैं ।

स्काला में छंटनी - बिल्लियों पर एक उदाहरण

समस्या का प्रारंभिक विवरण

पहला पुनरावृति

More articles: