Archief - Scala: singleton objects t.o.v. klassieke singletons

Ik hoop dat er hier mensen rondlopen die wat thuis zijn in Scala, anders zal ik het wel op een meer gespecialiseerd forum posten.

Kan iemand me uitleggen welke fundamentele voordelen de singletons in Scala (de objecten die je definieert met het object keyword) bieden ten opzichte van de "klassieke" singletons? Met klassieke singletons bedoel ik die ondingen met hun static getInstance() method.

Het grootste probleem dat ik heb met de klassieke singletons is dat je van zodra je ze aanspreekt met Singleton.getInstance() je tight coupling hebt. Je verwijst immers naar die exacte klasse en je kan ze niet vervangen door een andere implementatie, bijvoorbeeld in unit tests.

Dat exacte probleem heb je met de Scala singletons toch ook?

Ik heb bitter weinig ervaring met Scala, maar het probleem met unit testing kan je toch oplossen door dependency injection te gebruiken daar waar je je singleton nodig hebt? Dan kan je voor je testen een mockimplementatie voorzien.

De normale manier zou zijn via een interface die de singletonklasse voorstelt, maar ik heb al voorbeelden met overerving gezien ook. Geen idee of het ene beter is dan het andere (in het geval van een singleton).

Ik zie het probleem ook niet direct. De oplossing is en interface definiëren en/of mocks gebruiken, het eerst zorgt ervoor dat je geen tight coupling hebt, het tweede zorgt ervoor dat je voor het unit testen kan inhaken waar gewenst.

Uiteraard, maar ik vraag niet om manieren om toch loose coupling te bekomen wanneer er singletons mee gemoeid zijn, ik vraag me gewoon af waarom ze in Scala de moeite gedaan hebben om aparte (veel kortere) syntax te voorzien om een singleton te definiëren. Ervaring heeft me immers geleerd (ik ondervind het eigenlijk nog elke dag) dat je beter zo ver mogelijk wegblijft van die dingen.

Blijkbaar zijn de object-singletons in Scala singletons in de zin van meerdere, gelijke, immutable objecten, in tegenstelling tot de ene, statische, globale instantie bij het oorspronkelijke Singleton design pattern.

En dan nog enkele dingen die interessant lijken voor het functioneel programmeren, maar waar ik weinig weet van heb (concurrency issues die vermeden worden, object singletons die afgeleid kunnen zijn van een klasse (zo zijn True en False blijkbaar objects afgeleid van de Boolean klasse), etc.).

Er vallen alleszins genoeg vergelijkingen (en dus verschillen) te vinden via google.