Extending Functions

One of the age-old rifts between programmers is the one between those who think that using the operator + for strings makes sense and those who are right. In this example, we will finally settle this debate with the only semantics that make sense, and on the way, we learn how to extend built-in functions in Kronos.

Roman Numerals

Let us define arithmetic operators for strings that work with Roman numerals. The first step is to decode and encode numeral strings into the mundane numeric types Kronos readily understands.

Numerals =
   [("M"   #1000)
	("CM"  #900)
	("D"   #500)
	("CD"  #400)
	("C"   #100)
	("XC"  #90)
	("L"   #50)
	("XL"  #40)
	("X"   #10)
	("V"   #5)
	("IV"  #4)
	("I"   #1)]

To-Roman(value) {
	; Compile-time loop using an inner function
	; that recurs.
	encode(value decimals) {
		; examine the head of current list of encodable
		; numerals
		((r d) next) = decimals

		When(; already encoded all numerals?
			 value == #0
				""
			 ; is largest encodable numeral applicable?
			 value >= d
			 	; if so, output it and append the rest.
			 	String:Append(r Recur(value - d decimals))
			 ; skip this numeral and try the next one
			 Otherwise
			 	Recur(value next))
	}

	encode(value Numerals)
}

From-Roman(numeral) #[Pattern] {
	Use Algorithm
	; a loop
 	decode(value previous numeral-chars) {
		; split list of numerals into head and tail
		(vn rn) = numeral-chars
		; find a matching numeral. '==t' checks for compile time
		; type equality.
		num = Some((nn _) => (nn ==t vn) Numerals)
		; Extract the increment
		(_ inc) = num

		When(; all numerals decoded?
			Nil?(numeral-chars)
				value
			; not a valid numeral?
			Nil?(num)
				nil
			; is current numeral smaller than previous?
			inc < previous
			 	; then substract and decode the rest
				Recur(value - inc inc rn)
			Otherwise
			 	; otherwise add and decode the rest
			 	Recur(value + inc inc rn))
	}

	; split string into characters in reverse
	len = String:Length(numeral)
	chars = Map(i => String:Take(String:Skip(numeral i) #1)
				Expand(len (- #1) len - #1))

	; check that we got a valid numeral
	result = decode(#0 #0 chars)
	When(Constant?(result) result)
}

test = Algorithm:Expand(#11 (* #2) #1)
numerals = Algorithm:Map(To-Roman test)
decoded = Algorithm:Map(From-Roman numerals)
test#1 #2 #4 #8 #16 #32 #64 #128 #256 #512 #1024 nil

numeralsI II IV VIII XVI XXXII LXIV CXXVIII CCLVI DXII MXXIV nil

decoded#1 #2 #4 #8 #16 #32 #64 #128 #256 #512 #1024 nil

We put the #[Pattern] attribute on From-Roman. That enables the use of From-Roman as a pattern matching accessor. Any polymorphic function that makes use of From-Roman will move to the next form if the numeral can't be decoded.

Extending Arithmetic Ops

Now we have the basic plumbing to operate with Roman numerals.

; the Extend attribute allows us to append a polymorphic form to Add
Add(a b) #[Extend] {
	ar = From-Roman(a)
	br = From-Roman(b)
	To-Roman(ar + br)
}

"XIV" + "VIII"XXII


; make sure that non-numeral strings don't match with From-Roman
"foo" + "bar"
* E-9995: Fatal{Eval (Anon-Fn nil) Fatal{eval nil Fatal{ (foo bar) Fatal{:Fallback:Binary-Op (:Fn{:Add} Add foo bar) Fatal{:Fallback:No-Match (Add foo bar) Exception{Type mismatch{Could not find a valid form of ' Add ' for arguments of type ' (foo bar) '}}}}}}}

| (foo bar)
|  From-Roman(foo)
No match

Cannot 'Add' these types at compile time
Received (foo bar)

Cannot 'Add' these types natively
Received foo

|  :Fallback:Binary-Op(:Fn{:Add} Add foo b ... )
|     Coerce-Binary(foo bar)
|       Type-Conversion:Implicit(bar foo)
No match
 in C:\ProgramData\Kronos\Cache\kronoslang\core\0.12.9\Implicit-Coerce.k(8;19)
	Coerce-Binary = (Type-Conversion:Implicit(b a) b)
	                 ^^^

|       Type-Conversion:Implicit(foo bar)
No match
 in C:\ProgramData\Kronos\Cache\kronoslang\core\0.12.9\Implicit-Coerce.k(7;21)
	Coerce-Binary = (a Type-Conversion:Implicit(a b))
	                   ^^^

No match
 in C:\ProgramData\Kronos\Cache\kronoslang\core\0.12.9\Implicit-Coerce.k(15;10)
	func(Coerce-Binary(a b))
	     ^^^

|    :Fallback:No-Match(Add foo bar)
Could not find a valid form of ' Add ' for arguments of type ' (foo bar) ' (Type mismatch)
Received (Add foo bar)

Sorry for the slightly intimidating error: the type constraints in From-Roman causes "foo" to be rejected as a Roman numeral.

While we could overload all the arithmetic ops, it is more useful to hitch a ride on the type coercion machinery built into the standard library. Let's override the Binary-Op fallback point instead:

Fallback:Binary-Op(func name a b) #[Extend] {
	ar = From-Roman(a)
	br = From-Roman(b)
	To-Roman(func(ar br))
}

"XIV" * "V"LXX


Math:Pow("II" "VIII")CCLVI

This has the benefit of only hitting our code path if no other method succeeds (the builtin binary ops call Fallback:Binary-Op in that case), and it extends all the binary operators in one fell swoop.

Conclusion

Ok, this is getting ridicilous. However, I hope you enjoyed it, and maybe got something useful out of it. That's the best kind of ridicilous. If you're looking for a less tongue-in-cheek example of extending the number types, please have a look at the complex number type in the standard library.