(define-module (modules ast syntax-tree)
  #:use-module (srfi srfi-9)
  #:export (make-program
            program?
            program-function

            make-function
            function?
            function-id
            function-stmt

            make-stmt
            stmt?
            stmt-expr

            make-expr
            expr?
            expr-type

            make-unary
            unary?
            unary-operator
            unary-expr

            make-const
            const?
            const-int

            make-id
            id?
            id-symbol))

(define-record-type <program>
  (make-program func)
  program?
  (func program-function))

(define-record-type <function>
  (make-function id stmt)
  function?
  (id function-id)
  (stmt function-stmt))

(define-record-type <stmt>
  (make-stmt expr)
  stmt?
  (expr stmt-expr))

(define-record-type <expr>
  (make-expr type)
  expr?
  (type expr-type))

(define-record-type <unary>
  (make-unary op expr)
  unary?
  (op unary-operator)
  (expr unary-expr))

(define-record-type <const>
  (make-const int)
  const?
  (int const-int))

(define-record-type <id>
  (make-id symbol)
  id?
  (symbol id-symbol))