Operator vs. Function - Haskell

In Haskell, both operators and functions are used to perform operations on values, but they differ in their syntax and sometimes in how they are used. Here’s a breakdown of the differences:

1. Syntax and Notation

Operators: Typically use symbols (! # $ % * + . / < = > ? \ ^ | : – ~) rather than letters (e.g., +, *, &&, ++) and are used in infix notation. This means they are placed between the operands (e.g., 3 + 4).
Functions: Typically use alphabetic names (e.g., add, sum, map) and are used in prefix notation, where the function name comes before its arguments (e.g., add 3 4).

Example:

-- Using an operator (infix notation)
3 + 4      -- Result: 7

-- Using a function (prefix notation)
add 3 4    -- Result: 7

2. Infix vs. Prefix Application

Operators are generally used infix by default, which makes them look more like mathematical expressions. You can use operators as prefix functions by enclosing them in parentheses (e.g., (+) 3 4).
Functions are typically used in prefix notation but can be used in infix notation if enclosed in backticks (e.g., 3 `add` 4).

Example:

-- Using the `+` operator as a prefix function
(+) 3 4    -- Result: 7

-- Using a function in infix notation
let add x y = x + y
3 `add` 4  -- Result: 7

3. Custom Operators vs. Regular Functions

You can create custom operators in Haskell by using symbolic names (e.g., !+!, ++=). Custom operators have to be symbols rather than letters.
Functions can be named with alphabetic identifiers, allowing more descriptive naming (e.g., multiply, concatLists).

Example of a Custom Operator:

-- Defining a custom operator that mimics add (+)
(!+!) :: Int -> Int -> Int
x !+! y = x + y

3 !+! 4  -- Result: 7

4. Readability and Intent

Operators are often used when an operation is simple, frequently used, or mathematically intuitive (e.g., + for addition, * for multiplication). They can make code involving calculations or data manipulation concise and closer to mathematical notation.
Functions are generally used when an operation is more complex or needs a descriptive name for clarity (e.g., filter, map, sumList). This improves readability, especially in larger programs.

5. Precedence and Associativity

Operators have defined precedence and associativity, which control the order of evaluation in expressions. For example, * has higher precedence than +, so 3 + 4 * 2 is evaluated as 3 + (4 * 2).
Functions don’t have precedence rules like operators. They are evaluated in the order they are applied, from left to right, unless parentheses are used to change the order.

Summary Table

Aspect	Operators	Functions
Syntax	Symbols (e.g., `+`, `*`, `&&`)	Alphabetic names (e.g., `add`, `map`)
Default Notation	Infix	Prefix
Infix Usage	By default, e.g., `3 + 4`	Use backticks, e.g., 3 `add` 4
Custom Naming	Symbols only	Alphabetic names
Precedence/Associativity	Yes	No
Readability Intent	For concise, common operations	For descriptive, complex operations

In essence, operators are specialized, symbolic functions that allow for infix notation and precedence handling, while functions are more general-purpose and are often used to improve readability with descriptive names.

Conceptually, there is no difference between an operator and a function, and you can use backticks or parens to make one work like the other.

💡 Helpful References

StackOverflow - Difference between an operator and a function in Haskell
https://stackoverflow.com/questions/2480974/what-is-the-difference-between-an-operator-and-a-function-in-haskell

Operator vs. Function – Haskell