Nemerle & R# - Философия программирования

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

VD>Не понял этого шаманства. Соственно вот так будет достаточно:
Извини, но у меня сейчас настроение препаршивое. Я бы с радостью его еще кому-нибудь бы испортил, но делать в отличие от тебя этого не буду.

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

VD>Главное, что по жизни подобный код невозможно встретить днем с огнем.
А вот с этим соглашусь.

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

А слабо во время компиляции посчитать нечто типа double, стоку или скажем дату?
Например, посчитай во время компиляции сколько будет 1.234 + 123.23232.

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

... << RSDN@Home 1.2.0 alpha rev. 637>>

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

E>Кстати, если сравнить реализацию compile-time вычисления факториала на C++:
E>

E>template< int N >
E>struct Factorial {
E>    enum { value = N * Factorial< N-1 >::value };
E>};

E>template<>
E>struct Factorial< 1 > {
E>    enum { value = 1 };
E>};

E>template<>
E>struct Factorial< 0 > {};
E>

E>то мне кажется, что она получается в более функциональном стиле, что ли

Не, она получается запутанной и корявой.

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

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

using System;

macro CompileTimeFactorial(x : uint)
{
  // Приведение типов (второй  : ulong) требуется из-за ошибки в компиляторе :(
  <[ ($(Math.Factorial(x) : ulong) : ulong) ]>
}

public module Math
{
  public static Factorial(x : uint) : ulong
  {
    def Loop(acc : ulong, x : uint)
    {
      if (x <= 1) acc else Loop(acc * x, x - 1)
    }
    
    Loop (1UL, x)
  }
}

А вот применение того и другого:

using System.Console;

WriteLine(Math.Factorial(20));
WriteLine(Math.Factorial(0));
WriteLine(CompileTimeFactorial(0));
WriteLine(CompileTimeFactorial(1));
WriteLine(CompileTimeFactorial(7));
WriteLine(CompileTimeFactorial(20));

Вывод на констоль:

2432902008176640000
1
1
1
5040
2432902008176640000

Вот декомпиляция кода сгенерированного компилятором Немерла в C#:

private static void Main()
{
      Console.WriteLine(Math.Factorial(20));
      Console.WriteLine(Math.Factorial(0));
      Console.WriteLine((ulong) 1);
      Console.WriteLine((ulong) 1);
      Console.WriteLine((ulong) 0x13b0);
      Console.WriteLine((ulong) 0x21c3677c82b40000);
}

Если попытаться подставить в макрос или функцию отрицательное число:

using System.Console;

WriteLine(Math.Factorial(-1));
WriteLine(CompileTimeFactorial(-1));

то компилятор корректно сообщит об ошибке:

test-014.n:3:11:3:25: error: in argument #1 (x), needed a System.UInt32, got int: System.Int32 is not a subtype of System.UInt32 [simple require]
test-014.n:3:11:3:25: error: typing error in call
test-014.n:4:11:4:31: error: macro `CompileTimeFactorial' expects following list of arguments: (uint) got some 1 parameters [-1]

Жаль, правда, что по разному.

Попытка подсунуть в макрос динамическое значение тоже не пройдет:

using System.Console;

def x = 7;
WriteLine(CompileTimeFactorial(7));

выдаст:

test-014.n:4:11:4:31: error: macro `CompileTimeFactorial' expects following list of arguments: (uint) got some 1 parameters [x]

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

ЗЫ

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

... << RSDN@Home 1.2.0 alpha rev. 637>>

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

VD>>Не понял этого шаманства. Соственно вот так будет достаточно:
VK>Извини, но у меня сейчас настроение препаршивое.

Хм. Похоже на то.

VK>Я бы с радостью его еще кому-нибудь бы испортил, но делать в отличие от тебя этого не буду.

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

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

Извини если тебя это задело.

... << RSDN@Home 1.2.0 alpha rev. 637>>

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

VD>>Кстати, раз уж мы говорим о функциональном языке, то факториалы лучше тоже в функциональном стиле описывать:

VK>Код который ты привел крайне похож на то, что генерирует макрос for.

Естественно.

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

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

def Fact(x : uint) : ulong
{
    mutable acc = 1UL;
    
    for (mutable i = x; i > 0; i--)
        acc = acc * i;
    
    acc
}

и:

def Fact(x : uint) : ulong
{
  def Loop(acc : ulong, x : uint)
  {
    if (x <= 1) acc else Loop(acc * x, x - 1)
  }
  
  Loop(1UL, x)
}

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

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

ЗЫ

Похоже у тебя и правда плохое настроение.

... << RSDN@Home 1.2.0 alpha rev. 637>>

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

VK>Я как-то задавал подобные вопросы авторам языка. Судя по ответам их подобные задачи совсем не интересуют. Это было достаточно давно и вопросы были о проблемах и упрощении реализации аналога expression templates на Nemerle.

В общем, разумно.

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

Тут ты не прав. Авторы языка могут подсказать решение которое для нас не очевидно. Ведь они скорее всего зудумывались над подобными вопросами.

VK>Больше пользы будет если они потратят это время на фиксинг багов.

Согласен. Я собственно и сам говорю, что это балоство. Но все же мнение авторов языка интересно.

... << RSDN@Home 1.2.0 alpha rev. 637>>

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

FR>многие, после того как прочитали Александреску и Со, или просто немного понимают функцианольное программирование.

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

VD>>Примеры, именно такого использования приведи, плиз.

FR>Примеры использования boost?

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

