Чому прив’язка не є рідною особливістю для більшості мов?

ІМХО, прив'язування змінної до іншої змінної чи виразу, є дуже поширеним сценарієм у математиці. Насправді на початку багато студентів вважають, що оператор присвоєння (=) є якоюсь прив'язкою. Але в більшості мов прив'язка не підтримується як рідна особливість. У деяких мовах, таких як C #, прив'язка підтримується в деяких випадках з виконанням деяких умов.

Але реалізувати це як основну функцію IMHO було так само просто, як і змінити наступний код -

int a,b,sum;
sum := a + b;
a = 10;
b = 20;
a++;

до цього-

int a,b,sum;
a = 10;
sum = a + b;
b = 20;
sum = a + b;
a++;
sum = a + b;

Значення розміщення інструкції зв’язування як присвоєння після кожної інструкції змінює значення будь-якої змінної, що міститься у виразі праворуч. Після цього буде зроблено обрізання зайвих інструкцій (або оптимізація в зборі після компіляції).

Отож, чому вона не підтримується в основному на більшості мов. Спеціально до сімейства мов С?

Оновлення:

З різних думок, я думаю, я мав би визначити це запропоноване "обов'язкове" точніше -

• Це один із способів зв’язування. Тільки сума прив’язана до + b, а не навпаки.
• Область зв’язування локальна.
• Після встановлення прив'язки її неможливо змінити. Значить, як тільки сума прив’язана до + b, сума завжди буде + b.

Сподіваюся, ідея зараз зрозуміліша.

Оновлення 2:

Я просто хотів цю функцію P # . Сподіваюся, це буде там і надалі.

Ви плутаєте програмування з математикою. Навіть функціональне програмування не є повністю математичним, хоча воно запозичує багато ідей і перетворює їх у те, що можна виконати і використовувати для програмування. Імперативне програмування (яке включає в себе більшість мов, натхнених С, винятком яких є винятки JavaScript та новіші доповнення до C #) майже нічого спільного з математикою, тож чому ці змінні повинні вести себе як змінні в математиці?

Ви повинні врахувати, що це не завжди те, що ви хочете. Так багато людей кусаються замиканнями, створеними в циклах саме тому, що закриття зберігають змінну, а не копію її значення в якийсь момент, тобто for (i = 0; i < 10; i++) { var f = function() { return i; }; /* store f */ }створює десять закриттів, які повертаються 9. Тому вам потрібно буде підтримувати обидва способи - це означає, що вдвічі більше витрат на "складність бюджету" та ще одного оператора. Можливо також нездатності між кодом, що використовує цей код, і кодом, який не використовує його, якщо тільки система типів не є достатньо складною (більше складності!).

Також реалізувати це досить важко. Наївна реалізація додає постійних витрат на кожне завдання, що може швидко доповнити необхідні програми. Інші реалізації можуть затримати оновлення, поки змінна не буде прочитана, але це значно складніше і все ще має накладні витрати, навіть коли змінна ніколи не читається знову. Досить розумний компілятор може оптимізувати і те, і інше, але досить розумні компілятори є рідкісними і вимагають великих зусиль для створення (зауважте, що це не завжди так просто, як у вашому прикладі, особливо коли змінні мають широку сферу застосування та багатогранність читає!).

Зауважте, що реактивне програмування - це в основному про це (наскільки я можу сказати), тому воно існує. Це просто не так часто в традиційних мовах програмування. І я сумніваюся, що деякі проблеми з реалізацією, які я перелічував у попередньому пункті, вирішені.

Він дуже погано підходить для більшості моделей програмування. Це буде представляти собою якусь повністю неконтрольовану дію на відстані, в якій можна було знищити значення сотень чи тисяч змінних та об'єктних полів, зробивши єдине завдання.

Я знаю, я відчуваю, що реактивне програмування може бути здоровим у середовищі Web2.0. Чому почуття? Ну, у мене є одна сторінка, яка в основному являє собою таблицю, яка весь час змінюється у відповідь на події onClick-комірки таблиці. А кліки клітинок часто означають зміну класу всіх комірок у комірці чи рядку; а це означає нескінченні петлі getRefToDiv () тощо) для пошуку інших споріднених комірок.

IOW, багато з написаних ~ 3000 рядків JavaScript, які я написав, не займаються лише пошуком об'єктів. Можливо, реактивне програмування могло б зробити це все за невеликі витрати; і при величезному скороченні рядків коду.

