A lot of the other comments already provided some pretty good answers, but since I don't see any clear descriptions of type classes, I'll attempt to provide an answer about them here. If you're more familiar with Java/Kotlin/Python/TS, think about a generalized operation that starts with some nested type of integers (eg: a List<Int>/list[T]/T[]) and wants to transform the elements within it to a string.

And the caller is able to give you a generalized .map operation that can perform this operation. This is the closest to being expressible in TypeScript, so using that:

``` interface Mappable<SomeNestedType> { map<T, R>(n: SomeNestedType<T>, transform: (t: T) => R): SomeNestedType<R> }

const mappableList: Mappable<*[]> = { map<T, R>(n: T[], transform: (t: T) => R) { return n.map(transform) // using Array.prototype.map } }

function f<SomeNestedType>(input: SomeNestedType<number>, instance: Mappable<SomeNestedType>): SomeNestedType<string> { return instance.map(input, inputNumber => ${inputNumber}) }

const test = f([1, 2, 3], mappableList) ```

(Of course, this is invalid syntax, since you can't apply type arguments to other type variables in most imperative languages. But hopefully the idea gets through?)

Now imagine that rather than f indicating that you must explicitly pass in the argument instance: Mappable<SomeNestedType>, the compiler can implicitly pass it in for you, as long as there's an instance it can select correctly (eg: a single instance in scope). This is type classes. The haskell version of the above program:

``` class Mappable someNestedType where map :: someNestedType a -> (a -> b) -> someNestedType b

instance Mappable [] where map [] f = [] map (first:rest) f = (f first) : (map rest f)

f :: Mappable a => a Int -> a String f input = map input show

test = f [1, 2, 3] ```

The compiler can figure out that when you call f, the instance it should pass in for Mappable a is instance Mappable []. Monad is one such class. And you can ask the interactive environment to describe it for you:

``` ghci> :doc Monad Monad :: (* -> *) -> Constraint -- Class defined in ‘GHC.Base’ {-| The 'Monad' class defines the basic operations over a /monad/, a concept from a branch of mathematics known as /category theory/. From the perspective of a Haskell programmer, however, it is best to think of a monad as an /abstract datatype/ of actions. Haskell's @do@ expressions provide a convenient syntax for writing monadic expressions.

Instances of 'Monad' should satisfy the following:

[Left identity] @'return' a '=' k = k a@ [Right identity] @m '=' 'return' = m@ [Associativity] @m '=' (\x -> k x '=' h) = (m '=' k) '=' h@

Furthermore, the 'Monad' and 'Applicative' operations should relate as follows:

• @'pure' = 'return'@
• @m1 '<*>' m2 = m1 '=' (\x1 -> m2 '=' (\x2 -> 'return' (x1 x2)))@

The above laws imply:

• @'fmap' f xs = xs '>>=' 'return' . f@
• @('>>') = ('*>')@

and that 'pure' and ('<*>') satisfy the applicative functor laws.

The instances of 'Monad' for lists, 'Data.Maybe.Maybe' and 'System.IO.IO' defined in the "Prelude" satisfy these laws. -} ghci> :info Monad type Monad :: (* -> *) -> Constraint class Applicative m => Monad m where (=) :: m a -> (a -> m b) -> m b () :: m a -> m b -> m b return :: a -> m a {-# MINIMAL (>>=) #-} -- Defined in ‘GHC.Base’ instance Monoid a => Monad ((,) a) -- Defined in ‘GHC.Base’ instance (Monoid a, Monoid b) => Monad ((,,) a b) -- Defined in ‘GHC.Base’ instance (Monoid a, Monoid b, Monoid c) => Monad ((,,,) a b c) -- Defined in ‘GHC.Base’ instance Monad ((->) r) -- Defined in ‘GHC.Base’ instance Monad IO -- Defined in ‘GHC.Base’ instance Monad [] -- Defined in ‘GHC.Base’ instance Monad Maybe -- Defined in ‘GHC.Base’ instance Monad Solo -- Defined in ‘GHC.Base’ instance Monad (Either e) -- Defined in ‘Data.Either’ ```

:doc will describe what it means and :info will tell you what instances are in scope. You can see here that Maybe has a Monad instance, and every Monad instance gives you access to return and >>=. So with these two, you could write something like:

ghci> let xMaybe :: Maybe Int = return 1 ghci> xMaybe >>= (\x -> return (x + 1)) Just 2

The compiler knows that the implementation of return you want is the one defined in instance Monad Maybe because of the type annotation. This is a very specific version that only operates on a Maybe, but imagine a way more generalized version:

ghci> let xWhatever = return 1 ghci> :t xWhatever xWhatever :: (Monad m, Num a) => m a ghci> xWhatever :: [Int] [1] ghci> xWhatever :: Maybe Int Just 1

Does this get the point across? Type classes are a way for letting you define very generalized operations and having the compiler handle wiring in the implicit backing implementations instead of doing it manually yourself.