Ruby.CodeCompared.To/Haskell

Every Haskell program's entry point is main :: IO (). The IO () type signals that this function performs side effects. putStrLn prints a string followed by a newline — the direct counterpart of Ruby's puts.

putStrLn outputs a String as-is, just like Ruby's puts. print is equivalent to Ruby's p — it calls show on the value (adding quotes around strings) and prints the result. Use putStrLn for user-facing output and print for debugging.

The do block sequences multiple IO actions. Each line is executed in order, just like a Ruby method body. Haskell normally evaluates lazily, but IO actions in a do block are performed strictly from top to bottom.

Haskell's let inside a do block creates an immutable local binding — there is no way to reassign it. Ruby's local variables are mutable; Haskell's are not. The :: Int annotation tells the compiler which numeric type to use when it cannot infer one.

The where clause attaches private definitions to a function — like giving a Ruby method private helper variables that are only visible in that scope. In Haskell where bindings can be mutually recursive and can themselves have their own where clauses. Ruby has no direct equivalent; the closest idiom is local variables or private helper methods.

Haskell is statically typed and infers most types automatically, but you can annotate with :: Type to be explicit or to resolve ambiguity. Ruby never requires type annotations — types are checked at runtime, not compile time.

Haskell has no string interpolation. You concatenate strings with the ++ operator, or use show to convert non-string values. The Data.Text.printf and Text.Printf.printf modules provide C-style formatting as an alternative. For Rubyists the lack of interpolation is one of the first friction points in Haskell.

Haskell's basic types — Int, Double, Bool, Char — are similar to Ruby's, but declared at compile time. A notable difference is that Haskell's Char uses single quotes exclusively, while String (which is [Char]) uses double quotes.

Haskell's type inference (the Hindley–Milner algorithm) figures out the type of every expression at compile time without requiring annotations. The compiler catches type mismatches before the program ever runs — something Ruby only discovers at runtime.

Haskell never implicitly converts between numeric types — you must use fromIntegral to promote an Int to a Double. This is more verbose than Ruby's .to_f but prevents silent precision loss. floor and ceiling need a type annotation on the result because they are polymorphic.

Haskell uses && and || for boolean operators, just like Ruby. The difference is that Haskell uses the function not instead of the ! prefix operator. Haskell's Bool is a proper algebraic data type with two constructors: True and False (capitalized).

Haskell uses ++ for list concatenation, and since String is just [Char], ++ concatenates strings too. Ruby uses +. The ++ operator works on any list, making string and list operations consistent — though for performance-critical code the Data.Text type is preferred.

Because String is [Char], length is the standard list length function — it counts characters. Be aware that this counts Unicode code points, not grapheme clusters, which matters for international text. The Data.Text package handles text encoding more robustly for production use.

read parses a string into any type that implements the Read typeclass — it is the inverse of show. read throws a runtime exception on invalid input, so production code uses reads or Text.Read.readMaybe for safe parsing. Ruby's Integer() similarly raises on invalid strings.

words splits on whitespace (like Ruby's split with no arguments) and lines splits on newlines (like Ruby's lines). Their inverses are unwords and unlines, which join with spaces and newlines respectively — the same role Ruby's join plays.

Because String is [Char], the polymorphic list function reverse works on strings without any special string methods. This is a recurring Haskell pattern: functions that operate on lists automatically work on strings too.

Haskell lists use the same [...] syntax as Ruby, but they are singly-linked lists under the hood — not arrays. head and tail correspond roughly to Ruby's first and [1..] slice. Calling head or tail on an empty list raises a runtime exception, so idiomatic Haskell prefers pattern matching.

The : operator (pronounced "cons") prepends a single element to a list. Because Haskell lists are singly-linked, cons is O(1). Ruby's + allocates a new array; Haskell's : just adds a node. All list literals are syntactic sugar for cons chains: [1,2,3] is 1:(2:(3:[])).

Haskell's [start..end] syntax mirrors Ruby's ranges. The two-element form [start,step..end] specifies a step — equivalent to Ruby's step. Ranges work on any type that implements the Enum typeclass, including characters and integers. Haskell also supports infinite ranges like [1..] thanks to lazy evaluation.

