Re: Custom Format

[Aaron Hill]

On 2021-03-31 12:12 pm, Callum Cassidy-Nolan wrote:
> Could you explain why 6 usually corresponds to the pitch B and not 
> always?

B does not always mean B natural.  In systems where H is a note, B is 
the name for B flat.  The documentation here is perhaps a little 
misleading in that it implies the implementation is doing something 
conditionally.


> Also I am new to Scheme and still trying to wrap my head around your
> original function:
>
> #(define (: n)
>    (apply
>     ly:make-pitch
>     (cons (1- (floor (/ n 12)))
>           (list-ref `((0 0) (0 ,SHARP) (1 0) (1 ,SHARP)
>                       (2 0) (3 0) (3 ,SHARP) (4 0)
>                       (4 ,SHARP) (5 0) (5 ,SHARP) (6 0))
>                     (modulo n 12)))))
>
> Here is my best guess, for each element in the following list - apply
> the function make-pitch to each element.

There is no "for each" going on here.  apply lets you call a procedure 
and supply the arguments as a list.  Consider:

;;;;
(apply proc '(1 2 3))
; ...is equivalent to...
(proc 1 2 3)
;;;;

Upon reflection, I did not need to use cons to form the argument list.  
apply also supports this pattern:

;;;;
(apply proc 1 '(a b))
; ...is equivalent to...
(proc 1 'a 'b)
;;;;

The reason I need to use apply at all is because I need to customize the 
second and third arguments based on the input index n, and I wanted to 
avoid duplicating logic.


> floor (/ n 12 ): is representing how many octaves fit into this
> number? Why do you subtract this number from one?

The Scheme expression (1- n) must not be confused with the algebraic (1 
- n) [which would be written in Scheme as (- 1 n)].  The procedures 1+ 
and 1- are the increment and decrement operations.  So what I am doing 
is subtracting one from the number, not the other way around.

The reason for this is simply to follow existing LilyPond convention.  
The unadorned note { c } is (ly:make-pitch -1 0 0).  To get Middle C, 
you need to say { c' } which puts you in octave 0.


> The list-ref thing is choosing one of the elements from that list ,
> but I don't fully understand what an arbitrary element from that list
> actually is, for example what does (3, SHARP) mean?

These are the second and third arguments for ly:make-pitch.  So using (3 
,SHARP) results in F#.

NOTE: As you are new to Scheme, the comma can be an unexpected item.  
The original list uses a feature called quasi-quotation.  This is 
indicated by the leading backtick (`) as opposed to a straight quote (') 
which is the shorthand for normal quoting.  Quasi-quoting lets you 
"unquote" by using the comma.  Since we need the value of SHARP, not its 
name as a symbol, this is useful.  Consider:

;;;;
'(3 SHARP)  ;; => (list 3 (quote SHARP))
`(3 ,SHARP) ;; => (list 3 1/2)
;;;;

I could avoid quasi-quoting by defining the list as follows:

;;;;
'((0 0) (0 1/2) (1 0) (1 1/2) (2 0) (3 0)
  (3 1/2) (4 0) (4 1/2) (5 0) (5 1/2) (6 0))
;;;;

But then one wonders what the magic 1/2 means.  Technically, I should 
have used ,NATURAL in place of zero in the original list since that is 
also a magic number.


-- Aaron Hill