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!

Hi Sander,

Sure, I somewhat expected that nothing had changed for this in Mathematica 11. I guess my expectation is at a minimum the help documentation should document the return type in the help info - since Mathematica is essentially functional programming, the entire documentation set can be viewed as function API's that should include well documented return types.

More optimistically as a mentioned above, since Mathematica now has the help tips while typing in a notebook and since the kernel/framework in this example has enough type information available, the notebook input cell should be able to at least provide some guidance or provide the user with type info when trying to do dec2 = BaseForm[16^^FFFFD188,10]-400.... instead of just returning this result -400+4294955400.

For now agree with treating BaseForm[] as a "display only" function with BaseForm return type.

Thanks

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