►
Description
Все видео курса https://www.youtube.com/playlist?list=PL9tzQn_TEuFUakOn-IY9cDQL2ztNzZunh
Совместный курс NEAR & 4ire Labs
Подписывайтесь, чтобы получать обновления о новостях NEAR, акциях, запуске проектов, баунти, хакатонов
Русскоязычное сообщество NEAR https://t.me/near_protocol
Твиттер https://twitter.com/near_protocol
Общение с разработчиками https://t.me/openwebdev
Follow the latest from NEAR Protocol on:
Website: https://near.org/
Discord: https://near.chat/
Blog: https://near.org/blog/
Twitter: https://twitter.com/NEARProtocol
GitHub: https://github.com/near https://github.com/nearprotocol
#Blockchain #FutureIsNEAR #NEAR #nearprotocol #rust #wasm #assemblyscript #раст
A
Topic
is
rather
complicated,,
but
I
hope
that
it
will
be
interesting,
again,.
Let
me
remind
you
that
if
you
have
questions,
write
a
special
section,
because
now,
unfortunately,
I
can't
see
the
children,
I,
don't
know
why,.
So
if
you
have
questions
as
you
present
them
feel
free
to
ask
them.
Ok,
let's
decide
what
our
goals
are.
A
B
A
It
would
be
nice
to
understand
the
definitions,.
We
will
deal
with
the
approaches
of
functionally
non-
functional
programming,
precisely
in
the
context
of
the
growth
of
floors,,
but
they
are
also
closures
below
the
lambda
functions
as
one
of
the
components
of
programming
and
sp
specificity
of
the
growth
of
function.
Trades
as
type
parameters
is
also
one
of
our
goals,.
We
will
also
look
at
specific
examples
of
using.
A
Once
in
itself
has
chosen
quite
a
lot
of
programming
paradigm,
and
one
of
such
rather
interesting
features
is
that
there
is
the
possibility
of
using
quite
different
things,,
including
the
example
and
the
functional
object-oriented,
as
I
spoke
with
here,,
since
we
use
trade
and
but
there
is
the
possibility
of
using
writers,
I
will
change
straight
off.
This
is
already
in
advance
as
if
directed
by
emperors,
and
there
is
the
possibility
of
using
robotic
approaches,
and
this
is
one
of
the
strong
growth
opportunities
that
I
spoke
about
and
directly
in
growing.
A
You
can
use
such
a
tradition,
a
traditional
approach,
like
writing
enough
new
code,
without
applying
any
additional
extra
abstraction,.
As
is
customary
in
many
example,
languages,,
you
can
quite
easily
describe
spaghetti
code
if
you
want,.
Of
course,
you
can
also
do
this,,
but
the
problem
is
that
the
year
will
not
be
readable
and.
B
A
A
Include
languages
such
as
husky,
idris,
oh
yes,,
as
far
as
I
remember,,
yes,,
it’s,
quite
old,,
but
an
example
of
purely
functional
programming
languages.
\u200b\u200bis
include
such
a
programming
language,
as
in
the
USA
from
the
platform..
What
is
the
difference
from
purely
functional
under
not
purely
functional
in
general?
Why
all
this
newfangled
function?
Further?
We
need
angelina.
Far
from
newfangled
functional
programming,
languages
appeared
almost
40
years
ago,
huskies
as
far
as
I.
Remember
80,
if
I'm
not
mistaken,
38
6
7
years
a
year
and
they
are
actually
themselves
represent.
A
With
such
mathematical
abstractions
of
examples
to
the
skeleton,,
we
will
be
category
theory,,
type,
theory,
and
so
on,,
and
over
time
it
became
obvious
that
this
approach
has
their
advantages,,
but
if
they
also
have
their
obvious
disadvantages,,
they
are
related
to
the
fact
that,
firstly,.
The
passage
is
quite
high,
and
the
second
is
that
at
the
moment,
unfortunately,
it
is
difficult
to
say
that
these
programming
languages,
and
despite
all
their
reliability
and
strong
types
are
growth.
A
Boosters
are
systemic
programming.
Language,.
Remember
that
it
is
possible
to
write
programs
of
any
complexity
on
it,
including,
for
example,
operating
at
the
kernel
level
or
bare
metal.
Bare
metal
deals
with
what
to
write
in
general
for
a
pure
piece
of
iron
without
an
operating
system,,
and
this
is
one
of
the
strong
features
and
developers
of
growth.
In
particular.
A
Mozilla
do
not
came
up
with
quite
interesting
questions,
and
they
realized
that
some
elements
can
still
be
borrowed,,
because
on
the
one
hand,
it
seems
to
me
not
very
rational
to
do
purely
functional
growth,
on
the
other
hand,.
It
will
not
be
so
in
demand
by
the
community
itself,,
but
on
the
other
hand,
you
can
introduce
some
elements
which
can
be
used
and
some
advantages.
A
A
Present
the
software
product
in
the
form
of
some
kind
of
abstraction
that
will
allow
us
to
operate
already
at
a
higher
level,
on
the
one
hand,
and
on
the
other,
hand,
to
have
the
property
of
reliability
through
guaranteeing
by
an
example
of
strong
typing,,
including
both
generics
and
3,
which
we
told,
that
is,.
This
is
some
kind
of
representation
in
such
a
simplified
form
of
the
theory
of
categories
of
confidence.
A
In
the
theory
of
types
where
we
are
already
on
at
the
type
level,,
we
can
prove
the
correctness
of
our
program,,
the
fact
that
purely
functional
programming
languages
are
already
out
of
the
box,
and
we
can
operate
with
quite
complex
categories
from
category
theory
like
the
monads
of
Marxism,
and
so
on,.
Then.
A
In
Russia,
there
are
only
some
elements
of
the:
what
are
the
elements
in
Russia
of
the
light
higher
order
functions?
What
is
a
higher
order
function
is
a
function
that
other
functions
can
always
take
on
is
already
such
a
more
mathematical
term
of
which
in
growing,
unfortunately,
there
is
no
growth.
There
is
no.
B
C
A
Also
functional,,
unfortunately,
this
is
not
through
coding.
We
could,
through
the
partial
application
of
the
function,.
We
could
combine
them
and,
for
example,,
get
such
an
interesting
representation
as
a
functor
or
represent
such
a
concept
as
an
arrow,,
but
it’s
like
I’m.
Now
doing
such
a
general
introduction
of
what
functions
are
not
there,,
but
at
the
same
time,
some
elements
are
all-,
T
like
there
is
and
how
it
is
now
and
in
other
programming
languages,
.
B
A
Is
a
very
common
use
of
higher-
order
functions
in
society,
for
example,,
it
seems
like
there
are
many
other
programming
languages
in
python,,
but
since
you
still
provide
such
an
opportunity
for
such
a
lambda,
function,
I
will
now
compare
with
python
just
a
little
it’s
more
convenient
in
python.
It
also
has.
C
B
A
We
will
consider
how
this
can
affect
performance
for
the
better
and
it
is
possible
to
grow,
therefore,
from
the
limitations
of
the
functional
programming
in
growth,.
I
have
already
voiced
a
lot
of
things,
unfortunately,,
including
independent
types,.
We
want
roskilde,.
They
also
don’t
have
the
most
wonderful
possibilities
for
variation,.
B
A
Effectively
use
elements
of
functional
programming
ru
one
of
such
common
ones
is
a
wrapper
from
if
we
we
can
do.
Mapping
folding
through
from
zip
and
this
whole
gentleman's
set.
That
is
typical
for
operating
with
a
data
set
and
their
flow
in
whether
they
are
present
right
away.
I
want
to
make
a
reservation
that
we
will
not
consider
the
entire
set
of
features
and
specific
functions,
because.
A
There
are
actually
quite
a
lot
of
them
and
they
can
be
found
in
the
documentation,,
but
it
is
important
that
we
understand
what
the
key
features
are,
and
already
a
set
of
advanced
features
can
be
viewed
directly
in
the
documentation,,
and
it
is
important
to
understand
how
it
works
in
general,.
So
we
move
on,,
let's
not
Means,
of
growth
itself,.
Let's
try
to
understand
the
difference
between
writing
a
functional
and
non-
functional
year,.
A
What
does
functional
mean
in
the
context
of
growth
itself
and
what
possibilities
are
there,
I
will
briefly
voice
them
now,,
but
in
fact
they
have
already
been
voiced.
Is
the
possibility
of
using
a
function
as
a
type
of
function,
that
is,
a
function
of
higher
orders
of
a
function
as
types
for
structures
are
practically
the
same
type
of
function,?
We
will
also
consider
this
later
today.
They
are
also
lambda
functions,
if
it’s
correct
to
say
so
and
lambda
function.
A
Anonymous
functions
are
all
of
them
and
an
iterator,
and
so
it
practically
provides,
compared
to
a
non-,
functional
approach,.
Writing
in
the
form
of
such
a
functional
I
will
use
an
example
to
show
this
that
we
can
write
the
code
itself
more
concisely,
that
is,
I
represent
it
in
such
an
abstract
form,.
We
can
write
it
more
compact
on
the
one
hand,,
on
the
other
hand,
concisely
and
from
a
third
party.
It
can
be
effective
in
terms
of
performance
and
not
always.
A
Sometimes
it’s
just
necessary
to
proceed
from
rationality,,
also
on
the
implementation
of
mathematical
abstractions,,
as
I
already
spoke
about
this,.
What
is
the
advantage
in
that?
We
can
make
a
fairly
flexible
design
of
our
application.
On
the
example
of
trade,
of
which
we
considered
last
time,
we
saw
that
we
can
thus
operate
with
a
set
under
a
set
and
impose
certain
restrictions
on
the
set
through
trade,,
and
this
is
still
part
of
functional
programming,,
since
here
our
concept
is
already
expanding,,
since
the
set
in
this
case
can
already
be
represented
through
functions,.
A
This
is
quite
such
an
amazing
thing
when
our
a
set
is
not
a
set
of
types
that
are
simple
types,
but
I'm
confused
about
calling
it
so
or
complex,,
but
types
that
are
in
a
sense
executable
by
them,
and
in
this
context
we
can
talk
about
some
such
function
on
a
set,.
And
if
you
remember
that
mathematics,
the
function
is
determined
by
fx
matter,
small
from
x,,
but
the
set
and
set
of
functions
is
determined
through
large,
f
from
x,.
A
And
if
we
recall
the
example,
some
elements
of
optimization
methods,
for
example,
this
set
can
be
operated
on
using
the
integral
in
and
so
on,
and
in
Russia.
This
set
can
be
operated
on
through
trade
and
and
through
iterators,
that
is,
actually
doing
over
them
the
same
functions
and
a
set
of
methods
that
are
available
over
ordinary
types,,
and
this
is
quite
a
powerful
thing
when
our
generic
type
can
also
be
a
function,
that
is,
many
functions,
and
one
of
such
last
points
that
here
I
mean
again.
A
A
May
turn
out
that
this
approach
will
save
us
a
lot
in
terms
of
elegant
presentation
of
the
design
of
the
program
by
design
in
this
case,
I
understand
its
internal
structures,.
Then,
what
experience?
What
methods
guys
we
we
use
and
as
a
whole,
about
in
the
abstract
in
this
form,,
our
program,
I,
will
specifically
repeat
from
the
past
in
the
last
lecture,
I
talked
about
this,
why
it
is
important,.
C
A
This
functionality
will
be
therefore
a
sufficiently
high
degree
of
abstraction.
It
is
useful
in
this
sense,
but
again,
you
should
always
keep
a
healthy
balance
between
abstraction
and
a
specific
scope,
because
if
you
get
very
carried
away
with
this,
approximately
the
same
elements
of
generic
type
functional
programming
come
the.
B
A
Can
gradually
become
readable,,
it
is
very
heavily
overloaded,.
This
is
a
breed
of
formation,,
and
this
means
that
I
highly
recommend
that
you
keep
such
a
balance
for
cognitive
perception,,
as
if
I
understand
that
your
code
will
read
others
other
people,
and
that,
if
you
heavily
overload
the
program
with
some
abstractions,,
then
it
can
be
difficult
not
only
for
perception,,
but
also
for
further
maintenance,
therefore,
common
sense
should
always
prevail
over
the
desire
to
present
yourself
very
beautifully..
A
A
C
A
B
A
This
case,
without
specifying
which
type
returns
in
karla
may
way,
we
don’t
indicate
the
type
either,,
because
in
this
case,
once
he
can
figure
it
out,,
but
not
always,
therefore,.
If
he
needs
help,,
he
will
immediately
demand
it
from
you
now,.
These
are
purely
examples
of
such,.
We
will
all
consider
this
in
more
detail
in
the
second
example,,
the
skin,
that
is
shown
how
they
can
be
transmitted
arguments,,
as
you
can
see,
here,.
The
type
is
also
optional,.
A
It
contains
quite
conveniently
agree,,
because
the
function
when
we
write
a
function
growing,,
we
must
definitely
indicate
the
type
in
this
case,.
The
course
provides
us
with
flexibility.
In
this
regard
and
a
more
extended
example
for,,
as
you
can
see,,
there
are
type
descriptions
here
received
by
the
variable
and
return
a
variable,
and
also,
as
you
see,
through
the
square
through
the
curly
brace,,
we
can
already
do
such
actions
in
the
body
of
the
function
for
a
day,,
just
in
case
I,
repeat
that
in
Russia
there
is
a
wonderful
thing
like
curly
braces,.
A
They
actually
return
you
a
certain
block
block
in
which
you
can
perform
operations,
and
it
means
that
these
blocks
themselves
are
isolated
from
those
actions
that
occur.
And,
accordingly,,
the
blog
can
be
transferred
from
outside
the
variable,
that
is,.
This
happens
exactly
in
this
block,.
They
can
also
move
through
the
mountain
and
the
block
can
return,
and
in
the
general
case,
as
you
can.
See,
blocks
are
applied,,
including
like
functions,,
but
they
can
be
completely
independent.
In
the
past
lectures,
we
considered
this,.
C
A
I
now
just
distort
the
input,
and
now,
let's
look
at
what
functions
are
as
a
variable,
that
is,
here
we
are
already
getting
close,
since
we
have
already
considered
the
first
element
of
functional
programming.
Here
is
clearly
a
function
and
we’ll
call
it
that
way,
it’s
just
more
convenient
for
me,,
but
in
general,
isn’t
it
called
skin
and,
as
you
can
see
what
we
are
doing
here,
here,
we
describe
some
of
our
function
that
performs
an
absolutely
simple
operation
on
returning
a
number,
in
fact,
in
this
example,
it
doesn’t
matter
what
the
function
does.
A
A
We
see
in
practice,
then
why
it
is
needed,,
but
here
there
is
already
such
an
interesting
fact
is
that
this
variable
f
1.
It
already
has
a
different
type,,
a
special
type
that
describes
the
function
further
to
the
program,.
We
can
call
this
function.
This
alternating
current,
write
and
call
y
as
a
function
through
parentheses,
respectively,.
If
the
function
will
accept
changes,,
we
can
always
pass
the
variable,
but
an
important
aspect
is
that
here,
in
fact,.
This
is
a
nissan
function.
Here,
here
we
have
described.
B
A
A
Now
we
are
consistently
moving
towards
how
we
can
describe
the
same
functionality
that
is
here
through
how
easy
it
is
to
see
on
the
closure.
They
simplify.
Writing
like
as
I
said,
conciseness,
because
how
great,,
unlike
this
example,
I,
write
it
in
a
more
such
Nagano,
see
here,
I
need
to
return
a
type
variable
explicitly
indicate
here,
since
it
can
independently
understand
what
it
is
and
in
general,
our
program
looks
more
neat
and
tidy,
I
would
even
say
dory
further.
We
will
see
how
many
elements,,
including
those
that
can
be
simplified,,
were
logical,
abstract,.
C
A
Interesting
now,
let's
look
at
lambda
functions
with
an
argument.
In
fact,
in
an
example,
we
see
this,,
but
here
again,
I
will
specifically
show
that,
instead
of
describing
a
function
that
took
a
certain
argument,
here,
I
explicitly
already
indicate
what
type
is
accepted
and
the
return
type,,
as
you
can
see,,
in
order
to
describe
everything.
What
type
is
returned
in
the
skin
with
again
still
apply
standard
fits
as
well
as
functions..
A
We
indicate
what
type
is
returned,
and
here
already
in
the
body
of
the
anonymous
function,
we
make
the
necessary
set
of
operations
and
accordingly,
we
were
taken
aback
to
get
our
variable
2,
which
we
can
apply
the
function.
Arguments
in
this
case
it
is
the
Spaniards
as
a
function
will
return
the
number
31
and
now.
B
A
This
concept
already
actually
characterizes
that
something
operating
on
a
set
that
we
talked
about
will
be
limited
to
tracks.
Just
in
case,.
I,
repeat
that
trade
grow
in
some
of
its
limited
form
is
analogous
to
interfaces
in
other
languages,
or
eye
face
classes
and
the
use
of
a
type
class
hit
and
so
on,.
But
the
bottom
line
is
that
in.
A
B
A
You
remember
we
we
consider
what
once
and
assign
and
describe
this
type
for
the
function.
Argument,-
and
here
is
already
such
an
interesting
nuance.
If
earlier
we
described
generics
as
trade
and
or
as
other
restrictions
on
which
we
can
overlay
them,
here,,
as
you
can
see,,
their
representations
have
changed
a
little
here.
We
describe
sand
wraith.
This
argument
that
the
function
takes,
that
is,
the
given
sl
we
teach
this
function,
3
finance,.
It
is
a
form
of
everything
that
can
take
one
element
which
is
type
t32
and.
B
A
Should
return
type
a
and
32,
as
you
remember,,
this
is
different
from
how
we
teletrade
and
last
time,,
but
nonetheless,
composition.
At
the
same
time,
we
can
still
make
it
interesting.
This
nuance
is
that
we
can
describe
the
function
parameter
optionally
through
a
generic,
as
you
remember
trade,
and
we
can
directly
pass
as
a
type
for
the
function
argument.
A
The
same
thing
happens,
this
is
our
variable
is
a
certain
function
and
we
can
already
manage
certain
operations
on
this
function,
that
is,.
We
can
pass
an
argument
here
and
accordingly,
it
will
return
the
result
and
we
will
do
calculations
on
them,
that
is,
in
fact,
we
passed
functions,
applied
it
and
got
us
the
desired
result,
and
accordingly
we
can
this
function,,
which
remember
this:
is
our
anonymous
function
only
on
it.
B
A
Is
this
function,
including
this
here
functions?
They
can
be
passed
as
a
function
argument
when
we
try
to
print
here
and
accordingly
we
do
the
calculation
and
get
our
result,
and
now,
for
the
sake
of
curiosity,.
Let
's
write
the
same
thing,
but
pass
the
anonymous
function
directly
as
such
a
parameter,.
This
is
one
of
the
advantages,
just
that
we
can
pass
anonymous
functions
as
a
function.
Parameter,
respectively,
again,
here
we
get
the
function
of
the
higher
order.
C
A
Case,
we
write
the
claus
simply
as
a
parameter,.
The
rule
is
all
the
same,
that
is,
we
describe
what
it
is
through
straight
lines.
On
such
we
have
a
change
course
that
can
be
taken,
and
then
we
do
operations
on
them
here,
that
is,.
This
is
already
a
completely
different
function,.
As
you
can
see,
naturally,
the
result
of
the
execution
has
changed
for
us,,
let's
figure
out
what
features
of
the
skin
in
general.
They
differ
from
the
usual
functions
of
one
of
these.
A
Normal
function,
that
is
described,,
we
can
access
the
variables
as
far
as
you
remember
x,
in
normal
functions,,
there
is
no
such
possibility,
that
is,
we
do
not
have
the
opportunity
to
access
this
kind
of
change,,
and
here
I
will
give
an
example,.
I
will
digress
a
little
from
this
story,
and
here
I
will.
A
Ownership
is
transferred
in
this
case
for
day
functions,
that
is,,
how
you
see
here
we
describe
the
change
which
is-
and
in
this
case
we
describe
the
skin
and
the
variable
which
is
accessed
here
x.
It
is
described
outside
of
this
anonymous
function,
that
is
when
I
say,
environment
variable
it
suspects.
Only
this
understanding,
I.e.
A
we
have
a
certain
block
in
which
an
operation
takes
place,
as
I
said
it
in
the
description
occurs
through
curly
braces
and
within
this
sparingly
we
can
access
these
changes
here
there
are
some
nuances
of
what
is
happening,
but
so
that
you
understand
that
we
can
access
and
here
so
here
we
are
already
returning
to
how
way
these
variables-
let's
say
conditionally
and
media,
cannot
be
obtained
and
p.
Okemon
said.
C
A
C
A
This
is
the
transfer
of
ownership,.
This
is
finance,
that
is,
at
least,
and
as
you
can
see,
trade
which
describes
this
approach
is
called
fn.
The
second
is
born
with
ability
for
at
the
beginning,
they
have
the
ability
it
is
described
through
hanshin,
that
is,
borrowing
without
the
possibility
of
change,.
A
You
remember
when
we
borrow,
respectively,
the
husband
of
the
example,.
This
is
the
change
to
return
here.
If
we
borrowed,,
then
we
could
not
call
it
from
him
here
in
the
future.
Why?
Because
the
u-wing
device
borrowing
occurs
around
these
functions
and
in
fact
it
is
completely
transferred
here.
Here,.
The
compiler
will
already
give
us
an
error,,
so
in
this
case,,
no
matter
how
big
it
happens,
here,
who
has
cash,
that
is,
and
how
we
see
the
result
of
executing
this
function
will
be
appropriate
here.
B
A
There
is
a
convolution
here,,
but
I
will
return
to
this
a
little
later
and
the
third
possibility,,
which
is
the
first
one,,
is
the
hair
dryer,,
which
describes
the
archive
2
bora,,
the
guys
beliki,
through
the
counter,
is
described,
and
the
third
is
the
level
in
the
methodology
and
inspect
accordingly,.
We
have
three
possibilities
for
describing
the
transfer
functions,
for
example
in
the
description
of
generics,
that
is,.
Here
we
have
the
possibilities
of
fans,
and
I
open
my
youth
sheer
as
a
concept,
in
which
case
what
do
you
need?
A
If
you
have
transfer
of
ownership
there,
it
is
described
through
it
through
fn
you.
If
borrowing
then,
depending
on
what
it
does
through
fn
is
described,
and
if
you
have
a
task
before
the
variable
of
the
function
will
change
here,,
then
we
describe
in
minutes
how
easy
it
is.
Then
the
circuit
is
collected,
and
so
we
have
three
main
types
of
functions.
A
That
can
be
an
example
when
applying
this
just
needs
to
be
remembered,
just
in
case,
if
you
forget
about
it,
I
will
provide
links
to
relevant
materials
at
the
end
of
the
lecture
ly,
and
you
can
read
about
this
in
more
detail
and
let's
look
at
this
example
in
more
detail.
Why
this
example
is
also
clear
in
that.
The
first
thing
we
accept
here
is
the
change
that
is
stored
in
the
archive,
that
is,
the
heap,,
because
the
trait
copy
is
not
applied
to
it
by
default,.
A
That
is,
there
is
no
copying
together,,
there
is
a
transfer
of
ownership,,
and
here
we
have
some
elements
to
which
I'm
sorry,,
which
I
will
pay
attention
to
closer
to
our
end
of
the
lecture,.
There
are
already
interesting
elements
of
the
functional
approach,
that
is,
the
first
first.
Such
basic
element
is
that
we
are.
A
Itself
we
write
it
as
a
cluja,
that
is,
as
a
lambda
of
the
function
as
a
whole,.
The
second
is
that
we
can
pass
this
function
as
a
function
parameter
for
another
function,
c,
that
is,
this
function
of
higher
orders
and
the
third
and
we
can
operate
with
a
stream
yes,
in
order
to
generate
a
data.
Stream,
iterators
are
used,
they
describe
through
through
them.
What
it
is
I
in
more
detail,
p
I’ll
tell
you
a
little
later
and
you
also
already
know
how
such
a
seed
is,.
A
C
C
A
Describes
an
auxiliary
function
that
performs
an
operation
on
the
data
flow
that
occurs,
here,
that
is,
it
actually
collapses,
such
a
single
sequence
and
what
happens
here
y
is
an
accumulator,.
It
is
transmitted
to
us,
x1
and
x2,.
We
are
transmitted
through
and
you
are
glad
and
in
fact
we
each
variable
sequentially
on
each
other.
A
Will
that
is,?
It
is
a
very
convenient
thing,.
In
fact,
it
is
such
an
introductory
cost,,
and
we
will
dwell
on
this
a
little
more
later
when
there
will
be
such
a
field;.
A
complex,
interesting
example,,
but
I
specifically
gave
this
example
right
now,
so
that
you
can
see
how
concisely,
using
such
a
functional
approach,,
we
can
write
down
our
fairly
complex
logic,
because,
for
example,
from
and
write
it
through
a
loop,.
Then
it
will
naturally
be
much
longer,.
B
B
A
A
A
Our
previous
function,
which
from
what
is
described
here
we
describe
in
a
different
way
there
is
a
keyword,
what
it
means
and
its
meaning
is
very
simple.
It
means
that
these
variables
that
we
take
sorry
.e.
in
this
case
it
is
the
variable
apex
how
to
increase
here
these
variables.
We
borrow
this
way,
and
there
is
a
crown
here.
The
collection
takes
place
in
and
that
after
execution-
I.e.
A
C
A
Competitive
processes,,
this
concept
is
very
often
used,
and
look
if
we
call
it
as
before,
like
here,
here,.
As
you
can
see,,
we
display
our
variable
x,.
This
is
what
it
is
and
its
result,
that
is,
x
itself
and
this
x
also.
At
the
same
time,
everything
is
fine,,
but
when
we
make
a
move
here
and
there
and
we
can’t
apply
this
entry
anymore,,
because
the
compiler
will
swear
what’s.
A
Going
on
here,
burvin
is
going
on
here,,
so
we
can’t
refer
to
this
variable
again,
in
fact,.
This
is
what
our
compilers
should
worry
about.
A
reliable
friend
will
always
carefully
tell
you.
Borrowing
is
a
rather
complicated
concept.
Sometimes
you
have
to
fight
with
it,
because
it
is
a
rather
interesting
feature
in
our
lifetime
and
in
such
complex,
complex
functions
and
complex
logic,
it
can
spoil
your
nerves,
a
lot.
C
A
A
C
C
A
A
A
A
C
C
A
A
A
A
A
C
A
C
A
A
little
unusual
because,
as
you
remember,,
we
can
do
the
implementation
of
a
function
or,.
If
we
want
methods
for
a
given
structure,,
they
are
described
through
.
and
opening
brackets,.
Then
we
pass
an
argument,,
but
here
an
important
feature
is
that
this
is
not
a
method
of
this
structure,.
It
is
actually
this
structure,
respectively,.
B
A
Play
it
through
parentheses,,
the
compiler
will
be
categorically
indignant
if
you
do
this,
how
to
use
it
as
parameters,
he
himself
it’s,
just
that
it’s
just
not
allowed
to
do
it
there.
It
looks
a
bit
unusual
like
these
two
parentheses,
but
in
general
they
rarely
do
this
because
in
reality,
when
we
describe,
we
pass
a
function
as
a
structure.
Field,
then
just
in
this
case
it
was
convenient
to
use
it
as
higher-
order.
Functions
then,
is
to
pass
a
function
to
another
function,
and
accordingly,.
A
C
A
Which
I
gov
oril,
in
fact,,
it
is
described
in
exactly
the
same
way,
that
is,
there
is
no
particular
difference.
There,,
absolutely
nothing.
Changes,,
so
I
propose
to
gradually
move
the
generator
and,
in
general,.
Consider
what
is
an
iterator
iterator
allows
you
to
perform
an
operation
on
a
certain
set.
C
A
Sequence
of
data
and,,
as
you
remember,
a
subset,
we
may
mean
different
such
concepts,,
but
the
first
thing
you
need
to
understand
is
that
the
iterator
is,
first
of
all,
again,,
a
trade
too,
so,
accordingly,.
This
is
the
third
we
can
apply
to
a
specific
type
and
an
example
to
a
vector,.
It
will
already
be
accepted,
and
now
note
that
here
we
describe
the
vector
through
through
captive
and
just
in
such
a
very
convenient
way.
A
We
write
our
sequence
of
oils
and
an
important
feature
of
growth
is
that
iterators
are
lazy,
that
is,
the
physics
of
elysion,
as
in
purely
functional
programming,
languages,
that
is,
they
are
applied
as
the
data
stream
is
processed,
and
this
is
the
very
element
that
allows
us
to
work
effectively
on
the
set
yes,.
This
means
that,
in
fact,
our
data
set
can
be
infinite
and
imagine
a
situation
when,
for
example,.
We
have
a
terabyte
data
bank
and
we
put
arrays
in
it,.
We
do
it,
as
it
were,.
We
integrate
its
iterator.
C
A
Whole
array
will
be
processed,,
but
only
the
sequence
part
by
part
for
this,.
The
camera
does
not
have
the
next
method,
that
is,.
It
applies
completely
specific
trades,
and
this
is
one
of
those
very
cool
features.
That,
for
example,.
There
are
also
forgive
me,.
Is
there
not
a
calculation
that
allows
we
save
resources
and
significantly
speed
up
the
execution
of
our
program,
and
how
it
might
look
like
in
practice,?
We
will
consider
it
a
little
bit,
for
God's
sake,.
It
is
important
to
remember
that
if
we
consider,,
we
considered
a
certain
set.
A
A
Important
aspect
is
that,
in
fact,
this
is
the
record
when
we
assign
x
to
y
and
the
direct
ritter
is
applied
from
it.
Actually
at
all
does
nothing,
that
is,
we
are
here,
here,
our
operator
is
presented,,
but
nothing
happened.
Because,
again,
our
hurry
up
the
rotary
to
lazy,
that
is,.
Only
when
accessing
a
specific
element,,
an
operation
is
performed
on
it
and
let's
look
at
such
more
specific
examples
of
how
this
happens,
see
here.
B
A
A
A
B
A
B
A
If
it
works
like
I’m,
just
overturning
the
example,
that
is,
it
doesn’t
use,
it,-
and
here
is
another
type
of
function,.
This
is
a
generator
function,
that
is,
it
generates.
Others
data,
that
is,
this
function,
we
consume
data,
that
is,
it
can
do
the
following,.
It
can
either
skip
them
under
certain
conditions,
that
is,
by
skipping
or
how
to
actually
send
the
filter,
of
course,.
The
only
function,,
let's
say,,
relatively
speaking,,
refers
to
the
consumer
of
such
a
very
well.
The
name
of
each
element.
Data
stream
from
he
uses,
sets.
B
B
A
C
A
C
A
It
will
need
to
be
assembled
using
some
function
at
the
time
for
this,.
There
is
a
connect
function,
that
is,
it
can
aggregate
this
data
as
a
responsive
function.
For
this
case,
such
and
alloying
functions
is
an
adder,.
What
is
it
for
our
data
there
about
summarize,
and
here
already,
such
in
full
form
p
before
us,
is
presented
the
power
of
how
complex
the
operation
is
actually
carried
out,
here,,
naturally,
that
of
course,
the
logic
here
is
described
quite
simple,
but
it
is
not
difficult
to
see
that
in
order
to
do
all
this,
we.
B
B
A
Would
be
necessary
to
make
a
loop
iv,
then
we
must,,
subject
to
execution,,
carry
out
an
operation
on
it,,
then
again
do
them,,
and
if
this
one
does
not
work
them,
out,
also
do
it
there
or
bricks
the
container,
and
then
we
should
already
sum
up,
that
is,,
but
in
fact
our
program,
then
a
certain
number
of
lines
will
increase
in
reality,
I.
Think
not.
A
It
is
difficult
to
find
an
example
that
can
you
wrap
the
code
from
a
special
line
into
such
a
very
compact
and
rather
concise
form
on
the
one
hand,,
but
on
the
other
hand,
you
see,
it
is
not
only
concise
and
it
is
abstract
clear
on
the
one
hand,
on
the
other
hand,.
It
has
the
amazing
property
that
if
on
some
function,
we
need
to
change.
B
C
A
Will
carefully
format
it
for
you,?
You
don’t
need
to
give
it
to
dots
on
each
line
to
translate
it,
depending
on
the
formatting
settings,.
It
will
do
all
this
for
you
and,
as
you
can
see,
this
code
is
much
more
readable
because
in
reality,,
as
you
might
guess,,
this
is
all
you
can
write
in
one
line,.
It
will
become
completely
unreadable;
on
the
other
side
of
the
formatting,.
It
will
automatically
do
all
this
for
you
and
let's
look
at
another
example,.
B
A
Example
of
the
same
fold,
application,
and
then
I
said
earlier
here,
the
following
is
already
happening.
Here,
I
already
said
more.
Let
's
take
a
closer
look
at
an
example
of
how
the
battery
works
op
for
such
data
about
it,.
It
is
understood
that
we
have
a
certain
variable
that
will
accumulate
data,
that
we
will
have
in
the
process
of
processing
the
data
stream,
that
is,.
In
this
case
we
have
the
first
change
that
initializes
this
data
stream
and
further
and
the
torero
we
perform
operations
on
it.
A
Accordingly,
in
this
case,
x1
will
be
an
accumulator
accumulator,,
which
means
that
it
will
aggregate
this
data,,
which
means,
for
example,
x1
contains
the
execution
of
the
previous
function,.
If
this
is
the
first
element,,
then
the
default
values
\u200b\u200bare
taken
in
our
case,.
This
is
a
tiger
if,
for
example,.
This
is
element
2,
for
example,.
In
our
case
20,
then
the
result
of
calculating
x1
from
men
x2
will
be
taken,
respectively.
C
A
A
An
important
nuance
is
that
this
function
is
an
aggregator,
that
is,
one
aggregates
data
returns
a
specific
result,,
but
we
we
can
implement
any
set
of
functions
that
we
have
previously
considered,
in
particular,.
As
you
can
see,
here,
we
can
apply
filters
and
we
would
or
any
other
functions
from
I
will
conditionally
call
them.
Generators
consumers,
in
fact,
grow
some
not
very
strong
usable,,
although
in
the
official
documentation,
this
can
be
found
in
general,.
There
are
quite
a
lot
of
such
functions,
I
won’t
give
them
all,,
but
you
can
familiarize
yourself
with
the
documentation.
The.
A
Here
we
are
just
a
griver,
but
already
such
a
rather
complicated
function,
fold
to
see
the
differences
in
person
and
again
let
's
go
through
a
little
bit
already
summarizing
the
concept
of
what
concerns
generator
consumers,
but
in
particular,
as
we
said
earlier,
meg
is
a
fund.
Generator
is
an
aggregator
of
colleagues
is
also
an
aggregator,.
A
filter
is
a
consumer,.
A
Just
remember
that
in
fact,
we
have
a
certain
set
of
abstractions
that
allow
us
to
operate
on
the
data
stream
that
we
have,
that
is,
as
a
result,.
We
have
the
following,.
We
have
summing
up
the
following,.
We
have
a
function
that
we
can
pass
as
a
function
to
other
functions,
that
is,
a
form
of
the
highest
consecutive
order,.
We
have
a
function
that
can
act
as
types
represented
through
the
third,.
We
can.
B
A
C
A
I
mentioned
earlier,
and
let's
stop
already,
stop
at
the
end
about
what
materials
we
have
on
the
topic,
in
fact,.
This
is
standard.
Documentation,
here
is
a
link
that
indicates
how
it
is
described
in
separation,.
This
is
general
an
introductory
article,
and
you
can
also
refer
to
the
description
of
trade
of
such
as
fnf
and
youth
advance
and
the
description
of
trade
of
writers.
Iterators
are
also
of
different
types,.
In
particular.
They
are
also
we
are
personnel,,
but
I
won’t
dwell
on
this,
as
it.
A
Is
meant
by
abundant
it?
It
means
that
we
can
change
this
data
set,,
but
in
fact,
it
still
makes
sense
to
adhere
to
such
a
cleaner
approach
using
a
pure
approach,,
and
the
following
is
meant
that
we
do
not
change
the
original
data
stream,
that
is,
as
you
remember,
in
pure
functions,,
in
what
it
is
guaranteed
by
what
do
we
get
when
we
receive
the
same
data
stream?
We
always
yes,,
we
get
the
same
result,.
A
This
is
guaranteed
by
the
fact
that
our
function
is
rich
and
does
not
have
side
effects
any
side
effects
side
effects.
This
means
that
something
inside
the
function
happens
to
our
data,
such
that
our
data
will
change
and
accordingly
return
the
result
functions.
It
will
be
different
and
the
data
on
which
the
operation
takes
place,.
They
also
change,
so
always
be
careful,
after
all,
handle
mobility
and
I,
suggest
you
very
consciously,
and
of
course,
there
are
situations
when
it
is
easier
to
use
mouth
profusion
as
a
parameter
of
the
function.
Mouth
profusion
with
an
iterator,.
C
A
Again,
I
suggest
that
you
think
about
such
a
more
architectural
and
design
abstract
thing
in
your
program
as
you
operate
with
this
data
stream,
and
perhaps
all
the
same,
it
can
be
presented
in
a
more
predictable
form,
and
because
in
fact,
embarrassing
profusion,.
Sometimes
you
can
shoot
yourself
in
the
head
and
then
for
a
very
long
time
and
it’s
painful
where
everything
is
on
this
and
let’s
move
on
to
your
questions.
A
So
well,
already
answered
there
are
so
new
foul.
The
first
element
is
something
like
an
accumulator.
As
I
told
you
it’s
an
accumulator,
yes
it’s
possible
to
make
constants
already
le
clau.
I
didn’t
really
understand
your
question,
that
is,
you.
You
want
to
ask
if
it
can
be
described
through
the
keyword,
const.
A
Listeners,
I
remember
that
in
Russia
there
is
such
a
possibility
with
the
ends
of
constant
functions,
I
used
it,,
but
I
will
tell
you
honestly,
as
far
as
I
remember,,
only
1
or
2
times
in
general,
I
will
answer
that
there
is
such
a
possibility
appeared
relatively
recently,
but
very
dense,
I
didn’t
use
it,.
The
most
important
thing
is
to
understand
why.
A
The
filter
is
for
it
and
the
time
sheet
wine
has
the
same
flow,.
It
refers
to
it
as
time
sheet
until
the
flow
is
changed,
for
example,.
It
throws
changes,
that
is,.
This
change
does
nothing,.
Look
at
us
when
the
iterator
transfers
control
to
him,
the
following
example
from
our
example:
occurs,
when,,
well,
and
then
the
mayor
was
used,.
He
does.
A
Well,
look,,
he
discards
some
of
the
data,,
but
he
doesn’t
change,
them,
he’s,
not
mutable,.
Why
does
natalie
have
him,,
he
doesn’t
quite
correct
them,.
He
doesn’t
discard
them
then
have
a
look
at.
We
have
an
iterator
iterator
sequentially
each
element
by
element
passes,
and
here
what
is
the
difference
from
the
usual
set
from
which
we
sequentially
loop,
one
back
pass
and
from
the
writer,
because
in
fact
you
use
the
rotary
special
method
next,
which
processes
each
subsequent
element
from
actually
in
fact,.
A
A
C
A
A
A
That
I
apologize,
I
just
set
the
result
next
to
the
previous
example,,
so
everything
turns
out
right
when
they
say
that
the
language
is
multipro
dermal,.
This
means
that
you
are
writing
the
code.
If
you
use
different
pradiks,
they
would
clean
between
them.
So
well,
kiril
answered
him.
The
advantage
is
that
it
is
possible
to
combine
the
best
of
different
paradigms.
I
completely
agree
on
the
slide.
This
is
ratas
in
action
if
you
use
not
x
in
the
second
filter,
but
let's
say
mushroom
can
be
used
in
the
second
4x.
A
B
A
For
why,
in
this
example,
there
is
no
error,
burs
can
oli,
oh
my
god
maxim
and
in
the
second
there
is
a
difference
only
in
the
center,,
so
the
essence
of
it
was
answered
by
kiril
in
the
type
the
center
is
important.
So
let's
go
further,
that
is,
here,
as
I
understand.
It,.
The
difference
between
the
implementation
of
the
copy
is
the
clone
of
the
first
element,.
So
one
more
question
to
page,
enter
the
conversation,,
and
what
is
the
error
from
him,?
A
A
A
One
of
them
because,
as
you
know,
there
comrade
are
so
serious,
they
are
olympiads
everything
and
they
will
be
interested
in
how
you
will
cope
with
such
algorithmic
and
tasks,.
Sometimes
they
are
so
knowledgeable
about
algorithms
and
ingenuity
and
in
general,
the
ability
to
think,
but
look,.
There
is
an
interview
at
which
you
will
still
be
asked
if
I
need
it
in
what
context,,
so
it
still
makes
sense.
A
A
A
So
ask
more
questions
like
Thursday
testing
and
June
testing
Yes,,
just
in
case,.
Look
at
all
the
links
that
you
were
given
this
swollen
and
introductory
article
on
functional
programming
and
standard
documentation
on
iterators
and
the
like
am
and
trade
of
you.
If
you
are
at
all
interested
in
this
topic,,
you
will
read
it
because
you
know
that
it
will
be
useful
to
ask
another
question
with
us,
in
fact,.
We
have
gone
over
the
time
already
and
let
me
wait
for
your
questions
for
a
minute.
If
you
don’t
have
any
questions,,
we
will
complete.