Тут что-то очень похоже на Alternative, надо только придумать для какого типа

*да, хочется натянуть тайпклассы на задачу :)

да, но все равно хуже чем комбинаторы комбинировать

Да, зачем делать просто если можно сложно.

именно так. комбинировать комбинаторы просто, ПМ и рекурсия - сложно

Ну скомбинируй

пм?

прикладная математика?

паттерн матчинг

Продакт менеджмент

пакетный менеджер

а бывает zipWith с дефолтным значением, которое применяется вместо недостающих элементов короткого списка? или это правильнее по-другому делать?

раз zipWith, значит списки разных типов. Раз мы не знаем, какой из списков короче, то не знаем, какого типа требовать дефолт. Значит дефолт - результат операции g :: (a -> b -> c) -> c -> ([a] -> [b] -> [c]) g f d a b = zipWith f a b ++ replicate delta d where delta = abs (length a - length b) h :: (a -> b -> c) -> c -> ([a] -> [b] -> [c]) h _ d [] ys = replicate (length ys) d h _ d xs [] = replicate (length xs) d h f d (x:xs) (y:ys) = f x y : h f d xs ys

по идее ор-паттерны помогут превые два кейса к одному виду свести

раз zipWith, значит списки разных типов. Раз мы не знаем, какой из списков короче, то не знаем, какого типа требовать дефолт. Значит дефолт - результат операции g :: (a -> b -> c) -> c -> ([a] -> [b] -> [c]) g f d a b = zipWith f a b ++ replicate delta d where delta = abs (length a - length b) h :: (a -> b -> c) -> c -> ([a] -> [b] -> [c]) h _ d [] ys = replicate (length ys) d h _ d xs [] = replicate (length xs) d h f d (x:xs) (y:ys) = f x y : h f d xs ys

Дефолт для каждого из списков

ну делать два дефолтных параметра тоже не оч как-то

Как раз логично

раз zipWith, значит списки разных типов. Раз мы не знаем, какой из списков короче, то не знаем, какого типа требовать дефолт. Значит дефолт - результат операции g :: (a -> b -> c) -> c -> ([a] -> [b] -> [c]) g f d a b = zipWith f a b ++ replicate delta d where delta = abs (length a - length b) h :: (a -> b -> c) -> c -> ([a] -> [b] -> [c]) h _ d [] ys = replicate (length ys) d h _ d xs [] = replicate (length xs) d h f d (x:xs) (y:ys) = f x y : h f d xs ys

это я не корректно обобщил, наверное. у меня списки списков одного типа и надо просто слить соответствующие элементы. соответственно, дефолтный - пустой список

это я не корректно обобщил, наверное. у меня списки списков одного типа и надо просто слить соответствующие элементы. соответственно, дефолтный - пустой список

Я кинул ссылку на готовое решение

Чёт проще в Maybe впаковать, имхо

zipWith' f xs ys = catMaybes $ zipWith (liftA2 f) (wrap xs) (wrap ys) where wrap zs = Just <$> zs ++ repeat Nothing

никогда не остановится же, наверное?

zipzip def1 def2 f xs ys = map (\(a,b) -> f (fromMaybe def1 a) (fromMaybe def2 b)) . takeWhile (\(a,b) -> not $ null a && null b) $ zip (extend xs) (extend ys) where extend xs = map Just xs ++ repeat Nothing

зацените import Prelude hiding (zipWith) import Control.Applicative import Data.Functor zipWith :: (a -> b -> c) -> [a] -> [b] -> [c] zipWith f xs ys = getZipList $ f <$> zxs <*> zys where zxs = ZipList xs zys = ZipList ys zipDefWith :: a -> b -> (a -> b -> c) -> [a] -> [b] -> [c] zipDefWith x y f xs ys = getZipList $ f <$> (zxs <|> zys $> x) <*> (zys <|> zxs $> y) where zxs = ZipList xs zys = ZipList ys

для сравнения реализация обычного zipWith

Тут что-то очень похоже на Alternative, надо только придумать для какого типа

таки удалось притянуть

никогда не остановится же, наверное?

можно вместо catMaybes сделать takeWhile isJust

всё уже реализовано, используйте ZipList :) правда требует base 4.11.0.0

zipWith' f xs ys = takeWhile isJust $ zipWith (liftA2 f) (wrap xs) (wrap ys) where wrap zs = Just <$> zs ++ repeat Nothing

Так. Походу у меня обычный zipWith получился :)

Кароч, нужно просто зипать через Maybe a -> Maybe b -> Maybe c и будет нормально - контроль над остановом, вот это всё: zipWith' f xs ys = takeWhile isJust $ zipWith f (wrap xs) (wrap ys) where wrap zs = Just <$> zs ++ repeat Nothing

