Вики проекта PascalABC.NET - Вклад [ru]

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

2009-11-12T09:54:18Z

213.138.92.85: /* Обзор */

==Реализовано с помощью узлов синтаксического дерева PascalABC :==
* Подключение внешних сборок (import)
* Типы данных : булевский, вещественный, целый, символьный и строки
* Простые операции с ними
* Описание функций и главная функция main
* Сопоставление с образцом
* if, case, охранные выражения
* Операторы do, print, return
* Локальные переменные (where)
* Списки (перечислимые, прогрессии, бесконечные)
* Оператор ‘:’
* Частично обработка ошибок
* Комментарии --, <--, -->
==Обзор==
<ol>
<li TYPE=I>
Математическим фундаментом функционального программирования является '''лямбда-исчисление'''. Такие языки как Haskell и Clean имеют 100% соответствие своей семантики с семантикой подразумеваемых конструкций лямбда-исчисления. Используя лямбда-абстракции можно определить булевские значения и условия, пары и кортежи и даже натуральные числа. 
Натуральные числа и булевские выражения и операции с ними проще определить, используя их определение в PascalABC. Прямую рекурсию также легче реализовать естественным путем. Для других конструкций целесообразно использовать лямбда-функции:
<ol>
<li> безымянные функции
<li> именованные выражения
<ol>
<li TYPE=a> let x=s in T ↔ (λx.T) s
<li TYPE=a> T where x=s ↔ (λx.T) s
</ol>
<li> определение правой части функции через лямбда-выражение, т.е. реализовать if, case и сравнение с образцом → благодаря этому будет возможно описание функции, используя if и case, внутри выражения
<li> реализация функций высшего порядка и каррирования.
</ol>
Для реализации лямбда-исчисления может быть использована библиотека в .NET Framework 4 Beta1 Expression.Lambda.
private static Func<object, object> CreateGetter(object entity, string propertyName)
{
var param = Expression.Parameter(typeof (object), «e»);
Expression body = Expression.PropertyOrField(Expression.TypeAs(param, entity.GetType()), propertyName);
var getterExpression = Expression.Lambda<Func<object, object>>(body, param);
return getterExpression.Compile();
}

<li TYPE=I>
'''Выводимость типов.''' Тип функции выводится интерпретатором в зависимости от того, от каких аргументов она вызывается.
<li TYPE=I>
'''Реализация ленивых вычислений.''' Функциональные языки делятся на 2 лагеря: те, в которых параметры передаются по значению, и те, в которых имеет место вызов по необходимости (вычисление производится один раз). Ленивые вычисления можно реализовать, сделав специальную обертку для параметров. В Framework 4 есть такая поддержка ленивых вычислений – класс Lazy.</li>
static void F(Lazy<int> a)
{
Console.WriteLine(a.value);// a вычислится только здесь при вызове
}
<li TYPE=I>
'''Классы типов.''' Класс типов представляет собой некоторое множество типов языка, обладающих общими свойствами. Классы позволяют определять, какие типы являются экземплярами каких классов, и предоставлять определения ассоциированных с классом операций, перегруженных для каждого типа. Интуитивно классы типов можно понимать как интерфейсы.
<li TYPE=I>
'''Монады и определение типов data, операция ←.''' В Haskell монады нужны в первую очередь для определения операций ввода-вывода, т.к. они не соответствуют парадигмам функционального программирования (getChar вызывается от одного и того же аргумента, а результат разный).
</ol>

==Ссылки==
* http://kchri.narod.ru
* http://ru.wikipedia.org/wiki/Язык_функционального_программирования

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

2009-11-12T09:48:54Z

213.138.92.85: /* Обзор */

==Реализовано с помощью узлов синтаксического дерева PascalABC :==
* Подключение внешних сборок (import)
* Типы данных : булевский, вещественный, целый, символьный и строки
* Простые операции с ними
* Описание функций и главная функция main
* Сопоставление с образцом
* if, case, охранные выражения
* Операторы do, print, return
* Локальные переменные (where)
* Списки (перечислимые, прогрессии, бесконечные)
* Оператор ‘:’
* Частично обработка ошибок
* Комментарии --, <--, -->
==Обзор==
<ol>
<li TYPE=I>
Математическим фундаментом функционального программирования является '''лямбда-исчисление'''. Такие языки как Haskell и Clean имеют 100% соответствие своей семантики с семантикой подразумеваемых конструкций лямбда-исчисления. Используя лямбда-абстракции можно определить булевские значения и условия, пары и кортежи и даже натуральные числа. 
Натуральные числа и булевские выражения и операции с ними на мой взгляд проще определить, используя их определение в PascalABC. Прямую рекурсию также легче реализовать естественным путем. Для других конструкций целесообразно использовать лямбда-функции:
<ol>
<li> безымянные функции
<li> именованные выражения
<ol>
<li TYPE=a> let x=s in T ↔ (λx.T) s
<li TYPE=a> T where x=s ↔ (λx.T) s
</ol>
<li> определение правой части функции через лямбда-выражение, т.е. реализовать if, case и сравнение с образцом → благодаря этому будет возможно описание функции, используя if и case, внутри выражения
<li> реализация функций высшего порядка и каррирования.
</ol>
Для реализации лямбда-исчисления может быть использована библиотека в .NET Framework 4 Beta1 Expression.Lambda.
private static Func<object, object> CreateGetter(object entity, string propertyName)
{
var param = Expression.Parameter(typeof (object), «e»);
Expression body = Expression.PropertyOrField(Expression.TypeAs(param, entity.GetType()), propertyName);
var getterExpression = Expression.Lambda<Func<object, object>>(body, param);
return getterExpression.Compile();
}

