Зачем нужно функциональное программирование?

Ivan8209

Ivan8209

Chupa

Ivan8209

Chupa

Ivan8209

Chupa

Ivan8209

Chupa

Marinavo_0507

Marinavo_0507

Aleksei66

Dasar

Dasar

Ivan8209

Marinavo_0507

Ivan8209

Dasar

Marinavo_0507

Ivan8209

Dasar

Ivan8209

Dasar

Dasar

Ivan8209

Marinavo_0507

Marinavo_0507

Marinavo_0507

Dasar

Dasar

Marinavo_0507

Ivan8209

(define (orl . l)

  (if (null? l) #f

    (if (car l) #t (apply orl (cdr l

(define (mapcar f l)

  (if (null? l) l

    (cons (f (car l (mapcar f (cdr l

(define (map f . l)

  (if (apply orl (mapcar null? l '

    (cons (apply f (mapcar car l

	  (map f (mapcar cdr l

(map + '(1 2 3 4) '(5 6 7 8

Dasar

#include <algorithm>

#include <functional>

#include <iterator>

#include <vector>

int _tmain(int argc, _TCHAR* argv[])

{

	int f1[] = {1, 4, 2};

	int f2[] = {3, -4, 1};

	std::vector<int> result;

	std::transform(&f1[0], &f1[sizeof(f1)/sizeof(int)], &f2[0], 

		std::back_insert_iterator<std::vector<int> >(result

		std::plus<int>

	return 0;

}

Ivan8209

Dasar

Dasar

Ivan8209

Ivan8209

Dasar

solteron

> В отличие от Лиспа ни у одного ИЯ нет единства программ и данных.
У ФЯ тоже

Dasar

Ivan8209

Ivan8209

Ivan8209

solteron

Aleksei66

DiDiPi

freezer

 

#include <algorithm>

#include <functional>

#include <iterator>

#include <vector>

using namespace std;

int main

{

	int f1[] = {1, 4, 2}, f2[] = {3, -4, 1};

	vector<int> result;

	transform(f1, f1+sizeof(f1)/sizeof(int f2, back_inserter(result plus<int>

	return 0;

}

 

 

#include "vectop.h"

using namespace cmpml;

void main

{

   array1d<int> a, b, c;

  a=1, 4, 2; b=3, -4, 1;

  c=a, b;

}

 

Dasar

double pi = 3,1415;

Darion

Dasar

Marinavo_0507

Marinavo_0507

Chupa

Chupa

Функциональное программирование прекрасно, оно - радость созерцания. Как только кто-то поймет функциональное программирование, он немедленно перейдет к нему. Массы, которые застряли в устаревшем императивном и объектно-ориентированном программировании, делают это из слепого предубеждения. Они просто не понимают.

Papazyan

Как пример готового проекта, дам ссылку:
http://www.fdc.ru/portal/page?pageid=60,54746&_dad=portal&_schema=PORTAL
это адрес страницы, на которой описывается проект миграции из PL/SQL в современные Java технологии.

Papazyan

Я не понимаю, как этот самый pattern matching поможет в больших проектах, если он работает только со списками.
Сначала пара вопросов:
что такое тип в понятие ML-я?
можно ли на нем описать тип натуральное число? как это будет выглядить? Что это нам даст?
можно ли описать, например, тип C-идентификатор - это строка, с рядом ограничений
можно ли описать, например, тип идентификатор - это нечто, которое можно между собой сравнивать.

Dasar

Papazyan

Dasar

Dasar

Dasar

sergey_m

Приведи примеры программ, для которых ОО лишний, и не дает ничего полезного.

Замечу, что список, атом, число, строка, функция - это все тоже объекты, каждый из которых поддерживает свой набор операций над ним.
т.е. получается, что в программе на ФЯ у нас есть только объекты зашитые в язык, но нет возможности описать свои объекты.

Papazyan

Marinavo_0507

Dasar

Marinavo_0507

Darion

structure Nat :> sig

    (* это что-то типа интерфейса *)

    type nat

    val make_nat : int -> nat

    val to_int : nat -> int

    val plus : nat -> nat -> nat

    val minus: nat -> nat -> nat

    (* тут идут другие декларации *)

end = struct

    datatype nat = 

          Nat of int

        | NotNat

    fun make_nat n = if n > 0 then Nat n else NotNat

    fun to_int (Nat n) = n

      | to_int _ = 0

    fun plus (Nat n1) (Nat n2) = Nat (n1 + n2)

      | plus _ _ = NotNat

    fun minus (Nat n1) (Nat n2) = if n1 > n2 then Nat (n1 - n2) else NotNat

      | minus _ _ = NotNat

    (* тут идут другие функции *)

end

structure Circle :> sig

    type circle

    val make_circle: real * real * real -> circle

    val relocate : (real * real) -> circle -> circle

    val to_graphics : circle -> Graphics.graphics

end = struct

    datatype circle = 

          Circle of real * real * real (* коорд. х, коорд. у, радиус *)

        | NotCircle

    fun make_circle (x, y, r: real) = if r > 0 then Circle (x, y, r) else NotCircle

    fun relocate (x', y') (Circle (x, y, r = Circle (x', y', r)

      | relocate _ _ = NotCircle

    fun to_graphics (c as (Circle _ = let

        fun to_graphics' (c as (Circle (x, y, r graphics alpha = let

            val x1 = (x + r * (Math.cos alpha

            val y1 = (y + r * (Math.sin alpha

            val alpha = alpha + 1;

            val x2 = (x + r * (Math.cos alpha

            val y2 = (y + r * (Math.sin alpha

            val graphics = Graphics.DrawLine x1, y1 (x2, y2 graphics

        in

            if alpha < 360 then 

                to_graphics' c graphics alpha

            else

                graphics

        end

          | to_graphics' _ g _ = g

    in

        to_graphics' c Graphics.empty 0

    end

      | to_graphics _ = Graphics.empty

end

Dasar

Dasar

Dasar

Papazyan

sergey_m

> Посмотри в исходники Linux или FreeBSD.
Там полно ОО
Так что пример плохой.

Dasar

sergey_m

> Ну и отлично. Там же не только ОО. Требовались примеры, где ОО лишнее - вот примеры.
Тогда говори точнее. Иначе получается "иди туда не знаю куда, но там где-то точно есть места, где ОО нет".

Dasar

Рассмотрим класс "эллипс". Этот класс может обозначать две разные сущности:
1. Элиппс, не являющейся кругом. Или другими словами - это эллипс без вырожденных случаев.
2. Эллипс с учетом всех вырожденных случаев. Фактически такой эллипс должен содержать поведение и для таких вырожденных случаев, как круг, точка и может быть такие вырожденные случаи, как "плоскость"(эллипс бесконечного радиуса "отрезок" (эллипс нулевой длины и какой-то ширины "прямая" (эллипс нулевой длины и бесконечного радиуса
"полоса" (эллипс какой-то ширины и бесконечной длины).
Теперь поговорим об интерфейсах для данного случая.
Интерфейсы получаются следующие:
Не вырожденный эллипс ( 0 < ширина < бесконечность, 0 < высота < бесконечность, ширина != высота)
Круг
"Точка"
"Плоскость"
"Полоса"
"Отрезок"
Обобщенный эллипс
Рассмотрим интерфейс "круг". Здесь тоже возможны два разных интерфейса, которые скрываются под одним словом "круг".
С одной стороны - это интерфейс, который поддерживает все операции доступные над кругом, в том числе и растяжение по одной из оси, с другой стороны - возможен интерфейс, который допускает только те операции, результат которых остается в поле "круг" (т.е. в результате после операции круг остается кругом).
рассмотрим интерфейс "обобщенный эллипс".
Например, метод "Дай оси симметрии". такой метод в отличии от такого же метода для невырожденного эллипса, должен возвращать не только пару осей, как для невырожденного эллипса, но и должен уметь возвращать множество из бесконечного числа осей симметрии, т.к. у частного случая "круг" именно такой набор осей симметрии.
Или возьмем метод "Дай больший радиус", если для невырожденного эллипса такой метод имел смысл, то для обобщенного эллипса - этот метод уже может заканчиваться ошибкой, т.к. большего радиуса у вырожденных случаев (круг/точка) просто нет.
Получается, что когда мы говорим про интерфейс "обобщенный эллипс" мы также подразумеваем два разных интерфейса: один интерфейс - это операции, которые доступны над каждым вариантом эллипса, второй интерфейс - это набор операций, которые доступны хотя бы над одним вариантом эллипса.
Компоненты не имеют право, напрямую, ссылаться на типы-реализации (иначе получаем нарушение инкапсуляции и нарушение полиморфизма). Компоненты имеют право только пользоваться вышеприведенными интерфейсами.
Теперь вернемся к наследованию, как я уже вышеупомянул, термин "наследование" в первую очередь означает наследование реализации.
Рассмотрим класс-реализацию "обобщенный эллипс".
Этот класс должен реализовывать все вышеуказанные интерфейсы, а их у нас получилось, как минимум 12 штук.
Т.е. получается, что класс-реализация "обобщенный эллипс" содержит реализации интерфейсов "круг", "точка", "невырожденный эллипс" и т.д.
Рассмотрим класс-реализацию "круг".
Этот класс содержит 3 реализации интерфейсов: класс-реализация "точка", класс-реализация "круг с операциями из поля круг", класс-реализация "круг с операциями, выводящие из поля круг".
Теперь рассмотрим наследование реализаций.
Наследовать мы можем, как класс-реализацию "круг" от класс-реализации "обобщенный эллипс", так и "обобщенный эллипс" от "круга".
-- наследование класса-реализации "обобщенный эллипс" от класса-реализации "круг" --
Здесь все просто. Обобщенный эллипс добавляет реализацию тех методов, которые не были реализованы в круге.
-- Наследование класса-реализации "круг" от класса-реализации "обобщенный эллипс". --
Вот мы и добрались до самого интересного.
В данном случае такое наследование тоже может быть. Класс-реализация "круг" после наследования от класса-реализации "обощенный эллипс" отключает ненужные ему реализации, оставляя только необходимые.
В данном случае, нет нарушений правил Лисковой, потому что внешние компоненты не имеют права ссылаться на класс-реализации, они имеют право только ссылаться на интерфейсы.
А для всех внешних компонентов, данный класс-реализация выглядит как правильная класс-реализация "круг"-а.
И для внешних компонентов такое наследование совершенно прозрачно.
Поговорим чуть-чуть о динамической типизации.
Как мы уже выше убедились, у нас есть интерфейсы, которые оставляют класс в том же поле, что и до операции, но есть также и операции, которые переводят класс из одного поля в другое.
Если программе достаточно интерфейсов первого рода, то можно обойтись статической типизацией, а также тем, что объект не меняет набор поддерживаемых интерфейсов по ходу работы.
Если же нам нужны и интерфейсы второго рода и не достаточно интерфейсов первого рода, то необходимы также и динамической типизации, а также изменение набора поддерживаемых интерфейсов у объекта по ходу работы.
Все текущие индустриальные языки (C++, Java, C#) довольствуются интерфейсами только первого рода, и не поддерживают, напрямую, интерфейсы второго рода.

Papazyan

Dasar

sergey_m

Приведи законченный пример.

Chupa

Dasar

Darion

Пока стандартный вопрос на засыпку, что возвращает (какой тип) функция "растянуть по оси-x", если ее применить к кругу или эллипсу?
какой тип будет в результате, если к кругу применить последовательно операции: растянуть по осиX в два раза, сжать по осиX в два раза?

Papazyan

freezer

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

 

int f1[3];

int f2[3];

f1[0]=1;

f1[1]=4;

f[2]=2;

f2[0]=3;

f2[1]= -4;

f2[2]=1;

 

В больших приложения за такое убивают.

тем более данной кусок изменяет семантику оператора запятая

Dasar

void Пнуть (Мяч, НогаВБутце){}

void Пнуть (Шкаф, ГолаяНога){}

Chupa

Papazyan

Papazyan

Darion

Papazyan

shlyumper

Chupa

yaantonio

Интересно, как в ABBYY с ЕЯ работают?

Aleksei66

borneo5

Dasar

Dasar

int in_broadcast(struct in_addr, struct ifnet *);
int in_canforward(struct in_addr);
int in_cksum(struct mbuf *, int);
int in4_cksum(struct mbuf *, u_int8_t, int, int);
void in_delayed_cksum(struct mbuf *);
int in_localaddr(struct in_addr);
void in_socktrim(struct sockaddr_in *);
char *inet_ntoa(struct in_addr);

sergey_m

Dasar

public class IPAddress

{

 private static IPAddress;

public IPAddress(byte[] address);

public IPAddress(byte[] address, long scopeid);

internal IPAddress(int newAddress);

public IPAddress(long newAddress);

public override bool Equals(object comparand);

public byte[] GetAddressBytes;

public override int GetHashCode;

public static short HostToNetworkOrder(short host);

public static int HostToNetworkOrder(int host);

public static long HostToNetworkOrder(long host);

internal bool IsIPv4Compatible;

internal bool IsIPv4Mapped;

internal bool IsIPv6LinkLocal;

internal bool IsIPv6Multicast;

internal bool IsIPv6MulticastGlobal;

internal bool IsIPv6MulticastLinkLocal;

internal bool IsIPv6MulticastNodeLocal;

internal bool IsIPv6MulticastOrgLocal;

internal bool IsIPv6MulticastSiteLocal;

internal bool IsIPv6SiteLocal;

public static bool IsLoopback(IPAddress address);

public static short NetworkToHostOrder(short network);

public static int NetworkToHostOrder(int network);

public static long NetworkToHostOrder(long network);

public static IPAddress Parse(string ipString);

public override string ToString;

public long Address { get; set; }

public AddressFamily AddressFamily { get; }

internal bool IsBroadcast { get; }

public long ScopeId { get; set; }

public static readonly IPAddress Any;

public static readonly IPAddress Broadcast;

internal const string InaddrNoneString = "255.255.255.255";

internal const string InaddrNoneStringHex = "0xff.0xff.0xff.0xff";

internal const string InaddrNoneStringOct = "0377.0377.0377.0377";

public static readonly IPAddress IPv6Any;

public static readonly IPAddress IPv6Loopback;

public static readonly IPAddress IPv6None;

public static readonly IPAddress Loopback;

internal const long LoopbackMask = 127;

internal long m_Address;

private AddressFamily m_Family;

private int m_HashCode;

private ushort[] m_Numbers;

private long m_ScopeId;

public static readonly IPAddress None;

internal const int NumberOfLabels = 8;

private static bool s_Initialized;

 

}

 

Dasar

sergey_m

И чем этот In_Addr Отличается от вот такого класса: ?

struct in_addr {

        in_addr_t s_addr;

};

Dasar

Dasar

struct in_addr

 {

        in_addr_t s_addr;

};

char *inet_ntoa(struct in_addr);

class in_addr

 {

public:

        in_addr_t s_addr;

        char *inet_ntoa;

};

Chupa

Dasar

Marinavo_0507

Chupa

Dasar

Marinavo_0507

Dasar

Dasar

sergey_m

Вызовы
inet_ntoa(in_addr);
и
in_addr.inet_ntoa;
даже один и тот же asm-код генерируют.

Marinavo_0507

Ivan8209

let vec_res = map (+) vec1 vec2; (* SML *)

(set! vec-res (map + vec1 vec2  ;; Scheme

Ivan8209

(define old-+ +)

(define (+ a b)

  (cond number? a) (+ (cons a 0) b

	number? b) (+ a (cons b 0

	(else (cons (old-+ (car a) (car b (old-+ (cdr acdr b

Ivan8209

Ivan8209

Ivan8209

Ivan8209

Dasar

Dasar

Dasar

Dasar

template<typename Function, typename Result, typename Source>

Result fold(Function function, Result initialValue, list<Source> items)

{

   Result res = initialValue;

   foreach (Source item in items)

   {

     res = function(res, item);

   }

   return res;

}

template<typename Result, typename Function, typename Source>

list<Result> transform(Function function, std::list<Source> items)

{

   return fold(delegate(list<Result> items, Source item) {items.add(function(item;},

      new list<Result> items);

}

Ivan8209

Dasar

Dasar

Dasar

Ivan8209

Dasar

Ivan8209

Ivan8209

Ivan8209

for(i=0,a=0; i<чего-то-там; i++) a+=x[i]*y[i];

Dasar

template<class Left, class Right, class Result>

class plus

{

  Result operator  (Left left, Right right) {return Left + Right;}

}

Dasar

Dasar

Ivan8209

Ivan8209

Ivan8209

Aleksei66

Aleksei66

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

sergey_m

Мне лень искать ссылки.
Но относительно глаголов повелительного наклонения я прав.
Можешь исследовать этот вопрос.

Извини, если ты настаиваешь на весьма спорном утверждении, то приводить ссылки твоё дело, а не оппонента. Иначе Ваш славный спор превратится в флейм.

Dasar

Aleksei66

Ivan8209

rosali

rosali

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

freezer

мультиметоды (функции, полиморфные по нескольким параметрам

@ В Haskell-е весь полиморфизм статический. Точный тип любой переменной известен на момент компиляции.

в ООП до сих пор нет

Marinavo_0507

freezer

Marinavo_0507

Smaug

тогда этот "полиморфизм" - то же самое, что перегрузка в C++.

double f(double x, double y){ return(x+y); }

int f(int x, int y){ return(x-y); }

double f(double x, int y){ return(x*y); } 

template<class T, class S>

T g(T t, S s){  return(f(f(t,ss; } 

g(5, 6);

g(5.5, 6.6);

rosali

rosali

Тот кто не изучил вопрос

Ivan8209

1234554321

Ivan8209

rosali

code:
let vec_res = map (+) vec1 vec2; (* SML *)

map :: (a->b) -> [a] -> [b]

map : ('a->'b) -> 'a list -> 'b list

rosali

"сложить произведения пар", через "(fold 0 (map + x y" описывается куда более естественно, чем через ...

foldl (+) 0 (zipWith (*) x y) 

Ivan8209

(map + x y z)               ;; для сложения векторов

(apply + (map * x y       ;; для сложения попарных произведений

rosali

(map + x y z) ;; для сложения векторов
(apply + (map * x y ;; для сложения попарных произведений

Ivan8209

rosali

Ivan8209

rosali

Chupa

Marinavo_0507

rosali

А весь мир "является" ли строго типизированным?

"Any lisp hacker will tell you there is only one type: a list." (c) Alan Cox

Ivan8209

Ivan8209

Marinavo_0507

Chupa

Elina74

Chupa

Marinavo_0507

rosali

Кстати, ты знаком с понятием "динамическая типизация?"

А зачем нужна динамическая типизация?

rosali

А весь мир "является" ли строго типизированным?

 

virtual Object Clone;

virtual bool Equals(Object o);

rosali

Ivan8209

Ivan8209

Aleksei66

Marinavo_0507

sergey_m

с отрицанием возможности апгрейда по частям, как и положено в монотеизме и в *BSD

Marinavo_0507

rosali

Сборка такой системы завершалась бы глобальной проверкой типов, и апгрейд был бы возможен только полный

rosali

Пролог изобрели тоже где-то в начале 70-х.

Chupa

map :: (a->b) -> [a] -> [b]

rosali

То есть функции типа read : string -> 'a и print : 'a -> string ?

Marinavo_0507

rosali

map :: (a->b) -> [a] -> [ b]

rosali

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

Marinavo_0507

rosali

...производить сериализацию/десериализацию...

Ivan8209

Ivan8209

Ivan8209

Ivan8209

rosali

Переменные --- это имена.

На твои посты даже ответить нечего

rosali

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

Marinavo_0507

rosali

а в лиспе то, про что я читал - это именно на стадии выполнения

Marinavo_0507

Ivan8209

(define-syntax fn

  (syntax-rules (lambda) fn . l) (lambda . l

...

(map (fn (x) (* x x lst

Ivan8209

rosali

Тип есть только у значения переменной.

Ivan8209

Papazyan

Marinavo_0507

Papazyan

Marinavo_0507

rosali

И тип 'переменной' и значения вообще может быть разный

Не вижу причин приписывать дополнительные свойства обычной ссылке на другой объект

И все-таки типа у переменной нет, есть тип у выражения, на которое она ссылается

 

intMap :: (Int->Int) ->[Int] -> [Int]

intMap = map

Papazyan

Marinavo_0507

rosali

В ФП в некотором смысле возможна противоположная ситуация, программист может наcильно сузить тип переменной
code:--------------------------------------------------------------------------------
intMap :: (Int->Int) ->[Int] -> [Int]
intMap = map
--------------------------------------------------------------------------------
Тип переменной intMap -- (Int->Int) ->[Int] -> [Int], а тип ее значения -- (a->b)->[a]->[ b].

rosali

А теперь покажи мне программный продукт платный или бесплатный на этих самых языках.

rosali

ФЯ плохо ложаться на архитектуру современных компьютеров.

rosali

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

Ivan8209

xz_post

Ivan8209

Ivan8209

Ivan8209