иногда приходится с мультипоточностью ебаться итд итд. в теории звучит конечно хорошо, но на практике когда ты поуши в работе проще накостылять функцию с 10 аргументами, проверить что твоя задумка работает а потом в свободное время структурировать по человечески
Твои бы слова да моим легаси-макакам в уши, которые в конструктор по 12 - 20 аргументов приопихивают
>мелкобуквенный
>говнокодер
Как думаешь, почему я не удивлен?
Ну вон, выше как раз один такой экземпляр, лол.
>Назовите хоть один пример функции, которой нужно принимать >=3 аргументов, и я поясню, почему вы неправы и пишете говнокод.
ssize_t write(int fildes, const void *buf, size_t nbytes);
Вперед.
Надеюсь ты знаешь, чем отличается функция от метода.
>Назовите хоть один пример функции, которой нужно принимать >=3 аргументов, и я поясню, почему вы неправы и пишете говнокод.
ну хотя бы вот
https://github.com/TTimo/doom3.gpl/blob/master/neo/game/physics/Physics_RigidBody.cpp
ну а вообще говоря C бояре могут на тебя спокойно поссать. Потому что за что я уважаю C за то что там пишутся офигенные функции.
Полехче, а то Оп смузи захлебнётся
Ну вообще я подразумевал разговор о высокоуровневых языках, а не о всяких там портабельных ассемблерах.
Но даже сишнику должно быть очевидно, что на самом деле эта функция принимает два аргумента: файл и (bounded) буфер, который в этот файл нужно записать. И возвращает файл, кстати. Собственно, в расте, например, сигнатура у этой функции именно такая.
>ну хотя бы вот
Укажи конкретную функцию, которая тебе нравится, не буду же я за весь файл пояснять.
>C бояре
Отличная шутка, братан!
https://pastebin.com/yHhcDsr1
ну ладно просто признай что в больших сложных проектах хипстерские смехуёчки пока не работают
>пишете
Шкальник не палится.
>Назовите
curry, zipWith, if, foldr/foldl ... (трёхаргументные) - самые очевидные. Тысячи их. Можно начать с необозримого зоопарка многоаргументных комбинаторов. Если не считать вообще все термы одноаргументными в смысле каррирования или раззложения по CL-базису. Что, разумеется, глупо. Кроме того, такая интерпретация не имеет силу в случе согласованного разбора нескольких термов алгебраических типов.
Ну там вообще адский говнокод: t вовсе не используется, derivatives - это output param, rigidBody разнесен на два параметра (с даункастами из voidptr, олололо). Не вижу смысла всерьез это обсуждать. Любому очевидно, что это унарная функция.
>хипстерские
Значение знаешь?
>Шкальник не палится.
К чему ты это спизданул, наркоман?
>curry
Значение знаешь, дебилушка? Это унарная функция. Алсо, в *мл все функции унарные, если уж на то пошло, но я этот - чисто технический - момент в дальнейшем опускаю.
>zipWith
Это комбинатор. Из (a b -> c) делает ([a] -> [c]). Отличная иллюстрация моего поинта, кстати.
>foldr/foldl
Это комбинатор. Из (a b -> a) делает (a -> a). Отличная иллюстрация моего поинта, кстати.
>if
>2018
Если тебе по какой-то причине так нужен иф, то разделяй его на then-часть: (Bool, a -> Maybe a) и else-часть: (Maybe a, a -> a).
Макаба съела [ b ] в двух местах, нутыпонел.
быстрофикс
быстрофикс
>К чему ты это спизданул, наркоман?
К тому, что ты не осилил даже орфографию школьного курса.
>>curry
>Значение знаешь, дебилушка?
Значение чего?
>Это комбинатор
>Это комбинатор
Так я о том и говорю.
>Если тебе по какой-то причине так нужен иф, то разделяй его на then-часть: (Bool, a -> Maybe a) и else-часть: (Maybe a, a -> a).
Точно. Так и есть. Шкальник.
Я же как раз написал, что это - многоаргументные фунции 'по модулю' каррирования. А считать их в самом деле одноаргументными - максимально глупо. Что особенно заметно на примере функций согласованного разбора.
>К чему ты это спизданул, наркоман?
К тому, что ты не осилил даже орфографию школьного курса.
>>curry
>Значение знаешь, дебилушка?
Значение чего?
>Это комбинатор
>Это комбинатор
Так я о том и говорю.
>Если тебе по какой-то причине так нужен иф, то разделяй его на then-часть: (Bool, a -> Maybe a) и else-часть: (Maybe a, a -> a).
Точно. Так и есть. Шкальник.
Я же как раз написал, что это - многоаргументные фунции 'по модулю' каррирования. А считать их в самом деле одноаргументными - максимально глупо. Что особенно заметно на примере функций согласованного разбора.
> И возвращает файл, кстати
Нет.
>высокоуровневых языках,
Ok, вот сишарп, чтение из сокета
public IAsyncResult BeginReceive(
byte[] buffer,
int offset,
int size,
SocketFlags socketFlags,
out SocketError errorCode,
AsyncCallback callback,
object state
)
функция которая складывает 20 чисел:
foo(a1,a2,a3,a4,...,a20):
return a1+a2+a3+a4+..+a20
Попробуй сделать ее с 0, 1, 2 аргументами
Ну давай оп. Есть функция проектирующая вектор, на заданную плоскость вдоль заданного же вектора.
Очевидно, аргументов необходимо три: плоскость на которую проектируем, вектор, задающий направление, вдоль которого проектируем и собственно проектируемый вектор.
Хочешь не хочешь, а аргументов в общем случае три. Можно конечно исхитриться, и порождать сначала оператор проектирования на заданную плоскость вдоль заданного направления. Но это как по мне хреновая затея. Как по мне, более правильно порождать эти операторы в случае их надобности каррированием исходной трёхаргуметной функции.
Очевидно, аргументов необходимо три: плоскость на которую проектируем, вектор, задающий направление, вдоль которого проектируем и собственно проектируемый вектор.
Хочешь не хочешь, а аргументов в общем случае три. Можно конечно исхитриться, и порождать сначала оператор проектирования на заданную плоскость вдоль заданного направления. Но это как по мне хреновая затея. Как по мне, более правильно порождать эти операторы в случае их надобности каррированием исходной трёхаргуметной функции.
Ты даун? Передавай в функцию массив чисел.
Ну ты и поехавший, однако. Я зашел в тред, думаю присоединюсь, а тут в самом деле какой-то смузихлеб решил патраллить но внезапно сосет хуи в прямом эфире.
ну таких примеров в графике тысячи. Опчик чёто поспешил выступить с сим смелым заявлением. Вот к чему приводит непомерное смузихлёбство.
>К тому, что ты не осилил даже орфографию школьного курса.
Просвещайся, мань: https://ru.wiktionary.org/wiki/%D0%BF%D0%B8%D1%81%D0%B0%D1%82%D1%8C#%D0%BF%D0%B8%D1%81%D0%B0%CC%81%D1%82%D1%8C
>Значение чего?
Значение curry. Попробуй описать ее смысл на естественном языке. Curry - это HOF, которая принимает одну функцию с определенными свойствами и возвращает другую функцию с другими свойствами. Алсо, более логичным бы было имя pack (и unpack). Pack берет бинарную функцию и превращает ее в униарную (от тапла); unpack берет унарную (от тапла) функцию и превращает ее в бинарную. Все просто и понятно.
>Так я о том и говорю.
Так твои функции как раз не комбинаторы, ибо в них есть сабэкспрешны со свободными переменными.
>Точно. Так и есть. Шкальник.
Один раз ты уже обосрался, на этот поинт по теме тебе тоже ответить нечего. Мне остается только снисходительно пожать плечами.
>А считать их в самом деле одноаргументными - максимально глупо
Гхм, перечитай мой предыдущий пост. Я надеюсь, что ты видишь разницу между
((a b -> a) -> (a [ b ] -> a))
и
(a -> b -> a) -> a -> -> a
в контексте этого разговора. Если нет, уточняю: обыкновенно фолд воспринимается как функция трех аргументов над (условно) списком. Попробуй ее объяснить естественным языком ее в таких терминах. Мой поинт в том, что Ъ-смысл фолда раскрывается, если логически смотреть на него как на комбинатор функций. Тогда одного взгляда на тип достаточно, чтобы интуитивно понять, что эта функция делает. В итоге получаем, что такой подход одновременно и более интуитивный\естественный, и более простой технически.
>Нет.
Пидора ответ.
>чтение из сокета
Я надеюсь, что это неудачная шутка, анон. Посмеялся, типа.
В ньюфаг-тред сбрызни.
>Я зашел в тред
Выйди обратно, у тебя недостаточно фундаментальных знаний для участия в дискуссии.
Спасибо, ты тоже хуй.
Это хороший пример, да. Я для себя решил, что в подобных случаях лучше все же избегать каррирования, и использовать вместо этого именованные аргументы (ну, рекорды\таплы в общем случае). Почему?
Потому что логически твоя функция все-таки имеет вид (t x -> t). Ты берешь вектор и возвращаешь некую производную от этого вектора. То есть в общем случае ты хочешь иметь возможность делать композицию операций над этим вектором. Поэтому логично написать (в псевдо-ооп синтаксисе): vec.project(to: a-plain, along: a-vec).
В смолтоке именованые аргументы были частью имени функции. Я долго присматривался к этому, но в итоге все-таки для себя решил, что лучше иметь легкий синтаксис для structural typing'а и компилятор, гарантирующий элиминацию литералов структур\рекордов. В итоге получается, опять же, и более читабельно, и технически более просто и единообразно.
>vec.project(to: a-plain, along: a-vec).
это хуевая идея по многим причинам.
основная то что ты прячешь функционал который по хорошему надо выносить в оператор в какой то класс. А это ебатня с наследованием итк итк и вообще усложение ради упрощения
Съеби из треда, пожалуйста. Ты не понимаешь, о чем идет речь, и поэтому только засоряешь эфир комментариями совершенно мимо кассы. Ничего личного.
да я сам пожалел что это написал.
Всё съёбываю обосааный и обосраный
>Просвещайся, мань: https://ru.wiktionary.org/wiki/%D0%BF%D0%B8%D1%81%D0%B0%D1%82%D1%8C#%D0%BF%D0%B8%D1%81%D0%B0%CC%81%D1%82%D1%8C
Извини. Я промахнулся. Ты прав.
>берет бинарную функцию и превращает ее в униарную
Ничего она ни во что не превращает. curry x y z = x (y, z)
Позиционных аргументов — поддерживаю.
Именованных можно сколько угодно.
fn(name='John', surname='Smith', phone='333', address='NewYork', etc etc
Именованных можно сколько угодно.
fn(name='John', surname='Smith', phone='333', address='NewYork', etc etc
>ибо в них есть сабэкспрешны со свободными переменными.
Где?
curry : ((a b) -> c) -> a -> b -> c
= ((a b) -> c) -> (a -> b -> c)
мммкей?
Принято. Проехали.
Ну, в рид-онли можешь остаться, лол. В обычном инфиксном (как a+b, только вместо плюса - project) синтаксисе это будет:
vec project {to: a-plain; along: a-vec}
Да, но весь поинт в том, что именованные аргументы - никакие не аргументы, а обычные таплы\рекорды. То есть именно аргументов остается ровно два.
Ну они же каррированные, анон.
Ебаная макаба.
curry : ((a,b) -> c) -> a -> b -> c
= ((a,b) -> c) -> (a -> b -> c)
curry : ((a,b) -> c) -> a -> b -> c
= ((a,b) -> c) -> (a -> b -> c)
>Ну они же каррированные, анон.
Так в Λ и CL все многоаргументные термы типизируются каррированно. Но понимаются они всё-равно как многоаргументные. В общем, это зависит от того, как считать аргументы, как это определить. Но считать их в смысле каррированности - очень глупо.
http://en.cppreference.com/w/cpp/algorithm/accumulate
ОП -- тупоголовая макака, которой смузи не долили.
ща манявры пойдут.
РЕЕЕЕЕЕ Я НЕ ИМЕЛ ВВИДУ ТАКИЕ ЯЗЫКИ, ЭТА ГАВНАКОД, БЛЯ НУ МАМ СКАЖИ ИМ
ОП -- тупоголовая макака, которой смузи не долили.
ща манявры пойдут.
РЕЕЕЕЕЕ Я НЕ ИМЕЛ ВВИДУ ТАКИЕ ЯЗЫКИ, ЭТА ГАВНАКОД, БЛЯ НУ МАМ СКАЖИ ИМ
Да понятно, как там скобки стоят.
>Ну они же каррированные, анон.
Так а свабодные переменные в них где?
>свабодные
fix свободные
>Но считать их в смысле каррированности - очень глупо.
Гхм, так я же и не предлагаю это делать. Просто в некоторых случаях - как, например, с fold и zipWith - естественная за неимением лучшего слова форма функции совпадает с каррированной. Но, например, для map я предлагаю бинарный тип ([a] (a -> b) -> [ b ]), а не унарный ([a] -> ((a -> b) -> ...)), нутыпонел.
Тогда к чему тот пост был? Думать о значении (смысле) функции в терминах ее реализации через рерайтинг - не особо полезно, имхо.
Разобрали еще в начале треда, le glupyshechka.
Поиск элемента в массиве, ты маленький что ли?
Подаём в функцию указатель, размер и искомый элемент. Дада щас ты скажешь что массив нужно об'явить глобально, пошёл нахуй.
>Думать о значении (смысле) функции в терминах ее реализации через рерайтинг - не особо полезно, имхо.
Как так. Почему? Не понимаю. Как ещё можно думать о смысле функции?
Во внутренней лямбде. Короче, я понял, в чем недопонимание. Я под "комбинатором" имел в виду "суперкомбинатор", функцию вида \f.(transform f) - именно на такую реализацию нам интуитивно как бы намекает предложенная мной сигнатура для тех функций, в противоположность обычной \xs\ys\f.(...); энивей, обе формы эквивалентны, и реализация к типам никак строго не привязана, так что можете забить на эту цепочку разговора - я неудачно и некорректно выразился.
Впрочем, перечисленные функции в том же х-ле, например, комбинаторами все равно не являются, так что предлагаю в рамках этого треда вообще забить на общеупотребимое значение этого слова (ввиду его малой полезности) и под комбинатором подразумевать функцию вида ((... -> ...) -> (... -> ...)), например.
>Как так. Почему?
Ну потому что если ты думаешь о функции в терминах ее реализации, то тем самым убиваешь весь смысл существования этой функции (абстракцию).
>Как ещё можно думать о смысле функции?
Через типы.
Это бинарный предикат: contains? :: ([a] a -> Bool). Иди делай laba1.cpp и в ньюфаготред.
>Через типы.
Я, всё равно, не понимаю.
Терм как вычисление имеет смысл именно в системе переписывания. Типизация есть привнесение внешней логической системы для строгого рассуждения о том, что для термов возможно/невозможно/нежелательно и никак не влияет на их вычислительный смысл.
Анон, ну ты какой-то аутизм разводишь. Ты когда видишь функцию increment, думаешь о том, как она выражается в нумералах Черча? Или о том, в какой регистр на х86 записывается ее аргумент? Или все-таки о том, что эта функция увеличивает число на единицу? Типы нужны людям, чтобы нагляднее видеть, что функция делает. Вот смотришь на тип curry - и сразу видишь: она берет функцию от a,b тапла и преобразует ее в функцию от a и b. И никакого рерайтинга.
>а потом в свободное время структурировать по человечески
Нет ничего более постоянного, чем временное.
>Анон, ну ты какой-то аутизм разводишь.
Что значит? Межу прочем, не я предложил, что функции с числом аргументов >=3 не нужны.
>эта функция увеличивает число на единицу
Так. Но типизация тут не поможет.
>Типы нужны людям, чтобы нагляднее видеть, что функция делает
Не для этого. Я же написал, для чего.
Для понимания (вычислительного) смысла функции тип содержит слишком мало информации - почти ничего.
>преобразует ее в функцию от a и b
Да не преобразует он её. Я же писал уже: curry x y z = x (y, z). Ну где здесь преобразование? Что это такое, вообще?
Полагаю, количество аргументов терма T осмысленно будет определять как кратность (n) аппликации вида (T M₁ … Mₙ) для образования означиваемого терма.
>Межу прочем, не я предложил, что функции с числом аргументов >=3 не нужны.
Ну так вроде вот этот конкретный наш диалог и не имеет никакого отношения к тому предложению, разве нет?
>Так. Но типизация тут не поможет.
Конечно поможет, ведь тип имеет дескриптивное имя. "increment : Num -> Num" полностью достаточно для понимания того, что это объявление делает (инкрементирует число).
>Не для этого.
>Да не преобразует он её.
Ну ок, лол.
>Ну где здесь преобразование?
Эм, ну (curry f) возвращает функцию g соответствующего типа. autism-intensifies.png
>Полагаю, количество аргументов
Не совсем понял, к чему этот абзац. Алсо, определение выглядит кольцевым.
>дескриптивное имя
Ничего не гарантирует. В общем случае не отражает все существенные детали.
>инкрементирует число
А как именно? А может умножает на 10? А может отображает в 0? А может это id?
>Не совсем понял, к чему этот абзац.
Предположение как определить количество аргуменов терма более осмысленно, чем в духе каррирования. В случае карриования всё и так ясно. Хотелось бы понимать число аргументов функции как общее количество термов параметризующих вычисление, которое определяет терм.
>определение выглядит кольцевым.
Где?
function getDistance(x1:int, y1:int, x2:int, y2:int):uint {}
function drawButton(x:int, y:int, buttonText:String, w:uint, h:uint):void {}
function networkConnection(host:String, port:uint, tryReconnect:Boolean):void {}
>А как именно? А может умножает на 10?
Ну, в cs у этого слова все-таки одно вполне понятное значение. В целом, лично у меня нет особого интереса продолжать разговор на эту тему, да и тред про другое.
>Предположение как определить количество аргуменов
Ну мне кажется все и так понимают, что такое "количество аргументов", а давать строгое определение вне конкретного формализма особого смысла нет.
>Где?
>>Полагаю, количество аргументов терма T...
>>...для образования означиваемого терма (то есть Т).
Получается, из (T M_1..M_n) у тебя образуется T. Но ты под "означиваемым" что-то другое имел в виду, очевидно. (Впрочем, опять же, не вижу смысла об этом рассуждать вне конкретного формализма.)
Все перечисленные тобой функции должны принимать структуру.
Кстати, я поражаюсь количеству вкатывальщиков, которое привлек этот тред, лол.
distance : (Point Point -> Num)
draw : (Context Widget -> Context)
Последнее это вообще какая-то шизофазия. В общем случае connect : (Config -> Connection).
аргументы функции это конвенция передачи параметров через стек, а функция это лишь частный случай JMP.
я бы вообще сказал, что функции не нужно. только basic и goto, только хардкор.
Это такой тонкий стеб путем пародирования вконец поехавших байтоебов, лол? Неплохо, анон, оценил.
>вне конкретного формализма
Почему вне? Я предполагал системы переписывания термов: Λ или CL.
>Получается, из (T M_1..M_n) у тебя образуется T
Нет. С помощью терма T образуется "n-кратная" означиваемая аппликация вида (T M₁ … Mₙ). В отличие от неё аппликация (T M₁ … Mₙ₋₁), например, редуцируется до некоторой нормальной формы, но не до значения. Значит аргументов недостаточно.
>Ну, в cs у этого слова все-таки одно вполне понятное значение.
Сейчас бы по сигнатуре функции прозревать детали её реализации. Впрочем, если ты - телепат, никаких проблем.
>тред про другое
Согласен. Но ты же сам предложил обходиться типами для понимания смысла функций.
>Нет.
Ну я потому и написал, что ты, очевидно, имел в виду не то, что написано, см:
>Сейчас бы по сигнатуре функции прозревать детали её реализации.
См.: и следующий пост.
>Согласен.
Ну вот и славно.
Чтобы уже точно сменить тему, предлагаю обсудить, нужны ли двухаргументным функциям first-class таплы и какой тип будет у (полифорфных по количеству аргументов) apply и compose.
>Назовите хоть один пример функции, которой нужно принимать >=3 аргументов, и я поясню, почему вы неправы и пишете говнокод.
Point Point Point -> Plane
Поясняй.
Line Point -> Plane
Зачем 2? Любые аргументы можно заменить одним parameter object'ом.
Зачем аргументы функции вообще? Можно завести один глобальный стэк и пихать все в него.
Функции с количеством параметров отличным от одного нужны только для оптимизации (то есть чтобы не создавать кучи промежуточных каррированных функций)
Мочерок, иди нахуй.
(Автор этого поста был забанен. Помянем.)
Что угодно можно заменить (почти) чем угодно, но не всегда это имеет смысл. Бинарные функции выражают базовую идею композиции двух разных вещей. Если ты знаешь, как из соединить две вещи, то ты легко можешь обобщить это на n вещей. Алсо, попробуй сходу (без гугла!) привести пример тернарной операции из математики.
Оптимизации компилятора (и карринга в частности) не имеют никакого отношения к логической арности функций. Алсо, только что полтреда это обсуждали, лол, посмотри выше посты (и не вскрывай эту тему еще раз, пожалуйста).
Чет проиграл и зарепортил, разумеется.
>Чет проиграл
Вся твоя жизнь в двух словах.
>Назовите хоть один пример функции, которой нужно принимать >=3 аргументов
Функция, которая считает корни квадратного уравнения, например.
P(x) = \sum[k](a_k x^k). Иными словами, коэффиценты полинома задаются вектором [a_0..a_n], и квадратное уравнение - это просто частный случай при n=2.
Вместо аргументов векторы.
Чего? Не понял, что ты сказать хотел.
Если проще объяснять: функция нахождения корней многочлена принимает один аргумент - этот многочлен.
А еще можно ПРИНЯТЬ все предыдущее состояние программы.
Зачем?
> Алсо, попробуй сходу (без гугла!) привести пример тернарной операции из математики
Я не он, но что в голову сразу приходит, так это смешанное произведение векторов.
Конечно, его можно представить через скалярное и векторное произведение, но всё-таки его лучше иметь для него представление, в качестве отдельной функции о трёх аргументах.
В принципе, этот пример аналогичен : с одной стороны вроде бы и легко подобрать бинарный аналог, но с другой вроде лучше бы без него обойтись - и при этом если использовать именованные параметры, то они будут иметь имена уровня b a, b, c. Но, во-первых, тут возникает мысль, почему бы не обобщить на произвольное n; а во-вторых - в англоязычной литературе, например, обозначение (a,b,c) не используется.
Наконец, проблему бессмысленных имен в рекордах можно решить позиционными конструкторами для этих самых рекордов. Тогда:
a × b или a cross b
но
triple{a, b, c} или triple{first:a, second:b, third:c}
Можно даже заменить {} на обычные круглые скобки, и тогда вообще никто даже подвоха не заметит.
> Назовите хоть один пример функции, которой нужно принимать >=3 аргументов,
найти площадь треугольника по трем точкам.
Еще один, лол. Это унарная функция треугольник -> площадь треугольника.
егорушка это ты? ок, тогда "создать треугольник с заданными тремя точками".
Структура.
Тебе бы какой-нибудь учебник по cs для старшеклассников почитать, анон.
> Назовите хоть один пример функции, которой нужно принимать >=3 аргументов,
Вообще, таких функций море. Банально они могут родиться в ходе построения мат. модели, для которой пишем программу.
Вполне может случиться так, что у тебя есть функция, считающая что либо и имеющая вид, например
f(a, b, c, d) => c * cos(d) / a + b
Причём все параметры вполне могут быть независимы и структурно не являться частями одной сущности. Так что однозначно заявлять, что больше двух функций не надо глупо. Всегда стоит помнить о научном софте для конкретных рассчётов, в котором может родиться и не такое
Вообще, таких функций море. Банально они могут родиться в ходе построения мат. модели, для которой пишем программу.
Вполне может случиться так, что у тебя есть функция, считающая что либо и имеющая вид, например
f(a, b, c, d) => c * cos(d) / a + b
Причём все параметры вполне могут быть независимы и структурно не являться частями одной сущности. Так что однозначно заявлять, что больше двух функций не надо глупо. Всегда стоит помнить о научном софте для конкретных рассчётов, в котором может родиться и не такое
* двух аргументов
быстрофикс
С чего ты сделал вывод что я его не читал? то что вы предлагаете хуету которая не применима в реальной жизни говорит только о том, что вы шизики из академии, не видившие реальных проектов.
С этого:
Анон, посмотри вот этот пост, там я по большому счету ответил на этот твой поинт:
Любая такая функция будет естественным образом зависеть от имен аргументов. Конечно, можно и c * cos(d) / a + b написать в tacit-стиле, но... это очень мозгоебно получится если только тебя зовут не Слава, лол. Более того, над такой функцией не будет никаких естественных трансформаций аргументов типа flip : ((a,b) -> (b,a)). На самом деле, она ничем не отличается от какой-нибудь connect(host, port, timeout, onSuccess, onFailure) - разница только в том, что здесь аргументы более абстрактные, а потому им трудно дать короткие дескриптивные имена (ну не писать же arg-to-cos вместо d, в самом деле).То есть логически эта функция имеет именованные параметры (тапл\рекорд) и является унарной.
Давай, поясняй за спецификацию
developer.mozilla.org/ru/docs/Web/API/CanvasRenderingContext2D/drawImage
> Назовите хоть один пример функции, которой нужно принимать >=3 аргументов
Сложить три строки
> .cpp
По определению говнокод если ты об этом.
В методах 3 параметра хватает, как правило. В функциях нет, и ты сосешь хуй.
>Я надеюсь, что это неудачная шутка
>Твоя функция не функция ррряя!
А ты точно программист?
Уже было.
concat : Str Str -> Str, дальше сам догадаешься?
Есть такое, да.
Лол, ну тогда все плохо, анон. Тебе в ньюфаготред.
Алсо, все еще поражаюсь. Практически каждый первый ответ - вкатывальщики и прочие первый-курс-не-школота. Как от них защищаться-то? В (некоторых) других тредах такого пиздеца нет.
strncpy( char destptr, const char srcptr, size_t num )
А такой вариант?
>эти маневры
тащемта программисты, внезапно, программируют компьютеры, которые выполняют какую-то работу. и, представь себе, иногда программистам действительно нужно читать данные из сокета, а не только слаживать векторы и находить площадь треугольника.
я надеюсь ты понимаешь, что жидко серишь в этом треде? твои вскукареки имеют мало отношения к профессии программирования.
>Положняк такой: функции с 3 или больше аргументами НЕНУЖНЫ.
Излишество. Каждая функция должна принимать только один аргумент, да и то неявно.
Какой?
>concat : Str Str -> Str,
Прощу прощения за нубский вопрос. Что значит эта запись? Что за нотация и как её расшифровывать?
>concat
Это название функции?
>Str Str
Это два аргумента?
>-> Str
Это типа возвращаемое значение?
Зачем использовать несколько функций с двумя аргументами, если можно одну с бОльшим количеством?
интырфейс сеграгатион принцып
Можно вообще без аргументов. Передавать параметры через глобальные переменные и возвращать значения через них же.
В общем-то выше уже обсуждали. Вместо num+srcptr должен быть один параметр - слайс. В том же расте это так и работает.
Ньюфаготред тут:
Ну, рекорды даже в паскале есть, так что по идее вообще любой. Чего-то специфического для старшеклассников я посоветовать не могу, извиняй. Разве что htdp?
"конкат имеет тип: функция из пары (Str, Str) в Str". Нотация - обычная нотация для комплюктер сцайенс, x : t обычно означает "икс имеет тип тэ", стрелочка обычно означает функциональный тип; сравни с х-лем, например: concat :: String -> String -> String. На все остальные вопросы ответ "да".
Можно и срать, не снимая свитер, да.
>Можно и срать, не снимая свитер, да.
Именно этим ты тут целый тред тред и занимаешься.
>срать, не снимая свитер
А зачем его снимать?
https://github.com/fantasyland/fantasy-land
освящаю этот итт тред
освящаю этот итт тред
js
[1,2,3,4,5].reduce((x, y) => x + y)
У тебя функция принимает три аргумента.
(,,)
data Point = Point Float Float Float
Ну ты понел. Вот только не надо тут, что "конструкторы - это не функции".
Вот только ты не сможешь написать функцию нахождения корней для произвольного полинома. А для квадратичного - можешь, и у неё тогда будет ровно три аргумента.
map :: (a -> b) -> ([a] -> ) как раз естественнее в унарной форме, как и zipWith, обе лифтят функцию на уровень списков.
Си так то тоже ЯП высокого уровня. То что ты не можешь двинуться дальше хелловорлда не означает, автоматически, что язык становится ассемблером.
Так что давай поясняй за memcpy, хуесос
> Си так то тоже ЯП высокого уровня.
Как оно там, в 70-х?
Проигал с вас. Зачем на такую очевидную толстоту отвечать?
>лифтят функцию
Чего?
>уровень списков
Что это?
Аргументы опа легко ломаются, если понять, что заворачивание множества параметров функции в структуру, написанную только для этой функции - это больший говнокод, чем их обычная передача.
Я не в курсе, но это уже, возможно, кто-то написал. Ситуация такая: я пишу на процедурке, мне нужна функция взятия подстроки. Аргументы, соответственно, такие: строка, индекс начала, индекс конца подстроки
Двух итераторов достаточно.
>итераторов
Говнокодер as is.
Впрочем, что с хацкельдебила взять.
Структура чего, девяти координат?
>хацкельдебила
А хуй ты угадал.
Всё же не стоит путать категоризацию вычисления (терма) и его параметризацию.
>функции
Нормальные люди используют методы
Нормальные люди используют методы
Как скажешь.
Чтобы не испачкался :3
>Algebraic
>JavaScript
/0
А вообще - спасибо, прикольная штука.
Два, ты чем читаешь?
Конструкторы - это не функции.
>ты не сможешь написать функцию нахождения корней для произвольного полинома
Численные методы не завезли?
>и у неё тогда будет ровно три аргумента.
Нет, один (полином).
Тоже хороший поинт. Но все-таки логичнее тогда давать ей более общий тип (х-льский fmap). Опять же, тут можно смотреть на мап как на функцию от списка или как на функциональный комбинатор. Первое выглядит лучше, если предполагается ад-хок полифорфизм. А второе выглядит более APL-но.
Алсо, можно же вообще все функции над последовательностями рассматривать как (хикковские) трансдьюсеры, тогда естественным образом это все будут функциональные преобразования.
Второй абзац прочитать мсье лабодел не осилил?
Ну представь, что у тебя есть тип t и функция, работающая с этим типом - например, (t -> t). И тут у тебя ВНЕЗАПНО появляется тип f<t>, зависящий от t. И тебе нужно твою функцию заставить работать с этим новым типом. То есть было (t -> t), а нужно (f<t> -> f<t>). То есть ты ее как бы "поднимаешь" (лифтишь) на уровень выше. Makes sense?
Алсо, не путать с лямбда-лифтингом.
Вот смотри. У тебя есть вызов: (substr "foo" 0 1). Что такое 0? Что такое 1? Какие-то беспонтовые magic numbers, хуй поймешь что они значат, пока в документацию не посмотришь. А лучшая документация, как известно, - та, которую не нужно писать. Так что вне зависимости от темы этого треда, подобные функции всегда должны принимать именованные аргументы: "foo".substr(from: 0, to: 1). Ну и чисто случайно тогда получается, что функция принимает как раз два аргумента (строку и слайс-to-be) и имеет вид (t x -> t).
Алсо, перед тем как ты скажешь ОЧИВИДНА ЖИ НУ СЛЕВА НАПРАВО ЖИ ЗНАЧИТ СПЕРВА ИНДЕКС СТАРТА ПОТОМ ИНДЕКС КОНЦА, я напомню, что евреи - самый могущественный народ в мире, на минуточку - пишут справа налево.
Не понимаю месседжа ОП-поста. Очевидно, что любую функцию f(x,x1,x2...) можно превратить в функцию f(struct), где struct = {x1,x2..}.
Но что поменяется от этой словесной эквилибристики? Логика работы? Память? Нихуя не поменяется, это просто жонглирование словами. Это такой же мусор как ифлесс дурачки. Соотвественно, ОП - пидор, а его мать шлюха. /тред
Но что поменяется от этой словесной эквилибристики? Логика работы? Память? Нихуя не поменяется, это просто жонглирование словами. Это такой же мусор как ифлесс дурачки. Соотвественно, ОП - пидор, а его мать шлюха. /тред
>ифлесс дурачки
Так это он и есть
Пфффф
>в функцию f(struct), где struct = {x1,x2..}.
Я не это предлагаю. Постарайся читать внимательнее, прежде чем отвечать.
>это просто жонглирование словами
As a side note, все программирование да и вся математика, кстати, тоже состоит исключительно из синтаксических преобразований, то есть "жонглирования словами".
"Ифлесс дурачком" является, например, Боб Харпер - надеюсь, не нужно объяснять, кто это такой. Кроме того, иф - это просто одна специфическая функция, в которой нет ничего фундаментального, так что нет никакого смысла заострять на ней внимание. С тем же успехом можно говорить о "гото-лесс дурачках", например.
Ну откуда столько лабоделов с процедурщиной головного мозга лезет? Process - это рекорд, не нужно никаких функций для его создания.
Кроме, быть может, бинарной функции ассоциации пары label+value к имеющемуся рекорду, если наща система типов это поддерживает.
>Ифлесс дурачком" является, например, Боб Харпер
Аппеляция к авторитету не аргумент.
>надеюсь, не нужно объяснять
Нужно.
>математика, кстати, тоже состоит исключительно из синтаксических преобразований, то есть "жонглирования словами"
С этого и надо было начинать.
Функции больше чем с 1 аргументом не нужны.
Для передачи нескольких значений существуют списки/структуры/кортежи.
>Я не это предлагаю.
>Все функции должны принимать либо 0 аргументов (тогда это и не функции вовсе), либо 1 аргумент (унарные функции), либо 2 аргумента (бинарные функции). Все остальное нужно запретить (code convention'ом или компилятором).
В глаза ебешься, собственно ничего необычного. ВЕсь тред маневров и порваной сраки ОПа-хуя.
А о чем спор-то? Не вижу утверждений для опровержения, кроме "ррряя ифлесс-дурачок))".
http://existentialtype.wordpress.com/
Ну это любому совершеннолетнему посетителю этого раздела должно быть очевидно, разве нет?
>любую функцию f(x,x1,x2...) можно превратить в функцию f(struct)
>Все функции должны принимать либо 0 аргументов (тогда это и не функции вовсе), либо 1 аргумент (унарные функции), либо 2 аргумента (бинарные функции).
Если ты не видишь разницы между этими двумя пропозишнами, то тебе в /me, анон.
Кортежи - антипаттерн. Списки - антипаттерн.
Вместо первых всегда должны использоваться структуры, а вторые попросту ненужны.
Если же ты предлагаешь все-таки использовать кортежи и арифметику, например, типизировать как + :: ((Num, Num) -> Num), то у тебя получаются функции, которые только технически имеют (якобы) 1 аргумент, а на самом деле являются многоаргументными (выше по треду мы этот нюанс уже обсудили, можешь глянуть). И в таком случае лучше предпочесть карринг кортежам энивей.
>Ну это любому совершеннолетнему посетителю этого раздела должно быть очевидно, разве нет?
Тебе видней. Отправляйся в /math/, там тебе ещё видней станет.
>Кортежи - антипаттерн. Списки - антипаттерн.
Одно утверждение офигительней другого. Доказывать их ты, конечно, не будешь?
>Тебе видней.
Тут не поспоришь, да.
Кортежи - это рекорды с имплиситными именами. Режем их бритвой Оккама. Списки - это вообще артефакт из 80-ых; вместо них давным-давно используются tree-like структуры данных. Stelee разбирал эту тему, погугли "cons cosidered harmful" или что-то в таком духе.
>Если ты не видишь разницы между этими двумя пропозишнами, то тебе в /me, анон.
Тебе просто неприятно, что тебя обоссали даже на уровне голой теории.
В изначальном утверждении не было ограничений на типы аргументов функции, соответственно структура - валидный аргумент, поэтому каждая функция может быть сведена к 1-3 параметрической и твое утверждение рассыпается как карточный домик.
>Режем их бритвой Оккама
Почему не рекорды?
>структуры данных
Выплюнь гадость.
Братишка, я тебе Oberon принес. Ссылки, да с такими-то nil'ами, алгол 68 сосет!
Почитай начало треда.
Потому что рекорды заменяют кортежи, но не наоборот.
М?
>Братишка, я тебе Oberon принес.
Выплюнь гадость. ^_^
>М?
Структуры данных - это муть, эрзац топосов для неосиляторов. Даже сочетание этих слов - кромешное недомыслие.
>но не наоборот
Почему, это?
И по совместительству это устоявшийся термин с понятным всем значением. Если ты хочешь заменить "tree-like структуры данных" более удачным выражением, то можешь не стесняться, а просто взять и заменить.
Имен нет.
>понятным
Хрен там плавал. Как и любая словемная муть - для иллюзии понимания и успокоения сомнений.
>Имен нет.
Какая .. жаль.
Вот была функция y = f(x,y,z) - плохая уебищая, громоздкая запись. Быдлоговнокод. Так писать не надо
А вот y = f(x, g(y, z)) - совсем другое дело. Красивый, великолепный, замечательный код. Только выиграли, ввели функцию g( y, z) и избавились аж от двух аргументов x, y, добавив всего-лишь промежуточную функцию g.
Господи, до чего же функциональное программирование прекрасное и элегантное.
А вот y = f(x, g(y, z)) - совсем другое дело. Красивый, великолепный, замечательный код. Только выиграли, ввели функцию g( y, z) и избавились аж от двух аргументов x, y, добавив всего-лишь промежуточную функцию g.
Господи, до чего же функциональное программирование прекрасное и элегантное.
При чем тут функциональное программирование? Алсо, какой-то идиотский пример. Почитай тред, выше уже разбирали кучу примеров.
Адекват итт
Семен итт
Мойша Шейнфинкель рад этому треду.
inb4 каррирование
Предлагаю в честь солидарности с нашим соотечественником сгноенным в подвалах большевиками, кстати впредь использовать термин "мойшинг". Ну или хотя бы "шейнфинкельшинг".
Увы, момент потерян, надо было это делать в конце 90х, начале нулевых, пока программистская терминология формировалась. А так - мойшинг отличное трололо.
>в конце 90х, начале нулевых, пока программистская терминология формировалась
Ты хотел сказать пока декоммунизация еще была актуальна?
>А так - мойшинг отличное трололо.
So be it! К тому же ассоциаций с запахами немытых индусов не вызывает, в отличие от.
Странно, что никто не упомянул про put(map, key, val)
Кажется, мы стали забывать...
>Назовите хоть один пример функции
заливка прямоугольника по координатам, сосни манька
draw (Context, Shape) -> Context
Какая-нибудь fold(list, callback, initialValue);
>Назовите хоть один пример функции, которой нужно принимать >=3 аргументов,
get_something_by_key(collection, key, default)
inb4 завернуть в монаду Maybe
Выше обсуждали, поищи в треде по "fold".
>завернуть в монаду Maybe
Очевидно, не правда ли?
Функция должна принимать ровно один аргумент, иначе это и не функция вовсе
>Очевидно, не правда ли?
А нахуя? Потом накатывать maybe(default, get_something(collection, key)) ? Дольше же писать.
А тут от другого анона вопрос похожий, что скажешь?
>чем отличается функция от метода.
ничем, удаляй паскаль
>Дольше же писать.
Я не вижу смысла ради экономии пары символов нарушать принцип single responsibility. Алсо, у тебя какая-то хуйня написано, на самом деле это выглядит как-то так: val = get(coll, key) || default.
>вопрос похожий, что скажешь?
Мапы - это последовательности пар ключ-значение, по идее. Так что put(m, [k v]). Хотя наверное лучше все-таки использовать описанные выше именованные аргументы, то есть в итоге будет что-то вроде m.put(key: "foo", val: 42). Есть еще предложения?
>put(m, [k v])
Почему бы тогда все аргументы в тапл не завернуть?
>m.put(key: "foo", val: 42)
Тут все равно остается три аргумента: m неявный аргумент.
>Есть еще предложения?
А смысл? Если в принципе можно всё в таплы/рекорды попихать и быть довольным с функцией одного аргумента? Даже двух не надо.
>Почему бы тогда все аргументы в тапл не завернуть?
Потому что это тупо и бесполезно, выше по треду подробно обсуждалось.
>Тут все равно остается три аргумента: m неявный аргумент.
Здесь два аргумента: m<K,V> и {key: K, val: V}.
>А смысл?
Опять же, см. выше по треду.
Есть такая функция:
school_dot m1 m2 a = m1 m2 cos a
В паскале процедуры
К А Р Р И Р О В А Н И Е
А
Р
Р
И
Р
О
В
А
Н
И
Е
А
Р
Р
И
Р
О
В
А
Н
И
Е
Что?
Ненужно.
А если у меня аргументов два-три, но один из них это структура на 5 членов?
Садись на все.
printf("Автор этого поста - %s. Кто он? %s. Что он сосет? %s.", op, pidor, huj);
drawRect(int x, int y, int width, int height);
Это нормально, если твоя структура действительно представляет собой какую-то конкретную сущность.
Два аргумента - строка и список подстановок. Откуда в этом треде столько дебилов-вкатывальщиков?
draw : (Context, Shape -> Context). Rect - это рекорд или класс. Зачем ты вылез из ньюфаготреда?
А ты из под шконки вылези, Дейкстра недоделанная. Похуй, что неудобно, зато 3 аргумента.
>какую-то конкретную сущность.
Человек не видел WIN API...
Конструктор вектора в 3D
>зато 3 аргумента.
Оп-пост хотя бы прочитай, школотрон.
Ну почему, говнища я много всякого повидал.
Конструктор. А речь о функциях. Обсуждали сотню раз выше по треду.
>Конструктор. А речь о функциях.
Конструктор и есть функция, вылезай из своих маняабстракций, растоман.
>Оп-пост хотя бы прочитай, школотрон
Боже, я не заметил, что ты пишешь, что функции даже на 3 аргумента не нужны. Ору, конечно, гений кода.
->
Всегда удобно не ответить по сути и выдать загадочную хуйню.
Покажи мне хоть одну баблиотеку, в которой ббольше 100 строк кода, и которая следовала бы этим правилам.
Нашел? ок. Теперь найди такой фрейцмворк,адепт теор. программирования.
Зачем тебе функции?
Тебе нужно только сплочение и патриотизм.
(И ещё начальная школа и тюрьма.)
Тебе нужно только сплочение и патриотизм.
(И ещё начальная школа и тюрьма.)
def print(*args, sep, end):
sys.stdout.write(sep.join([arg for arg in args])+end)
Самое лёгкое что вспомнил, лол
Ясно, что многомерный
массив можно элементарно свести к одномерному (и даже двумерность не требуется.
Но это никак не оправдывает маразматично хаявления этого субъекта.)
массив можно элементарно свести к одномерному (и даже двумерность не требуется.
Но это никак не оправдывает маразматично хаявления этого субъекта.)
Залетный из ньюфаг треда /ph/ отсылает почтенных мужей в ньюфаг тред /pr/, умилительно.
Ничего, ОП, вот окончишь второй курс и рано или поздно свыкнешься с мыслью что откровения, которые ты вычитал для себя в статье про логический позитивизм на вики совсем не откровения для взрослых людей.
Ничего, ОП, вот окончишь второй курс и рано или поздно свыкнешься с мыслью что откровения, которые ты вычитал для себя в статье про логический позитивизм на вики совсем не откровения для взрослых людей.
Всегда удобно съебать обратно в ньюфаг-тред.
Показал, проверяй личку.
Аппроприэйт подпись у тебя.
Параша, авторы которой не слышали про single responsibility principle. Намешали говна в кучу и рады. ЗАТО УДОБНО!!1 Ты и сам видишь, что там только бинарные функции: джойн, конкатенация, запись в поток. Если хочется иметь именно такой принт, то следует использовать именованные аргументы (выше уже обсуждали).
Чего, блядь? Иди таблетки прими, шизик.
Показал, проверяй личку.
Аппроприэйт подпись у тебя.
Параша, авторы которой не слышали про single responsibility principle. Намешали говна в кучу и рады. ЗАТО УДОБНО!!1 Ты и сам видишь, что там только бинарные функции: джойн, конкатенация, запись в поток. Если хочется иметь именно такой принт, то следует использовать именованные аргументы (выше уже обсуждали).
Чего, блядь? Иди таблетки прими, шизик.
>Вы все говно! Говно! УУУУУ!!!! Говно! Моча!
Содержательно.
>Что?
Макаба звездочки съела.
school_dot m1 m2 a = m1 × m2 × cos a
Скалярное произведение векторов же.
Смотришь в книгу - видишь фигу.
Скалярное произведение для двух векторов определяется вообще-то. Алсо, выше уже подробно обсуждали разные произведения векторов, почитай.
Ну да. Умножаешь магнитуды двух векторов на косинус угла между ними и вуаля. Теперь покажи как эту функцию запилить с одним-двумя параметрами.
В этой задаче вектора заданы не координатами, а магнитудами и углом. Т.е. координаты взять не откуда.
А, хоспати, ты про это. Ну ты можешь либо повыебываться и принимать пару векторов и угол, либо просто использовать именованные параметры, выше это уже обсуждали в контексте математических функций.
Все ясно с твоими манёврами.
Совсем шизик?
Ты чтоли оп треда про мейби списки? Тогда всё ясно.
>Назовите хоть один пример функции,
Найти медиану множеств.
ОП пытается сказать, что не бывает таких ситуаций, когда необходимо послать три аргумента, я все правильно понял? Нет, ну вообще, если мы мыслим а том,о можно сделать, а не о том, что следовало бы, можно вообще в том же c# переписать ВСЕ функции под один аргумент, передавая массив []object, вот вообще без проблем. Код пишут для того, чтобы легче его поддерживать было. Компилятору по большому счёту до лампочки в большинстве случаев, два или три.
ОП путает математические функции с программированием
Ждем от ОПа reduce с двумя или одним аргументом.
Скажу за ОПа - заверни все аргументы в рекорд.
Ага - больше 2-х аргументов нельзя, а тапл с 100 элементов - норм. Тапл же один.
Логика!
Объединение разных цепочек в rxjava.
Комбинатор S
/thread
> >высокоуровневых языках,
> Ok, вот сишарп, чтение из сокета
> public IAsyncResult BeginReceive(
> \tbyte[] buffer,
> \tint offset,
> \tint size,
> \tSocketFlags socketFlags,
> \tout SocketError errorCode,
> \tAsyncCallback callback,
> \tobject state
> )
Ебашу класс с полями buffer offset size socketflags errorcode callback, заполняю его и отправляю в метод как первый параметр, обжектстейт будет как второй
Хуле нам, далбаебам
Тебя и там шизиком назвали, лол?
Выше уже обсуждали аналогичные случаи.
О том и речь, что если аргументов больше 2, то стоит ради читаемости и всего святого, что есть на этой планете, использовать именованные аргументы, как смолток-диды завещали.
Выше уже подробно обсуждали, почитай тред.
Зачем там больше двух аргументов?
Ненужно, ведь есть cake.
Выше уже обсуждали аналогичные случаи.
О том и речь, что если аргументов больше 2, то стоит ради читаемости и всего святого, что есть на этой планете, использовать именованные аргументы, как смолток-диды завещали.
Выше уже подробно обсуждали, почитай тред.
Зачем там больше двух аргументов?
Ненужно, ведь есть cake.
На архитектуре AMD64 Micosoft ABI- три аргумента для extern "C" функций , по числу аргументов, передающихся в регистрах.
Для методов классов - два ааргумента, потому что один регистр отъедает this.
/thread
Байтоеб в треде, все в регистры.
>Ненужно
Ты скозал?
Разные источники данных -> разные цепочки -> их надо каким-то образом объединить -> несколько аргументов функции
Дя ^_^
То есть про списки ты не слышал, так?
Всегда работаешь с указателями на структуры
@
Никаких проблем
мимо-пишу-драйвера-под-линукс
C ncruses когда-нибудь работал?
Там функции типа
void print_title(WINDOW ⁕win, int starty, int startx,
int width, char ⁕string, chtype color);
в порядке вещей.
Ты еще вонючий WinAPI с его монструозными функциями вспомни - это сделает ОПа неправым что ли?
Функций с более чем 1 аргументом просто не бывает.
N аргументов - это, на самом деле - один N-tuple.
Так что ОП-хуй.
/thread
Уважуха мужикам!
Да я много с каким говнокодом работал, но тред-то не про это.
>N аргументов - это, на самом деле - один N-tuple.
Про карринг мойшинг мсье, видимо, не слышал.
Когда разберешься чем tuples отличаются от currying, тогда и заходи.
Карринг, хуярринг - какое это сюда имеет отношение вообще?
Если вы не поняли, о чём речь, попробуйте понять.
Ебал ваш рот, тоже хочу таким умным быть.
>Карринг, хуярринг - какое это сюда имеет отношение вообще?
А исходники ядра linux видели?
Там немало функций типа
void __wait_rcu_gp(bool checktiny, int n, call_rcu_func_t ⁕crcu_array, struct rcu_synchronize ⁕rs_array);
>Положняк такой: функции с 3 или больше аргументами НЕНУЖНЫ.
Правильно ли я догадываюсь, что ты с таким убеждением так и не написал ни одной широко востребованной программы?
По делу есть что сказать?
Речь о высокоуровневых языках.
Для графики - vector(x, y, z)
Для БД - add(id, name, desc)
Для расчет промежутка времени - period(time1, time2)
И много других подобных примеров.
Иди нахуй школьник.
Открой для себя алгебраические типы данных.
Исходники redox kernel видели?
fn file_op(a: usize, fd: FileHandle, c: usize, d: usize) -> Result<usize>
slozhit_chetire_chisla(a, b, c, d) { return a + b + c + d; }
Хорош, ОП обоссан. Ждём оправданий.
Зачем нужны эти параметры? Кто мешает все эти 4 параметра в один тип упаковать?
И че?
>Кто мешает все эти 4 параметра в один тип упаковать?
Нахуя?
Это и есть один тип.
Круглые скобки по бокам видишь?
Ну и вот - это 4-tuple.
Для меня до сих пор остается загадкой, почему именно этот тред привлекает такое огромное количество не очень умных людей. Причем они пишут раз за разом одно и то же, как под копирку. Мне бы даже хотелось верить, что это полтора семена тут создают видимость такого низкого интеллектуального уровня доски, но, увы, вероятность такого исхода ничтожно мала.
Нет, анон. Раст не поддерживает именованные компоненты в таплах. Это не тапл, а синтаксис вызова функции. Чисто формально можно считать любую функцию принимающей тапл, так как в расте нет карри^W мойшинга, но в этом нет никакого смысла (и это уже осбуждалось в начале треда, почитай).
Кроме того, это очень плохой пример кода. Параметры с именами a,c,d типа usize - это просто квинтэссенция говнокодерства впрочем, я предполагаю, что это не реальная строка оттуда, а просто contrived пример. Случаи, в которых действительно необходимо использовать рекорды с несодержательными именами мемберов, уже подробно описали в начале треда (правда, почитай).
>Исходники redox kernel видели?
Вот ещё оттуда
fn futex(addr: &mut i32, op: usize, val: i32, val2: usize, addr2: *mut i32) -> Result<usize>
> Назовите хоть один пример функции, которой нужно принимать >=3 аргументов
int sum(const double ★arr1, const double ★arr2, double ★result)
Смотрим исходники servo
fn create_cached_response(request: &Request, cached_resource: &CachedResource, cached_headers: &Headers, done_chan: &mut DoneChannel) -> CachedResponse
fn handle_range_request(request: &Request, candidates: Vec<&CachedResource>, range_spec: &[header::ByteRangeSpec], done_chan: &mut DoneChannel) -> Option<CachedResponse>
ОПа закормили уже хуями, лол.
Он, наверное, так счастлив никогда раньше не был.
Он, наверное, так счастлив никогда раньше не был.
>val
>val2
>addr
>addr2
Коуд квалити из аур хайест прайорити! Ты бы хоть доку или сурс скинул, телепаты в отпуске. Сама операция принимает addr и val, а что они в своей реализации наворотили яхз.
Отличный пример кода, в котором обязательно должны использоваться именованные параметры, спасибо.
Изливай свои проекции в /ga.
>Смотрим исходники servo
Ещё
fn new_resource_threads(user_agent: Cow<'static, str>, devtools_chan: Option<Sender<DevtoolsControlMsg>>, time_profiler_chan: ProfilerChan, mem_profiler_chan: MemProfilerChan, embedder_proxy: EmbedderProxy, config_dir: Option<PathBuf>) -> (ResourceThreads, ResourceThreads)
fn classify(&self, context: LoadContext, no_sniff_flag: NoSniffFlag, apache_bug_flag: ApacheBugFlag, supplied_type: &Option<MimeType>,
data: &[u8]) -> MimeType
Двачую.
ОП, я вот тоже стал загоняться над этим и пришлось перейти на ассемблер, там инструкции обычно по 1-2 операнда принимают.
Теперь вот работаю в НИИ, кайфую, пишу на x86 ассемблере в NASM.
Ну ты черт. Давай привнесем матбазы в твою воду и вспомним, что функция - частный случай оператора. А среди них бывают и тернарные.
Лол. Не, серьезно?
>функция - частный случай оператора
У вас какая-то неправильная матбаза.
string hui(int a, int b, int c){
...
return trun;
}
|
|
(стрелочка типо вниз ага)
struct spesialno_for_hui{
int a, b, c;
}
string hui(spesialno_for_hui ssssssssy_na_ebalo){
int a = ssssssssy_na_ebalo.a, b = ssssssssy_na_ebalo.b, c = ssssssssy_na_ebalo.c;
...
return trun;
}
Бинарные функции не нужны
...
return trun;
}
|
|
(стрелочка типо вниз ага)
struct spesialno_for_hui{
int a, b, c;
}
string hui(spesialno_for_hui ssssssssy_na_ebalo){
int a = ssssssssy_na_ebalo.a, b = ssssssssy_na_ebalo.b, c = ssssssssy_na_ebalo.c;
...
return trun;
}
Бинарные функции не нужны
ФУНКЦИЯ выебать_мамку_опа(ХУЙ в_ротан, ХУЙ в_пиздень, ХУЙ в_анус);
Очевидная хуйня. Функции должны быть разделены по уровням абстракций и если на одном уровне необходимо выполнить что-то с количеством аргументов >2, то не нужно хуячить говно типа оберток для аргументов, оставь это для фанатиков уровня https://habr.com/company/piter/blog/418157/
тест
>https://habr.com/company/piter/blog/418157/
Ну он как бы все правильно говорит (и любому более-менее опытному/любознательному разработчику это все должно быть очевидно), разве что примеры не всегда самые удачные.
Быдло не знает про каррирование.
Ну собственно да.
Ибо есть инкапсуляция.
JavaDebilFuncitonBean javaDebilFuncitonBean = JavaDebilFuncitonBeanFactory.createJavaDebilFuncitonBean()
javaDebilFuncitonBean.setParameter0(..)
javaDebilFuncitonBean.setParameter1(..)
...
javaDebilFuncitonBean.run()
JavaDebilFuncitonBeanResult javaDebilFuncitonBeanResult = javaDebilFuncitonBean.getResult()
Кажется, мы стали забывать...
Внатуре, он то нихуя дельного сказал, но ты то просто информационная бомба
> Если вы не поняли, о чём речь, попробуйте понять.
Тут очевидный список же.
ФУНКЦИЯ выебать_мамку_опа(ХУЙ *в_место, int число_смычков);
Тред не читал, сразу отвечал.
Все функции должны принимать либо 0 аргументов, либо 1 аргумент (структура с описанием всех входных данных). Всё остальное нужно запретить. Пруф ми ронг.
В динамическом языке это равносильно именованным аргументам, а в статическом заебешься структуры под каждую функцию делать.
>Все функции должны принимать либо 0 аргументов
Все функции принимают хотя бы 1 параметр на сам объект:
self, this итд
иди собирай портфель на понедельник
>Пруф ми ронг.
Выше по треду подробно объяснялось - глянь ближе к началу, если интересно. Заодно поржешь с местного контингента.
Алсо,
>либо 0 аргументов
>тогда это и не функции вовсе
Не заебешься, тоже уже обсуждалось - гугли rows, labels, intersection/union types, смотри выше.
Ну и говнокод. Неудивительно, что эта параша не взлетела.
У функции draw тип такой: (DrawingContext ctx, Sprite s -> DrawingContext), обыкновенная бинарная функция. Тыщу раз уже этот пример приводили.
Ты лох чмо твои доводы рушит любой конструктор с параметрами соси тварь привет здравствуйте
>253 строка
А ссылки на строки ты давать не научился еще, даун?
Не обижай местных ребятишек, у них еще все впереди.
Предлагаешь на каждую из этих функций завести структуру с параметрами? И ничего, что проблема большого количества аргументов не решается, а просто переходит на новый уровень?
Приведи пример кода для данного конкретного случая
Нормальную структуру, а не какой-нибудь кей-валуе лист.
Не атомарно же. А если твой волшебный читатель дед Пердед из соседнего отдела будет юзать?
Какого кода? Я тебе сигнатуру функции привел, дальше думаю сам сможешь разобраться, если не дурак.
Научи их Builder-паттерну, а не на двощах жалуйся.
Что мне твоя сигнатура, ты мне реальный код покажи (c#). На словах я тоже могу много каких сигнатур привести.
> 253 строка
На гитхабе можно делать ссылки на строку
https://github.com/MonoGame/MonoGame/blob/develop/MonoGame.Framework/Graphics/SpriteBatch.cs#L253
Или даже блок
https://github.com/MonoGame/MonoGame/blob/develop/MonoGame.Framework/Graphics/SpriteBatch.cs#L253-L262
>дальше думаю сам сможешь разобраться, если не дурак.
Ну, вы поняли.
>(DrawingContext ctx, Sprite s -> DrawingContext)
>Какого кода?
Сделал тебе тестовый "проект" за 5 минут. Покажи, что ты хотел сделать с этим.
https://pastebin.com/aAhxwr4G
Слив засчитан. Тред можно закрывать.
Некоторые функции требуют некоторое количество параметров, чтобы юзер смог влиять на работу функции.
Я что по-твоему должен в один параметр массив/объект ложить? Нахуй пройди.
Лично ты ничего не должен, ведь ты не имеешь никакого отношения к разработке софта, малыш.
> ведь ты не имеешь никакого отношения к разработке софта, малыш.
Давай ретурни свой брейнлог уже.
Два трехмерных вектора заданных параметрически. Решай это в двух аргументах, чмо мразь говно падла ну давай иди сюда я тебя сам трахну ублюдок мать твою говно собачье
>Два трехмерных вектора
>Два
Слышал про структуры?
ОП, отгадай загадку. Сколько параметров у функции f:A×B×C→D ?
У меня от тебя КАРРИРОВАНИЕ
один?
Не оп.
работал с несолькими библиотеками на сях когда то
весь интерфейс библиотеки представлял собой три функции - инициализирующую, закрывающую и выполняющую основную работу
главная функция принимала в себя структуры определенного типа, тип которой определялся первым полем этой структуры, и вторым параметром выплевывала вторую структуру в которой значит первое поле был размер выплевываемого, а вторым полем значит месиво байтов в виде результа, все это вы дело приводили к соотв структуре у себя в коде
ах, да, еще было два варианта работы - либо библиотека вам изнутри себя память под результат выдавала, либо вы соотв вызовом все той же функции могли передать ей выделенную память и она уже туда помещала результат
и еще было версионирование библиотеки - все у той же функции тем же макаром вы запрашивали какой она версии, и потом могли соответственно работать
ну и еще с парочкой библиотек работал с похожими принципами
конечно, такой подход имеет место быть
но, бля, вершина библиотекостроения на сишке, импо, это все равно com-интерфейсы, больше всего нравились они
потому что с наколенными поделиями все равно больше проблем было
весь интерфейс библиотеки представлял собой три функции - инициализирующую, закрывающую и выполняющую основную работу
главная функция принимала в себя структуры определенного типа, тип которой определялся первым полем этой структуры, и вторым параметром выплевывала вторую структуру в которой значит первое поле был размер выплевываемого, а вторым полем значит месиво байтов в виде результа, все это вы дело приводили к соотв структуре у себя в коде
ах, да, еще было два варианта работы - либо библиотека вам изнутри себя память под результат выдавала, либо вы соотв вызовом все той же функции могли передать ей выделенную память и она уже туда помещала результат
и еще было версионирование библиотеки - все у той же функции тем же макаром вы запрашивали какой она версии, и потом могли соответственно работать
ну и еще с парочкой библиотек работал с похожими принципами
конечно, такой подход имеет место быть
но, бля, вершина библиотекостроения на сишке, импо, это все равно com-интерфейсы, больше всего нравились они
потому что с наколенными поделиями все равно больше проблем было
И да и нет, с одной стороны конечно удобно, когда надо передать 1-2 аргумента, а не 4-5. С другой стороны, в развивающемся проекте код довольно динамичен и сегодня в функцию надо 3 аргумента, а завтра последний выкинуть и добавить 2 других, а после завтра выкинуть нахер эту функцию, а код ее раздербанить по другим методам.И не всегда, если агрегировать несколько аргементов один - будет реально нужная сущность, а не искуственно выдумая хрень для одного метода.
> И не всегда, если агрегировать несколько аргементов один - будет реально нужная сущность, а не искуственно выдумая хрень для одного метода.
Двачую этого.
Оп хуй
>Все функции должны принимать либо 0 аргументов (тогда это и не функции вовсе)
Это простые метки для переходов (замечательный мир ассемблера).
>либо 1 аргумент (унарные функции), либо 2 аргумента (бинарные функции)
Функция всегда возвращает значение, а как же процедуры, которые не возвращают значений?
>Все остальное нужно запретить (code convention'ом или компилятором)
Запрещать ничего не нужно, но ты можешь всегда написать свой "code convention" и предоставить свои труды на всеобщее обозрение осуждение.
>Назовите хоть один пример функции, которой нужно принимать >=3 аргументов, и я поясню, почему вы неправы и пишете говнокод.
Для начала предоставь свой не "говнокод", иначе любой разработанный код можно подвести под рамки "говнокода" с любой точки зрения субъективного самомнения, без исключений.
А какая вообще разница? Ну будет один аргумент, какой-нибудь тупль, и из него будем доставать все аргументы. Суть не меняется.
>ПОЛОЖНЯК ТАКОЙ: функции с 3 или больше аргументами НЕНУЖНЫ.
На самом деле положняк такой, что Хаскель не нужен. Пруф ми ронг.
>Это простые метки для переходов (замечательный мир ассемблера).
facepalm.jpg
>Функция всегда возвращает значение, а как же процедуры, которые не возвращают значений?
Процедуры неявно возвращают успешность своего завершения%или не завершаются вовсе, или вызывают эксепшены%
>Запрещать ничего не нужно
Иногда нужно. Но тут, пожалуй, соглашусь - хотите плодить говнокод - плодите.
Готов?
function Human(name,age,iq)
{
this.name=name;
this.age=age;
this.iq=iq;
}
op=new Human("OP",12,60);
Парируй!
[CODE]
function Identity(user)
{
this.name = user->name;
this.age = user->age;
this.iq = user->iq;
}
op = new Identity({"OP", 12, 60});
[/CODE]
>facepalm.jpg
holepalm.jpg
>Процедуры неявно возвращают успешность своего завершения%или не завершаются вовсе, или вызывают эксепшены%
Байтоёбы смотрять на тебя укоризненно, как на лиственную белоснежку в окружение 7 гномов.
>Иногда нужно. Но тут, пожалуй, соглашусь - хотите плодить говнокод - плодите.
Твой код также говнокод ханжа ты этакая.
ОП конструкторы не считает за функции. Такие дела.
>holepalm.jpg
Не отличаешь константную функцию от goto? У меня для тебя плохие новости.
>Байтоёбы
Байтоёбское мнение никто не спрашивал.
>Не отличаешь константную функцию от goto? У меня для тебя плохие новости.
Наоборот, это у меня плохие новости для анона, который не может в нисходящие абстракции вплоть до низкоуровнего представления инструкций машинного кода. Быстрее излечи свою высокоуровневость мозга.
>Байтоёбское мнение никто не спрашивал.
Ну тогда ты идёшь нахуй сладенький
>в нисходящие абстракции
Что же ты до ТТЛ-представления не добрался, а, байтоёб?
> ТТЛ-представления
Потому и байтоёб, а не элитный схемоёб.
Впрочем ты даже не можешь в байтоёбство.
>Потому и байтоёб, а не элитный схемоёб.
Мозгов не хватило?
Был бы байтоёбом, знал бы, что даже вызов функции с параметрами на уровне байтоёба - этот тот же сраный переход по метке.
>Мозгов не хватило?
Скорее интереса.
>что даже вызов функции с параметрами на уровне байтоёба - этот тот же сраный переход по метке.
Мне это и так известно, умник
А тебе известно, что абстракция под названием "функция" всегда обеспечивает возвращение в место вызоварасходимости не рассматриваем, а простой goto в метку о чем твое байтоебское низейшество и говорило нет?
Если говорить по факту функция может принимать аргументы и всегда предполагает возвращаемое значение.
Процедура может принимать аргументы и никогда сама не возвращает значения.
Переход не предполагает ни того ни другого.
>"функция" всегда обеспечивает возвращение в место вызова
Как и процедура, а вообще это обеспечивает инструкция call с ёблей через стэк, неуч.
Алсо по средством goto вполне организовывается тот же самый call, но более ёмко так как ебаться со стеком уже нужно самому.
>байтоебское низейшество
Как же сложно общаться с людьми без образования, которые обделены широтой мысли от природы.
При чем здесь процедура, call, стэк и прочая хуйня, относящаяся к конкретной архитектуре конкретного вычислителя? Твой изначальный тезис о нуль-арных функциях:
>Это простые метки для переходов (замечательный мир ассемблера).
И вот тут сильно обосрался, дебич, и начал уводить разговор в какую-то лютую хуйню. Это не простые метки для переходов, идиот, это функция (в высокоуровневом понимании), которая в зависимости от своего содержимого, компилятора и целевой архитектуры может быть скомпилирована в кусок машкода, или кусок данных, или в еще какую хуйню в лисп-машинах. Если ты этого не можешь понять, то какой ты нахуй байтоёб? Однобокий ты x86 байтоёб.
В чём разница?
> user->name;
Зачем когда можно
> user.name
?
> ОП конструкторы не считает за функции. Такие дела.
Может у него функции не объекты даже?
ООП>Функциональные.
Докажи обратное.
Какой же ты дебил, когда же ты сдохнешь.
>Твой изначальный тезис о нуль-арных функциях
Мой тезис был о том, что на низкоуровневом представлении кода отсутствуют какие-либо функции и процедуры в привычном понимании.
>И вот тут сильно обосрался, дебич, и начал уводить разговор в какую-то лютую хуйню.
Ты вообще на протяжении всего нашего диалога несешь какую то хуйню, не можешь нормально сформировать и высрать свои ничтожные мысли по данному предмету обсуждения.
>При чем здесь процедура, call, стэк и прочая хуйня
При том, что ты нихуя не разбираешься, а лезишь! берегись - убьёшься нахуй
>Процедуры неявно возвращают успешность своего завершения%или не завершаются вовсе, или вызывают эксепшены%
Вот тут ты обосрался.
>"функция" всегда обеспечивает возвращение в место вызова
Вот тут ты обосрался.
> компилятора и целевой архитектуры может быть скомпилирована в кусок машкода
Про машкод и была речь с самого начала, нахуй ты в компиляторы залез мудак
>Если ты этого не можешь понять
Я уже понял, что ты нихуя не понимаешь
Самый простой пример -- это онструктор структуры с более, чем двумя полями в Си, потому что в неё обычно надо передавать void, перед которым следуют инициализирующие значения.
Напомню, что обычно в таких конструкторах проводится проверка полей на допустимые значения.
А код ошибки, в хорошем тоне программирования возвращают из функции как значение. Вот тебе пример...
if ( InitializeMyStruct( foo, bar, baz, pMystuct ) != E_SUCCESS )
{
ErrCodeToMessage( int errno );
return E_BAD_INITIALIZE_MY_STRUCT;
}
А ещё вспомни про семейства printf\scanf. Где va_args -- это вообще неоценимая плюшка.
Напомню, что обычно в таких конструкторах проводится проверка полей на допустимые значения.
А код ошибки, в хорошем тоне программирования возвращают из функции как значение. Вот тебе пример...
if ( InitializeMyStruct( foo, bar, baz, pMystuct ) != E_SUCCESS )
{
ErrCodeToMessage( int errno );
return E_BAD_INITIALIZE_MY_STRUCT;
}
А ещё вспомни про семейства printf\scanf. Где va_args -- это вообще неоценимая плюшка.
int errno = InitializeMyStruct( foo, bar, baz, hui, pizda, dzhigurda, pMyStuct );
if ( errno != E_SUCCESS )
{
ErrCodeToMessage( int errno );
return E_BAD_INITIALIZE_MY_STRUCT;
}
фикс
>Мой тезис был о том, что на низкоуровневом представлении кода отсутствуют какие-либо функции и процедуры в привычном понимании.
Идиот, блядь, в конкретном вычислителе, скажем x86, так оно и есть. Но в каком-нибудь другом вычислителе может быть иначе, например, в машине, реализующей лямбда-исчисление.
>какие-либо функции и процедуры в привычном понимании.
Какое у тебя привычное понимание функции, байтоёб?
>Вот тут ты обосрался.
Нихуя. Ты сам утверждаешь, что процедуры возвращают управление вызывающему коду обратно. Сам факт возврата управления и есть то самое неявное возвращение успешного выполнения, и если ты этого не понимаешь, то ты клинический дебил.
>Вот тут ты обосрался.
Вырвал из контекста, сучий выродок. Там еще в скобочках приписка была.
>Про машкод и была речь с самого начала, нахуй ты в компиляторы залез мудак
Потому что ты, сраный байтоёб, высокуровневую абстракцию своим маленьким мозгом откомпилил в низкоуровневую конструкцию, откуда и взялся твой даунский тезис. Для тебя это произошло неявно, и так как ты глуп как валенок, ты этого не осознаешь.
>Может у него функции не объекты даже?
Конечно! Функции это не объекты, а стрелки между объектами.
Проиграно и мы оба идём нахуй, спасибо за неконструктивный диалог.
Дебич, пиздец.
Нахуя 2 одинаковых класса. Это называется констркутор
Он дурак просто. Всё объекты, а объекты это ВСЁ. И функция объект, и число объект, и объект объект, и небо объект, и Аллах объект.
>Может у него функции не объекты даже?
Ну тезис у него такой ебанутый, интересно как он каррировать конструкторы будет, если это не функции.
function Human({name,age,iq})
{
this.name=name;
this.age=age;
this.iq=iq;
}
op=new Human({name:"OP",age:12,ig:60});
> {name,age,iq}
Такое вообще законно?
С разморозкой.
Такое тоже.
function Human({name,age,iq})
{
Object.assign(this, {name,age,iq})
}
op=new Human({name:"OP",age:12,ig:60});
я короче любитель, сильно не пинайте, но смотри, почему если аргументов 0 то это не функция? вот объявил я функцию по синтаксису языка, везде ее прописал, там где я ее использую где должна выполняться сама функция каждый раз мне не нужно, и все нужные данные для функции я подгружаю при старте нужного потока, т.е. запускаю поток, подгружаю все нужные данные для работы, и кое какие подгруженные данные и будут аргументами для функции, их много и при каждом вызове функции данные всегда меняются. То есть в данном случае в моем софте было бы супербредом сначала получить данные для того что бы передать их в функцию и намного логичнее в моем случае что бы нужные данные функция сама выбирала когда я ее вызову.
Опять реанимирую этот кусок дерьма, но подумайте, очевидно что ОП троляка. Все базируется на том, что любая функция это попытка изменить состояние (не то состояние от которого пытаются избавиться хаскелеёбы), она принимает одно состояние и возвращает другое, так что нам даже два аргумента будет лишним, просто писать всё на унарных операторах было бы слишком толсто. В итоге оп говорит, что есть два состояния из которых мы получаем третий. Вся математика построена на бинарных операциях под собой, в конце концов процессоры построены на бинарной логике.
Можно ли преобразовать любую программу в такую бинарную программу на высокоуровневых языках, как завещал оп? Конечно можно.
Будет ли человек в здравом уме придерживаться такого ограничения и создавать из двух точек линию, а из точки и линии плоскость? Нет, так как если мы откуда-то получаем три точки, то каждый раз надо будет руками вызывать эту функцию линии, что приведет к копипасте ( в любом случае я не хочу об этом спорить в силу существования возможности разделить это на бинарные функции)
В любом случае это уже дело стиля, ничего доказать ОПу вы по определению не можете, мнение опа технически может существовать.
Спорить об этом бессмысленно.
Можно ли преобразовать любую программу в такую бинарную программу на высокоуровневых языках, как завещал оп? Конечно можно.
Будет ли человек в здравом уме придерживаться такого ограничения и создавать из двух точек линию, а из точки и линии плоскость? Нет, так как если мы откуда-то получаем три точки, то каждый раз надо будет руками вызывать эту функцию линии, что приведет к копипасте ( в любом случае я не хочу об этом спорить в силу существования возможности разделить это на бинарные функции)
В любом случае это уже дело стиля, ничего доказать ОПу вы по определению не можете, мнение опа технически может существовать.
Спорить об этом бессмысленно.
>почему если аргументов 0 то это не функция?
Если при этом функция ничего не возвращает то это метка.
Если функция ничего не возвращает, но принимает аргументы то это уже процедура.
Если функция не принимает аргументов, но что-то возвращает - это функция.
Любая функция подразумевает вызов или переход в тело функции, иначе это ненужный кусок кода.
Потоки это немного другое, но также относится к понятию функции.
Глобальные переменные не нужны, но функции являются глобальными указателями и только они и должны быть.
>Можно ли преобразовать любую программу в такую бинарную программу на высокоуровневых языках, как завещал оп? Конечно можно.
Можно всё, острый вопрос: а нужно ли? Программный код это лишь площадка для стиля и фундамент для структур, вопрос лишь в удобстве тех или иных решений (а также вкуса, однако он на последнем месте).
>Спорить об этом бессмысленно.
Тут никто не спорит, но ты прав.
>Если при этом функция ничего не возвращает то это метка.
А если функция имеет побочные эффекты?
>побочные эффекты
Перечень побочных эффектов, будьте добры, предоставте!
Системное время. Значения из контроллеров измерительных устройств. Файловый ввод-вывод. Сетевой ввод-вывод. Межпроцессный обмен.
Всё, что нарушает referential transparency.
>Если функция ничего не возвращает
То это не называется функцией.
Так это относительно понятия "функция", или ты не умеешь в относительность контекста?
>являются глобальными указателями
Быдлo, сэр.
>А ещё вспомни про семейства printf\scanf. Где va_args -- это вообще неоценимая плюшка.
Что ты с ним споришь? Это же смузихлеб дранный.
>Всё, что нарушает referential transparency.
Мы живём в мире погрешностей (иррациональных чисел), даже если высокоточно измерить какую-либо поверхность и заглянуть чуть глубже, то обнаружится, что на N * 10-100 метров на самом деле будет (N + С), где С это бесконечно малая.
Поэтому хватит строить иллюзии о незыбленном, вокруг одна сплошная конечная-бесконечность.
Это очень грубо говоря так.
>Быдло, сэр.
Как и вы, сэр.
Любое подобное суждение по дефолту ложное, это попытка зашаблонить нешаблонизируемое.
>это попытка зашаблонить нешаблонизируемое
Как будто что-то плохое... И да зашаблонить можно всё и без исключения, вопрос только в том, что стоит ли это того.
>Как и вы, сэр.
Я не отрицаю, сэр.
>И да зашаблонить можно всё и без исключения
Здесь шаблонизировать, сэр, нет надобности. Это лишь погоня за своим внутренним желанием анонизировать на искуственные правила.
>анонизировать
Онанировать, сэр, этот Т9 опять меня подвел.
>Здесь шаблонизировать, сэр, нет надобности. Это лишь погоня за своим внутренним желанием анонизировать на искуственные правила.
Все мы где-то в чём-то над чем-то, а порой в кого-то - онанируем, сэр.
Обезьянка не знакома с побочными эффектами, но смеет кукарекать про классификацию функций. Найс.
Но, cэр, если мы будем все дальше уходить в пучины онанизм, то от этого не стоит ожидать ничего хорошего.
Совершенно верно, сэр. Поэтому если вам данный онанизм не доставляет никакого удовольствия, то вам следует прекратить, сэр.
>Обезьянка не знакома с побочными эффектами, но смеет кукарекать про классификацию функций. Найс.
Обезьянок тут давно уже нету, только конверты. Насчёт побочных эффектов то это класс не решаемых задач, так как причина этих явлений находится в фундаменте человеческого восприятия и поэтому, чтобы от этого избавится придётся полностью менять всё людское познание вплоть до единиц измерения (например атомные линейки, которые будут мерить не какую-то абстрактную величину выражающиюся в мм, см, метрах и т.д., а вполне конкретную количественную), а на данный момент всё что мы можем делать, так это уменьшать побочные эффекты через усложнения и нагромождения ранее созданной системы восприятия.
Что несёт этот поехавший
Эй, мудила, объясни почему в javasripte не нужен array.map
А что тебе не нравится юный воскрицатель риторических вопросов?
Твои слова являются подтверждением твоего незнания о побочных эффектах функций.
Ты реально не понимаешь, что означают термины "функция" и "побочный эффект".
И втираешь нам какую-то дичь.
>Твои слова являются подтверждением твоего незнания о побочных эффектах функций.
>Ты реально не понимаешь, что означают термины "функция" и "побочный эффект".
У меня обратное мнение.
И заебали со своими "ты не знаешь", " ты не понимаешь"
Очень ёмко с вашей стороны пидоры, желаю вам мучительной смерти от хуёв методом пенетрации ваших пластиковых анальных отверстий!
>И втираешь нам какую-то дичь.
С твоей стороны так много аргументов моего не знания, наверное по двум причинам: ты сам не понимаешь в чём заключается сабж или боишься показаться глупым, если предоставишь аргументы, и сам же останешься в дураках.
Смотрите, траль обиделся.
Очень смищно затраллили этого уебана
Все функции должны принимать либо 0 аргументов (тогда это и не функции вовсе), либо 1 аргумент (унарные функции), либо 2 аргумента (бинарные функции). Все остальное нужно запретить (code convention'ом или компилятором). Пруф ми ронг.
Назовите хоть один пример функции, которой нужно принимать >=3 аргументов, и я поясню, почему вы неправы и пишете говнокод.