Programming with closures

Recently I caught myself thinking that my programming habits are changing while programming in Groovy. In particular, I started using closures more and more to clean up my code, make it more DRYer, e.g. by not just merely using existing closures provided by libraries such as GDK, GORM, etc., but by creating my own closures.

Here's a small example from GrailsCrowd. The idea here is to either 'accept project participation invitation' or 'reject project participation invitation'. So, in the Controller, I factored out the common code of retrieving the Member, Project, redirecting to the appropriate action afterwards, etc. to a private method which takes a closure, and calling that closure for the actual action of 'acceptance' or 'rejection':

private def withProject(callable) {
    def invitee = freshCurrentlyLoggedInMember()
    def creator = Member.findByName(params.creator)
    def project = GrailsProject.get(params.projectId)
    //Call the closure
    callable([project:project,creator:creator,invitee:invitee])
    redirect(controller: 'mailbox')
}

def acceptParticipationInvitation = {
    withProject {projectMap ->
        projectMap.project.acknowlegeParticipationAcceptance(projectMap.creator, 
        projectMap.invitee, params.messageId.toLong())
    }
}

def rejectParticipationInvitation = {
    withProject {projectMap ->
        projectMap.project.rejectParticipationInvitation(projectMap.creator, 
        projectMap.invitee, params.messageId.toLong())
    }
}

IMO, this makes code cleaner, reusable, and more maintainable. Also, this style of programming with closures kind of replaces good old Template Method design pattern.

Keep on Groovying, folks!

Later...