В FW 4 появился новый тип tuple, перенятый с функциональных языков.
В общем понятно предназначение его — получить возможность вернуть более одного параметра из функции.
Но насколько это делает код более понятным, ведь значения возвращаемые из tuple без именные.
Что можно понять глядя на функцию возвращающую tuple?

Здравствуйте, IDL, Вы писали:

IDL>Что можно понять глядя на функцию возвращающую tuple?

Какой нибудь приватный метод

def GetNameAndLength() : string * int

написать гораздо проще и удобнее, чем создавать отдельный класс с двумя именованными свойствами. Но в языках без встроенного pattern matching'а кортежи не очень удобно использовать.

Здравствуйте, nikov, Вы писали:

N>Здравствуйте, IDL, Вы писали:

IDL>>Что можно понять глядя на функцию возвращающую tuple?

N>Какой нибудь приватный метод
N>

N>def GetNameAndLength() : string * int
N>

N>написать гораздо проще и удобнее, чем создавать отдельный класс с двумя именованными свойствами. Но в языках без встроенного pattern matching'а кортежи не очень удобно использовать.

Но всё равно, смысл возвращаемого значения не совсем понятно.

Здравствуйте, IDL, Вы писали:

IDL>В FW 4 появился новый тип tuple, перенятый с функциональных языков.

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

IDL>Что можно понять глядя на функцию возвращающую tuple?

Для нормального использования кортежей нужен язык с соответствующим синтаксисом.

Здравствуйте, IDL, Вы писали:

N>>Какой нибудь приватный метод
N>>

N>>def GetName() : string
N>>

IDL>Но всё равно, смысл возвращаемого значения не совсем понятно.

А так понятней стало?

Здравствуйте, IT, Вы писали:

IT>Здравствуйте, IDL, Вы писали:

N>>>Какой нибудь приватный метод
N>>>

N>>>def GetName() : string
N>>>

IDL>>Но всё равно, смысл возвращаемого значения не совсем понятно.

IT>А так понятней стало?

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

Здравствуйте, IDL, Вы писали:

IDL>Из названия функции понятно, что функция возвращает имя, здесь нет неопределённости, а если это кортеж который возвращает имя и фамилию, то не очень понятно где имя, а где фамилия.

Назови свою функцию GetFirstAndLastNames, будет тоже самое.

IDL>>Что можно понять глядя на функцию возвращающую tuple?

AVK>Для нормального использования кортежей нужен язык с соответствующим синтаксисом.
Не совсем понятно о какой поддержке идёт речь

Здравствуйте, IT, Вы писали:

IT>Здравствуйте, IDL, Вы писали:

IDL>>Из названия функции понятно, что функция возвращает имя, здесь нет неопределённости, а если это кортеж который возвращает имя и фамилию, то не очень понятно где имя, а где фамилия.

IT>Назови свою функцию GetFirstAndLastNames, будет тоже самое.
Что-то мне не очень нравиться привязывать имена функции к количеству и порядку елементов в кортеже.

Здравствуйте, IDL, Вы писали:

IDL>Здравствуйте, IT, Вы писали:

IT>>Здравствуйте, IDL, Вы писали:

IDL>>>Из названия функции понятно, что функция возвращает имя, здесь нет неопределённости, а если это кортеж который возвращает имя и фамилию, то не очень понятно где имя, а где фамилия.

IT>>Назови свою функцию GetFirstAndLastNames, будет тоже самое.
IDL>Что-то мне не очень нравиться привязывать имена функции к количеству и порядку елементов в кортеже.

Это от того что язык слабоват.
На нормальном языке можно написать так:

let (firstName, lastName) = GetFirstAndLastNames()

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

Здравствуйте, gandjustas, Вы писали:

G>Это от того что язык слабоват.
G>На нормальном языке можно написать так:

G>

G>let (firstName, lastName) = GetFirstAndLastNames()
G>

G>И никаких проблем с читаемостью не будет.

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

Здравствуйте, IDL, Вы писали:

IDL>В FW 4 появился новый тип tuple, перенятый с функциональных языков.
IDL>В общем понятно предназначение его — получить возможность вернуть более одного параметра из функции.
IDL>Но насколько это делает код более понятным, ведь значения возвращаемые из tuple без именные.
IDL>Что можно понять глядя на функцию возвращающую tuple?

На мой взгляд, tuple можно использовать если объект нужного вида встречается (будет встречаться) в проекте 1-2 раза. Если чаще, то нужно писать объект. Из этого в частности следует, что tuple недопустим для использования в публичном интерфейсе класса.

Здравствуйте, Undying, Вы писали:

U>Здравствуйте, gandjustas, Вы писали:

G>>Это от того что язык слабоват.
G>>На нормальном языке можно написать так:

G>>

G>>let (firstName, lastName) = GetFirstAndLastNames()
G>>

G>>И никаких проблем с читаемостью не будет.

U>Это все равно костыль. При написании этой строчки нужно знать, что функция возвращает именно firstName и lastName и именно в таком порядке. При использовании честных объектов этого знать не нужно.

Пока ты не посмотришь внутрь объекта не узнаешь что там на самом деле возвращается.
Аналогично для кортежей — надо один раз прочитать описание. На читаемость кода такая запись не повлияет (ИМХО даже улучшит)

Здравствуйте, IDL, Вы писали:

IDL>В FW 4 появился новый тип tuple, перенятый с функциональных языков.
IDL>В общем понятно предназначение его — получить возможность вернуть более одного параметра из функции.
IDL>Но насколько это делает код более понятным, ведь значения возвращаемые из tuple без именные.
IDL>Что можно понять глядя на функцию возвращающую tuple?

С кортежами в реальной жизни познакомился только переведя разработку своей дипломной работы на Nemerle. Это было где-то год назад, поэтому я думаю, что я знаком с применением коржей на долгоживущим проекте. Плюсами кортежей оказалась гибкость при реорганизации кода и простота использования (отсутствие необходимости создавать классы только для того, что бы вернуть составное значение). Но в последствии оказалось, что иногда сложно быстро понять что за кортеж возвращает функция, поэтому я пришел к следующей схеме:
1. Стараться не использовать кортежи в публичных методах.
2. Использовать кортежи только в private методах и локальных функциях.
3. Всегда писать комментарии перед функциями, в которых описывать возвращаемый тип кортежа.

Здравствуйте, nikov, Вы писали:

IDL>>Что можно понять глядя на функцию возвращающую tuple?
N>Какой нибудь приватный метод

N>def GetNameAndLength() : string * int

N>написать гораздо проще и удобнее, чем создавать отдельный класс с двумя именованными свойствами. Но в языках без встроенного pattern matching'а кортежи не очень удобно использовать.

Кстати, а как в функциональных языках (в первую очередь, .NET-ных): принято ли использовать таплы в public API или рекомендуется использовать их только в локальных переменных и методах?

Здравствуйте, gandjustas, Вы писали:

G>Здравствуйте, IDL, Вы писали:

IDL>>Здравствуйте, IT, Вы писали:

IT>>>Здравствуйте, IDL, Вы писали:

IDL>>>>Из названия функции понятно, что функция возвращает имя, здесь нет неопределённости, а если это кортеж который возвращает имя и фамилию, то не очень понятно где имя, а где фамилия.

IT>>>Назови свою функцию GetFirstAndLastNames, будет тоже самое.
IDL>>Что-то мне не очень нравиться привязывать имена функции к количеству и порядку елементов в кортеже.

G>Это от того что язык слабоват.
G>На нормальном языке можно написать так:

G>

G>let (firstName, lastName) = GetFirstAndLastNames()
G>

G>И никаких проблем с читаемостью не будет.
Ну так конечно получше.
В принципе кортеж удобно использовать локально, тогда его создание, использование находиться перед глазами и возникают меньше вопросов по их использованию.
Ето очень хорошо ложится по видимость анонимных объектов.

Здравствуйте, Рысцов Денис, Вы писали:

РД>Здравствуйте, IDL, Вы писали:

IDL>>В FW 4 появился новый тип tuple, перенятый с функциональных языков.
IDL>>В общем понятно предназначение его — получить возможность вернуть более одного параметра из функции.
IDL>>Но насколько это делает код более понятным, ведь значения возвращаемые из tuple без именные.
IDL>>Что можно понять глядя на функцию возвращающую tuple?

РД>С кортежами в реальной жизни познакомился только переведя разработку своей дипломной работы на Nemerle. Это было где-то год назад, поэтому я думаю, что я знаком с применением коржей на долгоживущим проекте. Плюсами кортежей оказалась гибкость при реорганизации кода и простота использования (отсутствие необходимости создавать классы только для того, что бы вернуть составное значение). Но в последствии оказалось, что иногда сложно быстро понять что за кортеж возвращает функция, поэтому я пришел к следующей схеме:
РД>1. Стараться не использовать кортежи в публичных методах.
РД>2. Использовать кортежи только в private методах и локальных функциях.
РД>3. Всегда писать комментарии перед функциями, в которых описывать возвращаемый тип кортежа.

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

Здравствуйте, gandjustas, Вы писали:

U>>Это все равно костыль. При написании этой строчки нужно знать, что функция возвращает именно firstName и lastName и именно в таком порядке. При использовании честных объектов этого знать не нужно.

G>Пока ты не посмотришь внутрь объекта не узнаешь что там на самом деле возвращается.

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

G>Аналогично для кортежей — надо один раз прочитать описание. На читаемость кода такая запись не повлияет (ИМХО даже улучшит)

Нормальной записью была бы такая:

Tuple<string FirstName, string LastName> GetFirstAndLastNames()
{
  return new Tuple(firstName, lastName);
}

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

Здравствуйте, Undying, Вы писали:

U>Здравствуйте, gandjustas, Вы писали:

U>>>Это все равно костыль. При написании этой строчки нужно знать, что функция возвращает именно firstName и lastName и именно в таком порядке. При использовании честных объектов этого знать не нужно.

G>>Пока ты не посмотришь внутрь объекта не узнаешь что там на самом деле возвращается.

U>При использовании честных объектов интеллисенса, чтобы понять, обычно достаточно. В случае же Tuple интеллисенс практически ничем помочь не может.
Ну кроме того что когда набираешь имя функции подсказка выдает summary по ней. Этого вполне достаточно.

G>>Аналогично для кортежей — надо один раз прочитать описание. На читаемость кода такая запись не повлияет (ИМХО даже улучшит)

U>Нормальной записью была бы такая:

U>

U>Tuple<string FirstName, string LastName> GetFirstAndLastNames()
U>{
U>  return new Tuple(firstName, lastName);
U>}
U>

U>Эта запись ничем использованию честных объектов не уступает, здесь при декларации функции четко прописано, что функция возвращает. А let это костыль, хотя возможно и полезный в некоторых случаях.

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

Но тут возникают проблемы
1)Насколько записи и одинаковыми типами и разными именами полей соместимы нежду собой?
2)То же что выше, но когда типы в разных сборках?
3)Насколько такие типы будут совмсетимы с обычными туплами?

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

Здравствуйте, gandjustas, Вы писали:

U>>Нормальной записью была бы такая:

U>>

U>>Tuple<string FirstName, string LastName> GetFirstAndLastNames()
U>>{
U>>  return new Tuple(firstName, lastName);
U>>}
U>>

G>Ну это уже не туплы, а записи (records). Сейчас анонимные типы выполняют аналогичную функциональность, но их нельзя возврашать из методов класса.

G>Но тут возникают проблемы
G>1)Насколько записи и одинаковыми типами и разными именами полей соместимы нежду собой?
G>2)То же что выше, но когда типы в разных сборках?
G>3)Насколько такие типы будут совмсетимы с обычными туплами?

Tuple<string FirstName, string LastName> в любом месте и в любой сборке должен являться одним и тем же типом. С неименнованными туплами не должен иметь ничего общего.

G>ЗЫ. Как уже отмечали выше тупы применять в публичном контракте не стоит без крайней необходимости.

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