<bgdev />^free

Rust generics are awesome!

Примерно с това парче мога да парсвам редове от текстов файл към абсолютно всеки тип който имплементира FromStr без да трябва да му напиша типа нито веднъж:

pub fn parse_lines<I, T, E>(input: I) -> Vec<T>
where
    I: AsRef<str>,
    E: Debug,
    T: FromStr<Err = E>,
{
    input
        .as_ref()
        .lines()
        .map(|ж| ж.parse())
        .collect::<Result<_, _>>()
        .unwrap()
}

За сравнения, същото нещо не може да се напише на джава :)

I wished I cared. :) Даже дженерикс дето мислят да ги слагат в Go2 не съм ги гледал още. Дано да не пречат много.

това темплейти ли ще рече? ако слушкате и папкате, за следващата версия и new/delete може

Не са темплейти . С риск да се изложа, но те не работят ли на принципа search & replace, което ти позволява да плеснеш всеки тип на мястото на параметъра ?

По-скоро е concepts, но по-човешки направено

Да не би да бъркаш макроси с темплейти в С++ ?

Delegate

Да не би да бъркаш макроси с темплейти в С++ ?

Не, те и макросите са същата боза де, само че още по-прокиснала.

template <class T>
T GetMax (T a, T b) {
  T result;
  result = (a>b)? a : b;
  return (result);
}

и ако направя

k=GetMax<int>(i,j)

компилатора просто ще смени всяко срещане на Т с int и ако случайно резулатата се компилита - супер, ако не - кур.

Докато в ръст ако искаш да можеш да използваш операциите >, <, etc то трябва да каше, че типа ги поддържа:

fn max<T: *Ord*>(a: T, b: T)
 -> T

И ако се опиташ да ползваш нещо друго различно от >, <, etc ще т икаже че неможе, даже конкретния тип да го има тоя метод. Докато в Ц++ след като компилатора мине със search &replace na типа Т ако има метода - ще се компилира, ако не - пак ще се опита да го компилира

Не знам дали успях да обясня

Да, така е. Това е кофти в С++, ако ползваш някаква библиотека с темплейти и нали се сещаш какви еррори изплюва.

За такива неща като дженерикс трябва да има изискване да ги използват само хора, които ги мразят ужасно. Иначе се случват неща като C++ проекти.

ФейкПрофил

За сравнения, същото нещо не може да се напише на джава :)

Не ги разбирам тия неща, но в жабата има някакъв такъв тип. И в острото Ц май има. Може тук просто да е по-лачено. Жабата има огромно наследство и не може да чупи неща.

|

За такива неща като дженерикс трябва да има изискване да ги използват само хора, които ги мразят ужасно. Иначе се случват неща като C++ проекти.

Не само за дженерикс, но и за всяка малко "по-оплетена" технология трябва да се прилага този метод. Проблемът е, че 90% от тези които научат съответните технологии, то после се опитват да ги прилагат колкото се може повече, за да си докажат на себе си колко са велики.

ФейкПрофил

Rust generics are awesome!

Примерно с това парче мога да парсвам редове от текстов файл към абсолютно всеки тип който имплементира FromStr без да трябва да му напиша типа нито веднъж:

pub fn parse_lines<I, T, E>(input: I) -> Vec<T>
where
    I: AsRef<str>,
    E: Debug,
    T: FromStr<Err = E>,
{
    input
        .as_ref()
        .lines()
        .map(|ж| ж.parse())
        .collect::<Result<_, _>>()
        .unwrap()
}

За сравнения, същото нещо не може да се напише на джава :)

Какво гледаме? Че прекарва generic T от return-а обратно по веригата?

Stilgar

ФейкПрофил

Rust generics are awesome!

Примерно с това парче мога да парсвам редове от текстов файл към абсолютно всеки тип който имплементира FromStr без да трябва да му напиша типа нито веднъж:

pub fn parse_lines<I, T, E>(input: I) -> Vec<T>
where
    I: AsRef<str>,
    E: Debug,
    T: FromStr<Err = E>,
{
    input
        .as_ref()
        .lines()
        .map(|ж| ж.parse())
        .collect::<Result<_, _>>()
        .unwrap()
}

За сравнения, същото нещо не може да се напише на джава :)

Какво гледаме? Че прекарва generic T от return-а обратно по веригата?

Нещо такова, но не от ретърн-а, ами от извън функцият, но не това е интересното.

Интересното и важното в случая е, че може да се викат методи на конкретния тип през generic параметър-а, и точно това е което не може да се направи на джава, за Цострото не знам, но ще ми е интересно да разбера.

В случая parse() все едно се явява статичен метод на Dog & Cat, и компилатора вика правилния "статичен" метод в зависимост от конкретния тип, нищо че вътре в метода се споменава само интерфейса (FromStr).

Докато в джава няма статични методи в интрефейса - в смисъл има,но те принадлежат на типа на интерфейса, а не на типа на конкретния клас който го имплементира. И поради тази причина не може да се напише такъв generic method.

Примерно такова нещо е невалидно в джава:

interface FromStr{
  static FromStr parse(String input);
}

class Cat implements FromStr{
  static FromStr parse(String input);
}

class Dog implements FromStr{
  static FromStr parse(String input);
}

<T: extends FromStr> T parse_input(String input) {
  return T::parse(input);
}

Така на око ми изглежда сякаш това е feature на статичните методи, а не на generics конкретно. То като няма ООП май си е задължително да има нещо такова.