See the functions of mov programming. Types of functions

| | |
Function for programming - a fragment of the program code (subprogram), which can be downloaded from the next month of the program. Most of the options have an identifier associated with the function, but they also allow the function to be impersonal. The address of the first instruction (operator) to enter the function, which is transferred to the control when returning to the function, is inextricably linked to the name of the function. After the turning function is turned back to the address of the turn - the point of the program, where the function was turned.

The function can accept parameters and must rotate any value, possibly empty. Functions that rotate empty values ​​are often called procedures. deyakі movi programuvannya oboloshennya funktsіy and procedures mayut different syntax, zokrema can vikoristovuvatysya different keywords.

The function may be, but in a secondary rank, deafened and appointed. Anonymous functions, crime names, search for a list of names and types of passed parameters (or: arguments), as well as the type of value that is turned by the function. Defining a function Retrieve the delimited function code. Some moves of programming the voiced function without intermediary transfer of the designated function, while in other moves it is necessary to voice the function first, and then bring it to the designated function.

In an object-oriented programming function, declaring some kind of invisible part of the assigned class are called methods.

In order to win a single function earlier, it is necessary to specify the name of the function in the required area of ​​the program code and change the parameters that are passed to the function. Parameteries, ot, transmitted to funkії, you can transfer the Yak for meaning, so і for rasons: for zmіnnoї, transferred for meaning to the walled Kopіya і Be-Yakі zmіni, Shaho, in Tіlі funkії, I transmitted sninno, I will send it to the famous Kopіyu і nіyak not get acquainted on the change itself, the same change, as if it were in the function of the change, transferred by request, it is taken from the transferred change.

The function assigns a local (local) scope, where the input parameters are included, and navigate those changes, which are voiced by the function itself.

It is possible to call a function in the middle of the function itself: such a call of a function is called recursive, and the process of subsequent nesting of one-in-one calls of functions is called recursion. If it is necessary to store (near the stack) the address of the function rotation (and also see in the same stack the memory of the parameters and local changes, which are not dynamic), then there is nothing to do with the recursion to cause the stack to be re-arranged, so it will be restored in the programming language. boundary value of nesting of recursive links.

• 1 Applied functions
  • 1.1 JavaScript
  • 1.2 ActionScript
  • 1.3 Z++
  • 1.4 C#
  • 1.5 Pascal
  • PHP 1.6
  • 1.7 Stadard ML
  • 1.8 Visual Basic
  • 1.9 PureBasic
• 2 Div. also
• 3 Posilannya

Apply functions

JavaScript

function name(text, element) ( document.getElementById(element).innerHTML = text; )

ActionScript

public function name(text:string) ( var textfield: TextField = New TextField(); textfield.text = text; )

C++

void name(std::string text) ( std::cout<< text; }

C#

public void name(string text) ( System.Console.WriteLine(text); )

Pascal

procedure name(var text: string) begin write(text); end;

PHP

function name($text) ( echo $text; )

Stadard ML

fun name t = print t

abo, scho te same (div. curring):

fun name = print

Visual Basic

Sub Name(text) Console.WriteLine(text) End Sub

PureBasic

Procedure.l Name(text.s) PrintN(text) EndProcedure

Div. also

• anonymous function
• Function (mathematics)

Posilannya

Function (programming) Information About

Meta robots: 1) learn the rules for the description of functions; 2) pridbati novichki vykoristanny funktsіy pіd h poishenenya programm C ++.

Theoretical performance

The main module of the C++ program is the function.

Function- logical completions, in a singing manner of designing a fragment of the program, which may be im'ya. Functions allow you to divide large enumeration tasks into more details.

The skin program of my C ++ obov'yazkovo to replace the function of the names of main (head), like the body of the program. For all other functions, even if the stink is present in the program, there are prototypes - schematic records, which remind the compiler of them and the form of the skin function in the program.

Syntax for function prototype with parameters:

type_of_inverted_value_of_function_name (list_of_parameters_in_of_designated_types);

C++ functions are standard (library) and code-based programming.

Standard functions

The description of the standard functions is found in files that are included before the program for the help of the #include directive. Such files are called header files; stench may be expanded h.

The call to the name of the function in the main program is called the function call.

To calculate the number of functions until the end of the day or the calculation of the current value, as we win the program.

