xdddd

#lang racket

(define tlsyst.angle
    (lambda (lsystem)
        ((lsystem "get-angle"))))

(define tlsyst.lsystem
    (lambda (_axiom _prod-rules _prod-rules-proba _term-rules _term-rules-proba _angle)
        (define axiom _axiom)
        (define prod-rules _prod-rules)
        (define prod-rules-proba _prod-rules-proba)
        (define term-rules _term-rules)
        (define term-rules-proba _term-rules-proba)
        (define angle _angle)
        (define lsystem
            (lambda (method)
                (define get-axiom
                    (lambda () axiom))
                (define get-prod-rules
                    (lambda () prod-rules))
                (define get-prod-rules-proba
                    (lambda () prod-rules-proba))
                (define get-term-rules
                    (lambda () term-rules))
                (define get-term-rules-proba
                    (lambda () term-rules-proba))
                (define get-angle
                    (lambda () angle))
                (if (equal? method "get-axiom")
                    get-axiom
                    (if (equal? method "get-prod-rules")
                        get-prod-rules
                        (if (equal? method "get-prod-rules-proba")
                            get-prod-rules-proba
                            (if (equal? method "get-term-rules")
                                get-term-rules
                                (if (equal? method "get-term-rules-proba")
                                     get-term-rules-proba
                                     (if (equal? method "get-angle")
                                         get-angle
                                         (null)))))))
        lsystem))

(define lsystem-rules-mapping
    (lambda (rules rules-proba string)
        (define mapping-string string)
        (define is-special-char "true")

        (if (not (equal? string ""))
            (begin
                (for ([rule rules])
                    (if (equal? (substring string 0 1) (car rule))
                        (begin
                        (set! is-special-char "false")
                        (set! mapping-string
                             (string-append (cdr rule) (lsystem-rules-mapping rules (substring string 1)))))
                        null))
                (if (equal? is-special-char "true")
                    (set! mapping-string
                             (string-append (substring string 0 1) (lsystem-rules-mapping rules (substring string 1))))
                    null)
            mapping-string)
        "")))

(define lsystem.generate-string
    (lambda (lsystem order)
        (define prod-string ((lsystem "get-axiom"))) ; default production string value
        (for ([i order]) ; loops n times the production rule(s) (mapping)
            (set! prod-string (lsystem-rules-mapping ((lsystem "get-prod-rules")) prod-string)))
        (lsystem-rules-mapping ((lsystem "get-term-rules")) prod-string))) ; termination rule(s) (mapping)

(define lsystem (tlsyst.lsystem
                    "A-B[x]-A>[]" (list (cons "A" "AB") (cons "B" "BB"))
                    (list (cons "B" "B") (cons "A" "A"))
                    60))

(lsystem.generate-string lsystem 2)