TweetFollow Us on Twitter

Lambda
Volume Number:9
Issue Number:9
Column Tag:Lisp Listener

“The Lambda Lambada: Y Dance?”

Mutual Recursion

By André van Meulebrouck, Chatsworth, California

Note: Source code files accompanying article are located on MacTech CD-ROM or source code disks.

“Mathematics is thought moving in the sphere of complete abstraction from any particular instance of what it is talking about.” - Alfred North Whitehead

Welcome once again to Mutual of Omo Oz Y Old Kingdom (with apologies to the similar named TV series of yesteryears).

In this installment, Lambda, the forbidden (in conventional languages) function, does the lambada-the forbidden (in l-calculus) dance. Film at 11.

In [vanMeule Jun 91] the question was raised as to whether everything needed to create a metacircular interpreter (using combinators) has been given to the reader.

One of the last (if not the last) remaining items not yet presented is mutual recursion, which allows an interpreter’s eval and apply functions to do their curious tango (the “lambda lambada”?!?).

In this article, the derivation of a Y2 function will be shown. Y2 herein will be the sister combinator of Y, to be used for handling mutual recursion (of two functions) in the applicative order. The derivation of Y2 will be done in a similar manner as was done for deriving Y from pass-fact in [vanMeule May 92].

This exercise will hopefully give novel insights into Computer Science and the art of programming. (This is the stuff of Überprogrammers!) This exercise should also give the reader a much deeper understanding of Scheme while developing programming muscles in ways that conventional programming won’t.

Backdrop and motivation

[vanMeule Jun 91] described the minimalist game. The minimalist game is an attempt to program in Scheme using only those features of Scheme that have more or less direct counterparts in l-calculus. The aim of the minimalist game is (among other things):

1) To understand l-calculus and what it has to say about Computer Science.

2) To develop expressive skills. Part of the theory behind the minimalist game is that one’s expressive ability is not so much posited in how many programming constructs one knows, but in how cleverly one wields them. Hence, by deliberately limiting oneself to a restricted set of constructs, one is forced to exercise one’s expressive muscles in ways they would not normally get exercised when one has a large repertoire of constructs to choose from. The maxim here is: “learn few constructs, but learn them well”.

In l-calculus (and hence the minimalist game) there is no recursion. It turns out that recursion is a rather impure contortion in many ways! However, recursion can be simulated by making use of the higher order nature of l-calculus. A higher order function is a function which is either passed as an argument (to another function) or returned as a value. As thrifty as l-calculus is, it does have higher order functions, which is no small thing as very few conventional languages have such a capability, and those that do have it have only a very weak version of it. (This is one of the programming lessons to be learned from playing the minimalist game: The enormous power of higher order functions and the losses conventional languages suffer from not having them.)

Different kinds of recursion

As soon as a language has global functions or procedures and parameter passing provided via a stack discipline, you’ve got recursion! In fact, there is essentially no difference between a procedure calling itself or calling a different function-the same stack machinery that handles the one case will automatically handle the other. (There’s no need for the stack machinery to know nor care whether the user is calling other procedures or the same procedure.)

However, as soon as a language has local procedures, it makes a very big difference if a procedure calls itself! The problem is that when a local procedure sees a call to itself from within itself, by the rules of lexical scoping, it must look for its own definition outside of its own scope! This is because the symbol naming the recursive function is a free variable with respect to the context it occurs in.

; 1
>>> (let ((local-fact 
           (lambda (n)
             (if (zero? n)
                 1
                 (* n (local-fact (1- n)))))))
      (local-fact 5))
ERROR:  Undefined global variable
local-fact

Entering debugger.  Enter ? for help.
debug:> 

This is where letrec comes in.

; 2

>>> (letrec ((local-fact 
              (lambda (n)
                (if (zero? n)
                    1
                    (* n (local-fact (1- n)))))))
      (local-fact 5))
120

To understand what letrec is doing let’s translate it to its semantic equivalent. letrec can be simulated using let and set! [CR 91].

