LINUX.ORG.RU

Man or boy 2к25: Ваш статически типизированный ЯП полноценен?

 


0

4

Когда то Кнут придумал тест для ALGOL реализаций, и он известен под именем «Man or boy test». Но там просто локальные функции, не особо интересно.

Предоставляю вам версию для проверки языка программирования, на то, достоен ли он существовать в 21 веке!

Для начала нарушу это правило (у Python динамическая типизация), и покажу Python версию:

def print_sum(x):
  def make(acc):
    def f(y):
      print("acc(%d) + %d" % (acc, y))
      return make (acc + y)
    return f
  return make(x)

print_sum(10)(20)(30)(40)
Вывод
acc(10) + 20
acc(30) + 30
acc(60) + 40

Предлагаю попробовать повторить пример на вашем любимом статически типизированном языке, и поделиться им в комментариях.

Мое повторение на OCaml с rectypes:

let print_sum x =
  let rec f acc = fun y ->
    printf "acc(%d) + %d\n" acc y;
    f (acc + y)
  in 
  f x
  
let () = ignore (print_sum 10 20 30 40)
Типы он вывел сам, но можно и указать вручную:
type t = int -> t 

let print_sum (x : int) : t =
  let rec f (acc : int) : t = fun (y : int) : t ->
    printf "acc(%d) + %d\n" acc y;
    f (acc + y)
  in 
  f x
  
let () = ignore (print_sum 10 20 30 40)

Языки которые смогли реализовать тест на лямбдах/функциях, их система типов и ее записи позволяет строить рекурсивные по возврату лямбды и функции:

Языки у которых получилось, но замыкания были выраженны через структуры, потому что они так представленны в самом языке, это облегачает построение рекурсивных по возврату типов, потому что рекурсии в структурах есть везде:

Языки у которых пока не получилось без дополнительных средств типа классов/структур для обхода проблем с типами:

  • Rust (использование trait)
  • C (некорректная реализация)
  • Zig (использование классов)
  • D (использование делегатов)

Не являсь полностью статически типизированным языком, через свою систему типов смогли выразить пример

★★★★★

Последнее исправление: MOPKOBKA (всего исправлений: 21)
Ответ на: комментарий от anonymous

Любой боксинг стирает тип, что ломает типовую/железячную рекурсию.

Как понять стирает тип? Вот боксинг:

// тип является функцией, которая возвращает этот же тип
type fn func() fn

Вот железячная рекурсия:

// структура содержит сама себя
struct st {
  struct st st;
}

Очевидно, что структура не может содержать себя, ровно как и в почтовую упаковку не уместить идентичную упаковку, сохранив её идентичность.

Боксинг позволяет абстрагироваться от типов, полностью соответствующих железу. Но на камне не написано, что типы должны соответствовать материальным объектам. Типы в боксинге остаются типами и могут подразделяться на дин/стат.

А практически все «сишники» думают у функции тип void(*)(int), а что такое void(int) они знать не знают.

Ну я, видимо, знаю, хотя на 1% не претендую. Но чет я пока с трудом замечаю сакральную важность этого знания.

Фокус заключается в том, что шаг рекурсии должен где-то существовать явно.

Другое дело, что люди часто путают рекурсию и отдельные шаги.

Что значит «шаг рекурсии должен существовать явно»? И почему должен? В каком контексте это условие необходимо? Я не придираюсь, а ничего не понимаю, если что.

Рекурсия на то и рекурсия что должна вызывать самая себя. Но в случае с чейнингом ты всегда можешь его свести к отдельным вызовам (…). И ты хочешь это проверить, а не не то о чём пишешь.

«Это» — это остановку рекурсии в моменте?

«О чём пишешь» — о чём? Я вижу, что пишется о возможности выразить понятия, которые ссылаются на себя, полагаясь в первую очередь на систему типов (тип T содержит упоминание типа T).

(Хотя я ещё не понял по какому принципу был сформирован второй лагерь C++-Java-Crystal.)

kaldeon
()
Последнее исправление: kaldeon (всего исправлений: 1)
Ответ на: комментарий от MOPKOBKA

Вот пример: https://gcc.godbolt.org/z/fvqqKcTaj

auto print_sum(auto x) {
    auto make = [=](this auto self, auto acc) {
        return [=](auto y) {
            std::println(stderr, "acc({0}(type:{2})) + {1}(type: {3})", acc, y, type_name(acc), type_name(y));
            return self(acc + y);
        };
    };
    return make(x);
}

int main() {
    print_sum(10)(20)(30)(40);
    print_sum("10"s)("20")("30"s)("40");
    print_sum(int_c<10>)(int_c<20>)(int_c<30>)(int_c<40>);
    print_sum(std::tuple{int_c<10>})(std::tuple{int_c<20>})(int_c<30>)(int_c<40>);
}

Я беру ту исходную функцию и сую туда что угодно. Таплы с таплами. Таплы с не-таплами. Числа, строки. Это без учёта производительности и гарантий. Генерики в расте не дают ничего. У тебя либо базовая форма, где по-сути динамическая семантика. Либо инфа форма где такая же семантика просто немного генерик-лапши. Оно абсолютно бесполезное.

Единственное что сами трейты проще перегрузки и там ufcs. Первое имеет свои нюансы, а второй крайней сомнительно. В убогой реализации раста там практически ничего не остаётся. Кроме вездесущих дыр, нечитаемых ошибок, в 100раз более тормозной компилятор(там действительно разница пару порядков) и необходимости генерировать бесконечные портянки лапши даже в притивных случаях. А не в примитивных и лапша не помогает.

И да, в случае боксинга ты не знаешь к чему общаешься. Банально вот есть у тебя инт. Ты знаешь, условно, что там 10, но язык и рантайм думает что там что угодно. И если твой язык не может в это 10, то это не значит что это ненужно. Это просто мышление.

Ты действуешь в рамках ограничений. Чтобы тебе понять смысл - тебе нужно за них выйти. Если же ты изначально сгененрировал реализацию такую которой ненужна эта информация - это свойство твоей реализации.

anonymous
()
Ответ на: комментарий от kaldeon

// тип является функцией, которая возвращает этот же тип

Это уже следствие того что ты затёр тип и обмазал боксингом тип. Я приводил примеры. Я хочу возвращать из функции T[1] - T[2] - T[3] - ты не сможешь этого сделать. Конечно на уровне аби, в том числе, есть боксинг. Но это ничего не значит.

Очевидно, что структура не может содержать себя, ровно как и в почтовую упаковку не уместить идентичную упаковку, сохранив её идентичность.

Это не так работает. Там нет «идентичную». Наличие идентичность следствие боксинг-мышления. Аналогично как если ты сделаешь ветку в рекурсии она никогда не закончится. Но именно ветка заставляет её работать.

