Типы, как наборы функций, удовлетворяющие условиям?

[aa_dav]

arseniiv в сообщении #988902 писал(а):

Так вы же не с одним лиспом сравнивали, а с самим C++!

Ну я и сказал что это примерно как С++ по всяким заковыристостям. По моим внутренним ощущениям, конечно, что тоже сказал.

arseniiv в сообщении #988902 писал(а):

Можно всегда использовать { ; }.

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

arseniiv в сообщении #988902 писал(а):

Может, сравним с APL?

Я сравнивал с С++. APL не знаю.

[arseniiv]

aa_dav в сообщении #988905 писал(а):

Ну я и сказал что это примерно как С++ по всяким заковыристостям.

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

aa_dav в сообщении #988905 писал(а):

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

Ну чего-там знать-то. Раз и запомнил, а если забыл, то легко вспомнил после справочника.

[aa_dav]

arseniiv в сообщении #988911 писал(а):

Не особо понимаю

Да и не надо на самом деле, у меня нет такой цели чтобы вы чего то поняли.
Оффтоп пошёл неконструктивный.

-- 11.03.2015, 21:35 --

Для топиккастера - я имел ввиду что возможно имеет смысл дочитать SICP, чтобы в "чистом и простом ФП искупаться", а потом уже с этими силами и знаниями наступать на Хаскелль, он внесет много новых концептов.

[_Ivana]

arseniiv в сообщении #988867 писал(а):

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

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

-- 11.03.2015, 20:43 --

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

[arseniiv]

aa_dav в сообщении #988914 писал(а):

Оффтоп пошёл неконструктивный.

Согласен.

_Ivana в сообщении #988917 писал(а):

Но функционал новый - значит именно новый тип, абстрактный - как вы мне тут справедливо написали ранее.

Ну, вообще под абстрактным я склонен считать больше то, что упомянуто в статье Unfolding abstract datatypes. Но и тут тип forall c. (a -> b -> c) -> c, соответствующий паре, и т. д., особо новым не назвать. Но это всё слова получаются.

_Ivana в сообщении #988917 писал(а):

Как раз пара и список, гетерогенные причем.

Ну, гетерогенность и у обычных пар (конструируемых (,) вместо cons, мы ведь уже сравнивали их типы) есть.

[_Ivana]

Не прошло и полгода, как я навелосипедил примитивный тип, который позволил мне натянуть сову на глобус реализовать на Haskell то, что на Лиспе и Эле реализуется просто и само:

Используется синтаксис Haskell

module FunctionalData where

data FT a = Nil | A a | Fc (String -> FT a)

fromA :: FT a -> a
fromA (A a) = a

--------------   СПИСОК   -----------------

cons :: a -> FT a -> FT a
cons a l = Fc go where
    go "car" = A a
    go "cdr" = l

car :: FT a -> a
car (Fc c) = fromA $ c "car"
car (A x) = x
car _ = error "empty list in ""car"""

cdr :: FT a -> FT a
cdr (Fc c) = c "cdr"
cdr _ = Nil

showLst :: (Show a) => FT a -> String
showLst = ('(':) . tail . go where
    go Nil = ")"
    go l = " " ++ show (car l) ++ go (cdr l)

mapLst :: (a -> b) -> FT a -> FT b
mapLst _ Nil = Nil
mapLst f l   = cons (f . car $ l) (mapLst f $ cdr l)

foldlLst :: (a -> b -> b) -> b -> FT a -> b
foldlLst _ a Nil = a
foldlLst f a l   = foldlLst f (f (car l) a) $ cdr l

foldrLst :: (a -> b -> b) -> b -> FT a -> b
foldrLst _ a Nil = a
foldrLst f a l   = f (car l) $ foldrLst f a $ cdr l

reverseLst :: FT a -> FT a
reverseLst = foldlLst cons Nil

elemLst :: (Eq a) => a -> FT a -> Bool
elemLst e = foldrLst (\x a -> (x==e) || a) False