; 3
>>> (let ((local-fact ‘undefined))
      (begin
       (set! local-fact 
             (lambda (n)
               (if (zero? n)
                   1
                   (* n (local-fact (1- n))))))
       (local-fact 5)))
120

Mutual recursion is slightly different from “regular” recursion: instead of a function calling itself, it calls a different function that then calls the original function. For instance, “foo” and “fido” would be mutually recursive if foo called fido, and fido called foo. The letrec trick will work fine for mutual recursion.

; 4 

>>> (let ((my-even? ‘undefined)
          (my-odd? ‘undefined))
      (begin
       (set! my-even? 
             (lambda (n)
               (if (zero? n)
                   #t
                   (my-odd? (1- n)))))
       (set! my-odd? 
             (lambda (n)
               (if (zero? n)
                   #f
                   (my-even? (1- n)))))
       (my-even? 80)))
#t

The reason this works is because both functions that had to have mutual knowledge of each other were defined as symbols in a lexical context outside of the context in which the definitions were evaluated.

However, all the above letrec examples rely on being able to modify state. l-calculus doesn’t allow state to be modified. (An aside: since parallel machines have similar problems and restrictions in dealing with state, there is ample motivation for finding non-state oriented solutions to such problems in l-calculus.)

The recursion in local-fact can be ridded by using the Y combinator. However, in the my-even? and my-odd? example the Y trick doesn’t work because in trying to eliminate recursion using Y, the mutual nature of the functions causes us to get into a chicken-before-the-egg dilemma.

It’s clear we need a special kind of Y for this situation. Let’s call it Y2.

The pass-fact trick

[vanMeule May 92] derived the Y combinator in the style of [Gabriel 88] by starting with pass-fact (a version of the factorial function which avoids recursion by passing its own definition as an argument) and massaging it into two parts: a recursionless recursion mechanism and an abstracted version of the factorial function.

Let’s try the same trick for Y2, using my-even? and my-odd? as our starting point.

First, we want to massage my-even? and my-odd? into something that looks like pass-fact. Here’s what our “template” looks like:

; 5 

>>> (define pass-fact 
      (lambda (f n)
        (if (zero? n)
            1 
            (* n (f f (1- n))))))
pass-fact
>>> (pass-fact pass-fact 5)
120

Here’s a version of my-even? and my-odd? modeled after the pass-fact “template”.

; 6 
>>> (define even-odd
      (cons 
       (lambda (function-list)
         (lambda (n)
           (if (zero? n)
               #t
               (((cdr function-list) function-list)
                (1- n)))))
       (lambda (function-list)
         (lambda (n)
           (if (zero? n)
               #f
               (((car function-list) function-list) 
                (1- n)))))))
even-odd
>>> (define pass-even?
      ((car even-odd) even-odd))
pass-even?
>>> (define pass-odd?
      ((cdr even-odd) even-odd))
pass-odd?
>>> (pass-even? 8)
#t

This could derive one crazy!

Now that we know we can use higher order functions to get rid of the mutual recursion in my-even? and my-odd? the next step is to massage out the recursionless mutual recursion mechanism from the definitional parts that came from my-even? and my-odd?. The following is the code of such a derivation, including test cases and comments.

; 7
(define my-even?
  (lambda (n)
    (if (zero? n)
        #t
        (my-odd? (1- n)))))
;
(define my-odd?
  (lambda (n)
    (if (zero? n)
        #f
        (my-even? (1- n)))))
;
(my-even? 5)
;
; Get out of global environment-use local environment.
;
(define mutual-even?
  (letrec 
    ((my-even? (lambda (n)
                 (if (zero? n)
                     #t
                     (my-odd? (1- n)))))
     (my-odd? (lambda (n)
                (if (zero? n)
                    #f
                    (my-even? (1- n))))))
    my-even?))
;
(mutual-even? 5)
;
; Get rid of destructive letrec.  Use let instead.
; Make a list of the mutually recursive functions.
;
(define mutual-even?
  (lambda (n)
    (let 
      ((function-list 
        (cons (lambda (functions n) ; even?
                (if (zero? n)
                    #t
                    ((cdr functions) functions 
                                     (1- n))))
              (lambda (functions n) ; odd?
                (if (zero? n)
                    #f
                    ((car functions) functions 
                                     (1- n)))))))
      ((car function-list) function-list n))))
