нужна ли перегрузка функций

yroslavasako

Marinavo_0507

yroslavasako

Marinavo_0507

yroslavasako

agaaaa

Это такой костыль для языков, которые не умеют продвинутую типизацию и создавать суммы типов на лету.

apl13

Serab

про плюсовые темплейты?

apl13

setDoubleFromInt(f, divideIntByFloat(addIntToUnsignedIntToProduceInt(a, b y

f = (a + b) / y

yroslavasako

Ну или то есть если тебя не заебет писать

apl13

yroslavasako

doublemother

okunek

yroslavasako

doublemother

Хм. А кто сказал, что перегрузка функций - это самый удобный путь? Я же говорил об абстрактном языке. В абстрактном языке есть высокоуровневые типы и соответственно возможность задавать для аргумента этого типа одну-единственную функцию sqrt.

Изначальный вопрос касался, разумеется, нормальных OOP языков и тех функций, у которых принципиально разный список аргументов. Например, есть аргументы по умолчанию. И вопрос в том, как автоматически строить алгебраические типы для таких функций.
сейчас у нас приняты две перегруженные функции:
func(Int,Int)
func(Int)
Что эквивалентно одной функции
func( (Int,Int)|Int) где | обозначает анонимный тип полученный сложением данных.
Вопрос звучит просто: быть может стоит отказаться от перегрузки функций в пользу удобных анонимных алгебраических типов? Есть ли такие языки, которые уже отказались?

yroslavasako

Как это решает проблему разного извлечения корня из int и float?

class Rootable a where

      root :: a -> a



instance Rootable Integer where

      root = floor . sqrt . fromIntegral



instance Rootable Float where

      root = sqrt

yroslavasako

В чём профит иметь в одной функции реализацию (возможно, абсолютно различную) и всякие match/switch для всех возможных вариантов типа, вместо того чтобы делать это с удобством в отдельных функциях и добавлять реализации для новых типов легко и непринуждённо, не затрагивая уже написанный код?

doublemother

class Rootable a where root :: a -> a instance Rootable Integer where root = floor . sqrt . fromIntegral instance Rootable Float where root = sqrt

schipuchka1

сейчас у нас приняты две перегруженные функции:
func(Int,Int)
func(Int)
Что эквивалентно одной функции
func( (Int,Int)|Int) где | обозначает анонимный тип полученный сложением данных.

doublemother

Код с match ничем не длиннее чем десять разных функций. Правда и не короче

apl13

Как это решает проблему разного извлечения корня из int и float?

class Yobable a where

      yoba :: a -> a



instance Yobable Integer where

      yoba = floor . sqrt . fromIntegral



instance Yobable Float where

      yoba = sqrt

yroslavasako

yroslavasako

Я ничего не пропустил? Ты предлагаешь избавиться от перегрузки, прибегнув к перегрузке?

doublemother

Смотри на стандартный "интерфейс" Ordered в скала (если в хаскеле кто не заметил переменную типа - покажу на примере другого языка)

doublemother

Мне было заявлено, что без перегрузки никак нельзя сделать обобщённые операции.

yroslavasako

Он очень тонко намекает на перегруженную функцию sqrt, шаблонный конструктор std::vector и, кажется, ещё на то, что ты идиот.

yroslavasako

Тем не менее, они никак не помогут тебе написать sqrt, если только ты не будешь сам писать типы, с которыми sqrt работает.

yroslavasako

Ну это самая обычная примесь, trait, они сейчас даже в пхп есть.

doublemother

Хм, посмотри чуть правее примеси. Там ты обнаружишь параметризацию примеси через дополнительный тип. Именно этим и интересен пример. Попробуй реализуй это без параметризации типов.

doublemother

Так вот, sqrt не нужна перегрузка. Надо просто писать sqrt[A](x : Rootable[A]) : x

yroslavasako

doublemother

У многих всё что нужно уже есть. И ничто не мешает языку без перегрузки функций иметь базовую библиотеку с числами и sqrt

yroslavasako

doublemother

перегрузка функций (внутри, между прочим, описанного класса)

yroslavasako

Serab

doublemother

class QString; // класс строки из Qt, хранится в UTF-16



class MyString // моя уличная строка, хранится в UTF-8

{

   ...

public:

  inline MyString& add(const MyString &s)

  {

    d_ptr->data.append(s->d_ptr.data);

    return *this;

  }

  inline MyString& add(const QString &s)

  {

    QByteArray data = s.toUtf8;

    d_ptr->data.append(data.data;

    return *this;

  }

};

yroslavasako

class QString // класс строки из Qt. хранится в UTF-16



def Q2Data(st : QString) : ByteData // любой способ преобразования



class MyString {

  private var data : ByteData



  def add(st : Any) = st match ({

    case x : QString => data.append(Q2Data(x

    case x : MyString => data.append(x.data)

    case _ => throw Exception 

  }).andThen(_ => this)

}

class QString // класс строки из Qt. хранится в UTF-16



def Q2Data(st : QString) : ByteData // любой способ преобразования



sealed trait ArgumentData

final case class QStringData(string : QString)

final case class MyStringData(string : MyString)



class MyString {

  private var data : ByteData



  def add(st : ArgumentData) = st match ({

    case QStringData(x) => data.append(Q2Data(x

    case MyStringData(x) => data.append(x.data)

  }).andThen(_ => this)

}

class QString // класс строки из Qt. хранится в UTF-16



implicit def qstring2mystring(st : QString) : MyString // неявное преобразование



class MyString {

  private var data : ByteData



  def add(st : MyString) = {

    data.append(st.data)

    this 

  }

}

Serab

kokoc88

Решение 1, техническая прямая замена конкатенации строк.

Serab

yroslavasako

То есть вместо перегрузки предлагается сделать десяток телодвижений для замены её на полиморфизм?
Это типо самое новое веяние, вместо пары строк написать два десятка?

Serab

yroslavasako

kokoc88

Во-первых, где ты там видел полиморфизм? Там чёткая замена на switch.

Во-вторых, со switch короче, потому что один набор типо-параметров - одна строка + общая шапка, что явно не длинее, чем если бы я делал на каждый типо-параметр шапку и тело функции, к тому же я использую тот факт, что любая из перегруженных функций возвращает this и записываю её одной строкой композицией ".andThen(_ => this)", которую в противно случае пришлось бы писать в каждое перегруженное тело

yroslavasako

Там я его и увидел, а ты что, не видишь?

kokoc88

давай точную цитату, потому что я в затруднении

yroslavasako

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

kokoc88

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

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

yroslavasako

И тем не менее, в этом случае ты его смоделировал: для двух несвязанных типов высосал из пальца общий тип

Serab

yroslavasako

а свичи твои со временем сломаются, поддерживать их заебесся.

Serab

yroslavasako

Serab

yroslavasako

Serab

apl13

Мне было заявлено, что без перегрузки никак нельзя сделать обобщённые операции. Я сказал, что обобщённые операции легко сделать, если позволить конструировать сложные типы.

yroslavasako

apl13

Фактически любой тип T кастится к Serializable[T], пакуется в посылку, отсылается в Америку, там его кастят обратно, применяют перегруженный метод, через месяц присылают обратно, все нормально будет.

yroslavasako

Serab

kokoc88

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

Serab

apl13

yroslavasako

doublemother

//Так нельзя сделать, потому что f будет иметь сигнатуру double(*double)

auto f = &sqrt;

f(42); // 42 здесь просто скастуется в дабл

f(38.5);

yroslavasako

doublemother

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

auto f = &someverynicefunc;



char x = f("", "idiot");

bool y = f(&sqrt);

int  j = f(std::vector({"idiots", "are", "everywhere"};

yroslavasako

kokoc88

Для разнообразия хоть один пример с разным списком параметров приведи.

double Round(double val, int precision, round_interface* ri)

{

    code line 1;

    code line 2;

    code line 3;

    code line 4;

    code line 5;

}



double Round(float val, int precision, round_interface* ri)

{

    code line 6;

    code line 7;

    code line 8;

    code line 9;

    code line 10;

}



int Round(double val, int precision)

{

    code line 11;

    code line 12;

    code line 13;

    code line 14;

    code line 15;

}



int Round(float val, int precision)

{

    code line 16;

    code line 17;

    code line 18;

    code line 19;

    code line 20;

}

yroslavasako

trait Roundable[+T]{

  def round( from : Any ) : T

}



implicit object DoubleRoundable extends Roundable[Double] {

  def round ( from : Any) : Double = from match {

     case (value : Double, precision : Int, inteface : round_interface) => {

       line6

       line7

       line8

       line9

       line10

    }

    case (value : Float, precision : Int, interface : round_interface) => {

       line1

       line2

       line3

       line4

       line5

    }

  }

}



implicit object IntRoundable extends Roundable[Double] {

  def round(from : Any) : Double = from match {

  case (value : Double, precision : Int) => {

       line16

       line17

       line18

       line19

       line20

    }

    case (value : Float, precision : Int) => {

       line11

       line12

       line13

       line14

       line15

    }

  }

}

kokoc88

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

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

code

Marinavo_0507

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

Serab

agaaaa

Dasar

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

yroslavasako

Dasar

следует заменить простую перегрузку на T sqrt(T) where T:int|float

Только вот эта штука не работает при шизофрении вроде
int sqrt(float) и float sqrt(int)

int | float sqrt (int | float)

T1 sqrt (T2) where T1:int | float, T2:int | float

Serab

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

doublemother

всегда можно обобщить до
code:
int | float sqrt (int | float)
или что тоже самое:
code:
T1 sqrt (T2) where T1:int | float, T2:int | float

Dasar

Только ты так не можешь ограничить возможные конвертации только набором:

T2 sqrt(T1)

  where T1, T2:(int, float) | (int, int) | (float, float)

doublemother

то уже получится

Dasar

Угу) А потом в функции придётся всё равно самому диспетчеризацией заниматься)

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

yroslavasako

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

doublemother

это не понял, расшифруй, пожалуйста

type MyType = IntInt of (int, int) | IntFloat of (int, float) | FloatFloat of (float, float);;

T1 mymethod (T2 arg) where T1, T2: MyType {

 match (T1, T2) with

   | IntInt -> { ... }

   | IntFloat -> { ... }

   | FloatFloat -> { ... }

}

type MyType = Node of (Leaf, Leaf) | Leaf of int;;

let walk tree = function

 | Node (x, y) -> walk x; walk y

 | Leaf (x) -> print x;;

doublemother

Ну, смотри, если описывать метод в той нотации, которую ты приводишь, то это имеет смысл, если ты после такого объявления вынужден в самом методе писать матчинг:

Dasar

Ну, смотри, если описывать метод в той нотации, которую ты приводишь, то это имеет смысл, если ты после такого объявления вынужден в самом методе писать матчинг:

sqrt

  int -> int {..}

  int -> int {..}

  float -> float {..}

int sqrt(int){..}

float sqrt(int){..}

float sqrt(float){...}