List comprehensions combine a generator (x <- list) with optional guards (conditions after the comma) to produce a new list. The syntax mirrors mathematical set notation. Ruby achieves the same thing with map and select chained together; Haskell's comprehension syntax combines both in a single expression.

map and filter are the Haskell counterparts of Ruby's map and select. In Haskell they are standalone functions rather than methods — you pass the list as the last argument. (* 2) is an operator section: a partially-applied multiplication, equivalent to Ruby's { |x| x * 2 }.

foldr (fold right) is the Haskell equivalent of Ruby's inject/reduce. It takes a combining function, an initial value, and a list. foldl' (strict fold left, from Data.List) is more efficient for large lists because it does not build up a chain of thunks. foldr is preferred for lazy or infinite structures.

Haskell's standard list functions length, sum, maximum, minimum, and reverse map directly onto their Ruby counterparts. They are ordinary functions rather than methods, so they work on any list — including strings, since String is [Char].

Haskell evaluates lists lazily by default — elements are only computed when needed. This allows infinite lists like [1..] to exist as first-class values; take 5 forces only the first five. Ruby requires explicit .lazy enumerators to achieve the same effect. Lazy evaluation is one of Haskell's most distinctive and powerful features.

Haskell tuples are fixed-size, heterogeneous containers whose size and types are part of the type signature — (Int, String) and (String, Int) are different types. Ruby uses arrays where Haskell would use tuples. fst and snd extract the first and second elements of a pair; for larger tuples you use pattern matching.

Destructuring a tuple with let (a, b, c) = tuple works like Ruby's multiple assignment. Haskell's type system makes the structure explicit — (String, Int, Bool) is a distinct type from (Int, String, Bool). This lets the compiler catch mistakes that would only surface as runtime errors in Ruby.

zip combines two lists into a list of pairs, stopping at the shorter list — just like Ruby's zip. In Haskell, map fst pairs extracts the first element from each pair (equivalent to map(&:first) in Ruby). The combination of zip and map fst/snd is idiomatic for working with paired data.

In Haskell if/then/else is an expression, not a statement — it always produces a value, and the else branch is mandatory. This is similar to Ruby's ternary operator ? : rather than Ruby's if/end statement. Both branches must have the same type.

Guards (|) are Haskell's idiomatic multi-branch conditional — cleaner than chained if/else. Each guard is a boolean expression; otherwise is just True and acts as the catch-all. Guards can appear in function definitions, case expressions, and list comprehensions. They map naturally onto Ruby's if/elsif/else chains.

Haskell's case expression matches on values like Ruby's case/when, but _ is the wildcard rather than else. Crucially, Haskell's case is exhaustiveness-checked — the compiler warns (or errors) if you leave out a case. Ruby's case silently returns nil for unmatched values.

The let...in form is the pure-expression version of let in a do block. It introduces local bindings that are visible only in the in body and evaluates to the body's value. Ruby's begin...end serves a similar purpose for grouping expressions, though without name-scoping.

Haskell functions can have multiple equations, each matching a different pattern. The runtime tries each equation top-to-bottom and uses the first that matches. This is more expressive than Ruby's traditional case/when (which only tests equality) because patterns can match on structure. Ruby 3+ case/in is the closest Ruby equivalent. The compiler warns if your patterns are non-exhaustive.

The cons pattern (x:rest) binds the head element to x and the tail list to rest. Nesting it as (x:y:_) matches at least two elements. This mirrors Ruby 3's [x, y, *] pattern in case/in, but in Haskell it is the primary way to process lists recursively.

Tuple patterns destructure the tuple directly in the function parameter list — no separate destructuring statement needed. This is similar to Ruby's multiple assignment left, right = pair, but Haskell's compiler verifies that the tuple has exactly the right number of elements at compile time.

Haskell function equations can match on literal string, integer, or character values. The last equation with a variable name (name) acts as the catch-all, binding the unmatched argument. This is more readable than a sequence of if checks and directly maps to Ruby's case/when with string matches.

