Implement doesNotUnderstandWithKeys

HelpSource/Classes/Class.schelp

@@ -116,7 +116,6 @@ method::asString
 
 Return the name of the class as a String.
 
-
 subsection:: Accessing
 
 method::name

HelpSource/Classes/FunctionDef.schelp

@@ -110,6 +110,20 @@ code::
 { |a = 9, b = 10, c| a + b }.def.makeEnvirFromArgs;
 ::
 
+
+method:: makePerformableEnvir
+Create an link::Classes/IdentityDictionary:: from the passed in arguments and keyword arguments,
+ensuring all the arguments will be accepted by the link::Classes/FunctionDef:: and none of the arguments collide with each other.
+
+argument::argsArray
+The non-keyword arguments as an link::Classes/Array::.
+
+argument::keywordArgsEvent
+The 'keyworded' arguments as an link::Classes/IdentityDictionary::, where the keyword is the key.
+
+method::makePerformableArray
+Like link::#-makeNonOverlappingKeywordArgsEvent:: but returns an link::Classes/Array:: with the arguments in the correct order.
+
 subsection::Generating Strings
 
 method::makeFuncModifierString

HelpSource/Classes/Method.schelp

@@ -53,3 +53,11 @@ method:: filenameSymbol
 returns::
 A link::Classes/Symbol:: which is the full path of the source file that this method is defined in.
 
+method::isClassMethod
+returns::
+A link::Classes/Boolean:: where true represents if this link::Classes/Method:: is a class method,
+and false represents when this is an instance method.
+::
+
+
+

HelpSource/Classes/Object.schelp

@@ -530,6 +530,12 @@ Set[1, 2, 3].tryPerform(\keysValuesDo, { |key, value| [key, value].postln });
 (a: 1, b: 2, c: 3).tryPerform(\keysValuesDo, { |key, value| [key, value].flippityblargh });
 ::
 
+method::functionPerformList
+A method called in object prototyping, see link::Classes/IdentityDictionary#-new::.
+By default this will do nothing and return the object.
+link::Classes/Function#-functionPerformList:: provides a useful implementation.
+Not called in normal use.
+
 method::superPerform
 
 Like perform, superPerform calls a method, however it calls the method on the superclass.
@@ -613,7 +619,11 @@ Remove all dependants of the receiver. Any object that has had dependants added
 
 subsection::Error Support
 
-Object implements a number of methods which throw instances of Error. A number of methods (e.g. doesNotUnderstand) are 'private' and do not normally need to be called directly in user code. Others, such as those documented below can be useful for purposes such as object oriented design (e.g. to define an abstract interface which will be implemented in subclasses) and deprecation of methods. The reserved keyword thisMethod can be used to refer to the enclosing method. See also Method and Function (for exception handling).
+Object implements a number of methods which throw instances of Error.
+A number of methods (e.g. doesNotUnderstand) do not normally need to be called directly in user code.
+Others can be useful for purposes such as object oriented design (e.g. to define an abstract interface which will be implemented in subclasses) and deprecation of methods.
+The reserved keyword thisMethod can be used to refer to the enclosing method.
+See also Method and Function (for exception handling).
 
 method::throw
 
@@ -652,6 +662,41 @@ foo {
 }
 ::
 
+
+method::doesNotUnderstand
+Not usually called in user code.
+This is called when an object receives a message it does not understand.
+Object's implementation will throw an error, but other classes (link::Classes/IdentityDictionary::) might override this.
+
+argument::selector
+The name of the message as a link::Classes/Symbol::.
+
+argument::... args
+The arguments passed.
+
+code::
+4.someThing(2) // ERROR: Message 'someThing' not understood.
+::
+
+method::doesNotUnderstandWithKeys
+Not usually called in user code.
+This is called when an object receives a message it does not understand, but there are keyword arguments.
+Object's implementation will throw an error, but other classes (link::Classes/IdentityDictionary::) might override this.
+
+argument::selector
+The name of the message as a link::Classes/Symbol::.
+
+argument::argsArray
+The arguments passed that did not have keywords attached passed as an link::Classes/Array::
+
+argument::keywordArrayPair
+The arguments passed that did have keywords attached.
+These are formatted as an link::Classes/Array:: of key-value pairs link::Reference/Key-Value-Pairs::.
+
+code::
+4.someThing(3, someArgument: 42) // ERROR: Message 'someThing' not understood.
+::
+
 subsection::Printing and Introspection
 
 method::post

SCClassLibrary/Common/Collections/Dictionary.sc