Ну я, видимо, знаю, хотя на 1% не претендую. Но чет я пока с трудом замечаю сакральную важность этого знания.

Не особо. Допустим, ты писал указатель в decay-контексте.

Что значит «шаг рекурсии должен существовать явно»? И почему должен? В каком контексте это условие необходимо? Я не придираюсь, а ничего не понимаю, если что.

Тем, что когда ты вызываешь функцию ты должен знать тип её возврата. Если ты боксишь тип возврата у тебя * и поэтому ты можешь его не знать(вернее ты уже знаешь - это *).

Допустим всякая скриптота с рекурсивной реализацией просто не выводит тип возврата. Он ей ненужен.

«Это» — это остановку рекурсии в моменте?

Это - это наличие рекурсии. Если у тебя рекурсия используется в примере из трёх шагов, допустим, то ты можешь её свести к трём руками написанных шагов.

Такая же ситуация с циклом. Ты можешь не имея написать три раза его тело.

«О чём пишешь» — о чём? Я вижу, что пишется о возможности выразить понятия, которые ссылаются на себя, полагаясь в первую очередь на систему типов (тип T содержит упоминание типа T).

Не совсем. Я говорю о том, что семантика рекурсии в том же пистоне это не тоже самое что показывает он в остальных примерах.

Предположим ты человек не понимающий циклов. И тебе дали задачу как в примере выше, где есть for(i < 3) f и ты просто взял и написал f f f и сказал «работает».

Даже если наша задача ограничена 3 шагами, то цикл всё равно имеет отдельную семантику. Допустим то, что в теле не может меняться поведение. Ты можешь туда добавить веток, но это ничего не изменит.

Аналогичная ситуация тут. В питоне в рамках рекурсии создаются отдельные функции. Она могут обладать своими свойствами и поведением. Одна функция не может этого сделать. И если пример не может выявить эту разницу в семантики - это не значит что её нет. Это просто плохой пример.

(Хотя я ещё не понял по какому принципу был сформирован второй лагерь C++-Java-Crystal.)

Понятия не имею. Автор почему-то решил увязать это с агрегатами, но на самом деле это не особо связано.

anonymous
()
Ответ на: комментарий от MOPKOBKA

Вот авторитетный источник, указатель на функцию.

Указатель имеет базовый тип и при разыменовании мы получаем этот тип, и на какой тип указывает при разыменовании «указатель на функцию»?

что будет если присвоить вот так?

*fun_ptr1 = *fun_ptr2?

так что «указатель_на_функцию» следует читать как одно слово, это просто термин такой. он не относится к классу указателей. это просто такой вывырт тех, кто формулировал сишешку. им показалось, что раз указатель это адрес, а точка входа функции - тоже адрес, значит мы имеем указатель на фукцию!!! во как!

строго говоря это просто адрес точки входа в код функции и все. а не ее «адрес».

alysnix ★★★
()
Ответ на: комментарий от alysnix

Я не понимаю зачем мы это обсуждаем, давай заново. Почему недопустимо это определение типа?

typedef T = T (*)(void);
Допустим нету никаких указателей, а тип представляет собой описание некого хранилища, в которое можно записать метку функции, совместимой по сигнатуре.

«Метка» как и полагается по стандарту С, может быть записана от какой угодно функции, и происходить в рантайме, так, что компилятору заранее неизвестно какую именно функцию запишут в «указатель на функцию».

MOPKOBKA ★★★★★
() автор топика
Последнее исправление: MOPKOBKA (всего исправлений: 2)
Ответ на: комментарий от anonymous

На сишке это будет int(int, int). Никаких указателей тут нет. не ко мне вопрос. это морковкину нравятся «указатели на функции». а я говорю, что это просто «термин с путаной семантикой».

тип функция в привильном понимании (а не в понимании си) это не указатель вообще, это дескриптор функции, а его значение - это некий селектор, и не обязательно адрес.

Ты, наверное, хотел сказать что он понижает тип. Это свойство реальность. Есть иерархия - тип-функция - функция-указатель - указатель. Всё это есть в си. Допустим поэтому int() в си это вариадик, а не не как в цпп.

Реальность требует такой иерархии. Она такая в си. В си нет прямой редукции к указателю. Не говоря уже об отождествлении.

ты хоть понимаешь, что твои тексты - шизофренические?

alysnix ★★★
()
Ответ на: комментарий от MOPKOBKA

вопросы

  • указатель указывает на тип?

  • если указатель разыменовать какой получим тип?

  • если разыменовать «указатель на функцию». какой получим тип и какой его размер?

alysnix ★★★
()
Ответ на: комментарий от alysnix

Я не желаю обсуждать «указатели на функции». Это не тема для обсуждения, есть стандарт и мануалы.

MOPKOBKA ★★★★★
() автор топика
Последнее исправление: MOPKOBKA (всего исправлений: 1)
Ответ на: комментарий от MOPKOBKA

Я не желаю обсуждать «указатели на функции». Это не тема для обсуждения, есть стандарт и мануалы.

разговор начался с того, что ты объявил тип-функция «указателем». притащив неверную из терминологию из си. ни в одном культурном языке это тип с указателем и рядом не стоит, можешь хоть в вики посмотреть.

а обьявил ты его указателем для того, чтобы показать, что можно якобы потому спокойно и корректно завершить рекурсивный тип-функция. раз это проходит для полк класса с указателем на него самого. что совершенно не то же самое.

короче не страдай фигней, рекурсивные типы - зло. и хватит об этом

alysnix ★★★
()
Ответ на: комментарий от MOPKOBKA

В статических языках всё сложно. Я не знаю почему сишку называют именно статическим языком. Она статическая просто по факту того что компилируется без неявного боксинга. Но там везде динамика примерно как жс. Единственно что если жс(пистон) умеют что-то проверять, то сишка не умеет. Ну потому что нет рантайма.

Неявный боксинг можно свести к рантайму. Если твоя программа компилируется в типы иные нежели ты используешь - что-то должно их использовать. И даже если вся логика напрямую встраивается в программу без отдельной librt - это не меняет ситуации.

Сишка такой уродилась потому что люди в древние времена понимали - нам нужны фичи, но мы не можем их выразить. И они не стали сильно ограничивать возможности создавая какие-то убогие недопроверки.

Потом родился цпп, который попытался без ограничений выражения добавить проверки. Поэтому там всё не так как везде. Обычно люди реализуют крайне примитивную систему типов(типа как в расте с его днищем из 80-90. И прикрутка пару полурабочих «актуальных» фишек не делает типизацию не-дремучей. Как существующий авто в сишке не делает из него полноценный вывод) и потом пишут в рамках её ограничений. Скидывая всё это на рантайм.