Що ви думаєте про це? Так, я помічаю, що мій стіл має багато функцій, що нагадують електронну таблицю.

Я думаю, що те, що ви описуєте, називається електронною таблицею:

A1=5
B1=A1+1
A1=6

... потім оцінюється B1повернення 7.

EDIT

Мова С іноді називають "портативною збіркою". Це імперативна мова, тоді як електронні таблиці тощо - це декларативні мови. Висловлювання B1=A1+1та очікування B1переоцінки при зміні A1, безумовно, є декларативним. Декларативні мови (які функціональні мови є підмножиною), як правило, вважаються мовами вищого рівня, оскільки вони далекі від того, як працює апаратне забезпечення.

У відповідній примітці мови автоматизації, як логіка сходів, зазвичай є декларативними. Якщо ви пишете ланцюжок логіки, який говорить про output A = input B OR input Cте, що збирається постійно переоцінювати це твердження, і Aможе змінюватися, коли Bабо Cзмінюється. Інші мови автоматизації, такі як діаграма функціональних блоків (які, можливо, вам знайомі, якщо ви використовували Simulink), також є декларативними та виконують постійно.

Деяке (вбудоване) обладнання для автоматизації запрограмоване на C, і якщо це система в режимі реального часу, вона, ймовірно, має нескінченний цикл, який повторно виконує логіку знову і знову, подібно до того, як виконується логіка сходів. У цьому випадку всередині вашого основного циклу ви можете написати:

A = B || C;

... і оскільки він виконується весь час, він стає декларативним. Aбуде постійно переоцінюватися.

C, C ++, Objective-C:

Блоки надають функцію прив’язки, яку ви шукаєте.

У вашому прикладі:

сума: = a + b;

ви встановлюєте sumвираз a + bу контексті, де aі bє існуючі змінні. Це можна зробити саме за допомогою "блоку" (він же закриття, також вираз лямбда) в C, C ++ або Objective-C з розширеннями Apple (pdf):

__block int a = 0, b = 0;           // declare a and b
int (^sum)(void);                   // declare sum
sum = ^(void){return a + b;};       // sum := a + b

Це встановлює sumблок, який повертає суму a і b. __blockКлас зберігання специфікатор вказує на те, що aі bможе змінитися. З огляду на вищесказане, ми можемо запустити наступний код:

printf("a=%d\t b=%d\t sum=%d\n", a, b, sum());
a = 10;
printf("a=%d\t b=%d\t sum=%d\n", a, b, sum());
b = 32;
printf("a=%d\t b=%d\t sum=%d\n", a, b, sum());
a++;
printf("a=%d\t b=%d\t sum=%d\n", a, b, sum());

і отримати вихід:

a=0      b=0     sum=0
a=10     b=0     sum=10
a=10     b=32    sum=42
a=11     b=32    sum=43

Єдина різниця між використанням блоку та "прив'язкою", яку ви пропонуєте, - це порожня пара дужок у sum(). Різниця між sumі sum()є різницею між виразом і результатом цього виразу. Зауважте, що, як і у функціях, дужки не повинні бути порожніми - блоки можуть приймати параметри так, як це роблять функції.

C ++

Оновлено, щоб бути загальним. Параметризовано на типи повернення та введення. Може поставити будь-яку бінарну операцію, що задовольняє параметризованим типам. Код обчислює результат за потребою. Вона намагається не перераховувати результати, якщо зможе піти з нею. Вийміть це, якщо це не бажано (через побічні ефекти, тому що об'єкти містяться великі, через що-небудь.)

#include <iostream>

template <class R, class A, class B>
class Binding {
public:
    typedef R (*BinOp)(A, B);
    Binding (A &x, B &y, BinOp op)
        : op(op)
        , rx(x)
        , ry(y)
        , useCache(false)
    {}
    R value () const {
        if (useCache && x == rx && y == ry) {
            return cache;
        }
        x = rx;
        y = ry;
        cache = op(x, y);
        useCache = true;
        return cache;
    }
    operator R () const {
        return value();
    }
private:
    BinOp op;
    A &rx;
    B &ry;
    mutable A x;
    mutable B y;
    mutable R cache;
    mutable bool useCache;
};

int add (int x, int y) {
    return x + y;
}

int main () {
    int x = 1;
    int y = 2;
    Binding<int, int, int> z(x, y, add);
    x += 55;
    y *= x;
    std::cout << (int)z;
    return 0;
}