Introduction

pfcalc is a simple command-line prefix calculator written in Haskell. It provides a concise syntax for integer arithmetic, and is intended for situations where some quick math over a list of numbers is needed.

# Calculate a sum
pfcalc + 121 242 363
# 726

# Calculate a remainder
pfcalc mod 894 16
# 14

# Find the number of seconds in a year
pfcalc x 365 24 60 60
# 31536000

# Find the gcd of some piped-in arguments
echo "91 455 56" | xargs pfcalc gcd
# 7

# Add up numbers from a file
seq 1 100 > numbers_1_through_100.txt
pfcalc + $(cat numbers_1_through_100.txt)
# 5050

Implementation

pfcalc is written in the wonderful Haskell programming language, and is hence written in a functional style, which enabled the code to be appropriately concise. Find the source code here.

Operations

pfcalc supports the following operations:

+ (sum)
- (subtraction)
x (product)
/ (integer division)
% (modulus)
mod (alias for "%")
gcd (greatest common divisor)

(Note that the symbol x is used for product instead of *, because shells read * as a wildcard.)

These operations are implemented in src/Ops.hs as functions of type Op,

type Op = NonEmpty Integer -> Integer

which describes a function from a non-empty list of integers to a single integer.

Implementing operations like + and x is easily accomplished by folding the input list over the corresponding Haskell built-in operation.

opSum :: Op =
  foldl' (+) 0

opProduct :: Op =
  foldl' (*) 1

(Note that 0 and 1 are used in the fold calls because they’re the identity elements for addition and multiplication respectively.)

Implementing gcd is easily done via folding the list over the Euclidean Algorithm:

opGCD :: Op =
  foldl' euc 0
  where
    euc a b =
 -- euclidean algorithm
      if b == 0 then a
      else euc b (a `mod` b)

Implementing subtraction-chains presents an issue: Haskell’s lazy evaluation means that the math will only happen after the fold has created the entire expression; evaluation will then happen outside-in, so subtractions will cancel into additions. We can get around this problem by hand-rigging the fold, using the $! operator to force strict-evaluation on the arguments to the recursive call.

opSubtract :: Op =
  \nums ->
    case nums of
      a :| [] -> a
      a :| b : cs ->
        opSubtract $! ((a - b) :| cs)
        -- need strict eval with "$!" so that subtractions don't cancel into
        -- additions

Main

The rest of the program is just the main function, which handles reading in arguments from the command line, checking for invalid input, and passing the arguments along to the proper op function if everything checks out.

main :: IO () =
  do args <- getArgs
     case args of
       [] -> do putStrLn "Error: no arguments given"
                putStrLn opsDescription
       op : opArgs ->
         let numericArgs :: [Integer] =
               mapMaybe (readMaybe) (opArgs)
         in case numericArgs of
           [] -> opError op "cannot be applied to no arguments"
           arg1 : argRest ->
             let args = arg1 :| argRest
                 opDo opFn = print (opFn args)
             in case op of
               "+" -> opDo opSum
               "-" -> opDo opSubtract
			   -- ...
               "gcd" -> opDo opGCD
               _ -> do opError op "unknown"
                       putStrLn opsDescription

(Note that the pattern-match on numericArgs enabled us to branch into a case where we are certain that the list has at least one element, which enabled the use of the :| constructor to create the NonEmpty list needed by the op functions).

pfcalc handles non-numeric input tokens by simply discarding them, making it a useful tool for calculating over blocks of text which contain numbers.

echo "I wish I knew the gcd of 120, 330, and 540" \
| sed s/\,/\ /g \
| xargs pfcalc gcd
# 30

Installation

A Makefile is included in the pfcalc source repository, making compilation easy (as long as you have the ghc Haskell compiler).

git clone https://github.com/emfred-dot-com/pfcalc
cd pfcalc
make
sudo make install