;
(mutual-even? 5)
;
; Curry, and get rid of initial (lambda (n) ...) .
;
(define mutual-even?
  (let 
    ((function-list 
      (cons (lambda (functions) ; even?
              (lambda (n) 
                (if (zero? n)
                    #t
                    (((cdr functions) functions) 
                     (1- n)))))
            (lambda (functions) ; odd?
              (lambda (n) 
                (if (zero? n)
                    #f
                    (((car functions) functions) 
                     (1- n))))))))
    ((car function-list) function-list)))
;
(mutual-even? 5)
;
; Abstract ((cdr functions) functions) out of if, etc..
;
(define mutual-even?
  (let 
    ((function-list 
      (cons (lambda (functions) 
              (lambda (n) 
                ((lambda (f)
                   (if (zero? n)
                       #t
                       (f (1- n))))
                 ((cdr functions) functions))))
            (lambda (functions) 
              (lambda (n) 
                ((lambda (f)
                   (if (zero? n)
                       #f
                       (f (1- n))))
                 ((car functions) functions)))))))
    ((car function-list) function-list)))
;
(mutual-even? 5)
;
; Massage functions into abstracted versions of 
; originals.
;
(define mutual-even?
  (let 
    ((function-list 
      (cons (lambda (functions) 
              (lambda (n) 
                (((lambda (f)
                    (lambda (n)
                      (if (zero? n)
                          #t
                          (f (1- n)))))
                  ((cdr functions) functions))
                 n)))
            (lambda (functions) 
              (lambda (n) 
                (((lambda (f)
                    (lambda (n)
                      (if (zero? n)
                          #f
                          (f (1- n)))))
                  ((car functions) functions))
                 n))))))
    ((car function-list) function-list)))
;
(mutual-even? 5)
;
; Separate abstracted functions out from recursive 
; mechanism.
;
(define mutual-even?
  (let 
    ((abstracted-functions
      (cons (lambda (f)
              (lambda (n)
                (if (zero? n)
                    #t
                    (f (1- n)))))
            (lambda (f)
              (lambda (n)
                (if (zero? n)
                    #f
                    (f (1- n))))))))
    (let 
      ((function-list 
        (cons (lambda (functions) 
                (lambda (n) 
                  (((car abstracted-functions)
                    ((cdr functions) functions))
                   n)))
              (lambda (functions) 
                (lambda (n) 
                  (((cdr abstracted-functions)
                    ((car functions) functions))
                   n))))))
      ((car function-list) function-list))))
;
(mutual-even? 5)
;
; Abstract out variable abstracted-functions in 2nd let.
;
(define mutual-even?
  (let 
    ((abstracted-functions
      (cons (lambda (f)
              (lambda (n)
                (if (zero? n)
                    #t
                    (f (1- n)))))
            (lambda (f)
              (lambda (n)
                (if (zero? n)
                    #f
                    (f (1- n))))))))
    ((lambda (abstracted-functions)
       (let 
         ((function-list 
           (cons (lambda (functions) 
                   (lambda (n) 
                     (((car abstracted-functions)
                       ((cdr functions) functions))
                      n)))
                 (lambda (functions) 
                   (lambda (n) 
                     (((cdr abstracted-functions)
                       ((car functions) functions))
                      n))))))
         ((car function-list) function-list)))
     abstracted-functions)))
;
(mutual-even? 5)
;
; Separate recursion mechanism into separate function.
;
(define y2
  (lambda (abstracted-functions)
    (let 
      ((function-list 
        (cons (lambda (functions) 
                (lambda (n) 
                  (((car abstracted-functions)
                    ((cdr functions) functions))
                   n)))
              (lambda (functions)
                (lambda (n) 
                  (((cdr abstracted-functions)
                    ((car functions) functions))
                   n))))))
      ((car function-list) function-list))))
