I like how the function unfold allows for rather concisely expressed transformations. I also like that with this function, methods can easily by commented out or added without changing the nesting structure of the overall Lisp program. However, what I do not like is that the unfold methods don't support any further arguments, and as a result the required preliminary work with def-unfold-set is rather cumbersome.  

 

So, I rolled by own version of unfold that addresses this shortcoming. This new function works as follows: you can use the names of arbitrary Opusmodus functions, as long as they expect an OMN sequence as first argument. The following example applies first the function gen-retrograde and then quantum to the material mat. 

 

(setf mat '((q c4 d4 e4) (h f4 q b3)))

(fn-unfold '((gen-retrograde) (quantum :fraction -0.2)) mat)

=> ((7W B3 7H._QT F4 -E..) (E E4 D4 S. C4 -ET))

 

If you would like to have functions with more concise names (as unfold does), just define functions with shorter names. Here are some examples.

 

(defun tr (sequence transpose &key (section NIL) (exclude NIL) (ambitus 'piano) (omn NIL))
  "Like pitch-transpose, but sequence as first param."
  (pitch-transpose transpose sequence :section section :exclude exclude :ambitus ambitus :omn omn))

 

(defun ld (sequence values &key set ignore seed (section NIL) (exclude NIL) (omn NIL))
  "Like length-divide, but sequence as first param."
  (length-divide values sequence :set set :ignore ignore :section section :exclude exclude :omn omn :seed seed))

With the definitions above, we can now use fn-unfold as follows for computing an octave transposition of mat and then applying length-divide to the second bar with the given settings.

 

(fn-unfold '((tr 12) (ld (2 3) :section 1)) mat)

=> ((Q C5 D5 E5) (3H E5 FS5 G5 3Q A4 BB4 CS5))

 

BTW: The definition of fn-unfold is pretty short. By far the longest part of this definition is the doc string 🙂

 

(defun fn-unfold (fns sequence)
  "Much like the buildin Opusmodus `unfold`, but instead works with functions and additional arguments can be given to the functions. Apply to `sequence` all fns in order.

* Arguments:
  - fns (list of lists): Each sublist has the form (<omn-fn> &rest <args>), where <omn-fn> is a function expecting an OMN sequence as first argument and arbitrary further argments, and <args> are the further arguments beyond the OMN sequence given to the function.
  - sequence: OMN sequence


* Examples:

Some material to use
;;; (setf mat '((q c4 d4 e4) (h f4 q b3)))

Remember: all functions used must expect a OMN sequence as *first* argument.

;;; (fn-unfold '((gen-retrograde) (quantum :fraction -0.2)) mat)

Some short-hand versions of common functions are defined for conciseness.

;;; (fn-unfold '((tr 12) (ld (2 3) :section 1)) mat)
"
  (reduce (lambda (seq fn)
	    (apply (if (functionp (first fn))
		       (first fn)
		       (fdefinition (first fn)))
		   seq (rest fn)))
	  fns :initial-value sequence))

 

Looks great, Torsten ! Thank you !

 

I have a question about the origianal unfold function and by extension to your new unfold function:

 

Regarding the use of customized methods, can we  put on def-library folders in the Def-Unfold_Sets

a file with our customized methods with your function ?

This file must have an specific name ?

The sets of  methods are automatically loaded in the startup , so we can call the specific sets in

the unfold function without having to evaluate the complete procedure of each method ?

 

Best,

Julio

> can we ... a file with our customized methods with your function?

 

You can put this function fn-unfold wherever you want, as long as that file is loaded at startup, and likewise also any other function including functions like tr above  🙂

 

> we can call the specific sets in the unfold function without having to evaluate the complete procedure of each method ?

 

Questions concerning the original unfold function are better answered by Janusz, I guess... 

 

Good night (its 23:00 over here...),

Torsten

Good night. Sounds good.

Best,

Julio

> we can call the specific sets in the unfold function without having to evaluate the complete procedure of each method ?

 

Yes naturally,

 

you can create your own unfold-set, save it in unfold-set folder and call it in counterpoint or unfold with the optional keyword :set and specify here the name of your set.

 

SB.

More important you can apply the the unfold method to a specific bar or even to an event in a given bar number:

 

Method applied to entire sequence:

(unfold 'name 'method sequence)

 

Method1 applied to 2nd bar only:

(unfold 'name '((method1 2) method2) sequence)

 

Method1 applied to the 3rd event in the 1st bar:

(unfold 'name '((method1 1 3) method2) sequence)

 

Examples:

(setf mat '((s c4 d4 e4 f4 g4) (s c4 d4 e4 f4 g4) (s c4 d4 e4 f4 g4)))

(unfold 'om 't7 mat)
=> ((s g4 a4 b4 c5 d5) (s g4 a4 b4 c5 d5) (s g4 a4 b4 c5 d5))

(unfold 'om '((t-12 1 3) (t-1 2) (r 3)) mat)
=> ((s c4 mf d4 e3 f4 g4) (s b3 cs4 eb4 e4 fs4) (s g4 f4 e4 d4 c4))

(unfold 'om '? mat)
=> ((s c4 d4 e4 f4 g4) (s g4 a4 bb4 c5 d5) (s c4 bb3 gs3 g3 f3))

 

Why so may users do not read/examine the function documentation.🤓

Thank you, guys !!

 

Yes, I try to read all the stuff, but it does not mean I understand it all by myself...🤣🤣🤣🤣🤣🤣

 

And this quarantine is so lonely... I need to talk with you...

 

Fortunately, I have this marvelous forum !! With amazing people !

It´s very cool to have some functions with short "nicknames" !

 

Thanks a lot. I will try this.

 

 

 

 

 

 

I provided a variant for unfold that has some advantages (support for arbitrary function arguments instead of a custom symbol for each argument combination set up with def-unfold-set), but I did not say that it would replace it 🙂  In addition to what you said, the unfold function is also baked into your counterpoint function, while this alternative is not. 

 

> apply the the unfold method to a specific bar

 

Sure. That also works with this variant, as shown above by using the argument section supported by most OPMO functions.  

 

(fn-unfold '((tr 12) (ld (2 3) :section 1)) mat)

 

> even to an event

 

Yes, that is something currently not supported by the alternative fn-unfold (except individual functions would support it). As you can see, the definition of fn-unfold is pretty short, more stuff could be added, if we want to. 

 

> Why so may users do not read/examine the function documentation.

 

Actually, I was aware of that, which is why I included an example showing the same feature (applying a specific function only to a certain bar) in my original post 😊

I do like the concept of moving the sequence to the first argument. 🙂