rmtext = #(define-scheme-function
           (o)
           (ly:music?)
           (define (f o)
             (ly:music-set-property! o 'text "")
             (let ((t (ly:music-property o 'name)))
               (let ((els (ly:music-property o 'elements)))
                 (if (null? els)
                     (let ((arts (ly:music-property o 'articulations)))
                       (map (lambda (a)
                              (f a))
                            arts))
                     (map (lambda (e)
                            (f e)
                            )	
                          els))))
             )
           (let ((oo (ly:music-deep-copy o)))
             (f oo)
             oo)
           )

withDuration = #(define-scheme-function
                 (music duration adjusts)
                 (ly:music? number? number?)
                 (define (with-duration-internal m duration)
                   (cond 
                    ((or (music-is-of-type? m 'note-event) (music-is-of-type? m 'rest-event) (music-is-of-type? m 'skip-event))
                      (ly:music-set-property! m 'duration (apply ly:make-duration duration)))
                    ((music-is-of-type? m 'event-chord)
                      (map (lambda (n) (with-duration-internal n duration))
                        (ly:music-property m 'elements)))
                    (else (ly:warning "Neither note event nor chord"))
                  )
                   m		
                   )
                 (with-duration-internal (ly:music-deep-copy music) (list duration adjusts))
                 )

flattenPitch = #(define-scheme-function
                 (music)
                 (ly:music?)

                (define (adjust-first l)
                  (if (null? l)
                    'done
                    (let ((e (car l)))
                      (if (music-is-of-type? e 'note-event)
                        (adjust-pitch-i e)
                        (adjust-first (cdr l))))
                    )
                )
                 
                (define (adjust-pitch-i m)
                  (cond 
                   ((music-is-of-type? m 'note-event)
                    (let* ((p (ly:music-property m 'pitch))
                           (pa (ly:pitch-alteration p))
                           (pn (ly:pitch-notename p))
                           (pp (ly:make-pitch -1 pn pa))
                          )
                        (ly:music-set-property! m 'pitch pp))
                    )
                   ((or (music-is-of-type? m 'event-chord)
                        (music-is-of-type? m 'any))
                     (adjust-first (ly:music-property m 'elements))
                    )
                   )
                  m
                  )
                
                (adjust-pitch-i (ly:music-deep-copy music))
                )

rep = #(define-scheme-function 
        (n m)
        (index? ly:music?)
        (let ((nn (- n 1))
              (mm (flattenPitch (rmtext m)))
              )
          (if (> nn 0)
                #{
                  $m \repeat unfold $nn $mm
                #}
               #{
                 $m
               #}
              )
          )
        )

fr = #(define-scheme-function
        (n)
        (ly:music?)
        (rep 4 n))

frr = #(define-scheme-function
        (n)
        (ly:music?)
        (rep 8 n)
        )