Preallocation, Broadcasting, Overloading

[goyalyashpal]

Hi!

Thanks a lot for (trying to) bringing choice of type flexibility (static/dynamic) and choice of memory ownership (immutable borrowed or mutable inout) to python .py .

There are two three sort of generic (as in loosely defined in implementation) features from (julia, haskell) which i think can be helpful for mojo given its target for performance and AI.

Feature Name	Use-case/description	Comments
Array Preallocation	lots of times when creating arrays/lists, there is a pretty good idea of upper bound of number of elements required	communicating this to compiler would save unnecessary implicit move-overs or explicit hacks with None, undefined or Null types
Function Broadcasting	very useful for operating on columnar data which is very common in data analysis, & AI-ML	Performance Tips: "Use array (element-wise) operations instead of list comprehensions."
Static Method Overloading	very useful - maybe not in AI; but in general programming - makes code a lot more cleaner	Argument's: number, types Think C++ type-decorated or mangled names

Examples:

1. Array Preallocation:

# Julia
sizehint!(arr, 10^4)

2. Function Broadcasting:
   broadcasting/vectorizing operator . in Julia
   ref: cheats.quantecon, cheat.julia

# Julia
pyth(x) = sum(x .^ 2) ^ (0.5)   # pythagoras

pyth( [3, 4, 12] )              # 13
pyth( 3 )                       # 3

3. Method Overloading:

+ :: point -> point -> point 
+ point1 point2 = (point1[x] + point2[x], point1[y] + point2[y])

Additional:

• these may seem too fancy in implementation & may not align with Mojo's vision - that's why i prematurely marked it optional already - i just wanted to share how clean interface they provide 😅
• all these 3 feel more or less on the same lines of better expressiveness and simpler front facing syntax for defining functions
• i also like the "code as data" variable definition (aka lazy evaluation) for reactivity , but i think that's way too complicated. so, leaving it out.

Overloading based on literals	among others, one is clean implementation of recursive function definitions (for base converging cases)
Parameter Matching	applying some simple function on the arguments within the left side / function header itself	The function being, say equality for literal value based matching, or slicing for list based functionality

Examples:

4. Literal Based Overloading

fact 0 = 1
fact n = n * fact (n - 1)

5. Pattern Matching

-- Slicing the argument list into head and body/tail 
-- is done concisely on left side itself
len [x : xs] = 1 + len [xs]

[lattner]

Hi @goyalyashpal thanks for your interest!

Indeed, Mojo already supports function overloading, which is the language feature on your list. I'm definitely a fan of pattern matching, and Python has this as well - we just haven't gotten it high enough in the priority list to implement.

The others are aspects of library design - in Mojo, things like broadcasting and allocation are deferred to library authors rather being hard coded into the compiler. This allows different domains to make different tradeoffs that make sense for them. I'm going to close this out because we're too early to design specific libraries and the other features are tracked on the roadmap etc, thanks!