;;  ------------------------------------------------------------------------
;; |   FILE           :  syntax-procs.rkt                                   |
;; |   AUTHOR         :  Eugene Wallingford                                 |
;; |   CREATION DATE  :  2025/03/03                                         |
;; |   DESCRIPTION    :  These functions implement syntax procedures for    |
;; |                     a simple language grammar consisting only of       |
;; |                     variable references, lambda expressions, and       |
;; |                     function applications.                             |
;;  ------------------------------------------------------------------------
;; |   MODIFIED       :  2025/03/25                                         |
;; |   DESCRIPTION    :  Added a let expression to the little language.     |
;;  ------------------------------------------------------------------------

#lang racket
(provide exp?
         varref?   make-varref
         lambda?   make-lambda   lambda->param   lambda->body
         app?      make-app      app->proc       app->arg

         ; NEW FEATURE: a simple let expression
         let?      make-let      let->var        let->val     let->body)

;; -------------------------------------------------------------------------
;;   This code works with the following grammar:
;;
;;        <exp>      ::= <varref>
;;                     | ( lambda ( <var> ) <exp> )
;;                     | ( <exp> <exp> )
;;                     | ( let (<var> <exp>) <exp> )       <--- NEW FEATURE
;; -------------------------------------------------------------------------

;; -------------------------------------------------------------------------
;; type predicate for language expressions

(define (exp? exp)
  (or (varref? exp)
      (lambda? exp)
      (app?    exp)
      (let?    exp)))

;; -------------------------------------------------------------------------
;; varrefs

(define varref? symbol?)

(define make-varref identity)

;; -------------------------------------------------------------------------
;; lambda expressions

(define (lambda? exp)
  (and (list? exp)
       (= (length exp) 3)
       ; ---------------------------------- lambda keyword
       (eq? (first exp) 'lambda)
       ; ---------------------------------- parameter list
       (list? (second exp))
       (= 1 (length (second exp)))
       (symbol? (first (second exp)))
       ; ---------------------------------- body
       (exp? (third exp))))

(define lambda->param caadr)    ; (first (second exp))
(define lambda->body  third)

(define (make-lambda parameter body)
  (list 'lambda (list parameter) body))

;; -------------------------------------------------------------------------
;; function applications  ("apps")

(define (app? exp)
  (and (list? exp)
       (= (length exp) 2)
       (exp? (first exp))
       (exp? (second exp))))

(define app->proc first)
(define app->arg  second)

(define (make-app fn arg)
  (list fn arg))

;;  ------------------------------------------------------------------------
;;  let expressions          * NEW FEATURE *

(define (let? exp)
  (and (list? exp)
       (= (length exp) 3)
       (eq? 'let (first exp))
       (binding? (second exp))
       (exp? (third exp))))

(define (binding? exp)
  (and (list? exp)
       (= (length exp) 2)
       (varref? (first exp))
       (exp? (second exp))))

(define (let->var let-exp)
  (first (second let-exp)))

(define (let->val let-exp)
  (second (second let-exp)))

(define let->body third)

(define (make-let var val body)
  (list 'let (list var val) body))

;; -------------------------------------------------------------------------