Я кинул ссылку на готовое решение

ага, я увидел, пасиб

инстанс Alternative для ZipList появился. раньше такого не было

всё уже реализовано, используйте ZipList :) правда требует base 4.11.0.0

и как это поможет?

и как это поможет?

ну я выше же привёл код

да, комбинаторный парсер (инстансы апликатив и альтернатив) как обычно не победить

когда только знакомился с хаскелем, долго мучала идея, как сделать псевдогетерогенный список, где элементы чередуются единственная идея, которая тогда пришла - делать специальные отдельные списки, где не 2 конструктора, а типа: data IntAndStringList = Nil | PartCons Int | Cons Int String IntAndStringList

сейчас вспомнил о задаче (из-за другой книги, где рассказывается про индукцию как рекурсию, параметризованую значениями элементов, зависимую то есть) и пришла идея просто параметризовать тип каждого элемента индексом (от 0, если от 1, то Cons :: a (Succ n) ->)

а какая задача? сделать типа список, где могут лежать элементы двух разных типов, причём строго по очереди?

"сделать псевдогетерогенный список, где элементы чередуются"

да

интересно

А доставать как?

А чем проще всего собрать лог работы приложения и выгрузить в конце в файлик?

ща попробую написать индуктивный элиминатор

@kana_sama a у тебя список может начинаться с любого из типов?

или только с одного из двух

@kana_sama a у тебя список может начинаться с любого из типов?

тип элемента задается семейством, в данном случае в семействе задали, что IntString 0 = Int

нет, я про исходную задачу

решение с семействами не смотрел, хочу что-нибудь своё пока придумать:)

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

когда только знакомился с хаскелем, долго мучала идея, как сделать псевдогетерогенный список, где элементы чередуются единственная идея, которая тогда пришла - делать специальные отдельные списки, где не 2 конструктора, а типа: data IntAndStringList = Nil | PartCons Int | Cons Int String IntAndStringList

просто вот здесь как будто в конце обязательно должен быть Int, а строка быть не может

просто вот здесь как будто в конце обязательно должен быть Int, а строка быть не может

в твоей первой реализации, "когда ты только начинал знакомиться"

просто вот здесь как будто в конце обязательно должен быть Int, а строка быть не может

может

Cons 1 "2" Nil

а, ок

просто тип выглядел несимметричным

А доставать как?

похоже с семейством никак, нужно использовать gadt-ы

потому что я не могу сматчить IntegerString n

тип example обязательно вручную писать?

нет, выведется

отлично тогда

когда только знакомился с хаскелем, долго мучала идея, как сделать псевдогетерогенный список, где элементы чередуются единственная идея, которая тогда пришла - делать специальные отдельные списки, где не 2 конструктора, а типа: data IntAndStringList = Nil | PartCons Int | Cons Int String IntAndStringList

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

ERROR: S client not available

то есть ради чего усложняем?

необобщенность

можно обобщить по двум типам, но если мы захотим чередование по 3?

а потом по 4

можно обобщить по двум типам, но если мы захотим чередование по 3?

а, понял

в новом решении есть общий DVector, а сколько и как (там может быть и не чередование, а другая комплексная логика, например вектор из векторов такой же длины, чтобы такой треугольник получился) - решает клиент

Ох уж эти клиенты:))

@kana_sama data Rope a b = Nil | a :. Rope b a

@kana_sama data Rope a b = Nil | a :. Rope b a

тут чередование только двух элементов

для трех придется писать новый тип

наверное можно через семейство по тайплевел спискам обобщить до N типов

но выглядит красиво конечно, намного лучше того моего

обобщить бы как-нибудь до List, чтобы Rope '[] стало Void

а зачем так?

у шифта можно '[] не делать

чтобы его элиминировать, нужно делать какую-то n+1 арную функцию, где n - длина списка, на тайпклассах

тогда Rope '[] только Nil, хотя оно и так

там unary tuple вроде подвезут

так меня можно игнорировать

у шифта можно '[] не делать

да, в принципе и у head [] можно не делать, что позволит обобщить head до k

я так понимаю, неопределенный кейс семейства - то же самое, что и void

раньше я думал, что не скомпилируется

type family Head (as :: [k]) :: k where Head (a : as) = a y :: Head '[] y = undefined

интересно а. можно ли обощить, б. можно ли без GADT

обощить наверное можно щас попробую

type family Head (as :: [k]) :: k where Head (a : as) = a y :: Head '[] y = undefined

чтобы этого избегать, придумали TypeError

почему я всегда забываю хак с частичным примерением TF

почему я всегда забываю хак с частичным примерением TF

какой хак?