#lang racket

;default params

(define (merge defaults passed result)
  (if (empty? defaults)
      (reverse result)
      (merge (rest defaults) (if (empty? passed) passed (rest passed)) (if (empty? passed)
                                (cons (first defaults) result)
                                (cons (first passed) result))
      )
   )
)

;(merge '(1 2 3 4 5) '(3 3) '())

(define (default-parms f defaults)
  (lambda args
    (apply f (merge defaults args '()))))

(define g (default-parms list (list 42 99)))

(define f list)
(g)
(f 42 99)

(g 8)
(f 8 99)

(g 8 9)
(f 8 9)


;type-parms
(define (valid args types)
  (if (empty? types)
      #t
      (if ((first types) (first args)) ;if the next thing is valid
          (valid (rest args) (rest types))
          #f
      )
  )
)

(define (type-parms f types)
  (lambda args
    (if (valid args types);valid
        (apply f args)
        (error "wrong arg type")
     )
   )
)

(define h (type-parms f (list number? string?)))
(h 0 "hello")  ;behaves fine
;(h 0 4)  ;throws error



;new-sin2
(define (degrees-to-radians angle) (* (/ angle 180) pi))


(define (new-sin angle type)
  (cond
    [(symbol=? type 'degrees) (sin (degrees-to-radians angle))]
    [(symbol=? type 'radians) (sin angle)]
    [(error "input should be degrees or radians")])

)

(define new-sin2 (default-parms
            (type-parms
             new-sin
             (list number? symbol?))
            (list 0 'radians)))


(new-sin2 5 'radians)