Whenever I try to calculate the factorial of a number greater than 63 (and less than 66, else it returns 0.0) I get the following error:

thread 'main' panicked at 'index out of bounds: the len is 36 but the index is 9223372036854775808', /rustc/3c235d5600393dfe6c36eeed34042efad8d4f26e\src\libcore\slice\mod.rs:2686:10
note: Run with `RUST_BACKTRACE=1` environment variable to display a backtrace.

Exiting continuous mode with Ctrl-C causes it to panic.

thread 'main' panicked at 'called 'Result::unwrap()' on an 'Err' value: Io(0s { code:13, kind: PermissionDenied, message: "Permission denied" }), src/libcore/result.rs:1009:5

Whenever eva is run it writes a history.txt into the current directory. This results in a lot of these files lying around my system. I would prefer if eva used a central history file stored in the appropriate place on the given operating system (The directories crate can help with that).

~~:warning: Note: this is based on #51 and thus a draft for now.~~

The motivation behind this change is to implement / change the following functions:

• nroot(x,y) returns the y-th root of x.
• log(x,y) returns the logarithm of x for the base y.
• log10(x) returns the logarithm of x for the base 10. This is a breaking change as this is what log(x) was doing previously.

Internally, the following has changed:

• Each relation of a Token::Function now has the signature fn(Vec<f64>) -> f64 where Vec<f64> represents a list of arguments from the REPL. Via the macros arity_{1,2}! it's still possible to define functions with n arguments:

  arity_2!(|x, y| x+y)
  

  evaluates to a function which takes a Vec<f64> and evaluates x+y with x being vec.get(0).unwrap() and vec.get(1).unwrap(). The data-structure ensures previously that the size of the vector matches the number of required arguments.

• The parser now evaluates expressions starting from a closing bracket back to the next left bracket (as before) or the next comma and ensures that the latter case can only happen inside a function call.

Hi !

eva is for sure a very polished piece of software. However there is one thing I think it is lacking right now (or maybe it has that already, but it is not advertised anywhere in the docs):

The Python shell has a very nifty shortcut that let's you capture the result of the last expression in the next expression to be evaluated using the _ variable as a special case:

>>> 1+1
2
>>> _ * 3
6

Would you be interested in implementing that ? This way I'd consider switching to eva as my pocket CLI calculator for good :wink:

$ eva -f 1
> .1 + 4
         4.0

$ eva '.1 + 4'
         4.0999999999

I would have expected the result to be rounded to the specified number of decimal places (and produce 4.1) instead of truncated.

Would it be possible to publish a git tag for each release here? This would be way more convenient when creating packages for a distro when using the source tarball from github :)

When an expression value is large enough the application crashes.

> 2000000000*200000000*20000000
thread 'main' panicked at 'index out of bounds: the len is 36 but the index is 9223372036854775808', /rustc/3c235d5600393dfe6c36eeed34042efad8d4f26e/src/libcore/slice/mod.rs:2686:10
stack backtrace:
   0: std::sys::unix::backtrace::tracing::imp::unwind_backtrace
             at src/libstd/sys/unix/backtrace/tracing/gcc_s.rs:39
   1: std::sys_common::backtrace::_print
             at src/libstd/sys_common/backtrace.rs:71
   2: std::panicking::default_hook::{{closure}}
             at src/libstd/sys_common/backtrace.rs:59
             at src/libstd/panicking.rs:197
   3: std::panicking::default_hook
             at src/libstd/panicking.rs:211
   4: std::panicking::rust_panic_with_hook
             at src/libstd/panicking.rs:474
   5: std::panicking::continue_panic_fmt
             at src/libstd/panicking.rs:381
   6: rust_begin_unwind
             at src/libstd/panicking.rs:308
   7: core::panicking::panic_fmt
             at src/libcore/panicking.rs:85
   8: core::panicking::panic_bounds_check
             at src/libcore/panicking.rs:61
   9: eva::format::pprint
  10: eva::main
  11: std::rt::lang_start::{{closure}}
  12: std::panicking::try::do_call
             at src/libstd/rt.rs:49
             at src/libstd/panicking.rs:293
  13: __rust_maybe_catch_panic
             at src/libpanic_unwind/lib.rs:87
  14: std::rt::lang_start_internal
             at src/libstd/panicking.rs:272
             at src/libstd/panic.rs:388
             at src/libstd/rt.rs:48
  15: main
  16: __libc_start_main
  17: _start

This looks like a handy tool. I'd love to create and AUR package for eva. It's best to build these against publish releases instead of straight from git master though. I would be great if you could tag a release.

Superseeds https://github.com/nerdypepper/eva/pull/52

Test probably still break, need to add more tests.

Thanks for @Ma27 for his work on the testing suite and lexer part in #52 that I get to continue to work on this easily.

cc @Ma27

On current master (39e4e643981d5ac52a440bf7e3691fca3228b1d2) trying to build eva with cargo build --release results in the following error:

error[E0433]: failed to resolve: use of undeclared type or module `env_logger`
  --> src/main.rs:44:5
   |
44 |     env_logger::init();
   |     ^^^^^^^^^^ use of undeclared type or module `env_logger`

error: aborting due to previous error

For more information about this error, try `rustc --explain E0433`.
error: Could not compile `eva`.

Upon commenting out the line cargo check and build --release both finish with the following 2 warnings:

warning: unused `std::result::Result` that must be used
  --> src/main.rs:79:9
   |
79 |         std::fs::write(&previous_ans_path, "0");
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: #[warn(unused_must_use)] on by default
   = note: this `Result` may be an `Err` variant, which should be handled

warning: unused `std::result::Result` that must be used
   --> src/main.rs:103:29
    |
103 |                             writeln!(file, "{}", ans);
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: this `Result` may be an `Err` variant, which should be handled
    = note: this warning originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)

However eva seems to work properly even with the warnings.

Right now typing 1e6 will perform 1 * e * 6. I think it would be useful to first check whether the number should be evaluated using exponential notation.

> 1e6
1,000,000

> 1e12
1,000,000,000,000

Etc... Rust itself, Python and JavaScript support this and once you start using it, it's really hard to go without.

As of the current 0.3.0 tag (the second iteration of this tag), the Cargo.lock file is not in sync with Cargo.toml. This means distro packages are unable to create reproducible packaging because the dependencies must be bumped dynamically at build time instead of being able to use the ones specified (via --locked or --frozen).

I'll submit a patch for this release (and have already repackaged the Arch Linux release using that patch), but please also make refreshing the lock file part of the release checklist/process.

Functions like (sum, avg, etc.) over entire history of results.

sum(*) (or any other special character) should produce the sum of all results in the current session.

Or the way bc does it. Mark result as a variable then use the variable tip later in a sum with other variables.

bill=10+20+30+40+50
tip=bill*10/100
bill+tip

Add a basic let syntax for simple mathematical functions. Proposed EBNF:

expr ::= NUMBER
           | NAME
           | NAME '(' args? ')'
           | 'let' NAME+ '=' expr 'in' expr
args = expr (',' expr)*

Where an expression in the form let name = 5 in expr binds name to 5 in expr, and an expression in the form let name a b = a + b in expr binds name to the function f(a, b) = a + b in expr.