Oberon space

А что Вы подразумеваете под функциями высшего порядка? Полиномы N-ой степени? 

Функции, оперирующие другими функциями.

Проблему, на мой взгляд, можно решить введя в язык следующие правила:
1. Внутри функции глобальные (по отношению к ней) переменные доступны только для чтения.
2. Параметры, передаваемые в функцию по ссылке, доступны внутри функции только для чтения.
3. Внутри функции запрещено использовать вызов процедур.

И хватит благостной говорильни о вреде побочного эффекта 

Это же Хаскелл! 

Согласен с Ильёй. OUT-параметры вполне органично могут применяться и безболезненно применяются. Неприязнь к ним - просто особенность восприятия или привычка конкретных людей.

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

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

такие функции должны возвращать результат типа Есть_корректный_результат/Нет_корректного_результата или Есть_корректный_результат/Код_ошибки_такой-то.

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

Цитата: Geniepro от Февраль 22, 2011, 06:07:22 am

Однако иногда жалею, что в том же C# нет даже простых сишных макросов -- иногда они позволили бы не делать тупой копи-паст.

Ну так и приведите пример. Мне, например, не приходилось жалеть.
И, кстати, где эти примеры на Лиспе с уменьшением размера кода в 20 раз?

Ну вот мой пример:if (obj1[i].abracadabra1 != obj2[i].other_abracadabra1)
{
    какие-то действия с obj1[i].abracadabra1:
   
    obj1[i].abracadabra1 = obj2[i].other_abracadabra1;

    какие-то другие действия с obj1[i].abracadabra1:
}

if (obj1[i].abracadabra2 != obj2[i].other_abracadabra2)
{
    какие-то действия с obj1[i].abracadabra2:
   
    obj1[i].abracadabra2 = obj2[i].other_abracadabra2;

    какие-то другие действия с obj1[i].abracadabra2:
}

if (obj1[i].abracadabra3 != obj2[i].other_abracadabra3)
{
    какие-то действия с obj1[i].abracadabra3:
   
    obj1[i].abracadabra3 = obj2[i].other_abracadabra3;

    какие-то другие действия с obj1[i].abracadabra3:
}

if (obj1[i].abracadabra4 != obj2[i].other_abracadabra4)
{
    какие-то действия с obj1[i].abracadabra4:
   
    obj1[i].abracadabra4 = obj2[i].other_abracadabra4;

    какие-то другие действия с obj1[i].abracadabra4:
}

if (obj1[i].abracadabra5 != obj2[i].other_abracadabra5)
{
    какие-то действия с obj1[i].abracadabra5:
   
    obj1[i].abracadabra5 = obj2[i].other_abracadabra5;

    какие-то другие действия с obj1[i].abracadabra5:
}Типы у этих abracadabra1..abracadabra5 -- разные, не совместимые (в смысле нет там наследований всяких).

Были бы макросы (хоть сишные), можно было бы сделать так:
#define do_what_we_need(obj1,obj2)          \\
    if (obj1 != obj2)                       \\
    {                                       \\
        какие-то действия с obj1:           \\
                                            \\
        obj1 = obj2;                        \\
                                            \\
        какие-то другие действия с obj1;    \\
    }

do_what_we_need(obj1[i].abracadabra1, obj2[i].other_abracadabra1);
do_what_we_need(obj1[i].abracadabra2, obj2[i].other_abracadabra2);
do_what_we_need(obj1[i].abracadabra3, obj2[i].other_abracadabra3);
do_what_we_need(obj1[i].abracadabra4, obj2[i].other_abracadabra4);
do_what_we_need(obj1[i].abracadabra5, obj2[i].other_abracadabra5);
А по поводу 20-кратного уменьшения кода, да ещё и на Лиспе -- это Вы лучше у Пола Грэма спросите, у него наверняка есть таких примеров...

Цитата: valexey от Февраль 21, 2011, 03:11:01 pm

А Грейхем про него вообще что-то знает? :-)

Почему-то у меня отложилось в памяти, что он считает недостатком требование, чтобы в списке все элементы были одного типа. Но сейчас не смог этого найти.
Может я все переврал и возвел напраслину?... 

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

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

Недостаток такого решения -- если язык не поддерживает расширение существующих типов (аналог наследования в ООП), то в будущем потребуется переделывать программы, когда выяснится, что ещё значения каких-то новых типов надо помещать в этот список.

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

Во-вторых, можете привести пример гениального использования макросов? Типа, а вот здесь языки без макросов сосут.

В C# есть оператор using, который, в частности, позволяет автоматически закрывать файл после того, как с ним будет проведена какая-то работа:// точно на память работу с файлами в .NET не помню,
// просто пример как это может выглядеть

using (File file = File.Open("filename.txt"))
{
    // что-то делаем с файлом file

} // тут он автоматически закрывается
Когда в С# не было этого оператора (вроде когда-то его не было, может ошибаюсь), приходилось (да и теперь в том же С или Обероне приходится) закрывать файл вручную. Естественно, можно было по запарке забыть это дело сделать.

Макросы позволяют самостоятельно модифицировать язык, добавить этот самый "using":; условный синтаксис:

(defmacro with-open-file (file filename body)
    (let (,file (open-file filename)
      ,@body
      (close-file ,file))))

; пример использования:

(with-open-file file "filename.txt"
    ( ; что-то делаем с файлом file
    )) ; тут он автоматически закрываетсяНу, в некоторых языках некоторые возможности макросов можно реализовать и без макросов. Например, в Хаскелле:with_open_file :: FilePath -> IOMode -> (Handle -> IO a) -> IO a
with_open_file filename mode action = do
    fhnd   <- openFile filename mode
    result <- action fhnd
    hClose fhnd
    return result

-- Пример использования

do  ...
    with_open_file "filename.txt" ReadMode $ \\file -> do
        ... -- что-то делаем с файлом file
    -- тут он автоматически закрываетсяНо Хаскелл -- ленивый язык, в нём такие фокусы проходят.
В сях тоже можно соорудить макрос, но именно -- какой-никакой, а макрос.
А в оберонах?

module Main where

type GS = (Integer, Integer)

instance Num GS where
    (a, b) * (c, d) = (a*(c+d) + b*c, a*c + b*d)

fib n = fst $ ((1, 0)::GS) ^ n

main = do
    putStrLn $ take 10 $ show $ fib 1000000

Думаю, не стоит пытаться обучить программированию любого (каждого) ученика. Ведь далеко не все ученики становятся физиками, химиками, так же далеко не все станут и программистами.
Соотвественно, нет смысла и чрезмерно упрощать преподавание программированию. Действительно интересующийся ученик сам и Паскаль, и Лисп изучит...