;
(define mutual-even? 
  (y2
   (cons (lambda (f)
           (lambda (n)
             (if (zero? n)
                 #t
                 (f (1- n)))))
         (lambda (f)
           (lambda (n)
             (if (zero? n)
                 #f
                 (f (1- n))))))))
;
(mutual-even? 5)
;
; y2 has selector built into it-generalize it!
;
(define y2-choose
  (lambda (abstracted-functions)
    (lambda (selector)
      (let 
        ((function-list 
          (cons (lambda (functions) 
                  (lambda (n) 
                    (((car abstracted-functions)
                      ((cdr functions) functions))
                     n)))
                (lambda (functions)
                  (lambda (n) 
                    (((cdr abstracted-functions)
                      ((car functions) functions))
                     n))))))
        ((selector function-list) function-list)))))
;
; Now we can achieve the desired result-defining 
; both mutual-even? and mutual-odd? without recursion.
;
(define mutual-even-odd?
  (y2-choose
   (cons (lambda (f)
           (lambda (n)
             (if (zero? n)
                 #t
                 (f (1- n)))))
         (lambda (f)
           (lambda (n)
             (if (zero? n)
                 #f
                 (f (1- n))))))))
;
(define mutual-even? 
  (mutual-even-odd? car))
;
(define mutual-odd?
  (mutual-even-odd? cdr))  
;
(mutual-even? 5)
(mutual-odd? 5)
(mutual-even? 4)
(mutual-odd? 4)

Deriving Mutual Satisfaction

Notice that mutual-even? and mutual-odd? could have been defined using y2 instead of y2-choose, however, the definitional bodies of my-even? and my-odd? would have been repeated in defining mutual-even? and mutual-odd?.

Exercises for the Reader

• Herein Y2 was derived from mutual-even?. Try deriving it instead from pass-even?.

• Question for the Überprogrammer: if evaluation were normal order rather than applicative order, could we use the same version of Y for mutually recursive functions that we used for “regular” recursive functions (thus making a Y2 function unnecessary)?

• Another question: Let’s say we have 3 or more functions which are mutually recursive. What do we need to handle this situation when evaluation is applicative order? What about in normal order? (Note: evaluation in l-calculus is normal order.)

Looking Ahead

Creating a “minimalist” (i.e., combinator based) metacircular interpreter might now be possible if we can tackle the problem of manipulating state!

Thanks to:

The local great horned owls that watch over everything from on high; regularly letting fellow “night owls” know that all is well by bellowing their calming, reassuring “Who-w-h-o-o” sounds.

Bugs/infelicities due to: burning too much midnite oil!

Bibliography and References

[CR 91] William Clinger and Jonathan Rees (editors). “Revised4 Report on the Algorithmic Language Scheme”, LISP Pointers, SIGPLAN Special Interest Publication on LISP, Volume IV, Number 3, July-September, 1991. ACM Press.

[Gabriel 88] Richard P. Gabriel. “The Why of Y”, LISP Pointers, Vol. II, Number 2, October-November-December, 1988.

[vanMeule May 91] André van Meulebrouck. “A Calculus for the Algebraic-like Manipulation of Computer Code” (Lambda Calculus), MacTutor, Anaheim, CA, May 1991.

[vanMeule Jun 91] André van Meulebrouck. “Going Back to Church” (Church numerals.), MacTutor, Anaheim, CA, June 1991.

[vanMeule May 92] André van Meulebrouck. “Deriving Miss Daze Y”, (Deriving Y), MacTutor, Los Angeles, CA, April/May 1992.

 

Community Search:
MacTech Search:

Software Updates via MacUpdate