Есть всякие хаскели, которые пытаются расширить модель. Допустим чтобы были не только донные трейты полиморфные только по self.

Поэтому нужно искать ситуации где язык создавался вопреки академичности/практике. Есть тс, но он явно не про статическое, но про хотя бы попытку сделать нормальную систему типов/язык. Опять был сделан именно потому что жс много чего мог и нельзя было сказать «давайте заберём 95% фичей ради «безопасности»».

Поэтому там есть рекурсивные типы и реальная рекурсия в генериках. Оно ушло хоть далеко, но мало. Очень мало чтобы это можно было хоть в каком-то смысле сравнивать с цпп. Даже без относительно того что цпп статический и ему в разы тяжелее.

Ещё нужен туллинг/реализация. У тс есть туллинг, но реализация слишком слабая. Толку с системы типов если на любые усложнения у тебя отваливается компилятор. Либо на генерирует тебе нечитаемые ошибки.

У цпп с тулингом в какой-то степени всё плохо. Но тут даже не цпп виноват, а в принципе в мире туллинга для языков подобного уровня не существует.

Если взять раст, то то вообще позорище. Нечитаемые сообщения об ошибках. Она пытаются нелепо сделать какой-то огрызок рекурсивный трейсинг, но как обычно позорно. Если в тс/цпп тулинг сделан поверх компилятора, то в расте это какой-то убогий днищепарсинг который даже элементарные ошибки не отображает. Апогеем инновация для них это то, что они запускают отдельно. Ну примерно как всякий днищетуллинг в тс, который не умеет в тс.

Производительность компилятора просто нулевая. Они в на порядки более примитивный нежели цпп, но работает в десятки-сотни раз медленнее. Генерирует он адский мусор. Они ещё любят весь код принудительным инлайном обмазать. Его ллвм оптимизирует даже без оптимизаций. В результате там ещё и ллвм нереально лагает.

Производительности тоже нет. Ну рескин сишки если написать сишную лапшу авось сишный компилятор оптимизирует. Иногда. Но сишная лапша это не то что нужно.

Это как в тс. Когда мы хотим абстракций/хотим типов. Но и компилятор лагает и код результирующий получается ужасный. Поэтому важно не только наличии какой-то фичи, но и возможность её использовать. И бегать и врать про зерокост/статику/оптимизации не добавляет ничего из этого.

Поэтому мне в принципе неинтересно что-то неюзабельно. Даже если там есть какие-то фичи номинально. Хотя даже на уровне фич приемлемого я ничего не знаю.

Вон есть хаскель и вроде как есть не только донный полиморфизм по self. Есть операторы. Но толку с этого если это позволяет написать только врайтонли-хеловорлд.

Такая же ситуация с окамлом. Вроде есть что-то. Есть вывод. Но толку. Языкам нужна применимость. И только сверх этого фичи, а не наоборот.

anonymous
()
Ответ на: комментарий от MOPKOBKA

На уровне ассемблера указатель на функцию это указатель на функцию.

там нет ни указателей на функцию ни указателей вообще :) там просто числа. а вся интерпретация чисел делается из кода инструкции и формы операндов.

alysnix ★★★
()
Ответ на: комментарий от MOPKOBKA

А что тогда такое адрес функции?

строго говоря это адрес точки входа. ничто не мешает входить вовсе не в начало блока кода самой функции. то есть адресов будет уже два - начала кода и точки входа функции.

alysnix ★★★
()
Ответ на: комментарий от MOPKOBKA

Он просто адепт невежества и пересказывает тебе какие-то сказки про сишку из какой-то клоаки. Он ничего о ней не знает.

Никаких адресов нет. Он всё наврал. Ему поступила установка «гадить сишки», «у нас в скриптухе иные типы». Самое смешное что он пишет «ты показывал указатель, а не тип-функцию».

В общем давай попроще. Люди не знают сишку и думают что void(*)() - это функция. На самом деле нет. У него в скриптухе нет указателей. И вот на базе первого невежества предпринимается атака на сишку вида «ко-ко-ко у тебя указатель есть, а у нас есть. Сишка не осилила».

При этом его так же поймали на то, что он знает ничего о си и пытается в этом упрекать тебя. Типа ты не знаешь разницы между указателем и типом-функцией, но на самом деле это противоречит первому.

Я тебе уже рассказывал про боксинг. Вот в его скриптухе нет указателей, а те указатели что есть - это указатели на типы рантайма. Ну представь какой-нибудь жс где вместо указателя лежит ссылка на цпп-объект в памяти в котором лежит и контекст замыкания и код и прочее подобное.

anonymous
()
Ответ на: комментарий от anonymous

В статических языках всё сложно. Я не знаю почему сишку называют именно статическим языком. Она статическая просто по факту того что компилируется без неявного боксинга. Но там везде динамика примерно как жс. Единственно что если жс(пистон) умеют что-то проверять, то сишка не умеет. Ну потому что нет рантайма.

дядь причем тут «статические языки» (видимо вульгаризьм от языков со статической типизацией) и твой «боксинг». есть несчетное число «статических языков» вообще безо всякого «боксинга» и они прекрасно себя чувствуют. боксинг прилепили жувачкой чтобы скалярные типы себя чувствовали так же хреново, как и структурные.

чтобы передавать число 5 в некий псевдо"метод", который к инту привинтили как будто скалярный инт это класс. а от 5 можно брать ссылку.

боксинг это про ООП, а не статические типы.

alysnix ★★★
()
Последнее исправление: alysnix (всего исправлений: 2)
Ответ на: комментарий от MOPKOBKA

Обычно под адресом всегда имеется виду начальная точка входа.

ну и какой тип у этого нечта, у которого есть адрес начала кода, точка входа и длина в байтах? чтобы иметь на это «указатель», у этого должен быть тип. если у тебя строгая типизация.

а всякие сишечки стратают нечеткостью формулировок, это давно известно. и не надо трясти их мануалами как примером для подражания.

alysnix ★★★
()
Ответ на: комментарий от MOPKOBKA

По поводу сишки. У сишки есть символы - это такая глобальная хешмапа с объектами. У этих объектов есть типы. Один из них функция.

У этих объектов есть некоторые свойства. Один из которых то, что с ними ничего нельзя делать. Условно они «только для тения» и привязы определению.

Это типы-функции и типы-массивы. Но нужно понимать что это типы тех самых объектов, а не какие-то отдельные сущности.

Для них есть свои типы. Как уже было показано это int(int) или int[10] если мы про массивы. При том если объект-массива ты можешь создать рукой, допустим как (int[10]){} то создать функцию не можешь.