<li TYPE=I>
'''Выводимость типов.''' Тип функции выводится интерпретатором в зависимости от того, от каких аргументов она вызывается.
<li TYPE=I>
'''Реализация ленивых вычислений.''' Функциональные языки делятся на 2 лагеря: те, в которых параметры передаются по значению, и те, в которых имеет место вызов по необходимости (вычисление производится один раз). Ленивые вычисления можно реализовать, сделав специальную обертку для параметров. В Framework 4 есть такая поддержка ленивых вычислений – класс Lazy.</li>
static void F(Lazy<int> a)
{
Console.WriteLine(a.value);// a вычислится только здесь при вызове
}
<li TYPE=I>
'''Классы типов.''' Класс типов представляет собой некоторое множество типов языка, обладающих общими свойствами. Классы позволяют определять, какие типы являются экземплярами каких классов, и предоставлять определения ассоциированных с классом операций, перегруженных для каждого типа. Интуитивно классы типов можно понимать как интерфейсы.
<li TYPE=I>
'''Монады и определение типов data, операция ←.''' В Haskell монады нужны в первую очередь для определения операций ввода-вывода, т.к. они не соответствуют парадигмам функционального программирования (getChar вызывается от одного и того же аргумента, а результат разный).
</ol>
==Ссылки==
* http://kchri.narod.ru
* http://ru.wikipedia.org/wiki/Язык_функционального_программирования

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

2009-11-12T09:41:42Z

213.138.92.85: /* Обзор */

==Реализовано с помощью узлов синтаксического дерева PascalABC :==
* Подключение внешних сборок (import)
* Типы данных : булевский, вещественный, целый, символьный и строки
* Простые операции с ними
* Описание функций и главная функция main
* Сопоставление с образцом
* if, case, охранные выражения
* Операторы do, print, return
* Локальные переменные (where)
* Списки (перечислимые, прогрессии, бесконечные)
* Оператор ‘:’
* Частично обработка ошибок
* Комментарии --, <--, -->
==Обзор==
<ol>
<li TYPE=I>
Математическим фундаментом функционального программирования является '''лямбда-исчисление'''. Такие языки как Haskell и Clean имеют 100% соответствие своей семантики с семантикой подразумеваемых конструкций лямбда-исчисления. Используя лямбда-абстракции можно определить булевские значения и условия, пары и кортежи и даже натуральные числа. 
Натуральные числа и булевские выражения и операции с ними на мой взгляд проще определить, используя их определение в PascalABC. Прямую рекурсию также легче реализовать естественным путем. Для других конструкций целесообразно использовать лямбда-функции:
<ol>
<li> безымянные функции
<li> именованные выражения
<ol>
<li TYPE=a> let x=s in T ↔ (λx.T) s
<li TYPE=a> T where x=s ↔ (λx.T) s
</ol>
<li> определение правой части функции через лямбда-выражение, т.е. реализовать if, case и сравнение с образцом → благодаря этому будет возможно описание функции, используя if и case, внутри выражения
<li> реализация функций высшего порядка и каррирования.
</ol>
Для реализации лямбда-исчисления может быть использована библиотека в .NET Framework 4 Beta1 Expression.Lambda.
private static Func<object, object> CreateGetter(object entity, string propertyName)
{
var param = Expression.Parameter(typeof (object), «e»);
Expression body = Expression.PropertyOrField(Expression.TypeAs(param, entity.GetType()), propertyName);
var getterExpression = Expression.Lambda<Func<object, object>>(body, param);
return getterExpression.Compile();
}