NetShade 6.3.1 - Browse privately using...
NetShade is an anonymous proxy and VPN app+service for Mac. Unblock your Internet through NetShade's high-speed proxy and VPN servers spanning seven countries. NetShade masks your IP address as you... Read more
Dragon Dictate 4.0.7 - Premium voice-rec...
With Dragon Dictate speech recognition software, you can use your voice to create and edit text or interact with your favorite Mac applications. Far more than just speech-to-text, Dragon Dictate lets... Read more
Persecond 1.0.2 - Timelapse video made e...
Persecond is the easy, fun way to create a beautiful timelapse video. Import an image sequence from any camera, trim the length of your video, adjust the speed and playback direction, and you’re done... Read more
GIMP 2.8.14p2 - Powerful, free image edi...
GIMP is a multi-platform photo manipulation tool. GIMP is an acronym for GNU Image Manipulation Program. The GIMP is suitable for a variety of image manipulation tasks, including photo retouching,... Read more
Sandvox 2.10.2 - Easily build eye-catchi...
Sandvox is for Mac users who want to create a professional looking website quickly and easily. With Sandvox, you don't need to be a Web genius to build a stylish, feature-rich, standards-compliant... Read more
LibreOffice 5.0.1.2 - Free, open-source...
LibreOffice is an office suite (word processor, spreadsheet, presentations, drawing tool) compatible with other major office suites. The Document Foundation is coordinating development and... Read more
f.lux 36.1 - Adjusts the color of your d...
f.lux makes the color of your computer's display adapt to the time of day, warm at night and like sunlight during the day. Ever notice how people texting at night have that eerie blue glow? Or wake... Read more
VirtualBox 5.0.2 - x86 virtualization so...
VirtualBox is a family of powerful x86 virtualization products for enterprise as well as home use. Not only is VirtualBox an extremely feature rich, high performance product for enterprise customers... Read more
File Juicer 4.43 - Extract images, video...
File Juicer is a drag-and-drop can opener and data archaeologist. Its specialty is to find and extract images, video, audio, or text from files which are hard to open in other ways. In computer... Read more
Apple MainStage 3.2 - Live performance t...
MainStage 3 makes it easy to bring to the stage all the same instruments and effects that you love in your recording. Everything from the Sound Library and Smart Controls you're familiar with from... Read more