The @ pattern (pronounced "as") binds the whole matched value to a name while also destructuring it. list@(first:_) binds the whole list to list and the first element to first simultaneously. This avoids the need to reconstruct the original value after destructuring — a convenience with no direct Ruby equivalent.

Haskell function definitions use the form name argument = body with no parentheses around arguments and no return keyword — the body expression is the return value. Function application is written with a space: double 7, not double(7). Type signatures like double :: Int -> Int are optional but strongly recommended.

Haskell lambdas use a backslash (resembling λ) followed by parameters and -> to the body. A multi-parameter lambda \x y -> ... is syntactic sugar for a nested single-parameter lambda \x -> (\y -> ...). Ruby's ->(x, y) {} packs multiple parameters into a single closure; Haskell's currying keeps them separate.

The . operator composes two functions: (f . g) x is f (g x). It reads right-to-left — negate . (* 2) first doubles, then negates. Ruby 2.6+ has << and >> for proc composition, but Haskell's . is deeply idiomatic and used throughout real code.

The $ operator is just function application with the lowest possible precedence. f $ g $ x is f (g x) — it eliminates nested parentheses by associating to the right. Ruby's method chaining achieves the same readability goal but reads left-to-right, while $ chains read right-to-left.

Every Haskell function is automatically curried — applying it to fewer arguments than it expects produces a new function. Operator sections like (+ 5) and (* 2) partially apply the operator, creating a new one-argument function. Ruby achieves the same effect with lambdas or method(:name).curry, but in Haskell it is effortless and pervasive.

Functions that take other functions as arguments are first-class in Haskell. The type signature (Int -> Int) -> Int -> Int explicitly shows that the first argument is a function. Ruby requires lambdas or procs to pass callables; in Haskell any function — including operator sections — can be passed directly.

zipWith combines two lists element-by-element using a function — it is zip followed by map in one step. Ruby needs zip(...).map { } to achieve the same result. zipWith (+) adds lists element-wise, zipWith max gives element-wise maxima, and so on.

any and all are Haskell's counterparts of Ruby's any? and all?. They take a predicate function rather than a block. Haskell's lazy evaluation makes them short-circuit: any stops at the first True, all stops at the first False — just like Ruby.

flip f x y calls f y x — it reverses the order of the first two arguments. This is useful when partial application needs the "wrong" argument fixed first. For example, flip div 2 creates a function that divides its argument by 2, even though div's first parameter is the dividend. Ruby handles this with lambdas or curry.

concatMap f list maps f over the list and then concatenates the results — it is the Haskell name for what Ruby calls flat_map. It is also the implementation of the list monad's bind operation: concatMap is (>>=) for lists, making it a fundamental building block for list comprehensions.

iterate f x produces the infinite list [x, f x, f (f x), ...]. Combined with takeWhile or take, it replaces imperative loops that accumulate values. This is idiomatic Haskell: express the series you want, then take what you need — no mutable loop variable required.

Maybe a is Haskell's type-safe alternative to nil. A value of Maybe Int is either Just n (a present integer) or Nothing (absent). Unlike Ruby's nil, the type system forces you to handle both cases — you cannot call + 1 on a Maybe Int without unwrapping it first.

fromMaybe defaultValue maybeValue unwraps Just x to x, or returns the default if Nothing. It is the Haskell equivalent of Ruby's || default idiom. The key difference is that the compiler tracks whether a value is Maybe — you cannot accidentally forget to handle the missing case.

Pattern matching on Maybe is the idiomatic way to handle both cases. The compiler enforces exhaustiveness — if you forget to handle Nothing, you get a warning. Ruby's case/when nil is conventional but nothing prevents forgetting the nil branch.

Either String Int holds either a Left String (an error message) or a Right Int (a success value). It is Haskell's typed alternative to exceptions — the error path is visible in the type signature. Ruby conventionally uses tagged arrays [:ok, value] or raises exceptions; Haskell makes the two outcomes part of the type.