То, что ты показывал и то как думают о сишки всякие невежды - это другое свойство. Если мы не можем перемещать/копировать объекты(копировать нужно куда-то, а значит тогда они не ro) - нет смысла производить с ними операции/передачу. Поэтому в сишке существует специальный механизм конверсии объектов до их ссылок в контекстах, где объекта не может существовать.

Допустим это контекст передачи, где их так же существовать не может. Поэтому ты можешь писать int(int m[10], int f()). Аналогично происходит при остальных операциях. Включая разыменование потому как для него не определён результат. Не существует того в чём можно было представить функцию.

Существование преобразования не означает что функция/массив это тоже самое что и преобразованное. Аналогично никаких «указатель» нет. Функция как ссылка(в контексте си это указатель) это отдельный вид указателей. То, что они в каком-то виде могут преобразовываться в обычный не означает что это одно и тоже.

Самое интересное, что нигде не определено что функция это какой-то адрес начала и прочая чушь что генерирует срыватель покровов.

anonymous
()
Ответ на: комментарий от alysnix

дядь причем тут «статические языки» (видимо вульгаризьм от языков со статической типизацией)

нет, не атакуй меня своим невежеством.

чтобы передавать число 5 в некий псевдо"метод", который к инту привинтили как будто скалярный инт это класс. а от 5 можно брать ссылку.

Я ничего не понял. Ни тогда ни сейчас. Куда прикрутили? Кого прикрутили? 5 это не инт. Это и есть тот самый боксинг.

Банально даже потому что char[5] и char[10] - это не одно и тоже. В рамках твоих фантазий это одно и тоже. Вот статический язык это то, в том числе, где эти два примера не редуцируются до array

боксинг это про ООП, а не статические типы.

Причём тут ооп? Ты аналогично не знает что такое ооп. Начни с определения.

anonymous
()
Ответ на: комментарий от MOPKOBKA

Подавляющие большинство «цппистов» это всякие си с классами разнорабочие. Это как какие-нибудь сишники, которые на самом деле пишут напишут на си как на каком-нибудь паскале. Они как обычно ничего не знают о си/матчасти.

Аналогично си с классами обладает свойством тем, что они не знают ни си ни цпп. И зачастую им нужно как-то оправдывать своё неосиляторство и потому они верят во всякое «делфятня не приговор», «си что-то плохо». Типа не они такие.

Это как есть питонист, который хотя бы знает питон. А есть вкатун игого-нейронка. Но всё это называется одним словом «питонист».

anonymous
()
Ответ на: комментарий от anonymous

Банально даже потому что char[5] и char[10] - это не одно и тоже. В рамках твоих фантазий это одно и тоже. Вот статический язык это то, в том числе, где эти два примера не редуцируются до array

Дядь, у тебя в голове какая-то каша. знаешь как выглядит речь шизофреника? это когда три слова вместе имеют смысл, но со следующими тремя словами уже не образуют осмысленной фразы.

во-первых определись с синтаксисом. если ты лупишь в сишечном, то так и скажи. вообще-то сишечный есть муторный и сложночитаемый.

я вот вижу разницу в том, что похоже записано в сишечном синтаксисе(но жто не точно), но вот что такое - редуцируются до array - понять не в силах. ты слишком неточен в терминологии.

Ты хоть раскрой определение «статического языка», где его взять другим, если оно существует лишь в твоей голове? А причем там «боксинги», другие попробуют догадаться уже своими силами. Потому что определение боксинга в мире есть, а про «статический язык» никто ничего не знает.

alysnix ★★★
()
Последнее исправление: alysnix (всего исправлений: 2)
Ответ на: комментарий от alysnix

Вот здесь хорошо видно. И даже не враньё и не тотальное не знание си. А в принципе особенности восприятия/мышления.

Допустим часто люди не понимают почему в си объекты неизменяемые, но вроде как мы же можем менять значения в элементах массивов. Всё потому что это не одно и тоже.

Мы не можем int[10] записать в int[5]. Изменения типов сишка вообще не поддерживает. Да ничего особо в этом мире не поддерживает.