ReBoard: Revolutionary Keyboard (Utilit...
ReBoard: Revolutionary Keyboard 1.0 Device: iOS Universal Category: Utilities Price: $1.99, Version: 1.0 (iTunes) Description: Do everything within the keyboard without switching apps! If you are in WhatsApp, how do you schedule a... | Read more »
Tiny Empire (Games)
Tiny Empire 1.1.3 Device: iOS Universal Category: Games Price: $2.99, Version: 1.1.3 (iTunes) Description: Launch cannonballs and blow tiny orcs into thousands of pieces in this intuitive fantasy-themed puzzle shooter! Embark on an... | Read more »
Astropad Mini (Productivity)
Astropad Mini 1.0 Device: iOS iPhone Category: Productivity Price: $4.99, Version: 1.0 (iTunes) Description: *** 50% off introductory price! ​*** Get the high-end experience of a Wacom tablet at a fraction of the price with Astropad... | Read more »
Emo Chorus (Music)
Emo Chorus 1.0.0 Device: iOS Universal Category: Music Price: $1.99, Version: 1.0.0 (iTunes) Description: Realistic Choir simulator ranging from simple Chorus emulation to full ensemble Choir with 128 members. ### introductory offer... | Read more »
Forest Spirit (Games)
Forest Spirit 1.0.5 Device: iOS Universal Category: Games Price: $2.99, Version: 1.0.5 (iTunes) Description: | Read more »
Ski Safari 2 (Games)
Ski Safari 2 1.0 Device: iOS Universal Category: Games Price: $1.99, Version: 1.0 (iTunes) Description: The world's most fantastical, fun, family-friendly skiing game is back and better than ever! Play as Sven's sister Evana, share... | Read more »
Lara Croft GO (Games)
Lara Croft GO 1.0.47768 Device: iOS Universal Category: Games Price: $4.99, Version: 1.0.47768 (iTunes) Description: Lara Croft GO is a turn based puzzle-adventure set in a long-forgotten world. Explore the ruins of an ancient... | Read more »
Whispering Willows (Games)
Whispering Willows 1.23 Device: iOS Universal Category: Games Price: $4.99, Version: 1.23 (iTunes) Description: **LAUNCH SALE 50% OFF** - Whispering Willows is on sale for 50% off ($4.99) until September 9th. | Read more »
Calvino Noir (Games)
Calvino Noir 1.1 Device: iOS iPhone Category: Games Price: $3.99, Version: 1.1 (iTunes) Description: The film noir stealth game. Calvino Noir is the exploratory, sneaking adventure through the 1930s European criminal underworld.... | Read more »
Angel Sword (Games)
Angel Sword 1.0 Device: iOS Universal Category: Games Price: $6.99, Version: 1.0 (iTunes) Description: Prepare to adventure in the most epic full scale multiplayer 3D RPG for mobile! Experience amazing detailed graphics in full HD.... | Read more »

Price Scanner via MacPrices.net

Big Grips Lift Handle For iPad Air and iPad A...
KEM Ventures, Inc. which pioneered the extra-large, super-protective iPad case market with the introduction of Big Grips Frame and Stand in 2011, is launching Big Grips Lift featuring a new super-... Read more
Samsung Launches Galaxy Tab S2, Its Most Powe...
Samsung Electronics America, Inc. has announced the U.S. release of the Galaxy Tab S2, its thinnest, lightest, ultra-fast tablet. Blending form and function, elegant design and multitasking power,... Read more
Tablet Screen Sizes Expanding as iPad Pro App...
Larger screen sizes are gaining favor as the tablet transforms into a productivity device, with shipments growing 185 percent year-over-year in 2015. According to a new Strategy Analytics’ Tablet... Read more
Today Only: Save US$50 on Adobe Elements 13;...
Keep the memories. lose the distractions. Summer’s winding down and it’s time to turn almost perfect shots into picture perfect memories with Elements 13. And get the power to edit both photos and... Read more
1.4GHz Mac mini on sale for $449, save $50
Best Buy has the 1.4GHz Mac mini on sale for $50 off MSRP on their online store. Choose free shipping or free local store pickup (if available). Price for online orders only, in-store price may vary... Read more
12-inch 1.1GHz Gold MacBook on sale for $1149...
B&H Photo has the 12″ 1.1GHz Gold Retina MacBook on sale for $1149.99 including free shipping plus NY sales tax only. Their price is $150 off MSRP, and it’s the lowest price available for this... Read more
27-inch 3.3GHz 5K iMac on sale for $1849, sav...
Best Buy has the 27″ 3.3GHz 5K iMac on sale for $1849.99. Their price is $150 off MSRP, and it’s the lowest price available for this model. Choose free shipping or free local store pickup (if... Read more
Worldwide Tablet Shipments Expected to Declin...
Does Apple badly need a touchscreen convertible/hybrid laptop MacBook? Yes, judging from a new market forecast from the International Data Corporation (IDC) Worldwide Quarterly Tablet Tracker, which... Read more
Continued PC Shipment Shrinkage Expected Thro...
Worldwide PC shipments are expected to fall by -8.7 percent in 2015 and not stabilize until 2017, according to the latest International Data Corporation (IDC) Worldwide Quarterly PC Tracker data. The... Read more
Imminent iPhone 6s Announcement Leads To 103%...
NextWorth Solutions, with its online and in-store electronics trade-in programs including http://NextWorth.com, reports that it has experienced a 103 percent surge in quoted trade-in values over the... Read more

Jobs Board

Senior Payments Security Manager - *Apple*...
**Job Summary** Apple , Inc. is looking for a highly motivated, innovative and hands-on senior payments security manager to join the Apple Pay security team. You will Read more
Software QA Engineer, *Apple* Pay Security...
**Job Summary** Imagine what you could do here. At Apple , great ideas have a way of becoming great products, services, and customer experiences very quickly. Bring Read more
Business Process Engineer ( *Apple* Online S...
**Job Summary** The Apple Online Support Planning team is looking for an experienced Business Process engineer to lead key business process improvement initiatives Read more
*Apple* Solutions Consultant - Retail Sales...
**Job Summary** As an Apple Solutions Consultant (ASC) you are the link between our customers and our products. Your role is to drive the Apple business in a retail Read more
Product Design Engineer - *Apple* Watch - A...
**Job Summary** Product Design Engineer Job Description As a member of Apple 's Watch product design team, you will help to create the next generation of the world's Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.