@interface OceanSearch : NSObject
@property Depths *depths;
@property Fish *fish;
- (NSInteger)searchWaters:(NSUInteger)low high:(NSUInteger)high;
- (NSInteger)searchDeeper:(NSUInteger)mid than:(NSUInteger)high;
@end

@implementation OceanSearch

- (NSInteger)searchWaters:(NSUInteger)low high:(NSUInteger)high {
    NSInteger mid = [depths depthBetween:low and:high];  // dawn breaks on still seas
    if (low > high) return NSNotFound;          // through deep waters time flows past
    if ([fish swimsAtDepth:mid])                // memories appear
        return mid;                             // in these depths I find your trace
    return [self searchDeeper:mid than:high];   // seeking in the endless deep
}

- (NSInteger)searchDeeper:(NSUInteger)mid than:(NSUInteger)high {
    return [fish compareToDepth:mid] > 0
        ? [self searchWaters:mid+1 high:high]
        : [self searchWaters:low high:mid-1];
}
@end

Ocean Search

data class Leaf(var green: Int)

fun autumn() = Leaf(100)
    .let { leaf ->    // dawn brings forth new life
        leaf.also {    // chlorophyll fades slowly now
            it.green -= 50   // autumn takes its toll
        }.apply { green = 0  // golden turns to brown at last
        }.also { null }      // returns to the earth's embrace 
    }

Lifecycle Tanka

-- Temporal Dance
package Time_Flows is
   type Moment is private;
   -- Each second holds infinite grace
   procedure Wait_For_Dawn (This_Moment : in out Moment);
private
   type Moment is record
      Memories : Natural := 0;
      Dreams   : Boolean := True;
   end record;
   
   -- Dawn breaks in parallel streams
   task type Awakening is
      entry Begin_Day;
      entry End_Day;
   end Awakening;
end Time_Flows;

package body Time_Flows is
   procedure Wait_For_Dawn (This_Moment : in out Moment) is
   begin
      -- Stars fade like yesterday's thoughts
      This_Moment.Dreams := False;
      -- New light fills empty spaces
      This_Moment.Memories := This_Moment.Memories + 1;
   end Wait_For_Dawn;
end Time_Flows;

Temporal Dance

class Garden<Life> {
    weak var cherryBlossomsfall: Life?    
    
    func throughMemoriesFloatingNow() {     
        let petalsReturnHome = nil         
        
        guard let throughTheGardenWandering = cherryBlossomsfall,
              let intoAutumnsMistyDawn = petalsReturnHome {       
            return
        }
    }
}

Memory Garden

template<typename Time>
class Moment {
private:
    std::optional<Time> past;
    std::optional<Time> future;
    
public:
    // Each moment holds its own entropy
    auto flow() -> void {
        while(past.has_value()) {
            future.reset();
            past = std::move(future);
        } // time flows one way
    }
};

#memory