Paket nesneleri

Paket nesneleri nelerdir, kavram değil, kullanımları nelerdir?

Çalışan bir örnek almaya çalıştım ve çalışmamın tek formu şuydu:

package object investigations {
    val PackageObjectVal = "A package object val"
}

package investigations {

    object PackageObjectTest {
        def main(args: Array[String]) {
            println("Referencing a package object val: " + PackageObjectVal)
        }
    }
}

Şimdiye kadar yaptığım gözlemler:

package object _root_ { ... }

izin verilmiyor (makul olan),

package object x.y { ... }

ayrıca izin verilmiyor.

Bir paket nesnesinin hemen üst pakette bildirilmesi gerektiği görülmektedir ve eğer yukarıdaki gibi yazılırsa, küme ayracı sınırlandırılmış paket bildirim formu gereklidir.

Ortak kullanımda mı? Öyleyse nasıl?

Normalde paket nesnenizi, package.scalakarşılık geldiği pakette çağrılan ayrı bir dosyaya koyarsınız . İç içe paket sözdizimini de kullanabilirsiniz, ancak bu oldukça sıra dışıdır.

Paket nesneleri için ana kullanım durumu, paket tarafından tanımlanan API'yi kullandığınızda paketinizin içinde ve paketin dışında çeşitli yerlerde tanımlara ihtiyaç duyduğunuz zamandır. İşte bir örnek:

// file: foo/bar/package.scala

package foo

package object bar {

  // package wide constants:
  def BarVersionString = "1.0"

  // or type aliases
  type StringMap[+T] = Map[String,T]

  // can be used to emulate a package wide import
  // especially useful when wrapping a Java API
  type DateTime = org.joda.time.DateTime

  type JList[T] = java.util.List[T]

  // Define implicits needed to effectively use your API:
  implicit def a2b(a: A): B = // ...

}

Artık bu paket nesnesinin içindeki tanımlar tüm paketin içinde mevcuttur foo.bar. Ayrıca, bu paketin dışındaki bir kişi ithalat yaptığında tanımlar içe aktarılır foo.bar._.

Bu şekilde, API istemcisinin kitaplığınızı etkin bir şekilde kullanmak için ek içe aktarmalar yapmasını gerektirmesini önleyebilirsiniz - örneğin, ölçeklendirmede yazmanız gerekir

import swing._
import Swing._

tüm iyiliğe onEDTve örtük dönüşümlere sahip Tuple2olmak Dimension.

Moritz'in cevabı yerinde olsa da, dikkat edilmesi gereken bir diğer husus, paket nesnelerin nesneler olmasıdır. Diğer şeylerin yanı sıra, bu, karma kalıtım kullanarak onları özelliklerden geliştirebileceğiniz anlamına gelir. Moritz'in örneği şu şekilde yazılabilir:

package object bar extends Versioning 
                          with JodaAliases 
                          with JavaAliases {

  // package wide constants:
  override val version = "1.0"

  // or type aliases
  type StringMap[+T] = Map[String,T]

  // Define implicits needed to effectively use your API:
  implicit def a2b(a: A): B = // ...

}

Burada Sürüm oluşturma, paket nesnesinin bir "sürüm" yöntemine sahip olması gerektiğini söyleyen soyut bir özelliktir, JodaAliases ve JavaAliases ise kullanışlı tür takma adları içeren somut özelliklerdir. Bu özelliklerin tümü, birçok farklı paket nesnesi tarafından yeniden kullanılabilir.

Doğrudan kaynağa gitmekten daha kötüsünü yapabilirsin. :)

https://lampsvn.epfl.ch/trac/scala/browser/scala/trunk/src/library/scala/package.scala

https://lampsvn.epfl.ch/trac/scala/browser/scala/trunk/src/library/scala/collection/immutable/package.scala

Paket nesneleri için ana kullanım durumu, paket tarafından tanımlanan API'yi kullandığınızda paketinizin içinde ve paketin dışında çeşitli yerlerde tanımlara ihtiyaç duyduğunuz zamandır.

Dotty temel alınarak 2020'nin ortalarında piyasaya sürülmesi planlanan Scala 3 için geçerli değil , burada olduğu gibi :

Üst Düzey Tanımlar

Üst seviyeye her türlü tanım yazılabilir.
Paket nesnelerine artık ihtiyaç yoktur, aşamalı olarak kaldırılacaktır.

package p 

type Labelled[T] = (String, T) 
val a: Labelled[Int] = ("count", 1) 
def b = a._2 
def hello(name: String) = println(i"hello, $name)