<li TYPE=I>
'''Выводимость типов.''' Тип функции выводится интерпретатором в зависимости от того, от каких аргументов она вызывается.
<li TYPE=I>
'''Реализация ленивых вычислений.''' Функциональные языки делятся на 2 лагеря: те, в которых параметры передаются по значению, и те, в которых имеет место вызов по необходимости (вычисление производится один раз). Ленивые вычисления можно реализовать, сделав специальную обертку для параметров. В Framework 4 есть такая поддержка ленивых вычислений – класс Lazy.</li>
static void F(Lazy<int> a)
{
Console.WriteLine(a.value);// a вычислится только здесь при вызове
}
<li TYPE=I>
'''Классы типов.''' Класс типов представляет собой некоторое множество типов языка, обладающих общими свойствами. Классы позволяют определять, какие типы являются экземплярами каких классов, и предоставлять определения ассоциированных с классом операций, перегруженных для каждого типа. Интуитивно классы типов можно понимать как интерфейсы.
<li TYPE=I>
'''Монады и определение типов data, операция ←.''' В Haskell монады нужны в первую очередь для определения операций ввода-вывода, т.к. они не соответствуют парадигмам функционального программирования (getChar вызывается от одного и того же аргумента, а результат разный).
</ol>

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

2009-11-12T09:41:07Z

213.138.92.85: /* Обзор */

==Реализовано с помощью узлов синтаксического дерева PascalABC :==
* Подключение внешних сборок (import)
* Типы данных : булевский, вещественный, целый, символьный и строки
* Простые операции с ними
* Описание функций и главная функция main
* Сопоставление с образцом
* if, case, охранные выражения
* Операторы do, print, return
* Локальные переменные (where)
* Списки (перечислимые, прогрессии, бесконечные)
* Оператор ‘:’
* Частично обработка ошибок
* Комментарии --, <--, -->
==Обзор==
<ol>
<li TYPE=I>
Математическим фундаментом функционального программирования является лямбда-исчисление. Такие языки как Haskell и Clean имеют 100% соответствие своей семантики с семантикой подразумеваемых конструкций лямбда-исчисления. Используя лямбда-абстракции можно определить булевские значения и условия, пары и кортежи и даже натуральные числа. 
Натуральные числа и булевские выражения и операции с ними на мой взгляд проще определить, используя их определение в PascalABC. Прямую рекурсию также легче реализовать естественным путем. Для других конструкций целесообразно использовать лямбда-функции:
<ol>
<li> безымянные функции
<li> именованные выражения
<ol>
<li TYPE=a> let x=s in T ↔ (λx.T) s
<li TYPE=a> T where x=s ↔ (λx.T) s
</ol>
<li> определение правой части функции через лямбда-выражение, т.е. реализовать if, case и сравнение с образцом → благодаря этому будет возможно описание функции, используя if и case, внутри выражения
<li> реализация функций высшего порядка и каррирования.
</ol>
Для реализации лямбда-исчисления может быть использована библиотека в .NET Framework 4 Beta1 Expression.Lambda.
private static Func<object, object> CreateGetter(object entity, string propertyName)
{
var param = Expression.Parameter(typeof (object), «e»);
Expression body = Expression.PropertyOrField(Expression.TypeAs(param, entity.GetType()), propertyName);
var getterExpression = Expression.Lambda<Func<object, object>>(body, param);
return getterExpression.Compile();
}

<li TYPE=I>
'''Выводимость типов.''' Тип функции выводится интерпретатором в зависимости от того, от каких аргументов она вызывается.
<li TYPE=I>
'''Реализация ленивых вычислений.''' Функциональные языки делятся на 2 лагеря: те, в которых параметры передаются по значению, и те, в которых имеет место вызов по необходимости (вычисление производится один раз). Ленивые вычисления можно реализовать, сделав специальную обертку для параметров. В Framework 4 есть такая поддержка ленивых вычислений – класс Lazy.</li>
static void F(Lazy<int> a)
{
Console.WriteLine(a.value);// a вычислится только здесь при вызове
}
<li TYPE=I>
'''Классы типов.''' Класс типов представляет собой некоторое множество типов языка, обладающих общими свойствами. Классы позволяют определять, какие типы являются экземплярами каких классов, и предоставлять определения ассоциированных с классом операций, перегруженных для каждого типа. Интуитивно классы типов можно понимать как интерфейсы.
<li TYPE=I>
'''Монады и определение типов data, операция ←.''' В Haskell монады нужны в первую очередь для определения операций ввода-вывода, т.к. они не соответствуют парадигмам функционального программирования (getChar вызывается от одного и того же аргумента, а результат разный).
</ol>

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

2009-11-12T09:40:03Z

213.138.92.85: /* Обзор */