Такая же ситуация с передачей. Допустим мы хотим написать функцию foo(int[10])`, но если мы её напишем - мы не можем туда ничего передать. Включая забокшенный массив. Полиморфизма/перегрузки в сишки нет. Поэтому сишка боксит.

Но ничего не мешает взять ссылку на тип рукой и это будет именно int[10]. Всё это есть. Просто люди врут или повторяют глупости.

Теоретически можно говорить о том, что изначальная дин-модель сишки привела к этому. Но это такие себе заходы. Если мы говорим что объекты не конвертируются в ссылки, то нам нужно делать этой руками. memcpy(arr, arr1) уже не сделаешь.

И опять же, если мы говорим что &arr - это боксинг-вариант, то где обычный? Как взять ссылку на int[10], а не int *. Вот и получается что нужно писать каст.

Тут нет какого-то решения без добавления полиморфизма. Но сишка делалась на заре эпох и тогда ничего этого нет. Да и сейчас нигде ничего нет кроме как в цпп. Допустим раст только недавно научился в это(спустя 10лет) и то работает оно там как обычно так, что нихрена не работает.

К тому же будь в сишке полиморфизм раста(иного) бы не существовало. В сишке есть интеграция/аби именно потому что там нет полиморфизма(и манглинга). Значит те языки что его не поддерживают могут использовать си.

anonymous
()
Ответ на: комментарий от MOPKOBKA

Но в его словах о функциях чувствуется сильное влияение Delphi

причем тут дельфи. я вот вообще не помню чтобы тип функция хоть где-то столь примитивно считался указателем, кроме си и наследников. и о чем тут столь много разговора - непонятно.

alysnix ★★★
()
Ответ на: комментарий от anonymous

Вот здесь хорошо видно. И даже не враньё и не тотальное не знание си. А в принципе особенности восприятия/мышления.

ты не бурли, а дай определение статического языка. мне вот интересно откуда вылезли «боксинги» и зачем они тут вообще.

тебя похоже колбасит не по-детски и не по делу.

alysnix ★★★
()
Последнее исправление: alysnix (всего исправлений: 1)
Ответ на: комментарий от alysnix

я вот вижу разницу в том, что похоже записано в сишечном синтаксисе(но жто не точно), но вот что такое - редуцируются до array - понять не в силах. ты слишком неточен в терминологии.

Там было array<int> ака вектор. Динамический массив с размером.

Ты хоть раскрой определение «статического языка», где его взять другим, если оно существует лишь в твоей голове? А причем там «боксинги», другие попробуют догадаться уже своими силами. Потому что определение боксинга в мире есть, а про «статический язык» никто ничего не знает.

Есть. Оно очевидно любому кто более-менее знаком с темой. Если определение боксинга есть, а статический язык я противопоставляю боксингу - значит это «не-боксинг».

В общем когда-то давно статический значит си это имело смысл. Имеется ввиду в контексте типизации. Потом всё сломалось. И теперь статически-типизированным является и тс и дотнет и вообще всё что угодною. Даже пистон.

Очевидно в рамках современных реалий использовать статический в контексте типизации не имеет смысла. Ты же не думаешь что типы в си и тс это одно и тоже? Либо в жаве и си?

Боксинг это то, что является критерием. Условно статический язык может выразить foo(int[10]), а динамический нет. Он это выражает только через боксинг. Как базовый си, который это преобразует к foo(int *), но у си своим причины не связанные с боксингом. Выше я объяснил какие.

У тебя есть множество параметров включая типы и статический это такое, где это определено статически, очевидно. Нет толку описывать что это за параметры - все языки разные. Допустим в каждый момент времени должна быть чётка определена структура память, в том числе для этого нужны типы. Тип всегда должен быть один и только один - потому то лейаут памяти может быть только один. Сишка много чего шарит, но это отдельная тема.

Поэтому называть сишку статически типизированной не имеет смысла. Но она статическая. В сишке даже типовых аннотаций в синтаксисе не было. Только объекты.

Поэтому, кстати, невежды думают что их убогий паскалик-мусор можно натянуть на сишку. Либо что паскалик в принципе может что-то выражать из сишного.

В этом плане сишка опередила своё время на десятки лет. Сейчас еле-еле языки пришли к тем самым классам/группам что были в сишке.

anonymous
()
Ответ на: комментарий от alysnix

Ты продолжаешь врать и генерировать шизофазию? Откуда ты взял чушь что в си тип-функция считается указателем? Тебе уже 10раз доказали обратное. Считаю её только подобные тебе невежды или те кто генерируют для тебя методички.

К тому же ни в каких языках нет типов-функций. Там везде боксинг и там это как раз таки указатели, в отличии от си. Допустим поэтому в расте 10лет пытались скопипастить impl fn

anonymous
()
Ответ на: комментарий от alysnix

Сложно тебе объяснить. Ты не знаешь что такое язык. Что такое семантика/поведение.

Вот тебе пример https://gcc.godbolt.org/z/TndTxzxTe :

main() {
    typeof(main) main;
    typeof(main) * main_ptr = main;
    auto amain = main;
    amain = main_ptr;
    main_ptr = main;
    main = main_ptr;
}

Написано оно и тоже результат разный. Почему? Твоё невежество говорит что это одно и тоже. Как одно и тоже может давать разное поведение?

Соответственно ты через это попытаться понять боксинг. Босинг не может давать разное поведение потому как там семантика одна. Она динамическая. Поэтому foo(vec(10)) foo(vec(5)) - дают всегда одно поведение. А foo(int[10]) foo(int[5]) - дают разное.

Так же и с сишкой. Есть разные контексты. Там разные уполчания и разное поведение. Контексты в принципе сложные для делфятни. Как и типы. Как и всё остальное.

Но если ты хочешь обсуждать какие-то темы - ты должен это понимать.

anonymous
()
Ответ на: комментарий от anonymous

Никаких FA U FB - это всегда значит боксинг+рантайм-диспатч. Люди сказали что их язык «статически типизированный», потом сказали тоже самое про си. И они давай наделять свои фантазии свойствами си.

С чего это?

char a;
unsigned int b
n > 0 ? a : b // имеет тип int

А для совсем разных типов в си есть union. Это как раз FA U FB.

monk ★★★★★
()
Последнее исправление: monk (всего исправлений: 1)
Ответ на: комментарий от anonymous

Там было array ака вектор. Динамический массив с размером.

Ты счас в каком языке, и в какой вселенной - чтобы понимать точно.

Откуда в си взялся шаблон контейнтера с произвольным доступом и какое отношение он имеет к тривиальному типу - массив? просто по аналогии - андиан/мандриан? array это шаблон из другого мира с набором неких функций, итератором и именем на букву а, и все. причем тут массивы си??? это даже не массив с++. это такая условность. что там внутри - никому знать не надо.

Почему что-то должно редуцироваться к данной условности. короче пока неуд.

Есть. Оно очевидно любому кто более-менее знаком с темой. Если определение боксинга есть, а статический язык я противопоставляю боксингу - значит это «не-боксинг».

В общем когда-то давно статический значит си это имело смысл. Имеется ввиду в контексте типизации. Потом всё сломалось. И теперь статически-типизированным является и тс и дотнет и вообще всё что угодною. Даже пистон.

ну так дай нужное определение статического языка. или сошлись на что-то из инета.

На всякий случай вот тебе класическое определение боксинга, от дипсика. Даже не спорь, он лучше знает.

Боксинг (Boxing) в программировании — это процесс преобразования значимого типа (value type) в ссылочный тип (reference type) путем оборачивания его в объект.

википедия

In computer science, boxing (a.k.a. wrapping) is the transformation of placing a primitive type within an object so that the value can be used as a reference. Unboxing is the reverse transformation of extracting the primitive value from its wrapper object. Autoboxing is the term for automatically applying boxing and/or unboxing transformations as needed. 

Теперь вопрос, какое отношение этот костыль из некоторых языков с ооп(ООП), имеет к статическим(или нестатическим) языкам, как сумме понятий. Этот боксинг можно воткнуть куда хочешь, от него не ничто не изменится. Его даже можно не втыкать, и все равно ничто не изменится.

То есть ты вернись в эту вселенную, короче опять неуд.

Боксинг это то, что является критерием. Условно статический язык может выразить foo(int[10]), а динамический нет. Он это выражает только через боксинг. Как базовый си, который это преобразует к foo(int *), но у си своим причины не связанные с боксингом. Выше я объяснил какие.

да любой нормально типизированный язык может «выразить» твой foo(int[10]), это типа функция от массива из 10 интов?

Какая тебе разница, как массив передадут в данную функцию. Это не твой вопрос. В нормальном статически типизированном языке в функцию передадут указатель на какой-то внешний твой массив из 10 интов, который foo скопирует в прологе во внутренний буфер. Потому что нарисована передача параметра по значению, а это порождает собственную копию. И опять - это не про боксинг. А про эффективность реализации языка. И тебе еще скажут - что так делать неэффективно, и если ты не осел - передавай массив по константной ссылке.

Дальше даже комментировать нельзя, все равно что бить лежачего.

alysnix ★★★
()
Последнее исправление: alysnix (всего исправлений: 2)
Ответ на: комментарий от monk

С чего это?

Это твоя задача доказывать, а не моя. Ты вбросил.

n > 0 ? a : b // имеет тип int

К чему это? Это приведения типов. Там нет твоих фантазий. К тому же тебе объясняли, что объединение не работает. Это сложно понять находясь в примитивных скриптухах, но давая рассмотрим такой пример.

Есть write(), которые пишет в память значение. Последовательно. write(a); write(b); и их объединение имеет разную семантику. Понятно что типы/семантика/реальность это сложно для U задача которых лабы бацать, но всё же.

Объединение теряет свойства. В любых из вариаций. Это базовое свойство мироздания.

А для совсем разных типов в си есть union. Это как раз FA U FB.

Нет, это как раз такие не u потому что это вообще не тип. Там теряется тип и теряется свойство стореджа. Опять же, повторяю, в лабах всё просто в реальности нет. Ненужно проецировать сомнительные теории на реальность.

Юнион в си решает одну простую задачу. Данные где-то должны хранится и агрегаты/юнионы это в сишке это такие куски памяти в которых живут созданные там «переменные».

Хранение и сайзоф это одно из свойств, которые я так же затрагивал выше. Си просто использует то свойство, что более мелкий объект можно положить в пространство более крупного только останется хвост. Это такой эрзац-полиморфизм по сайзофу и не более.

То, что мы где-то там костылём свели 2 сущности к одной не означает что это работает. Это нишевые решения. Это как когда у тебя есть красная/синяя машинка ты можешь свести их к цвету. Просто для идентификации. Но это не значит что они цветом определяются и к нему сводятся.

Аналогично если мы можем оба типа привести к одному общему это не значит что он сохраняет свойства обоих. Ладно мне лень повторять одно и тоже.

anonymous
()
Ответ на: комментарий от anonymous

Тебе правда к доктору надо. Твои тексты изобилуют новыми открытиями и терминами прямо вот на каждой строке и, разумеется, среди простых смертных такие не уживаются. Таким обычно требуются отдельные помещения, и теплая компания единомышленников.

А ну давай говори, что такое статический язык и как он связан с боксингом! а то бригаду вызову.

alysnix ★★★
()
Последнее исправление: alysnix (всего исправлений: 1)
Ответ на: комментарий от kaldeon

Любая задача, в которой существуют понятия, ссылающиеся на самих себя

Годится любой ЯП, где возможно описать тип для односвязного списка. Это означает, что в языке присутствует выразительное средство для рекурсии в типах.

Reason enough?

Да, описанное в цитате называется «инкапсуляция». А уж как это синтаксически записывается, зачастую непринципиально.

wandrien ★★★
()
Ответ на: комментарий от alysnix

Ты счас в каком языке, и в какой вселенной - чтобы понимать точно.

Причём тут язык? К тому же ты не знаешь ни одного языка. К чему эти глупые вопросы? И да, ты не знаешь элементарное базы и потому теряешься. Динамический массив существует везде. Любой язык. Это общее понятие.

Откуда в си взялся шаблон контейнтера с произвольным доступом и какое отношение он имеет к тривиальному типу - массив?

Какой контейнер? Какой доступ? Что ты несёшь? Это очередной нейробред? А, тебе в букваре сказали что динмассив какой-то «шаблон контейнера»? Ну дак выкинь тот букварь.

ну так дай нужное определение статического языка. или сошлись на что-то из инета.

С чего вдруг? Интернет состоит из клоунов. Вот я ещё бегай за тебя ищи. Ты не можешь требовать что-то непонятно чего. Определение тебе дали.

На всякий случай вот тебе класическое определение боксинга, от дипсика. Даже не спорь, он лучше знает.

Что это за определение и что он лучше знает? Ты что ли? Твой уровень уже давно был продемонстрирован тобою же.

Ты родил какое-то мусорное определение. Из которого ничего не следует. Потом скопипастил непонятно что есть понятие «объект» и у тебя как у любого неофита мышление на уровне ключевых слов. Объект-ооп.

Иди посчитай сколько слово «объект» используется в стандарте си. Потом поясни там за ооп. Как раз с цитаткой. Придёшь и расскажешь «объект - это ооп. У меня в букваре написано что си это не ооп - почему у вас объекты». Только будь аккуратен. Тебя могут тут же телепортировать в дурку.

да любой нормально типизированный язык может «выразить» твой foo(int[10]), это типа функция от массива из 10 интов?

Нет. Ещё раз, зачем ты рассуждаешь о чём-то что находится выше твоего уровня понимания? Показывай. Там есть критерий. Берёшь свой язык и показываешь. Или ты его не знаешь?

Какая тебе разница, как массив передадут в данную функцию. Это не твой вопрос.

Это мой вопрос. Ты решил переобуваться? Ты погуглил? Молодец.

В нормальном статически типизированном языке в функцию передадут указатель на какой-то внешний твой массив из 10 интов, который foo скопирует в прологе во внутренний буфер.

Это и есть боксинг. Указатель это тот самый указатель на объект-обёртку.

И да, критерий был сделать функцию именно от 10интов и от 5интов с разным поведением. Ну и без боксинга, да. Если функция принимает 5интов она может их принять напрямую через аби, а не через обёртки.

А про эффективность реализации языка. И тебе еще скажут - что так делать неэффективно, и если ты не осел - передавай массив по константной ссылке.

Какой ссылки? Ты генерируешь базворды из си с классами ничего о них не зная? Молодец. Только толку?

И это не про эффективность - это про боксинг. Типом и объектом является 10интов. И передавать ты должен 10интов. Не обёртку, а именно 10интов/5интов.

anonymous
()
Ответ на: комментарий от kaldeon

Вот если бы нам требовалось наложить условия, что вызывающая сторона обязана восстановить значение опции, это было бы интереснее.

Можно было бы поспорить о пользе и вреде деструкторов, например.

Или о линейных типах.

Вот это и правда ближе к «21 веку».

wandrien ★★★
()
Последнее исправление: wandrien (всего исправлений: 1)
Ответ на: комментарий от anonymous

Это и есть боксинг. Указатель это тот самый указатель на объект-обёртку.

чудила, какой еще «обьект обертка». просто в памяти лежит например стурктурная константа - массив из 10 интов, или на стеке обьявлен такой массив.

и его передают в функцию по адресу. просто потому, что это так код вызова будет меньше. И ФСЕ!

можно передавать и копируя извне, как это делается для скаляров. компилятор может реализовать оба варианта, это никак не меняет семантики. и будешь вариант передачи выбирать опцией, если хочется.

на псевдоязыке

fun arr10 (fa: array[10] of int)
///такая функция будет получать адрес массива
///чтобы тут засосать его во внутренний буфер на стеке.
///просто потому что копировать изнутри  экономней по месту, чем снаружи
{
...
}

fun test() {
  var arr: array [10] of int; //на стеке место под 10 интов.
...
  arr10(arr); ///тут просто функции дадут адрес arr, безо всяких "оберток"
}

ононим, где обертки!!!??? обьекты-обертки тут - в твоей беспокойной голове. и никакого термина «боксинг» тут не возникает.

Боксинг совсем из другой оперы, в которую ты никак не можешь врубиться. Я уже писал для чего. Ищи сам зачем он в жаве или шарпе.

И передавать ты должен 10интов. Не обёртку, а именно 10интов/5интов.

да запросто! просто тогда вызов функции arr10 будет предваряться кодом копирования массива ей на стек. это тупо излишне. потому что таких копирований будет столько, сколько раз вызывается функция.

Потому делают передачей адреса, и копированием изнутри. Ты ж не знаешь как устроен самый простой компилятор. Тебе кажется в этом всем есть глубокий философский смысл…садись неуд.

alysnix ★★★
()
Последнее исправление: alysnix (всего исправлений: 2)
Ответ на: комментарий от alysnix

на псевдоязыке

Мне не интересны твоё манёвры. Критерий дан. Ты там рассказывал про какие-то языки - делай на язык. Не фантазии на тему, повторяю.

и его передают в функцию по адресу. просто потому, что это так код вызова будет меньше. И ФСЕ!

нет. Это боксинг. По определению. Ты не знаешь что такое семантика - не позорься. Ты пытаешься нелепо гуглить и вкидывать рандомные тезисы, но они не работают.

можно передавать и копируя извне, как это делается для скаляров. компилятор может реализовать оба варианта, это никак не меняет семантики.

Мне нужны не фантазии. Откуда ты взял что это делается для каких-то там «скаляров»? Понятно что ты ничего не знаешь, но всё же. Иди хоть запусти посмотри как агрегаты раскладывает компилятор.

ононим, где обертки!!!??? обьекты-обертки тут - в твоей беспокойной голове. и никакого термина «боксинг» тут не возникает.

Как не возникает, если возникает? Заметим как ты маневрируешь. То ссылка/не ссылка это деталь реализации, то уже боксинга нет. Ты воруешь из гугла тезисы которые не понимаешь.

Действительно в рамках семантики передачи нам не обязательно что-то копировать, но ты рассказывал что?

В нормальном статически типизированном языке в функцию передадут указатель на какой-то внешний твой массив из 10 интов, который foo скопирует в прологе во внутренний буфер.

Тут уже есть и «скопирует», и «указатель» и прочая чушь. А потом переобувочная.

Боксинг совсем из другой оперы, в которую ты никак не можешь врубиться. Я уже писал для чего. Ищи сам зачем он в жаве или шарпе.

Ты ничего не писал. Ты слился. Пытался пастить какую-то чушь. Обделался и с объектом и ооп. В гугле увидел в первой ссылки «объект» и всё. Методичка одна - объект - ооп. Квалификация нулевая, бекграунд нулевой. Потом понял что сел в лужу и съехал с темы.

да запросто! просто тогда вызов функции arr10 будет предваряться кодом копирования массива ей на стек. это тупо излишне. потому что таких копирований будет столько, сколько раз вызывается функция.

У тебя уже копирование выше было, а тут вдруг его не будет. К тому же тебе уже сообщали про аби. Он поддерживает передачу через регистры, а компилятор умеет агрегаты распиливать. Соответственно пока твоё днище что-то будет загружать из стека нормальный реализация не будет.

Но стек да. Это такое мышление уровня начальной школы.

Потому делают передачей адреса, и копированием изнутри. Ты ж не знаешь как устроен самый простой компилятор. Тебе кажется в этом всем есть глубокий философский смысл…садись неуд.

Куда передачу, какой адрес? Ты нагуглил что-то и решил мне сообщить? Зачем?

Кстати, да. Передача через указатель как раз таки боксинг. Понятно что твои представления ограничены гуглом с лабами, но всё же. Именно потому что железка не умеет в передачу необходимых типов нам приходится оборачивать. Указателя/стек пердолинг это оно самое.

Кстати, да. Ещё одна большая ошибка всяких разнорабочих в том, что они не понимают смыла того что написано. Что-то можно делать боксинг, когда это нужно. Это не является проблемой. Именно поэтому во второй заход ты начал пастить «деталь реализации», а не ту чушь что говорил изначально.

Но проблемой является то когда там есть боксинг. В базе. И ошибка заключается не столько в непонимании языков/боксинга сколько в попытках бездумно тащить всякие разные понятия.

Давай попроще. Вот человек может лежать. А может не лежать. Твоё невежество берёт это свойство и начинает орать «смотрите вон тоже лежит. Значит у тебя тоже лежит». Но один лежит потому что труп, а второй потому что лежит. Хотя и тот и тот лежит.

anonymous
()
Ответ на: комментарий от MOPKOBKA

на ассемблере можно? И во что компилируется Rust хотелось бы узнать…

В скомпилированном коде нет никакого борроу-чекера, это чисто компайлтаймовая штука.

unC0Rr ★★★★★
()
Ответ на: комментарий от anonymous

нет. Это боксинг. По определению.

тебе дали определение боксинга. его дал дипсик, вики и я. у нас троих совпало. у тебя одного свое определение, которое ты ни разу не показал. потому что у тебя его нет. :) поскольку ты его упоминаешь через строку, а определения у тебя нет, - значит ты просто балабол.

итак от тебя требуются два четких определения

«статического языка» и «боксинга». иначе тебя плющит не по-детски.

если у тебя каждый адрес это уже прям какой-то «боксинг», то огорчу, боксинг это не то, а адрес это просто адрес.

ты хотя бы прислушайся к мелодичной английской речи - боооксинг!, то есть «окоробочивание», обертка, запаковка. Причем тут просто передача адресов обьектов? Учи язык уже.

alysnix ★★★
()
Последнее исправление: alysnix (всего исправлений: 1)
Ответ на: комментарий от anonymous

зайти уже на дипсик и спроси его (он тебя умней, это точно… да что тебя, он и меня умней! :) )

спроси так - «зачем в программировании нужен боксинг». и там тебе напишут зачем вообше эта фуэта, и откуда она взялась (в основном для совместимости скаляров со структурными типами в ооп).

а потом вступи с ним в спор и долбись с ним хоть до бесконечности. и не морочь тут головы людям.

alysnix ★★★
()
Последнее исправление: alysnix (всего исправлений: 1)
Ответ на: комментарий от alysnix

тебе дали определение боксинга. его дал дипсик, вики и я. у нас троих совпало.

Ты тут вообще мимо. Ещё у того кто перепащивает нейронка-мусор/гугл что-то там не совпадёт. Опять же определение полностью соответствует тому что я писал. Тебе это сообщили. Даже твоё определение.

К тому же твой рассуждения ничего не стоят. Нейронка повторяет попсовые определение есть ей не дать нормальный контекст. Ты его, конечно же, дать не можешь.

У определений есть градации.

«статического языка» и «боксинга». иначе тебя плющит не по-детски.

Тебе всё дали. Ты даже не смог сообщить где и как твоя нейрошиза противоречит моим определениям. Показывай.

ты хотя бы прислушайся к мелодичной английской речи - боооксинг!, то есть «окоробочивание», обертка, запаковка. Причем тут просто передача адресов обьектов? Учи язык уже.

У тебя нет никаких адресов. Ты же сам рассказывал про какой-то стек/копирование и прочую чушь. Это и есть те самые обёртки. Как и указатель сам по себе является обёрткой.

Вот твоя функция, когда будет использовать твой стековый мусор - будет его распаковывать.

Давай попроще. Вот есть реальная семантика - размещение переменных не определено. Это вполне себе могут быть регистры, а далее происходит твоя шиза со стеком/ссылкой. Соответственно что нужно сделать? Нужно упаковать все эти регистры в стек-баланду и потом распаковать. Аналогично компилятор может и упаковать в регистры, но то неважно.

Мне даже лень обсуждать твоё невежество. Запаковка у него случилась. Тебе чётко написали что это объект-посредник и механизм преобразования из него/в него. ссылка это тоже самое. Потому что ссылка в твоей скриптухе имеет ту самую семантику боксинга.

В языке, конечно же, могут быть реальные ссылки они же алиасы. Тогда это действительно будет не боксинг, но это явно не твоя скиптуха. Успокойся.

anonymous
()
Ответ на: комментарий от alysnix

Удивительно как нейробот был пойман на том что он нейробот, а потом начал делать вид «ну я не бот», «ну там 100% инфа». Это такие манёвры уровня начальной школы. Ну как «аноним».

Кстати, а чего же ты не написал? Не помогли нейроботу ответы? Ты же явно в жалких попытках пытался пастить мои ответы туда и получить аргументацию. Но не получалось. Тебе говорили обратное. Бывает.

anonymous
()
Ответ на: комментарий от anonymous

реально сходи на дипсик, и спроси заодно - «что делать, если у меня видения». сначала прочитай про боксинг, потом про видения.

твои мыслиши про передачу параметров, аби, регистры, стек, носят все признаки божественных откровений и скорее напоминают некую религиозную ауру при височной эпилепсии, чем реальные факты.

именно с мессианских позиций нового пророка ты говоришь. тебе вообще неважно, что там проиходит внутри памяти и процессора. У тебя своя вселенная каких-то чудесатых штук, которые ты даже не можешь определить строго.

у тебя сцуко копирование память-память(это про массив)(чему обычно есть даже процессорная команда) называется уже боксингом из сферы извращенного ооп. ты совсем поехал что-ли?

alysnix ★★★
()
Ответ на: комментарий от alysnix

у тебя сцуко копирование память-память(это про массив)(чему обычно есть даже процессорная команда) называется уже боксингом из сферы извращенного ооп. ты совсем поехал что-ли?

Нету никаких инструкций ты опять опозорился. И тебе явно нейронка такую чушь не генерировала. Ладно с тобой всё понятно ты рядовой нейровкатун.

Для остальных поясню. Вот у нас есть есть «команда»(что такое комнда, которая память копирует? rep movsb? Я за тебя твою нейрошизу должен декодировать?

Дак вот. Какое апи у этой «команды»(которой не существует, но то ладно)? Оно предлагает побайтовое копирование, которое может быть не только b, но там нужна обвязка. Значит это уже не команда.

По-сути это банальный боксинг в байтовый динмассив. Аналогично как это происходит в си. Но ты же ныл про си, а тут вдруг уже не боксинг?

Проблема неофитов. Ну ладно ты просто несёшь херню особенно сейчас когда у тебя есть нейронка. Проблема в том что они не способны мыслить. Они не понимают смысла понятия зачем и почему оно создано. Почему в жаве оно существует и что это лишь локальная реализация. И он видит жаву и всё. Он не понимает. Такая же проблема у него была с объектом.

У тебя в википедии написано боксинг ака враппинг. Ты даже не осилил этого. Но обёртки в целом они имеют разную природу, а тут я говорю об одном из назначений.

Аналогично, допустим, у этой «команды» есть счётчик. Откуда от взялся? Если у меня агрегат, либо int[5] - здесь где-то есть счётчик? Нет тут никакого счётчика. Значит чтобы мочь это скопировать через «команду» его нужно преобразовать/обернуть в ptr+len.

Что делает боксинг в жаве? Ну как раз таки то самое и делает. Преобразует объект в условное ptr+len с которым может далее работать гц/лапша.

Выше он рассказывал какие-то сказки про какие-то скаляры. На самом деле никаких «скаляров» не существует. Это как раз таки прямо-отображаемые типы. Но агрегат/память так же могут быть прямо-отображаемыми.

anonymous
()
Ответ на: комментарий от anonymous

Дак вот. Какое апи у этой «команды»(которой не существует, но то ладно)? Оно предлагает побайтовое копирование, которое может быть не только b, но там нужна обвязка. Значит это уже не команда.

обисняю. копирует она как хошь, вплоть до длинных слов. естессно ей надо заряжать адреса источник/прмемник и число копируемых элементов.. а не какие-нить боксинги (аааахахаха).

По-сути это банальный боксинг в байтовый динмассив. Аналогично как это происходит в си. Но ты же ныл про си, а тут вдруг уже не боксинг?

боксинг это упаковка скаляра, например инта в обьект(размещая сие на куче), чтобы от него брать ссылку для оопешных фич(и скажи что это не так, дав свое определение боксинга). вот если б ты читал дипсик на ночь, ты бы это знал.

вот ты даже настолько улетел, что не понял, что боксинг это не для стуктурных типов(а массив - тип структурный), а для скалярных, навроде инта. то есть у тебя все перевернулось с ног на голову. «боксинг» массиву не нужен. от массива итак можно взять адрес, в силу того, что он в памяти по-любому. читай определение боксинга, але!

Выше он рассказывал какие-то сказки про какие-то скаляры. На самом деле никаких «скаляров» не существует.

ты настолько невежественен, что даже не знаешь стандартных дефиниций. сходи на дипсик, набери «скалярные типы данных», и будет тебе дзен. этому термину лет 60 с хвостиком. от первых еще языков програмирования со структурными типами. или ты не знаешь и что такое - «структурный тип данных»? опять же дипсик ждет тебя.

alysnix ★★★
()
Последнее исправление: alysnix (всего исправлений: 3)
Ответ на: комментарий от wandrien

Всё это имеет смысл исключительно в контексте практической применимости: создания программ, решающих какие-то задачи.

Для OCaml рекурсивные типы очень даже помогают в одной из основных областей его применения - написании компиляторов.

anonymous
()