Ok, I was referring to programmatically detecting type. Agree that it is nice that the notebook shows the subscript as the result of the calculation and the documentation saying "print" infers that the return type however that stuff is only useful if you are treating the Mathematica notebook as a line by line calculator.

I'm looking for the notebook to simply have a little more intelligence built-in for detecting and providing guidance with types. Note the following:

1. If the Mathematica notebook can "automagically" lookup the number of bananas consumed in the Olympics for an arbitrary year and can convert Boltzmann's Constant into a computable quantity as shown below (although here again with nested fuctions), the notebook and kernel/object-framework should be a little more intelligent in terms of managing variable types,

   K = QuantityMagnitude[UnitConvert[Quantity["BoltzmannConstant"]]];
   

2. I simply want the notebook to elegantly help me discover types and options for operating on types without the need to look for (missing) type information in the documentation while coding in-line. So it would just be nice if the notebook saw that I was trying to add a BaseForm (which obviously deals with numerical values by definition) and an integer and displayed the type mismatch with a conversion hint for BaseForm like "did you mean use "First[BaseForm]?" which Mathematical already does well in other instances.

3. Thanks for your example overloading the plus operator but that example (agree) seems unsafe as it could globally impact that operator. A similar example is Apple's Swift programming language where it is relatively simple to do the following in a (much more) type safe (and non global) manner:

   A similar example to yours in Swift would be to do the following
   "abc" * 5 = "abcabcabcabcabc"
   
   Using a function prototype like this (but this solution is more type safe as it is not unlocking the * operator globally)
   
   let aString = "abc"
   let largerString = aString * 5
   
   func *(lhs: String, rhs: Int) -> String {
   
   
   var result = lhs
   
       for _ in 2...rhs {
   
       result += lhs
   
       }
   
   return result
   }
   

Thanks

Just to clarify, my old post on this subject Base Form Computations used a similar solution I am just trying to find out if Mathematica 11 has any new features to make computations less tedious when moving between number bases. If I can ask WolframAlpha how many bananas were consumed during the Olympics using natural language and get visual summaries, I would expect Mathematica to be able to automatically detect computations being done between values in different number bases and at least provide some suggested options in the notebook for functions.

Here's a suggestion, perhaps adding an attribute to BaseForm (and other functions) that would permit changing the default return type to something computable such as......BaseForm[ <input value and number base>, <output number base>, <computable boolean flag>] where the return value from BaseForm would be the actual value instead of the BaseForm structure/list. Just a thought.

Thanks!