y = sin(x); //sine calculation function

Designated functions

For a stalwart looking person, the functions are assigned to such a rank:

function_name_inverted_value_type (parameter_im_type,..., parameter_im_type)

body_functions

Programming functions

Functions, like a programmer creates himself, to simplify the process of writing programs, stink shards:

help to avoid re-programming, so that the same function can be blocked in other programs;

to improve the modularity of the program, therefore, it is easier to read, change and correct pardons.

butt9 .1. Let's create a function, like another 65 symbols "*" in a row. In order for this function to be used in the singing context, it is included in the program of another letterhead. The program consists of functions: main() and stars().

// Firm form

#include

const intLimit = 65;

void stars(void); // prototype of the stars() function

cout<<"Moscow Institute of Electronic Engineering"<

// Assigned function stars()

for (count=1; count<=Limit; count++)

We looked at the example of the simplest function, but we can’t make arguments and don’t turn the same values.

Function parameters

Let's take a look at the example of using parameters in the function.

butt9. 2. Let's write the space() function, as an argument, if there will be a number of gaps, if the function can be abused.

#define address "Selograd"

#define name "Moscow Institute of Electronic Engineering"

#define department "Informatics and Programming"

const int LIMIT = 65;

#include

void space(int number);

cout<

spaces = (LIMIT - strlen(name)) / 2; // Calculate, skils

// Necessary clearing

cout<

space((LIMIT - strlen(department))/2); // argument - viraz

cout<

//Assignment of the stars() function

for (count=1; count<=LIMIT; count++)

//Definition of the function space()

void space(int number)

for (count=1; count<=number; count++)

Changing number is called a formal argument. Tsya change the value of the actual argument for the hour of the call of the function. In other words, formal argument- change in the designated subprograms that are called, and actual argument- specific meaning, assigned to the replacement program that called out.

If more than one argument is needed to link to a given function, then the order of the function names can be given a list of arguments separated by commas:

void printnum (int i, int j)