... << RSDN@Home 1.2.0 alpha rev. 637>>

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

O>>

O>>fact<6>::value
O>>

E>Это дело привычки, на самом-то деле. Люди вон к Lisp-овой нотации привыкают

Привыкание к грязи не является достижением. Но в случае С++ можно воспользоваться родными макросами и убрать эту грязь. Так что не так смертельно.

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

... << RSDN@Home 1.2.0 alpha rev. 637>>

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

SC>>А вот здесь поспорю. Пока не подходит. Это ограничение текущей реализации платформы, причём явно временное. Ни сам язык, ни спецификация .NET таких ограничений, вроде, не содержит.

Д>а я не буду спорить

Я говорил именно про текущую реализацию. Что там да как будет потом — это можно только догадываться.

Не, ты говорил про язык. Эдак можно и про С++ это сказать. Ведь есть же МС++?

... << RSDN@Home 1.2.0 alpha rev. 637>>

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

>> тогда расскажи хотя бы, какие принципиальные проблемы ты видишь в
>> реализации данной задачи на Немерле
>> очень просто, правда?
C>1. Интероперабельность с остальным кодом на C#.

C# то тут причем? Или проблем с интероперабельностью между решением на С++ и C# нет?

C>2. Куда будет записываться информация о размерности типа?

Например, в параметры атрибута.

... << RSDN@Home 1.2.0 alpha rev. 637>>

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

C>В С++ с интероперабельностью все нормально.

Знашь какой один из самых часто задаваемых вопросов в форуме .NET?
Как передать в программу на C# класс из неуправляемого С++.

Дальще о интероперабельностьи С++ рассказывать?

... << RSDN@Home 1.2.0 alpha rev. 637>>

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

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

FR>>многие, после того как прочитали Александреску и Со, или просто немного понимают функцианольное программирование.

VD>Данный вопрос ни к ФП, ни к Александреску отношения не имеет. Это именно что прямое использование возможности параметризовать тип константами и получить эффект от того, что компилятор генерирует уникальные типы для разных значений констант.

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

)

VD>>>Примеры, именно такого использования приведи, плиз.

FR>>Примеры использования boost?

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

Так мое мнение: такой код и не должен быть прикладным, он должен лежать в библиотеках.

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

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

VD>А слабо во время компиляции посчитать нечто типа double, стоку или скажем дату?

double легко и даже без шаблонов.

VD>Например, посчитай во время компиляции сколько будет 1.234 + 123.23232.

1.234 + 123.23232. такое даже компиляторы восьмилетней давности без проблем считали. Современные целые цепочки вызвов функции умеют в одну ассемблерную инструкцию превращать.

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

VD>Наверно самая разумная запись будет:

VD>def Fact(x : int) : int
VD>{ | 0
VD>  | 1 => 1
VD>  | x when x > 0 => x * Fact(x - 1)
VD>  | _ => throw ArgumentException("x")
VD>}

Спасибо! Вот что значит плохое знание языка — не знал, как же дописать условие в матче...

VladD2 wrote:
> C>В С++ с интероперабельностью все нормально.
> Знашь какой один из самых часто задаваемых вопросов в форуме .NET?
> Как передать в программу на C# класс из неуправляемого С++.
Я говорил про интероперабельность с С.

Posted via RSDN NNTP Server 2.0

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

VD>А нельзя ли просто воспользоваться отдельными переменными вместо массива?
Можно. Но ты же сам за абстракции. Причем если valarray дает нехилый abstraction penalty то код с fixed_valarray свободен от этого недостатка.

... << RSDN@Home 1.1.4 beta 6a rev. 436>>

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

>> C>В С++ с интероперабельностью все нормально.
>> Знашь какой один из самых часто задаваемых вопросов в форуме .NET?
>> Как передать в программу на C# класс из неуправляемого С++.
C>Я говорил про интероперабельность с С.

Интероперабельность Nemerle с C# присутствует как минимум в том же виде, что и интероперабельность C++ с Си.

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

FR>1.234 + 123.23232. такое даже компиляторы восьмилетней давности без проблем считали. Современные целые цепочки вызвов функции умеют в одну ассемблерную инструкцию превращать.
Ты путаешь оптимизацию и вычисления во время компиляции. Это хоть и близкие но всетки разные вещи.
Вот это вычисления во время компиляции

template< int N >
struct Factorial {
    enum { value = N * Factorial< N-1 >::value };
};

template<>
struct Factorial< 0 > {
    enum { value = 1 };
};
...
int i = Factorial< 0 >::value;

А это оптимизация

float foo()
{
    return 1;
}
float bar()
{
    return 2;
}
...
float i = foo() + bar();//в рантайме будет подставлена 3

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

Так вот С++ не умеет работать с числами с плавающей точкой во время компиляции. Стандарт у него такой.

... << RSDN@Home 1.1.4 beta 6a rev. 436>>

	От:	Vermicious Knid
	Дата:	28.03.06 00:33
	Оценка:

От:	VladD2	www.nemerle.org
Дата:	28.03.06 01:03
Оценка:

От:	VladD2	www.nemerle.org
Дата:	28.03.06 01:03
Оценка:

От:	VladD2	www.nemerle.org
Дата:	28.03.06 01:25
Оценка:

От:	VladD2	www.nemerle.org
Дата:	28.03.06 01:25
Оценка:

От:	Oyster	https://github.com/devoyster
Дата:	28.03.06 06:13
Оценка:

	От:	WolfHound
	Дата:	28.03.06 08:05
	Оценка:	28 (2)