Don't allow variables to leak down into classes or functions.

That includes xup, xstretch, yup, ystretch, etc.

Prevents multiprocessing of loops and is better replaced by the fold function.

The code there is very poorly written.

Should allow anything as keys. This could integrate with the existing classes, but need not.

Or, alternatively, make them all not interchangeable.

Unary not would be more useful than the factorial operator, as it is used far more often, and factorial could easily be a standard function.

All . syntax not for methods should be consolidated into a class like roll, deriv, or integ and handled in the same way.

A "stats" class, for example, would be useful.

Replace unicall and unifunc with a more available memoization procedure.

Add the ability to set to particular indexes in a list or string, as well as what already exists with classes

When importing another Rabbit module group all the defined names into a class and return that. Also allow some of those to then be put into the main namespace.

Evaluates an expression with a variable set to some value. Proposed symbol is the dollar sign ($).

Proposed syntax would be:

f(x) $ x = 1 $ f(x) = x+1
( f(x) $ x = 1 ) $ f(x) = x+1

Which would be equivalent to:

{ x = 1 ;; f(x) = x+1 }:"f(x)"

Will help insure more purely functional code.

Equality/inequality operators need improvement. for example, they should recursively search through containers and compare the elements in them. and 1 < x < 2 should translate into 1 < x & x < 2.

what it should do is loop through each element--for example:
check whether the first ones are equal, if not, compare them, if so, continue to the next element. same thing. then when you get to the last element if they're still equal, then fully compare them, as in, if they're equal, don't just continue--do what being equal would mean for the equality/inequality operator.

Use file objects similar to string objects

Add a function that will retrieve a list of errors

Like Haskell, all imperative code should be separated from all functional code. If this is done, it should be impossible to do resets in the functional code, or at least it should be disabled by default.

Use Python-like first-arg-is-self and insure self is always returned as the first return value, and that the old self isn't modified, only the new one that is returned.

Once side effects have fully been removed from the language, basic operations that take multiple parameters can and should be multithreaded.

For example:

{
  a = 1
  b = {
    c = 2
  }
}

This would significantly increase the number of available Rabbit functions.

, perhaps?

This one needs more consideration and might not be a final feature. Implementing it would be very difficult and might mess up certain other procedures, like memoization, or at least significantly complicate them.

For implementation guidelines, see:
https://en.wikipedia.org/wiki/Graph_reduction

Should facilitate both automatic currying and modeling of python functions.

Syntax:

# Old:
:"a := x:0":"b := x:1" $ x := 1,2

# New:
a,b = (1,2)

Should include something akin to Python's add, mul, etc. operators.

Something similar to python's assert statement might be helpful to facilitate this.

Syntax:

my_dict =
 {
  a key =
    "a_value" ~~
  2 =
   3 ~~
  f(x) =
   x
 }

my_dict : "a key"
my_dict "a key"
my_dict("a key")
my_dict["a key"]
my_dict . f

This currently doesn't work:

a(b).c

Solution:
Split based on where there is multiplication, then evaluate each individual one, then recombine.

This is because those built-ins are the ones that can't automatically be wrapped later.

Preferably in a functional style.

Lots of changes have been made to Rabbit since Grapher was written. The breaking changes were accounted for, but the code still needs additional modernization.

Replace the naive algorithm with something better.

See:
https://en.wikipedia.org/wiki/Prime_factorization
https://en.wikipedia.org/wiki/Dixon%27s_factorization_method

Should be implemented with a fake matrix that has a function built in that takes the coordinates as its params.

This will also allow multithreading, which is currently impossible due to tk objects not being pickleable.

Should go to start or end, depending on whether the empty indice is first or last. Also make sure negative steps and higher to lower work.

Get rid of silent failures.

Like Python's func(x, a=5, c=6, b=2).

Make func, inputfunc, inputclass, etc. all use one, set personal variable name.

Possibly convert current debug output into that.

As many statements should be made functions as is appropriate.

Just ignore all whitespace-only lines.

Make use of int and long instead of just float to allow the greatest precision in dealing with numbers.

Same as string multiplication but for lists using **

After Rabbit string processing, then apply Python string processing. Insure no code injection is possible. Also allow the use of raw strings.

That includes unicode, all special ascii characters. That is, everything Python can do.

Normal rendering works with matrices, but not parametric, polar, inverse, sum, etc.

Solution:
Make isnull check onlydiag

Functions should not be changing the original item.