Some of the basic concepts for learning functional programming. I noted all of them from wikipedia.
First class functions
In computer science, a programming language is said to have first-class functions if it treats functions as first-class citizens. Specifically, this means the language supports passing functions as arguments to other functions, returning them as the values from other functions, and assigning them to variables or storing them in data structures.
Higher order functions
In mathematics and computer science, a higher-order function (also functional form, functional or functor) is a function that does at least one of the following:
- takes one or more functions as an input
- outputs a function
Map function
In many programming languages, map is the name of a higher-order function that applies a given function to each element of a list, returning a list of results. It is often called apply-to-all when considered in functional form. This is an example of functoriality.
For example, if we define a function square as follows:
square x = x * x
Then calling map square [1,2,3,4,5] will return [1,4,9,16,25], as map will go through the list and apply the function square to each element.
Filter
In functional programming, filter is a higher-order function that processes a data structure (typically a list) in some order to produce a new data structure containing exactly those elements of the original data structure for which a given predicate returns the boolean value true.
Example Scala
list.filter(pred)
Or, via for-comprehension: for(x <- list; if pred) yield x
Scope
The term "scope" is also used to refer to the set of all identifiers that are visible within a portion of the program or at a given point in a program, which is more correctly referred to as context or environment.[a]
A fundamental distinction in scoping is what "part of a program" means – whether name resolution depends on the location in the source code (lexical scope, static scope, which depends on the lexical context) or depends on the program state when the name is encountered (dynamic scope, which depends on the execution context or calling context). Lexical resolution can be determined at compile time, and is also known as early binding, while dynamic resolution can in general only be determined at run time, and thus is known as late binding.
http://en.wikipedia.org/wiki/Scope_(computer_science)
Closure
In programming languages, a closure (also lexical closure or function closure) is a function or reference to a function together with a referencing environment—a table storing a reference to each of the non-local variables (also called free variables or upvalues) of that function
Anonymous function
In computer programming, an anonymous function (also function constant, function literal, or lambda function) is a function defined, and possibly called, without being bound to an identifier. Anonymous functions are convenient to pass as an argument to a higher-order function and are ubiquitous in languages with first-class functions such as Haskell. Anonymous functions are a form of nested function,
List Comprehension
A list comprehension is a syntactic construct available in some programming languages for creating a list based on existing lists. It follows the form of the mathematical set-builder notation (set comprehension) as distinct from the use of map and filter functions.
Example scala
val s = for (x <- Stream.from(0) if x*x > 3) yield 2*x
