4 Scheme functions (LilyPond Internals Reference)

glyph proc

(let ((arr (make-array 'a 4 4))
      (to-copy (make-array 'b 2 2)))
  (array-copy/subarray! to-copy arr 2 1)
  arr)
⇒
#2((a a a a)
   (a a a a)
   (a b b a)
   (a b b a))

\override Flag.stencil = #default-flag
\override Flag.style = #'mensural

(define-markup-command (command layout props arg1 arg2 …)
                       (type1? type2? …)
                       [ #:properties ((property1 default1)
                                       (property2 default2)
                                       …) ]
    [ #:category category ]
    [ #:as-string expression ]
    [ "doc-string" ]
    command-body)

(command-markup layout props arg1 arg2 …)

(make-command-markup arg1 arg2 …)

(define-music-function (arg1 arg2 …)
                       (type1? type2? …)
    function-body)

(define-syntax-function result-type?
                        (arg1 arg2 …)
                        (type1? type2? …)
  function-body)

#(define simple-hairpin
  (elbowed-hairpin '((0 . 0)(1.0 . 1.0)) #t))

\relative c' {
  \override Hairpin #'stencil = #simple-hairpin
  a\p\< a a a\f
}

(ly:expect-warning (G_ "Bar number is ~a; expected ~a") 3 15)

'((grob prop-name)
  (grob prop-name)
  ...)

(flat-zip-longest '(a b c d) '(e f) '(g h i)) ⇒ '(a e g b f h c i d)

(function-chain 1 `((,+ 1) (,- 2) (,+ 3) (,/)))
   ⇒ 1/3

(group-into-ranges '(1 4 3 6 7 2)) ⇒ ((1 . 4) (6 . 7))

(index-map (lambda (i elt)
             (format #f "~s is the element at index ~a" elt i))
           '(a b c d e))

(file-name first-line first-column last-line last-column)

(list-pad-right '(a b c) 10 'd 'e)
⇒ (a b c d e d e d e d)

(make-music 'OverrideProperty
            'symbol 'Stem
            'grob-property 'thickness
            'grob-value (* 2 1.5))

moveto rmoveto lineto rlineto curveto rcurveto closepath

M m L l C c Z z

abba =
#(define-music-function (a b) (ly:music? ly:music?)
  (make-relative (a b)
    #{ #a #b #}
    #{ $a $b $b $a #}))

\relative {
  \abba c'' g'
}

c cis d es e f fis g gis a bes b

(lambda (context)
  (let (local-variables ...)
    (make-translator
     ((initialize translator)
      ...)
     ((start-translation-timestep translator)
      ...)
     (listeners
      ((event-class-1 translator event)
       ...)
      ((event-class-2 translator event #:once)
       ...))
     ((process-music translator)
      ...)
     (acknowledgers
      ((grob-interface-1 translator grob source-translator)
       ...)
      ((grob-interface-2 translator grob source-translator)
       ...))
     ((process-acknowledged translator)
      ...)
     ((stop-translation-timestep translator)
      ...)
     ((finalize translator)
      ...))))

(map-selected-alist-keys - '(a b) '((a . 1) (b . -2) (c . 3) (d . 4)))
   ⇒ ((a . -1) (b . 2) (c . 3) (d . 4))

\markup { foo
          \raise #0.2 \hbracket \bold bar
          \override #'(baseline-skip . 4)
          \bracket \column { baz bazr bla }
}

(markup "foo"
        #:raise 0.2 #:hbracket #:bold "bar"
        #:override '(baseline-skip . 4)
        #:bracket #:column ("baz" "bazr" "bla"))

(minmax/cmp (comparator-from-key string-length <) "a" "aa" "aaa")
⇒ "a"
(minmax/cmp (comparator-from-key string-length >) "a" "aa" "aaa")
⇒ "aaa"

(music-clone start-span 'span-direction STOP)

(ly:paper-column::break-align-width col '(key-signature staff-bar))

#(define date-components
   (let ((date-regex (ly:make-regex "^(\\d{4})-(\\d{2})-(\\d{2})$")))
     (lambda (date)
       (let ((match (ly:regex-exec date-regex date)))
         (if match
             (list (string->number (ly:regex-match-substring match 1))
                   (string->number (ly:regex-match-substring match 2))
                   (string->number (ly:regex-match-substring match 3)))
             (error "not a date"))))))

(ly:regex-quote "$2")
⇒ "\\$2"

#(define date-yyyy-mm-dd->dd-mm-yyyy
   (let ((date-regex (ly:make-regex "(\\d{4})-(\\d{2})-(\\d{2})")))
     (lambda (date)
       (ly:regex-replace date-regex date 3 "-" 2 "-" 1))))

#(define date-yyyy-mm-dd->dd-mm-yyyy
   (let ((date-regex (ly:make-regex "(\\d{4})-(\\d{2})-(\\d{2})")))
     (lambda (date)
       (ly:regex-replace
        date-regex
        date
        (lambda (match)
          (format #f "~a-~a-~a"
                  (ly:regex-match-substring match 3)
                  (ly:regex-match-substring match 2)
                  (ly:regex-match-substring match 1)))))))

'((Stem thickness)
  (Slur line-thickness)
  ...)

'((Stem thickness)
  (Slur line-thickness)
  ...)

<<c d e>>-\markup{ foobar }

(split-list-by-group-lengths '(a b c d e f) '(3 2 1)
⇒ ((a b c) (d e) (f))

(split-list-by-separator '(a 0 b c 1 d) number?)
   ⇒ ((a) (b c) (d))

\markup \hspace #(to-staff-space 25 'mm)

[ << Backend ]	[Top][Contents][Index]	[ Indices >> ]
[ < Internal backend properties ]	[ Up : Top ]	[ Indices > ]

[ << Backend ]	[Top][Contents][Index]	[ Indices >> ]
[ < Internal backend properties ]	[ Up : Top ]	[ Indices > ]

4 Scheme functions

LilyPond Internals Reference v2.25.21 (development-branch).