А хаскелл такое умеет?

>Even (нечетные) и Odd (четные)

вообще-то наоборот

>для каждого можно определить свою функцию

и что сие должно значить?

> Т.е. у нас будет два числовых типа Even (нечетные) и Odd (четные), и для каждого можно определить свою функцию

Type class же ...

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

Type class же ...

зачем?

Попробуй хотя бы 4 основных арифметических операции релизовать для этих двух типов

data MNum = Odd  Int
          | Even Int

instance Show MNum where show (Odd n)  = "Odd:  " ++ show (2 * n + 1)
                         show (Even n) = "Even: " ++ show (2 * n)

fromInt :: Int -> MNum
fromInt n | (n `rem` 2 == 0) = Even (n `quot` 2)
          | otherwise        = Odd  ((n - 1) `quot` 2)

mAdd :: MNum -> MNum -> MNum
mAdd (Odd x) (Odd y)   = Even (x + y + 1)
mAdd (Odd x) (Even y)  = Odd  (x + y)
mAdd (Even x) (Odd y)  = Odd  (x + y)
mAdd (Even x) (Even y) = Even (x + y)

mMul :: MNum -> MNum -> MNum
mMul (Odd x) (Odd y)   = Odd  (2 * x * y + x + y)
mMul (Odd x) (Even y)  = Even (2 * x * y + y)
mMul (Even x) (Odd y)  = Even (2 * x * y + x)
mMul (Even x) (Even y) = Even (2 * x * y)

*Oddev> mAdd (fromInt 1) (fromInt 3)
Even: 4
*Oddev> mAdd (fromInt 2) (fromInt 5)
Odd:  7
*Oddev> mMul (fromInt 2) (fromInt 5)
Even: 10
*Oddev> mMul (fromInt 3) (fromInt 5)
Odd:  15

вычитание и деление тоже написать?

ну я и сам смог бы такое написать, вопрос в том, ради чего?

Это не полиморфизм, это хреновня какая-то.

>ну я и сам смог бы такое написать

похвально

>вопрос в том, ради чего?

а это уже не ко мне

[code] *Oddev> show 4 Even: 4 *Oddev> show 7 Odd: 7 [/code]

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

> Это не полиморфизм, это хреновня какая-то.

Почему это не полиморфизм? Кстати, еще вопрос в догонку, можно ли сделать в хаскелле полиморфизм по количеству аргументов к функции?

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

Прикинь, а есть еще ввод/вывод. Вот засада-то, да? :D

>Вот такое можно сделать с помощью типов, а не прямой проверки на четность, нечетность?

а как ты хочешь сделать это с помощью типов? какого типа у тебя 4 в этом выражении? Int, Integer, Double, Even?

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

это ещё с какой радости?

> Почему это не полиморфизм? Кстати, еще вопрос в догонку, можно ли сделать в хаскелле полиморфизм по количеству аргументов к функции?

Ты случайно не перегруженные функции имеешь ввиду?

*Oddev> show 4
Even: 4 
*Oddev> show 7
Odd: 7 

такое покатит?

*Oddev> show (fromInt 4)
"Even: 4"
*Oddev> show (fromInt 7)
"Odd:  7"

проверка во время исполнения

в чём разница между «прямой проверкой на чётность» и «проверкой во время исполнения»? не проблема делать как-то вот так, например:

*Oddev> (Even 2)
Even: 4
*Oddev> (Odd 3)
Odd:  7

всё, никаких проверок - но конструктор типа надо указать. можно написать TH-генератор, который будет делать это сам во время компиляции. тебя это интересовало?

> Почему это не полиморфизм?

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

>можно ли сделать в хаскелле полиморфизм по количеству аргументов к функции?

http://www.math.chalmers.se/~patrikj/poly/polyp/

здесь можно

> Ты случайно не перегруженные функции имеешь ввиду?

Перегруженные функции - это и есть частный случай полиморфизма.

> (Even 2)

ну а если (Even some_function_that_returns_int) ?

в чём разница между «прямой проверкой на чётность» и «проверкой во время исполнения»? не проблема делать как-то вот так, например:

*Oddev> (Even 2)
Even: 4
*Oddev> (Odd 3)
Odd:  7

всё, никаких проверок - но конструктор типа надо указать. можно написать TH-генератор, который будет делать это сам во время компиляции. тебя это интересовало?

Если есть f :: Int -> Int можно ли сделать такой тип Even и переопределить ее как f (Even a) -> Int, не указывая напрямую конструктор типа при вызове? f 3 вызовет одну функцию, а f 2 - другую?

> ну а если (Even some_function_that_returns_int) ?

(Even n) => 2*n + 1

Если есть f :: Int -> Int можно ли сделать такой тип Even и переопределить ее как f (Even a) -> Int, не указывая напрямую конструктор типа при вызове? f 3 вызовет одну функцию, а f 2 - другую?

ээ.... ну если я правильно понял, то:

 
class Fable a where 
    f :: a -> Int

instance Fable Int where 
    f x = -- код для Int

instance Fable Even where 
    f x = -- код для Even 

> Почему это не полиморфизм?

Полиморфизм обычно позволяет добавить что-то ещё. Чётные, нечётные... ещё что-то?

> можно ли сделать в хаскелле полиморфизм по количеству аргументов к функции?

Technically, no... потому что все функции в хаскеле имеют ровно один аргумент.

Если подходить менее формально - см. как printf сделан.

> Перегруженные функции - это и есть частный случай полиморфизма.

Ну просто есть устоявшиеся термины.

вычитание и деление тоже написать?

Ну деление вот писать не надо, но было бы неплохо сделать abs, signum, negate, s/Int/Integer/g, а потом instance Num MNum :) Заглядывая поглубже, получаем весьма правильный гуд:

data PNum = Odd PNum | Even PNum | Zero
data Sign = Plus | Minus
data MNum = MNum Sign PNum

Видимо, этого автор и желал. Весьма интересная фигня получается, btw.

>Если есть f :: Int -> Int можно ли сделать такой тип Even и переопределить ее как f (Even a) -> Int, не указывая напрямую конструктор типа при вызове? f 3 вызовет одну функцию, а f 2 - другую?

а в чём, собственно, профит?

>Видимо, этого автор и желал

боюсь, что нет

>Весьма интересная фигня получается

а вот это да

> Весьма интересная фигня получается, btw.

И называется она "двоичное представление числа", бгг :)