While Mathematicians like to talk non-sensical abstract idea, Informaticians want to know how to apply the idea concretely:
Monad = Monoid +Endofunctor
Monoid = Identity + Associative
Endo-functor = functor between 2 same categories
Monad is a ‘function’ to wrap the ‘side effects’ (exception errors, I/O,… ) so that function composition in ‘pipeline‘ chained operation sequence is still possible in pure FP (Functional Programming, which forbids side-effects).
Some common Monads: ‘Maybe’, ‘List’, ‘Reader’…
This allows monads to simplify a wide range of problems, like handling potential undefined values (with the
Maybe monad), or keeping values within a flexible, well-formed list (using the
List monad). With a monad, a programmer can turn a complicated sequence of functions into a succinct pipeline that abstracts away additional data management, control flow, or side-effects.
Exploring Monads in Scala Collections
(Part 1/3) – λC 2017
What is Category ?
Morphism (Arrows )
Rule 2: Identity
A <– C –> B
Product of Categories : A x B
Sum of Categories: A + B
(Either a b)
Reverse all arrows.
Functor F: C-> D
Mapping of all objects (A, B) in categories C,D
Mapping of arrows f
f : A -> B
Ff : FA -> FB (preservation)
F Id = Id
F (f。g) = Ff。Fg
Constant C -> F
FC = k
Ff = Id
Arrow Functor F: C -> D
For any object A in C,
F A = D -> A
(Functional Type is also Type)
Functors compose !
Category of categories:
Arrows : Functors
Haskell Category (Hask) is always Endo-Functor, ie Category Hask to itself.
Mapping of arrows.
Mapping of Objects = predefined
(Part 2/3) – λC 2017
(part 3/3) – λC 2017
3) Higher–Order Function, Closure
View story at Medium.com
As Tikhon Jelvis explained in his response, functions map sets to sets, and functions themselves form sets. This is the essence of the untyped lambda calculus. Unfortunately, untyped lambda calculus suffers from the Kleene–Rosser paradox (later simplified to Curry’s paradox).
This paradox can be removed by introducing types, as in the typed lambda calculus. Simple types are equivalent to sets, but in order to pass a function as an argument to another function (or return one), we have to give this function a type. To really understand what a function type is, you need to look into category theory.
The categorical model for the typed lambda calculus is a category in which objects are types and morphism are functions. So if you want to have higher order functions, you have to be able to represent morphisms as objects — in other words, create a type for functions. This is possible only if the category is cartesian closed. In such a category you can define product types and exponential types. The latter correspond to function types.
So that’s a mathematical explanation for higher order.