@@ -331,10 +331,10 @@ Dictionary : Set {
 		var oldElements = array;
 		array = Array.newClear(array.size * 2);
 		this.keysValuesArrayDo(oldElements,
-		{ arg key, val;
-			index = this.scanFor(key);
-			array.put(index, key);
-			array.put(index+1, val);
+			{ arg key, val;
+				index = this.scanFor(key);
+				array.put(index, key);
+				array.put(index+1, val);
 		});
 	}
 	fixCollisionsFrom { arg index;
@@ -438,9 +438,9 @@ IdentityDictionary : Dictionary {
 		index = this.scanFor(key);
 		array.put(index+1, value);
 		if ( array.at(index).isNil, {
-			array.put(index, key);
-			size = size + 1;
-			if (array.size < (size * 4), { this.grow });
+		array.put(index, key);
+		size = size + 1;
+		if (array.size < (size * 4), { this.grow });
 		});
 		*/
 	}
@@ -453,9 +453,9 @@ IdentityDictionary : Dictionary {
 		prev = array.at(index + 1);
 		array.put(index+1, value);
 		if ( array.at(index).isNil, {
-			array.put(index, key);
-			size = size + 1;
-			if (array.size < (size * 4), { this.grow });
+		array.put(index, key);
+		size = size + 1;
+		if (array.size < (size * 4), { this.grow });
 		});
 		^prev
 		*/
@@ -560,12 +560,39 @@ IdentityDictionary : Dictionary {
 		^this.superPerformList(\doesNotUnderstand, selector, args);
 	}
 
-		// Quant support.
-		// The Quant class assumes the quant/phase/offset scheduling model.
-		// If you want a different model, you can write a dictionary like so:
-		// (nextTimeOnGrid: { |self, clock| ... calculate absolute beat number here ... },
-		//	parameter: value, parameter: value, etc.)
-		// If you leave out the nextTimeOnGrid function, fallback to quant/phase/offset.
+	doesNotUnderstandWithKeys {|selector, argsArray, keywordArgsAsPairs|
+		if(know.not){
+			^this.superPerformList(\doesNotUnderstandWithKeys, selector, argsArray, keywordArgsAsPairs )
+		};
+
+		this[selector] !? {|f|
+			^f.functionPerformList(
+                \value,
+                 f.def.makePerformableArray([this] ++ argsArray, keywordArgsAsPairs.asEvent)
+             )
+		};
+
+		// Unlike in doesNotUnderstand, we don't convert to a setter as this isn't
+		// possible with keyword args.
+
+		// If the keyword arg names don't match this will fail.
+		// Note how the selector is passed in here.
+		this[\forward] !? {|f|
+			^f.functionPerformList(
+                \value,
+				f.def.makePerformableArray([this, selector] ++ argsArray, keywordArgsAsPairs.asEvent)
+			)
+		};
+
+		^nil
+	}
+
+	// Quant support.
+	// The Quant class assumes the quant/phase/offset scheduling model.
+	// If you want a different model, you can write a dictionary like so:
+	// (nextTimeOnGrid: { |self, clock| ... calculate absolute beat number here ... },
+	//	parameter: value, parameter: value, etc.)
+	// If you leave out the nextTimeOnGrid function, fallback to quant/phase/offset.
 
 	nextTimeOnGrid { |clock, referenceBeat|
 		if(this[\nextTimeOnGrid].notNil) {

SCClassLibrary/Common/Collections/Scale.sc

@@ -19,8 +19,16 @@ Scale {
 	}
 
 	*doesNotUnderstand { |selector, args|
-		var scale = this.newFromKey(selector, args).deepCopy;
-		^scale ?? { super.doesNotUnderstand(selector, args) };
+		^this.newFromKey(selector, args).deepCopy
+		!? { |v| v } //return if valid
+		?? { super.doesNotUnderstand(selector, args) }
+	}
+	*doesNotUnderstandWithKeys {|selector, argsArray, keywordArgsAsPairs|
+		^Scale.performWithEnvir(
+			\newFromKey,
+			Scale.class.findRespondingMethodFor(\newFromKey)
+			.makePerformableEnvir([selector] ++ argsArray, keywordArgsAsPairs)
+		)
 	}
 
 	*newFromKey { |key, tuning|
@@ -185,8 +193,17 @@ Tuning {
 	}
 
 	*doesNotUnderstand { |selector, args|
-		var tuning = this.newFromKey(selector, args).deepCopy;
-		^tuning ?? { super.doesNotUnderstand(selector, args) }
+		^this.newFromKey(selector, args).deepCopy
+		!? { |v| v } //return if valid
+		?? { super.doesNotUnderstand(selector, args) }
+	}
+
+	*doesNotUnderstandWithKeys {|selector, argsArray, keywordArgsAsPairs|
+		^Tuning.performWithEnvir(
+			\newFromKey,
+			Tuning.class.findRespondingMethodFor(\newFromKey)
+			.makePerformableEnvir([selector] ++ argsArray, keywordArgsAsPairs)
+		)
 	}
 
 	*newFromKey { | key |
@@ -295,7 +312,7 @@ ScaleAD : Scale {
 	var <>descScale;
 	*new { | degrees, pitchesPerOctave, descDegrees, tuning, name = "Unknown Scale" |
 		^super.new(degrees, pitchesPerOctave, tuning, name)
-			.descScale_(Scale(descDegrees, pitchesPerOctave, tuning, name ++ "desc"))
+		.descScale_(Scale(descDegrees, pitchesPerOctave, tuning, name ++ "desc"))
 		;
 	}
 	asStream { ^ScaleStream(this, 0) }
@@ -554,7 +571,7 @@ ScaleStream {
 				8.94, 10.04, 10.9], 2, "Meantone, 1/6 Pythagorean Comma"),
 			\kirnberger -> Tuning.new([1, 256/243, (5.sqrt)/2, 32/27, 5/4, 4/3,
 				45/32, 5 ** 0.25, 128/81, (5 ** 0.75)/2, 16/9, 15/8].ratiomidi, 2,
-				"Kirnberger III"),
+			"Kirnberger III"),
 			\werckmeister -> Tuning.new(#[0, 0.92, 1.93, 2.94, 3.915, 4.98, 5.9, 6.965,
 				7.93, 8.895, 9.96, 10.935], 2, "Werckmeister III"),
 			\vallotti -> Tuning.new(#[0, 0.94135, 1.9609, 2.98045, 3.92180, 5.01955,
@@ -588,13 +605,13 @@ ScaleStream {
 				8/7, 7/6, 32/27, 6/5, 11/9, 5/4, 14/11, 9/7, 21/16, 4/3, 27/20, 11/8,
 				7/5, 10/7, 16/11, 40/27, 3/2, 32/21, 14/9, 11/7, 8/5, 18/11, 5/3, 27/16,
 				12/7, 7/4, 16/9, 9/5, 20/11, 11/6, 15/8, 40/21, 64/33, 160/81].ratiomidi, 2,
-				"Harry Partch"),
+			"Harry Partch"),
 			\catler -> Tuning.new([1, 33/32, 16/15, 9/8, 8/7, 7/6, 6/5, 128/105, 16/13,
 				5/4, 21/16, 4/3, 11/8, 45/32, 16/11, 3/2, 8/5, 13/8, 5/3, 27/16, 7/4,
 				16/9, 24/13, 15/8].ratiomidi, 2, "Jon Catler"),
 			\chalmers -> Tuning.new([1, 21/20, 16/15, 9/8, 7/6, 6/5, 5/4, 21/16, 4/3, 7/5,
 				35/24, 3/2, 63/40, 8/5, 5/3, 7/4, 9/5, 28/15, 63/32].ratiomidi, 2,
-				"John Chalmers"),
+			"John Chalmers"),
 			\harrison -> Tuning.new([1, 16/15, 10/9, 8/7, 7/6, 6/5, 5/4, 4/3, 17/12, 3/2,
 				8/5, 5/3, 12/7, 7/4, 9/5, 15/8].ratiomidi, 2, "Lou Harrison"),
 			\sruti -> Tuning.new([1, 256/243, 16/15, 10/9, 9/8, 32/27, 6/5, 5/4, 81/64,

SCClassLibrary/Common/Core/Error.sc

@@ -191,6 +191,56 @@ DoesNotUnderstandError : MethodError {
 	}
 }
 
+DoesNotUnderstandWithKeysError : MethodError {
+	var <>selector, <>argsWithOutKeys, <>argsWithKeys, <suggestedCorrection, suggestion = "";
+	*new { arg receiver, selector, argsWithOutKeys, argsWithKeys;
+		^super.new(nil, receiver)
+		.selector_(selector)
+		.argsWithOutKeys_(argsWithOutKeys)
+		.argsWithKeys_(argsWithKeys.asEvent)
+		.init
+	}
+
+	init {
+		var methods, methodNames, editDistances, minIndex, lowerCaseSelector;
+
+		if(receiver.notNil) {
+			methods = receiver.class.superclasses.add(receiver.class).collect(_.methods).reduce('++');
+			methodNames = methods.collect { |x| x.name.asString.toLower };
+			// we compare lower-case versions to prioritize capitalization mistakes
+			lowerCaseSelector = selector.asString.toLower;
+			editDistances = methodNames.collect(_.editDistance(lowerCaseSelector));
+			minIndex = editDistances.minIndex;
+			// Edit distance of 3 chosen arbitrarily; also, filter out completely dissimilar matches
+			// to avoid unhelpful suggestions.
+			if(editDistances[minIndex] <= 3 and: { methodNames[minIndex].similarity(lowerCaseSelector) > 0 }) {
+				suggestedCorrection = methods[minIndex];
+				suggestion = "\nPerhaps you misspelled '%', or meant to call '%' on another receiver?"
+				.format(suggestedCorrection.name, selector);
+			}
+		}
+	}
+	errorString {
+		^"ERROR: Message '" ++ selector ++ "' not understood." ++ suggestion
+	}
+	reportError {
+		this.errorString.postln;
+		"RECEIVER:\n".post;
+		receiver.dump;
+		"ARGS WITHOUT KEYS:\n".post;
+		argsWithOutKeys.dumpAll;
+		"ARGS WITH KEYS:\n".post;
+		argsWithKeys.dumpAll;
+		this.errorPathString.post;
+		if(protectedBacktrace.notNil, { this.postProtectedBacktrace });
+		this.dumpBackTrace;
+		// this.adviceLink.postln;
+		"^^ %\nRECEIVER: %\n\n\n".postf(this.errorString, receiver);
+	}
+	adviceLinkPage {
+		^"%#%".format(this.class.name, selector)
+	}
+}
 
 MustBeBooleanError : MethodError {
 	errorString {