История изменений

Ошибку в чистой функции можно найти, просто внимательно изучая её входные данные и код (не только в Clojure). Чем больше логики реализовано в виде чистых функций — тем менее нужен отладчик.

А как именно это работает? Вот возьмем функцию на чистом языке:

function add(input: { a: int, b: int }) -> { c: int }
{
  return { c: input.a + input.b };
} 

int a;
int b;
int c;

function add(input: {}) -> {} 
{
  c = a + b; 
}

Цепочки строятся так:

// Императивный код который пишет программист
add()
add() 

// Модель в которую его преобразуют, тут args пустые оба
state1 = add(state0 + args) 
state2 = add(state1 + args)

Что дает чистый синтаксис? Почему он проще? Сколько было переменных, столько и осталось.

Ошибку в чистой функции можно найти, просто внимательно изучая её входные данные и код (не только в Clojure). Чем больше логики реализовано в виде чистых функций — тем менее нужен отладчик.

А как именно это работает? Вот возьмем функцию на чистом языке:

function add(input: { a: int, b: int }) -> { c: int }
{
  return { c: input.a + input.b };
} 

int a;
int b;
int c;

function add(input: {}) -> {} 
{
  c = a + b; 
}

Цепочки строятся так:

// Императивный код который пишет программист
add()
add() 

// Модель в которую его преобразуют, тут args пустые оба
state1 = add(state0 + args) 
state2 = add(state1 + args)

Ошибку в чистой функции можно найти, просто внимательно изучая её входные данные и код (не только в Clojure). Чем больше логики реализовано в виде чистых функций — тем менее нужен отладчик.

А как именно это работает? Вот возьмем функцию на чистом языке:

function add(input: { a: int, b: int }) -> { c: int }
{
  return { c: input.a + input.b };
} 

int a;
int b;
int c;

function add(input: {}) -> {} 
{
  c = a + b; 
}

Цепочки строятся так:

// Императивный код который пишет программист
add()
add() 

// Модель в которую его преобразуют
state1 = add(state0 + args) 
state2 = add(state1 + args)

Ошибку в чистой функции можно найти, просто внимательно изучая её входные данные и код (не только в Clojure). Чем больше логики реализовано в виде чистых функций — тем менее нужен отладчик.

А как именно это работает? Вот возьмем функцию на чистом языке:

function add(input: { a: int, b: int }) -> { c: int }
{
  return { c: input.a + input.b };
} 

int a;
int b;
int c;

function add(input: {}) -> {} 
{
  c = a + b; 
}