fmap f (Just x) returns Just (f x); fmap f Nothing returns Nothing. This is the same as Ruby's safe navigation operator &. — the function is applied only when the value is present. The power is that fmap is defined by the Functor typeclass and works on lists, Either, IO, and any other container.

Haskell's data keyword defines an algebraic data type. A sum type like Color enumerates all possible values — similar to Ruby symbols, but typed. deriving (Show) automatically generates a string representation. The compiler exhaustiveness-checks case and pattern matches against the type's constructors.

Constructors can carry data — Circle Double wraps a radius, Rectangle Double Double wraps width and height. Pattern matching in function equations unpacks the values. This is Haskell's equivalent of Ruby's Data.define value objects, but the type is a single coherent union rather than separate classes.

Record syntax adds named field accessors to a data type. personName person works like Ruby's person.name. Haskell also generates a record update syntax: person { personAge = 31 } creates a new Person with only the age changed — immutable update that mirrors Ruby's Data#with.

newtype creates a distinct type from an existing one with zero runtime overhead — the wrapper is erased after type-checking. It prevents accidentally passing a raw String where a Name is expected. Ruby achieves a similar effect with thin wrapper classes or Data.define, but the guarantee is conventional rather than compiler-enforced.

Show and Read are typeclasses that define how a type converts to and from a string representation. show is like Ruby's to_s and inspect; read is like Ruby's Integer() but generic over any readable type. deriving (Show, Read) generates these instances automatically for data types.

The Eq typeclass provides == and /= (not-equal); Ord provides <, >, compare, minimum, and maximum. compare returns an Ordering value: LT, EQ, or GT — the equivalent of Ruby's <=> spaceship operator but typed.

Typeclasses define an interface that types can implement — like Ruby's modules used as mixins, but enforced by the type system. class Describable a where declares the interface; instance Describable Season where implements it. The compiler verifies every instance provides all required methods and rejects uses that mix incompatible types.

The Functor typeclass defines fmap :: (a -> b) -> f a -> f b — the ability to apply a function inside a container without unwrapping it. Lists, Maybe, Either, and IO are all functors. Ruby's map on arrays and then/yield_self on objects serve similar roles, but they are not unified under a single abstraction.

The do notation sequences IO actions, making Haskell's otherwise pure, lazy code execute steps in order. putStr prints without a newline (like Ruby's print); putStrLn adds one (like Ruby's puts). Under the hood, do is syntactic sugar for >>= (bind) chains.

The <- arrow inside a do block "extracts" a value from an IO action and binds it to a name. doubled <- getDoubled 21 runs the IO action and gives the resulting Int the name doubled. Ruby's assignment result = method_call is the equivalent; the difference is that <- only works inside monadic context.

The backtick syntax x `div` y turns any two-argument function into an infix operator — total `div` count is the same as div total count. This mirrors the readability goal of Ruby's method chaining. Returning a tuple of computed values is Haskell's lightweight alternative to returning a struct or hash.

return in Haskell wraps a pure value in an IO context — it does not exit the function early as in Ruby. return 42 creates an IO Int action that, when executed, produces 42 without any side effects. This is often surprising for Ruby developers who expect return to control flow.

mapM_ applies an IO-returning function to each element of a list and sequences the actions in order, discarding the results. The trailing _ signals that return values are ignored — the same convention as Ruby's each versus map. mapM (without the underscore) collects results into a list of IO actions.

Data.List provides sort (like Ruby's sort), nub (remove duplicates, like Ruby's uniq), and intercalate (join with a separator, like Ruby's join). Imports are explicit in Haskell — listing names in parentheses like (sort, nub) prevents name collisions and makes dependencies obvious.

import qualified ... as Map imports the module but requires the Map. prefix on every function — preventing clashes with Prelude functions like lookup and null. Data.Map.Strict is a balanced binary search tree (O(log n) operations), equivalent to Ruby's Hash for key-value storage. Map.lookup returns Maybe, not nil.

Data.Char provides character predicates and transformers. Because String is [Char], applying map toUpper to a string works exactly like filter isAlpha on a list — list functions and string functions are the same functions. Ruby needs regex or explicit character class checks; Haskell uses composable predicates.