==Реализовано с помощью узлов синтаксического дерева PascalABC :==
* Подключение внешних сборок (import)
* Типы данных : булевский, вещественный, целый, символьный и строки
* Простые операции с ними
* Описание функций и главная функция main
* Сопоставление с образцом
* if, case, охранные выражения
* Операторы do, print, return
* Локальные переменные (where)
* Списки (перечислимые, прогрессии, бесконечные)
* Оператор ‘:’
* Частично обработка ошибок
* Комментарии --, <--, -->
==Обзор==
<ol>
<li TYPE=I>
Математическим фундаментом функционального программирования является лямбда-исчисление. Такие языки как Haskell и Clean имеют 100% соответствие своей семантики с семантикой подразумеваемых конструкций лямбда-исчисления. Используя лямбда-абстракции можно определить булевские значения и условия, пары и кортежи и даже натуральные числа. 
Натуральные числа и булевские выражения и операции с ними на мой взгляд проще определить, используя их определение в PascalABC. Прямую рекурсию также легче реализовать естественным путем. Для других конструкций целесообразно использовать лямбда-функции:
<ol>
<li> безымянные функции
<li> именованные выражения
<ol>
<li TYPE=a> let x=s in T ↔ (λx.T) s
<li TYPE=a> T where x=s ↔ (λx.T) s
</ol>
<li> определение правой части функции через лямбда-выражение, т.е. реализовать if, case и сравнение с образцом → благодаря этому будет возможно описание функции, используя if и case, внутри выражения
<li> реализация функций высшего порядка и каррирования.
</ol>
Для реализации лямбда-исчисления может быть использована библиотека в .NET Framework 4 Beta1 Expression.Lambda.
private static Func<object, object> CreateGetter(object entity, string propertyName)
{
var param = Expression.Parameter(typeof (object), «e»);
Expression body = Expression.PropertyOrField(Expression.TypeAs(param, entity.GetType()), propertyName);
var getterExpression = Expression.Lambda<Func<object, object>>(body, param);
return getterExpression.Compile();
}

<li TYPE=I>
'''Выводимость типов.''' Тип функции выводится интерпретатором в зависимости от того, от каких аргументов она вызывается.
<li TYPE=I>
'''Реализация ленивых вычислений.''' Функциональные языки делятся на 2 лагеря: те, в которых параметры передаются по значению, и те, в которых имеет место вызов по необходимости (вычисление производится один раз). Ленивые вычисления можно реализовать, сделав специальную обертку для параметров. В Framework 4 есть такая поддержка ленивых вычислений – класс Lazy.
static void F(Lazy<int> a)
{
Console.WriteLine(a.value);// a вычислится только здесь при вызове
}
<li TYPE=I>
'''Классы типов.''' Класс типов представляет собой некоторое множество типов языка, обладающих общими свойствами. Классы позволяют определять, какие типы являются экземплярами каких классов, и предоставлять определения ассоциированных с классом операций, перегруженных для каждого типа. Интуитивно классы типов можно понимать как интерфейсы.
<li TYPE=I>
'''Монады и определение типов data, операция ←.''' В Haskell монады нужны в первую очередь для определения операций ввода-вывода, т.к. они не соответствуют парадигмам функционального программирования (getChar вызывается от одного и того же аргумента, а результат разный).
</ol>

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

2009-11-12T09:33:56Z

213.138.92.85: /* Обзор */

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

2009-11-12T09:29:37Z

213.138.92.85: Новая: ==Реализовано с помощью узлов синтаксического дерева PascalABC :== * Подключение внешних сборок (import) * Типы ...

Заглавная страница

2009-11-12T09:23:31Z

213.138.92.85: /* Web-среда разработки PascalABC.NET */

== Некоторые статьи о PascalABC.NET ==
* [[FAQ по PascalABC.NET]]
* [[Шаблоны кода]]

== Web-среда разработки PascalABC.NET ==

[[Основная страница проекта WDE PascalABC.NET|Основная страница проекта]]

==Реализация основных возможностей функционального языка программирования в среде PascalABC.NET==

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

== Статьи о внутреннем представлении PascalABC.NET ==

* [[Архитектура PascalABC.NET]]
* [[Интерфейс подключения нового языка программирования]]
* [[Директивы компилятора]]
* [[Синтаксическое дерево]]
* [[Семантическое дерево]]
* [[Формат PCU]]
* [[Отладчик]]
* [[Intellisense]]

* [[OpenMP]]

== Статьи по программированию в PascalABC.NET ==
* [[Локализация приложений]]
* [[Плагины для PascalABC.NET]]
* [[OpenGL]]

== Другие статьи ==
* [[Использование базы данных MS SQL - ликбез]]
* [[Аспектно-ориентированное программирование]]
* [[Рефакторинг]]
* [[Алгоритмы для начинающих на примерах]]