(out<<"Координаты точек”<< i << j <

The input value of the function can be processed argument; The left value is rotated after the help of the keyword.

This is the third article in the series "Category Theory for Programmers".

Who needs tipi?

The spivtovaristvo has a deuce of bad luck about the advantages of static typification versus dynamic and strong typization versus weak. Allow me to illustrate a selection of typifications for the help of explicit experiment. Show your millions of maws with keyboards, like typing hot keys, like writing, compiling and running programs.

With machine language, be it a combination of bytes, viroblena mavpa, be accepted and launched. Ale, in high language languages, those are highly valued that the compiler of the building will bring out lexical and grammatical pardons. A lot of programs are simply thrown out, and mavpi is left without bananas, then there are more chances to be understood. Type checking secures one more barrier against stupid programs. In addition, at that time, dynamically typed mov types of inconsistency of types will only show up at the end of the day, strictly typing movs of statically typed inconsistencies of types will show up at the hour of compilation, but there will be no chance of running them incorrectly.

Otzhe, nourishment in what we want, so that the mavpis are happy, to create the correct programs?
(note perekladach: don’t look like a varto, the author just loves less boring metaphors, lower RNG and “violent sequence of bytes”, and don’t call programmers mawps).

Sound meta explicit experiment with mawps - the creation of a new selection of Shakespeare's works (note translation: abo War and Light of Tolstoy). Rechecking spelling and grammar in cycles sharply increase the chances of success. An analogue of the reverification of types is farther away: in addition, like Romeo is stunned by a person, the reverification of types is reconsidered, but on a new growth of leaves and shcho wines do not catch photons with your strained gravitational field.

Tipi needed for layout

The theory of category development of the composition of arrows. If not, two arrows can be arranged: the whole object of one arrow is guilty of zbіgatisya with the next advancing object. In programming, we transfer the results of one function to another. The program is not practicable, as another function cannot correctly interpret the data, taken for help first. Offending functions are due one to one, so that the composition ordered it. What is the strongest type system of the movie, the more quickly the approach can be described automatically and reverberated.

The only serious argument that I can smell against harsh static typification: you can choose some programs that are semantically correct. Really trapleyaetsya rarely (note translation: I’ll respect you that the author didn’t lie here, that he’s unfit, that he’s rich in styles, and that duck-typing is a prime programmer with scripting language duck-typing can have the right to life. On the other side, duck-typing is possible and in a good system types through templates, traits, type classes, interfaces, a lot of technologies, so the author’s idea cannot be considered wrong.) And, in any case, kozhna mova vengeance like a black hat, in order to bypass the system of types, if necessary. Navit Haskell can unsafeCoerce. But such constructions can vikoristovuvatisya wisely. Franz Kafka's character, Gregor Samsa, destroys the system of types, if he transforms into a giant beetle, we all know that he was skinned. (note translation: nasty:).

The second argument, which I often feel, is for someone who puts too much pressure on the programmer. I can deal with these problems, especially by writing myself a few voices of iterators in C ++, only the axis of technology, visnovok types, so that I allow the compiler to introduce more types from the context, in a way that stinks vikoristovuyutsya. With C++, you can change auto and the compiler will determine the type for you.

In Haskell, although it is a common practice, type-e instructions are optional. Programmers call them victorious, so that types can tell a lot about the semantics of the code, and voiced types help understand compiling pardons. The first practice in Haskell is to start a project from type development. Lastly, type instructions are the basis for implementation and become compiler-guaranteed comments.

Suvora's static typing is often exploited as a way to untest the code. Sometimes you can feel how Haskell programs seem to say: "If the code is picked up, it's correct." Of course, there is no guarantee that a program that is correct from a look of types is correct with a sense of the correct result. As a result of such a change in the lower reaches of Haskell, without becoming strongly reshuffled for the quality of the code, it could be improved. It turns out that in commercial minds the need for good bugs is less than equal to the soundness, which is connected with the economy of software security and the tolerance of the end of the short-lived, and even weakly po'yazanі z movoyu programming chi methodology The best criteria would be to choose how many projects are available in the graphics that are supplied with a greatly reduced functionality.

Now there is something that unit testing can replace strong typing. Let's take a look at the practice of refactoring in strongly typed moves: changing the type of an argument of a function. For strongly typed moves, it is enough to change the declaration of function, and then correct all the selection pardons. In weakly typified language, the fact that the function is now recognized by other data cannot be tied to a good side.

Modular testing can lead to evil deeds from inconsistencies, but testing is practical for immovable, rather than determining, processes (note translation: it’s possible, maw on your way to a set of tests: you don’t cover all the possible entries, but I’m a representative selection.) Testing is a filthy replacement for proving correctness.

What is tipi?

The simplest description of types: stench, meaningless. The Bool type (remember, specific types are based on the great letter in Haskell) consists of two elements: True and False. The Char type is the plurality of all Unicode characters, for example "a" or "ą".

Bagato can be endangered or unskinned. The String type, which is essentially synonymous with the Char list, is an example of the infinite multiplier.

If we stun x, like Integer:
x:: Integer
We say that the element is the multiplier of tsilih numbers. Integer in Haskell is impersonal, and can be used for precision arithmetic. Є th kіnceve impersonal Int, which looks like a machine type, like int C ++.

Є deyakі thin, yakі shy brіvnyuvannya typіv up to multiple folding. Є problems with polymorphic functions, which can be cyclical, and also because you cannot multiply all multiplies; but, as I said, I will not be a great mathematician. It is important that the category of multiples, as it is called Set, and we can work with it.
In Set, objects are impersonal, and morphism (arrows) are functions.

Set is a special category, so that we can look into the middle of the objects and help us to understand more intuitively. For example, we know that there are not many elements empty. We know that there are special multiplications from one element. We know that functions display elements of the same multiplier in other elements. The stench can match two elements to one, but not one element to two. We know that the same function reflects the skin element of the multiplier in itself, and so on. I plan step by step to forget all the information and to learn all the understanding from the categorical form, that is, in terms of objects and arrows.

In an ideal world, one could simply say that types in Haskell are impersonal, and functions in Haskell are mathematical functions between them. There is only one small problem: the mathematical function does not know whether any code - you know only the proof. The Haskell function is responsible for counting. Tse is not a problem, even though it can be taken away for the last number of krokiv, even though there were no great ones. Ale є deyaki counting, yakі include recursion and tі can never be completed. We can't just fence an unfinished function in Haskell to someone who can tell which function ends and which doesn't - the famous teething problem - undecoupling. The axis of why computer scientists came up with a brilliant idea, or a common hack, fallow in your point of view, is to expand the skin type to special values, which is called bottom (note translation: this term (bottom) feels like a bad Russian, if anyone knows a good option, be kind, pronounce.), which stands for _|_ or Unicode ⊥. This “meaning” confirms the calculation that is not completed. So the function, voiced like:
f::bool -> bool
can turn True, False or _|_; rest means that the function is never terminated.

Well, just as you accept bottom into the type system, manually look at the skin pardon for the hour of bottom, and let the function rotate bottom explicitly. Remain, as a rule, zdіysnyuєtsya for help virazu undefined:
f:: Bool -> Bool f x = undefined
It is intended to pass type checking because undefined is counted at bottom, as it is included in all types, including Bool. You can type to write:
f::bool -> bool f = undefined
(Without x) that bottom is another member of type Bool -> Bool.

Functions that can turn down are called partial, on the basis of the most significant functions, as they turn the correct results for all possible arguments.

Through bottom, the category of Haskell types and functions is called Hask, not Set. From a theoretical point of view, there were no more complicated things, so at this stage, I will finish the cycle of my butcher's vicarious. From a pragmatic point of view, it is possible to ignore the incomplete bottom functions and parse Hask as an complete Set.

Need a mathematical model for us?

As a programmer, you know well the syntax and grammar of my programming. Qi aspects of the movie, as a rule, are formally described on the cob of the specificity of the movie. But it’s better to describe the semantics of the movie; this description borrows more than a few sides, it is rare to file it formally and may not be exactly the same. The discussions of the middle jurists will never end, and all the artisanal craftsmanship of books dedicated to the tlumachennia of the subtleties of modern standards.

Formal description of the semantics of the movie, but through the slickness of the stink is mainly written for simple, academic language, and not the real giants of industrial programming. One of these tools is called operational semantics, which describes the mechanics of running a program. Winning formalizations, idealizations interpreter. The semantics of industrial words, such as C++, can be described in addition to informal interpretation, often in terms of an "abstract machine".

The problem is that it is important to bring about the program, like vikoristovuyut operational semantics. In order to show the power of the program, you, in fact, can “run it” through an idealized interpreter.

It doesn't matter that the programmers never formally bring correctness. We always "think" that we are writing the correct programs. No one sits at the keyboard, seeming: "Oh, I'll just write a few rows of code and wonder what comes up." (approx. translation: ah, yakby ...) We care that the code, which we write, vikonuvatime peevnі dії, yakі zroblyat bazhanі results. We ring out more zdivani, as it is not so. Tse means what we really think about programs, how we write, and we, as a rule, work at the same time, launching the interpreter in our heads. It's just that it's important to keep up with all the changes. Computers are good for programming, people are not! We were yakbies, we didn't need computers.

Ale is an alternative. It is called denotational semantics and is based on mathematics. The denotational semantics for the skin movable construction has a mathematical interpretation. In this manner, if you want to bring the power of the program, you simply bring the mathematical theorem. You think that it is important to bring the theorems, but really, people have been mathematical methods for thousands of years, so there is no need to accumulate knowledge, as you can win. In addition, it is equal to theorems, how to bring professional mathematicians, zavdannya, with which we stick with programming, it’s easy to do it, it’s not trivial. (note translation: for the sake of proof, the author does not try to imagine programmers.)

Let's take a look at the function of factorial in Haskell, which is easy to understand denotational semantics:
fact n = product
Viraz - a list of whole numbers from 1 to n. The product function expands all the elements of the list. So, as a destined factorial, take it from a handyman. Adjust price from C:
int fact(int n) ( int i; int result = 1; for (i = 2; i<= n; ++i) result *= i; return result; }
What do you need to continue? (note translation: the author cheated a little, taking the library function in Haskell. Actually, it was not necessary to be cunning, the honest description for the designation was not foldable):
fact 0 = 1 fact n = n * fact (n - 1)
Good, I’ll immediately admit that it’s a cheap trick! The factorial may be more obvious mathematically. The clerk can ask: What is the mathematical model for reading the symbol from the keyboard, or redirecting the package by size? For a long time, it would have been clumsy food, which led to the end of misleading explanations. It seemed that denotational semantics is not suitable for a significant number of important tasks, which are necessary for writing blue programs, and that they can easily be violated by operational semantics. Breaking through the theory of categories. Evgenio Modji having shown that the numbering effects can be translated into monads. It showed important cautions, as it not only gave a denotational semantic new life and smashed daily functional programs with handy ones, but also gave new information about traditional programming. I'm talking about monads less, if we can expand more categorical tools.

One of the important advantages of the obviousness of the mathematical model for programming is the possibility of vikonatie formal proof of the correctness of the software. It’s possible that it’s not important to build, if you write fast software, but also programming areas, the cost of failure can be majestic, but there, de people’s life is under a threat. Alternately, when writing web add-ons for the health care system, you can appreciate the idea that the functions and algorithms of the Haskell standard movie library are included in the set of proofs of correctness.

Pure and stupid functions

Those that we call functions in C++, or be it some other imperative language, are not the same ones that mathematicians call functions. A mathematical function is simply an expression of the value of a value.

We can implement the mathematical function of my programming: such a function, which can display the input value, will decompose the output value. The function of taking the square of a number, ymovirno, multiply the input value of the same vin. You'll be timid with skin wickedness, and it's guaranteed to break the same result right away, if you won't call out on this very argument. The square of the number does not change with the phases of the month.

In addition, the calculation of the square of the number is not guilty of the mother of the side effect, for the sake of seeing a savory brisket to your dog. "Function", as it turns out, cannot be easily modeled by a mathematical function.

Moves have programming functions that always give the same result on the same arguments and do not have side effects, they are called clean. In a pure functional language, like Haskell, all functions are pure. It is easier to define the denotational semantics of these words and to model them after the auxiliary theory of categories. If there are other words, then you can always surround yourself with a clean subset, or you can demystify about side effects okay. For better reason, as monads allow you to model all sorts of effects, vicarious and only pure functions. At the result, nothing is wasted, interspersed with mathematical functions.

Apply types

As soon as you see that tipi is impersonal, you can guess some exotic examples. For example, what type of type is used for empty loads? No, not Void C++, but the type is called Void in Haskell. Tse type, which is not reminiscent of the same values. You can designate a function to accept Void, but you can't call it at all. So, її viklikati, you happen to secure the value of the Void type, but it simply does not. What is the cost of what this function can turn - there are no daily boundaries. Vaughn can turn around, be a type (if you don’t want to, you can’t be a Viklikan). In other words, the function itself is, as it were, polymorphic behind the type that it rotates. The Haskeleri were named її:
absurd:: Void -> a
(note translation: in C ++ such a function cannot be assigned: in C ++ skin types can only have one value.)

(Remember that a is a type change, so you can be a type.) Іsnuє glibsha іninterpretаtsija typіv і funktsіy z vzglyadі logіki pod zvіd іzomorfіzm Karrі-Howard. The Void type represents untruthfulness, and the absurd function is a firmness that screeches out of hypocrisy, like the Latin phrase "ex falso sequitur quodlibet." (approx. translation: out of hilarity, it’s worth it.)

Given a type that matches a one-element multiplier. Tse type, which can only have one possible meaning. The value is simply є. You could not recognize it at once, but it's void in C ++. Think of functions as a type. The void function can always be viklican. Even though it is a pure function, the very result is always reversible. Axis butt has this function:
int f44() ( return 44; )
You can think about how a function accepts "nothing", but, as we have only tried, a function that accepts "nothing" cannot be viklikan, that which has no meaning, which represents the type of "nothing". So, what does this function accept? Conceptually, it has a fictitious meaning, for which there is only a single instance, we can clearly not show it in the code. Haskell, however, has a symbol for this meaning: an empty pair of shackles (). In this way, through a comedy zbіg (or not zbіg?), the viklik function in void looks the same in C ++ and in Haskell. In addition, through Haskell's love to conciseness, the very symbol () wins and for the type, constructor of the same value, which represents a one-element multiplier. Axis function in Haskell:
f44::() -> Integer f44() = 44
The first row deafens that f44 transforms the type (), the names "one", the type Integer. Another line is that f44, for additional pattern matching, transforms the single constructor for one, and itself () to the number 44. You call this function, giving the value ():
f44()
It should be noted that skin function alone is equivalent to the selection of one element for the target type (Integer 44 is selected here). Indeed, you can think of f44 as the other way around the number 44. This is an example of how we can replace the direct riddle of the elements by multiplying by the function (arrow). Functions with ones in type A have a one-to-one correspondence with the elements of the multiplier A.

And how many functions can rotate void, what, in Haskell, what can rotate one? C++ has such functions for side effects, but we know that such functions do not work in the mathematical sense of the word. A pure function, as if turning alone, not to rob: you see your argument.

Mathematically, the function of the multiplier A into a one-element multiplier converts the skin element of the single element of the multiplier. For dermal A, there is one such function. Won axis for Integer:
fInt::Integer -> () fInt x = ()
You give it be the whole number and you turn one. Inheriting the spirit of conciseness, Haskell allows the arbitrage symbol to be used as an argument to be taken. In this rank, it is not necessary to name you. The code above can be rewritten in the following way:
fInt::Integer -> () fInt_ = ()
To pay attention, that vikonannya tsієї funktsії not only not lie in the value passed to it, but also in the type of the argument.

Functions that can be assigned by one formula for any type are called parametrically polymorphic. You can implement the entire homeland of such functions to one peer, vicoristo the parameter to replace a specific type. How to name a polymorphic function from any type to one? Obviously, we call it a її unit:
unit::a -> () unit_=()
In C++, you would implement її like this:
template void unit(T)()
(note translation: to help the compiler optimize її in noop, more like this):
template void unit(T&&)()
Dali in the typology of the types of a set of two elements. C++ wins are called bool, and Haskell, not surprisingly, is called Bool. The difference is that C ++ bool is a type, at the same time, in Haskell, it can be assigned in the coming order:
data Bool = True | False
(Read the definition like this: Bool can be either True or False.) In principle, one could describe the type i in C++:
enum bool (true, false);
Ale, C++ is actually remapped by a whole number. You could use the C++11 "class enum" tag, but you could also specify the value with the class name: bool::true or bool::false, without seeming to need to include a custom header in the skin file, which is the tag.

The pure Bool functions simply select two values ​​of the integer type, one is True and the other is False.

Bool functions are called predicates. For example, the Data.Char library in Haskell has a lot of predicates, for example IsAlpha or isDigit. C++ has a similar library , What's more, the functions isalpha and isdigit, but they rotate an int, not a boolean value. Reference predicates assigned to i are called ctype::is(alpha, c) and ctype::is(digit, c).

If you are the same rozrobnik, like I, then, sing-song, on the cob they vied the OFP paradigm. First of all, Java or C ++ - otherwise, if you were lucky, Ruby, Python or C # - you, sing-song, you know, what kind of class, objects, instances, etc. What you don’t know for sure is that in the basics of that wonderful paradigm that is called functional programming, it’s not only about OOP, but also about procedural, prototype-oriented and other types of programming.

Functional programming is becoming popular - and for those reasons. The paradigm itself is not new: Haskell, perhaps, is functionally mine, but the culprit is in the 90s. So mov, like Erlang, Scala, Clojure also fall under the definition of functional. One of the main advantages of functional programming is the ability to write programs that work competitively (which is already forgotten, which is to refresh the memory of reading), and without pardon - that mutual blocking and thread safety will not bother you.

Functional programming may have a lot of advantages, but it is possible to use the maximum resources of the processor for a reason of competitive behavior - this is a big plus. Below we will look at the basic principles of functional programming.

Entry: All these principles are not obov'yazkovі (the rich language should not follow them). Use the theoretical and necessary essentials of the precise definition of the functional paradigm.

1. All functions are pure

This rule, insanely, is fundamental to functional programming. All functions are clean, as if the stink of two minds:

1. The function that is invoked by the arguments themselves always turns the same value.
2. Under the hour, the function does not blame side effects.

The first rule was understood - if I call the sum(2, 3) function, then I will check that the result is always more expensive 5. As soon as you call the rand() function, otherwise it will turn to a changed, not assigned function, the purity of the function will be destroyed. programming is unacceptable.

Another rule - the usual side effects - is wider for its nature. A side effect is the cost of changing the control function, as it is contagious. Changing the position of the function, displaying it in the console, turning off the call, reading data from the file - apply side effects, which will help the cleanliness function. You can get away, scho is serious, but think again. Even though you're convinced that the wiki function won't change anything "called", you can win this function in any scenario. This paves the way for competitive programming and rich streaming add-ons.

2. All functions - first class and highest order

This concept is not a special feature of the FP (it's won in Javascript, PHP and other languages) - but it's a good language. In fact, on Wikipedia, the purpose of the article is assigned to the functions of the first class. In order for the function to be first class, it is the mother’s fault that she can be naked in looking like a snake. Tse allows you to perform the function as a type of data and at the same time vikonuvat її.

3. Change unchangeable

Everything is simple here. For functional programming, you can change the change after initialization. You can create new ones, but you can’t change the existing ones - and you can be sure that you won’t change.

4. Visible clarity of functions

It is important to give the correct designation of the visible transparency. I pay attention to the following: if you can replace the click of a function with a value that rotates, and if it does not change, then the function is clearly visible. Tse, it’s possible, obviously, but I’ll point the butt.

Come on, we have a Java function, like adding 3 and 5:

Public int addNumbers()( return 3 + 5; ) addNumbers() // 8 8 // 8

It is obvious that if any viklik tsієї functions can be replaced by 8 - also, the function of visual prozor. Axis butt opaque functions:

Public void printText()( System.out.println("Hello World"); ) printText() // Returns nothing, but prints "Hello World"

This function does not rotate anything, but other text, and if you change the call of the function to something else, it will be different - again, the function is not visible to the vision.

5. Functional programming based on lambda enumeration

Functional programming is strongly based on a mathematical system, which is called lambda-calculus. I'm not a mathematician, so I won't go into details - but I want to pay attention to two key principles of lambda enumeration, which form the very understanding of functional programming:

1. In the lambda-calculus, all functions can be anonymous, but only one significant part of the function header is the same arguments.
2. When calling, all functions go through the process of caring. Vіn polagaє in the offensive: if the function is invoked with a large number of arguments, then it will be vikonated with the first argument and turn the new function, which will avenge 1 less argument, as it will be a negligent viklikan. This process is recursive and continues dots, the docks will not stop all the arguments, turning the final result. Shards of function are clean, clean.

As I have already said, the lambda-calculation does not end with anything - but we have looked at the key aspects related to FP. Now, when you talk about functional programming, you can shine with the word "lambda number", and everyone will think what you are doing 🙂

Visnovok

Functional programming is seriously stressing the muscles - but it’s also tighter, and I respect that its popularity is only growing.

If you want to learn more about functional programming, then we would like you to learn about the application of the principles of FP in JavaScript ( , ), as well as, we assign to functional C #.

So what is it "software function" ?

This is the strongest, head function of the structure of our psyche. The whole "legislative body" of our "department", the whole "director".

The information that is accepted by the software function is especially important for us. Therefore, it will be conquered by us with ease, without any effort, and practically without cost. All life is full of information from this aspect and we can’t oversit it, for that, behind the great rahunka, the ground, which is probably the whole and completely, one, that no one can cross us and do not cross us.

The information, as it takes on the program aspect, rarely reveals a new principle for us: we all know ourselves for a long time, and better for riches. We feel like this, we were born with this knowledge. Hurry, we need to know we know better .І, ozumіlo, zavzhda cover and comedy, if we are taught to whom else.

Software function - ce:

- "Function of informing the news",

- "function of innate professionalism",

- "the function of the main values, the main tasks and goals".

And for that very reason, people are very important to step into their "programs", not seeming to be about those who fix it all the way (which we often notice in the mind of psychological insanity).

Software function is important and unbreakable. The entirety of our intellectual activity is in her own hands. That is why we are protected as the remaining frontier, farther than ever to go anywhere. Oskіlki, as if entering into their own programs, we already see that we are spending ourselves and ruining ourselves as a specialty.

The software function determines the range of acceptable actions.

-Well, good - insert Reader, - ale yakshcho є in our psyche "function of goals and task", then can I be and as a function of their reach?

Such a function is functionally, and with the "software" won't be closely related, and in "Model "A" there is a right-hander in it, on the 2nd position of the equal HIS (Tobto borrows another cabinet on top). This function is called "creative" , or "creative function" .

The creative function is that creative aspect.

Іні її else name "implementation function" , or "instrumental function" , oskіlki won є as a bi "instrument" of the software function, її "a hacking body", important її in the middle of the middle.

As a software function, always analytical, principled, indestructible and to that inert , then the creative function is always gnuchka, maneuverable, guilty ,Oskіlki only tim and are engaged in developing forms, methods and methods for the implementation of "program" tasks and goals.

And now let's guess our first classification - " sensory -ethical","intuit -logical"And so on. What are my bachimo?

Bachimo those who creative function contributes to the quality of the software aspect, being a yak bi yakіsnoy yoga characteristic.

What rank? - Won "help" the software function "inform" the same information, as it can be implemented less within the framework of the aspect of creative function (Oskіlki creative function also has its own powerful aspect and through this aspect itself serves its "program").

- And what can you show on some butt? - squawk Reader.

- Applied impersonal! Let's say, as a program type, we have such an aspect, like "introverted ethics" - ("ethics vіdnosin"), The meta of what is - to make sure that people are mutually supportive, to correct the morality of the soul and to inculcate morality. But the morality of the soul can be planted in different ways: in different ways, people can be swung by the methods of forceful infusion - primus, fences, fencing, punishment, i.e., due to the aspect "volitional (extraverted) sensory".І cim method faster for everything sensoryethic, more precisely - ethical-sensory introvert(the program is introverted!) Another way to implement the introverted-ethical program is intuitive. Here people are given the opportunity to step by step and consequently dodoskonalyuvatisya ethically. Into this attitude, one should be injected into the new one by demonstrating positive applications: "work as you are taught, and everything in you will be good." And here the ethical program is already being implemented by the aspect "extraverted intuition" - "intuition of possibilities".І this method is the most popular intuitiveethical -ethical-intuitive introvert.

- Well, where is the difference in the ethical program, why should the methods of implementation be added? Why is sensory ethic impossible to master the methods themselves, like intuitive ethic, and at the same time?

- That is why, on the basis of this spiving of values, the principally different characteristics of the types are formed. Etico-intuitive introvert - penetrating, tolerant, vitrimanian optimist, you can see more clearly positive trends in the nature of people, she is guilty of them and spirals in her own mind. Penetration ethical-sensory introvert directed at those who show negative trends, which means a negayan vikorinennya. What can be said about sensory ethic What is it - a protective, distrustful pessimist, who cares for the best victorious methods of effective primus infusion, less risk for those who change the person herself.

-But why does it feel so good?

- Because our advances are the promotion of our shortcomings, and navpaki. That is, if a person has a strong sensory system, then it means that she will have a weak intuition, and it’s important to judge about future changes in the character of a person, the axis is out of reach of those effective results of rewiring by any means. I crim that there are no foreign types in society. Leather may have its own recognition, that leather is needed in its own place.

"Elementary model" type ІМ.

Aspects, blame on the river HIS hang out basic values ​​type The very same stench is the fault of yoga in the name.

For example, naming a type "etico-sensory extrovert" means yoga "programmatic" value - extraverted ethics ("ethics of emotions"), and "creative" value - introverted sensory ("sensory perception") .

On the river HIS it looks like this:

Respectful Reader, mabut, having respected what software introverted aspect is realized by extraverted aspects (i navpaki) .It seems to be the one that extrovert as the object's value may be of the first order, and in return between the objects it is of another order, so the program function (as the most significant) in the new one will be extraverted - a black symbol, and the implementation is introverted - a white symbol.

At introvert, apparently, obviously: the software function will be introverted (white symbol), and the implementation will be extraverted (black).

І more next mark: yakscho program aspect - rational (ethics of chi logic), then vin be realized by the irrational aspect .

-Why?

- But we have already said that the rational aspects are influenced by the aphids of the irrational and navpak. And by such a rank, we restore the equal aspects of our psyche on the skin z її equal and take care of ourselves vіdnosne equal to our mental structure.

Therefore, on the skin level model, one of the aspects will be extraverted, the other - introverted, one - rational, and the last - irrational.

The number of aspects and the sequence of their development of all the equals of our psyche still indicate the main psychological features of the skin type of informational metabolism.

In this manner, already for the name "type ІМ" it is possible to designate the structural spіvvіdnoshennia equal to HIM and create an elementary, two-position model that reflects the main characteristics of this mental structure.