хранение значений в схеме глобально

Question

У меня есть ряд математических операций, которые мне нужно выполнить.Ввод функции n.

, первые две операции являются суммированием.используя n.Результат должен быть сохранен как переменная для использования в последующих функциях.

отл.

main func(n)
       func1 (n)
         returns a1

       func2 (n)
         returns b1

       func4 
         uses b1 to compute c1

       etc....       

Я создал все отдельные функции, но мне нужно использовать основную функцию, которая просто принимает n, и способ хранения переменных глобально для использования в более поздних функциях (без их изменения).это первые 2 функции.

(define (main n)
 (define (a1func n)
   (let* ((a1 0))
   (let* ((i (- n 1)))
        (if (= n 1) 0
      (+(/ 1 i) (a1func(- n 1)))))))

 (define (a2func n)
   (let ((a2 0))
   (let ((i (- n 1)))
   (if (= n 1) 0
        (+(/ 1 (expt i 2)) (a2func(- n 1)))))))

  (define b1 
    (if (= n 1) 0
        (/(+ n 1)(* 3(- n 1))))) 
  (define b2 
    (if (= n 1) 0
        (/(* 2 (+ n 3 (expt n 2))) (*(- n 1)(* 9 n)))))
  (define c1 (- b1 (/ 1 a1)))   
  (define c2 (+ (- b2 (/ (+ n 2) (* a1 n))) (/ a2 (expt a1 2))))
  (define e1 (/ c1 a1))
  (define e2 (/ c2 (+ (expt a1 2) a2)))
  (list e1 e2))

Answer 1

Функциональное программирование отличается от императивного программирования. Схема - это функциональный язык. Не используйте связанные переменные в качестве областей памяти. Но если вам нужно что-то вроде области памяти, используйте вектор.

Если вы хотите использовать значение переменной в другой функции, передайте ее этой функции в качестве параметра:

(define (fun1 n) ...)
(define (fun2 n) ...)
(define (fun4 n b) ...)

(define (main n)
  (let ((a1 (fun1 n))
        (b1 (fun2 n)))
    (let ((c1 (fun4 n b1)))
      ( .....)))...))))

Answer 2

Идиоматический способ получения результата вычисления функции с использованием вывода другой функции - композиция .В следующем примере вы хотите, чтобы add2 работал с результатом add1 и достигал этого путем составления функций:

> (define (add1 n) (+ 1 n))
> (define (add2 n) (+ 2 n))

> (add2 (add1 10))
=> 13

Если вы действительно хотите работать с глобальнымиНапример, вы можете сделать это с помощью замыканий, чтобы само глобальное пространство имен не было испорчено:

(define (make-adder n)
  (lambda (msg)
    (case msg
      ((one) 
       (set! n (+ 1 n)))       
      ((two) 
       (set! n (+ 2 n))))
    n))


> (define adder (make-adder 10))
> (adder 'one)
11
> (adder 'two)
13