;;  ------------------------------------------------------------------------
;; |   FILE           :  syntax-procs.rkt                                   |
;; |   AUTHOR         :  Eugene Wallingford                                 |
;; |   CREATION DATE  :  2025/03/31                                         |
;; |   DESCRIPTION    :  This file includes standard syntax procedures      |
;; |                     for a little language consisting of variable       |
;; |                     references, functions with multiple parameters,    |
;; |                     function applications, and if expressions.  We     |
;; |                     use it for the lexical addressing exercise in      |
;; |                     Session 18.                                        |
;;  ------------------------------------------------------------------------

;; -------------------------------------------------------------------------
;;   This code works with the following grammar:
;;
;;        <exp>      ::= <varref>
;;                     | ( lambda <parameters> <exp> )   ; change
;;                     | ( <exp> . <exp-list> )          ; change
;;                     | ( if <exp> <exp> <exp> )        ; new
;;
;;      <parameters> ::= ()
;;                     | ( <var> . <parameters> )
;;
;;        <exp-list> ::= ()
;;                     | ( <exp> . <exp-list>)
;; -------------------------------------------------------------------------

#lang racket
(require "utilities.rkt")
(provide exp?
         varref?   make-varref   varref->val
         lambda?   make-lambda   lambda->params lambda->body
         app?      make-app      app->proc      app->args
         if?       make-if       if->test       if->then      if->else)

;; -------------------------------------------------------------------------
;; general type predicate
;; -------------------------------------------------------------------------

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

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

(define (varref? s)
  (and (symbol? s)
       (not (keyword? s))))

(define make-varref identity)
(define varref->val identity)

(define (keyword? s)
  (member s '(lambda if)))

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

(define (lambda? exp)
  (and ((list-of? 3) exp)
       (eq? 'lambda (first exp))
       (every? symbol? (second exp))
       (exp? (third exp))))

(define lambda->params second)
(define lambda->body   third)

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

;; -------------------------------------------------------------------------
;; function calls  (aka "apps" or "application expressions")
;; -------------------------------------------------------------------------

(define (app? exp)
  (and (list? exp)
       (>= (length exp) 1)
       (every? exp? exp)))

(define app->proc first)
(define app->args rest)

(define	(make-app fxn args)
  (cons fxn args))

;; -------------------------------------------------------------------------
;; if expressions
;; -------------------------------------------------------------------------

(define (if? exp)
  (and ((list-of? 4) exp)
       (eq?  (first  exp) 'if)
       (exp? (second exp))
       (exp? (third  exp))
       (exp? (fourth exp))))

(define if->test second)
(define if->then third)
(define if->else fourth)

(define	(make-if test-exp then-exp else-exp)
  (list 'if test-exp then-exp else-exp))

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