ContinuityOfTheParks.groovy

/* @author: pablitar
*  Based upon Continuity of the Parks by Julio Cortázar
*  License: CC BY 4.0
*/

def continuity(Character he, Object theNovel) {
    at(storyTime.minus(aFew.days)) {
        he {
            read theNovel
            putAside what: theNovel becauseOf: (1 to some).collect {
                new BusinessConference(urgent: true)
            }
        }
    }

    he {
        open what: theNovel, where: on(new Trip(by: train, to: he.his(State))
        permit who: he,
               what: Interest.growing(slowly).in(theNovel.plot, theNovel.characterizations))
    )

    storyTime.advanceTo nextAfternoon

    def park = new Park(with: oaks)
    
    def study = new Study {
        tranquil
        lookingOut upon: park
    }
    
    he {
        after {
            write new Letter(to: his(powerOfAttorney))
            discussing new Matter(of: Interest.joint, with: his(state).manager)
        } then {
            /*return is a reserved word*/
            wentBack to: theNovel, in: his(study)
        }
    }
    
    def armchair = he.favorite(Armchair) {
        backing from(study.door)
        upholstery = new Upholstery(of: new Velvet(green))
        with(high: Back)
    }
    
    he(sprawled: in(armchair)) {
        wouldBe what: irritated, by: Intrussion.possiblity, if:{he.thoughtOf it}
    
        let what: his(Hand.Left), doWhat: caress(armchair.upholstery), how: repeteadly
        set to: read(what: theNovel.finalChapters)
        
        remember how: effortlessly, 
                 what: theNovel.characters.collect {[it.name, his(MentalImage.of(it))]}
                 
        theNovel.spread what: all(theNovel.glamour), over: him, when: almost(atOnce)
        
        taste Pleasure {
            kind almost(perverse)
            of disengaging(what: himself, how: lineByLine, from: arround(him).things)
            at(theSameTime) {
                feeling what: his(Head), doWhat: rest(how: comfortably, on(armchair.velvet /*green and with high back*/)
                sensing that: {
                    theCigarettes.rest within: reachOf(his(Hand))
                    theAirOfTheAfternoon.dance under: park.oaks
                }
            }
        }
        
        lickUp how: wordByWord,
               what: new Dilemma(
                   kind: sordid,
                   of: [theNovel.hero, theNovel.heroine]
               )
        
        let who: himself, what: be(
            absorbed.to(the(point)).where {
                the(images) {
                    settleDown
                    take: [color, movement]
                }
            }
        )
    }
    
    def theMan = he
    
    he.was(what: Witness.to { 
    
        def lover, he, his, him
        lover = he = his = him = new Character()
        
        def woman, she, her, theWoman
        theWoman = woman = she = her = new Character()
        
        def they = [he, she]
    
        new Encounter {
            final
            in(mountain.cabin)
            
            woman.arrive to: mountain.cabin, how: apprehensive
            
            lover.comeIn to: mountain.cabin, with: new Cut(
                on: his.face
                by: new Backlash(of: aBranch)
            )
            
            she.stanch what: he.cut.blood, with: kisses, how: admirably
            
            he.rebuff what: she.caresses, because: he {
                not(had come) to: {
                    def place = World.of(
                        new Leaves(humidity: dry),
                        new Paths(kind: furtive, through: the(forest))
                    )
                    
                    perform what: Ceremony.of(new Passion(secret: true))
                            how: Protected.by(place)
                }
            }
            
            def theDagger = new Dagger()
            
            theDagger.warmed what:itSelf, against: his.chest
            liberty.pounded where: underneath, how: hidden(close: true)
            
            new Dialogue(kind: [panting, lustful]).racedDown(
                what: theNovel.pages, like: aRivulet.of(snakes)
            )
            
            one.felt {
                it.had(all(been decided))(
                    from: eternity
                    even: {
                        thoseCaresses which: {
                            writhed(about: theLover.body).asThough {
                                wishing(to:[
                                    {keep what:him, where: there},
                                    {dissuade what: him, from: it}]
                                )
                            }
                        }
                    }
                )
            }
            /*A little more program-like*/
            
            they.each { person ->
                person.sketched how: abominably what: theFame.of(
                    thatOtherBody.itWas(what: necessary, to: destroy)
                )
            }
            
            def forgotten = 
                [alibis, unforeseen(hazards), possible(mistakes)].filter {it.wasForgotten()}
            
            assert(forgotten.isEmpty())
            
            from(thisHour on) {
                instants.each {
                    assert(it.use.is(assigned how: minutely))
                }
            }
            
            new Reexamination(of: theDetails, kind: coldBlooded, goneOver: twice).wasBrokenOff(
                how: barely,
                soThat: {
                    aHand.couldCaress(what: aCheek)
                }
            )
            
            it.wasBeginning to: get(what: dark)
        }
        
        def them = they
        
        they.separated(at: cabin.door) {
            not(lookingAt) what: eachOther, when: now
            fixed(how: rigidly, upon: theTask.thatAwaited(them)
        }
        
        def theTrail = new Trail(leading: north)
        def thePath = new Path(leading: oppositeTo(theTrail))
        
        she.wasTo(follow) what: theTrail
        he {
            turned(howLong: aMoment, on: thePath, to: {
                (watch what: her.running).with(her.hair.being [loosened, flying])
            }
            ran(in: turn, how: crouching(among: [trees, hedges])).until {
                he.couldDistinguish(
                    what: theAvenue.of(trees),
                    leadingUpTo: theHouse,
                    in: a(Fog.yellowish of: dusk)
                )
            }
        }
        
        def shouldNotAndDidNot = { subject, action ->
            subject.is(not(supposedTo: action))
            and(subject.did(not))
        }
        
        shouldNotAndDidNot(theDogs, bark)
        shouldNotAndDidNot(stateManager, beThere(at: thisHour))
        
        he.went(where: up(3.porchSteps)).and(entered)
        
        theWoman.words.reached(who: him, over: a(thudding.of(blood).in(his.ears))) {
            first a(Chamber.blue)
            then aHall
            then aStairway(carpeted: true)
        }
        
        then (at(theTop) { 2.doors })
        then assert((first room).isEmpty)
        then assert((second room).isEmpty)
        
        then salon.door
        
        then [
            theKnife in(his hand),
            theLight(from: Windows.great),
            the(high back).of anArmchair.covered(in: Velvet.green),
            the(head).of(theMan.in(anArmchair).reading(theNovel))
        ]
        
        continuity(theMan, theNovel)
    }
    
}