listFromTo :: (Ord a, Num a) => a -> a -> FT a
listFromTo a b | a > b     = Nil
               | otherwise = cons a $ listFromTo (a+1) b

l :: FT Int
l = listFromTo 1 5

--------------   БИНАРНОЕ ДЕРЕВО   -----------------

makeBT :: a -> FT a -> FT a -> FT a
makeBT a l r = Fc go where
    go "nodeValue" = A a
    go "leftTree" = l
    go "rightTree" = r

nodeBT :: FT a -> a
nodeBT (Fc c) = fromA $ c "nodeValue"
nodeBT (A x) = x
nodeBT _ = error "empty binary tree in ""nodeBT"""

leftBT :: FT a -> FT a
leftBT (Fc c) = c "leftTree"
leftBT _ = Nil

rightBT :: FT a -> FT a
rightBT (Fc c) = c "rightTree"
rightBT _ = Nil

showBT :: (Show a) => FT a -> String
showBT Nil = "-"
showBT t = "(" ++ showBT (leftBT t) ++ " "
    ++ show (nodeBT t) ++ " " ++ showBT (rightBT t) ++ ")"

foldBT :: (a -> b -> b -> b) -> b -> FT a -> b
foldBT f e Nil = e
foldBT f e t = f (nodeBT t) (foldBT f e (leftBT t)) (foldBT f e (rightBT t))

sumBT :: (Num a) => FT a -> a
sumBT = foldBT (\v l r -> v + l + r) 0

depBT :: FT a -> Int
depBT = foldBT (\_ l r -> 1 + max l r) 0

t :: FT Int
t = makeBT 5 (makeBT 2 Nil (makeBT 4 Nil Nil)) (makeBT 10 Nil Nil)

--------------   МНОЖЕСТВО   -----------------

consSet :: (Eq a) => a -> FT a -> FT a
consSet a l = Fc go where
    d = elemLst a l
    go "car" = A $ if d then car l else a
    go "cdr" = if d then cdr l else l

mapSet :: (Eq a, Eq b) => (a -> b) -> FT a -> FT b
mapSet _ Nil = Nil
mapSet f l   = consSet (f . car $ l) (mapSet f $ cdr l)

unionSet :: (Eq a) => FT a -> FT a -> FT a
unionSet a Nil = a
unionSet a b   = unionSet (consSet (car b) a) $ cdr b

s = consSet 1 $ consSet 2 $ consSet 1 Nil

main:: IO ()
main = do
    putStrLn $ "start    list: " ++ showLst l
    putStrLn $ "mapped   list: " ++ (showLst . mapLst (+10) $ l)
    putStrLn $ "reversed list: " ++ (showLst . reverseLst $ l)
    putStrLn $ "sum      list: " ++ show (foldlLst (+) 0 l)

    putStrLn $ "start    set: " ++ showLst l
    putStrLn $ "mapped   set: " ++ (showLst . mapSet (`mod`4) $ l)
    putStrLn $ "union   sets: " ++ (showLst . unionSet l $ listFromTo 1 10)

    putStrLn $ "binary tree: " ++ showBT t
    putStrLn $ "sum    tree: " ++ show (sumBT t)
    putStrLn $ "depth  tree: " ++ show (depBT t)
    putStrLn $ "one type - in same standart homogenic list:"
    print $ zipWith ($) [showLst, showBT] [l, t]
 

*FunctionalData> :main
start    list: (1 2 3 4 5)
mapped   list: (11 12 13 14 15)
reversed list: (5 4 3 2 1)
sum      list: 15
start    set: (1 2 3 4 5)
mapped   set: (2 3 0 1)
union   sets: (10 9 8 7 6 1 2 3 4 5)
binary tree: ((- 2 (- 4 -)) 5 (- 10 -))
sum    tree: 21
depth  tree: 3
one type - in same standart homogenic list:
["(1 2 3 4 5)","((- 2 (- 4 -)) 5 (- 10 -))"]