joelniemela / calculator Goto Github PK

• Implement the concept of "units":
  • Numbers without explicit units should have the unit unit.
  • When two numbers of different units are in an expression, the result should have the unit expected of that operation.
• Add the button ° (degree). Add support to the parser for numbers such as 23° and 32.43°
  • A number that ends in ° has the unit degree

Create the type Exp.
All expressions and nodes in the AST should be of type Exp.

Implement the function stringifyExp that should turn an expression into the string that would be parsed as that expression.

Lambda functions should be added with the following syntax:

• Define lambdas like fn : λx.x + 2.
• Define multi-argument lambdas as fn : λx y.x + y
• Call a lambda either by calling the variable it is bound to: fn(4)
• or by calling it directly: (λx.x + 2)(2)

Add the function log2 to the calculator interface, using the label log₂

Currently, the Rad/Deg toggle doesn't affect the behavior of the trigonometry functions.

• When Rad is set, trigonometry functions should treat their input as radians.
• When Deg is set, trigonometry functions should treat their input as degrees.

Create the class Value.
Any runtime value should be of type Value.

There's no way to type the log₂ function.
This should be fixed by adding subscripts.

The variable module should contain a way to inspect variables' values and modify them. Buttons related to variables, such as :, currently in the function module, should be moved to the variable module.

Things to look out for:

• Make sure that the variable inspector has enough screen space to display longer values, such as big numbers and complicated functions.
• There should be a way to browse existing variables without taking up too much screen space. Maybe this could be a stacked layout, togglable with a button?
• Constans could also be moved to the variable module. These might also need to be in a stacked layout to save on space, or they could use the bottom row of the variable-browser layout.

Calling a lambda should create a function scope, where arguments and any temporary variables are stored.

The calculator's layout should be modular and organized in 4x5 segments (modules), which can be combined in different ways. Stacking modules and toggling between them with a button should also be possible to save screen space.

Potential modules:

• Base-module: contains the Numpad and basic arithmetic operators.
• Function-module: contains built-in functions, the lambda button (λ), and other function-related buttons.
• Variable-module: contains a variable-inspector where the user can inspect the variables' values and modify them. It also contains variable-related buttons, such as : for assigning variables.
• Scope-module: contains a list where the user can select variables in the global scope and then view them in the variable-inspector.

There should be an Auto mode which would allow the use of radians and degrees in the same equation.

Add the button ° (degree). Add support to the parser for numbers such as 23° and 32.43°

When Auto is enabled:

• Any number that ends in ° should be treated as degrees.
• Any number that doesn't end in ° should be treated as radians.

Organize all calculator state and logic into a class that creates all necessary DOM elements and sets up event handlers when instantiated.