Is there an equivalent to head/tail for Foldable functors in general?

Question

I would like to express the following Haskell code, using only functor algebra (i.e. - not relying on any specific container type, such as List):

ys = zipWith (+) (head xs : repeat 0)
                 (tail xs ++ [y])

It seems to me that there ought to be a way to do this, relying only on Foldable (or, maybe, Traversable), but I can't see it.

I'm wondering:

1. Is there a general notion of first and rest for Foldable/Traversable functors?
2. Is there an accepted idiomatic way, using only functor algebra, to shift the contents of a Foldable/Traversable functor? (Note that the computation above might be described in English as, "Shift in one value from the right, and add back the value that falls of on the left to the new first value.")

Answer 1

You can find the first or last element of a Foldable using the First or Last monoids from Data.Monoid.

foldMap (Last . Just)  :: Foldable t => t a -> Last a
foldMap (First . Just) :: Foldable t => t a -> First a

All Foldable are convertible to a list, and so because you can find the head and tail of a list, you can do so for any Foldable.

toList = foldr (:) [] :: Foldable t => t a -> [a]

That said, the tail will have a list type and not that of the Foldable (unless it was too a list). This is ultimately because not all that is Foldable can implement an uncons. For example:

data Pair a = Pair a a

This is Foldable, but you could not represent the tail of a Pair using a Pair.

Answer 2

The first part of your question (combining the first value of a structure with one thing and leaving the rest the same) can be done in a straightforward way with Traversable. We'll use State, start it off with the function we want to apply, and modify it to id immediately.

onlyOnHead :: Traversable t => (a -> a) -> t a -> t a
onlyOnHead f xs = evalState (traverse go xs) f where
    go x = do
        fCurrent <- get
        put id
        return (fCurrent x)

You can rotate elements with a similar idea: we'll rotate a list, and stuff that in our State as the thing to draw elements from.

rotate :: Traversable t => t a -> t a
rotate xs = evalState (traverse go xs) (rotateList (toList xs)) where
    rotateList [] = []
    rotateList vs = tail vs ++ [head vs]

    go _ = do
        v:vs <- get
        put vs
        return v

Answer 3

To rotate, you don't need any ugly partial functions. This weird Applicative will do the trick.

data Foo a t where
  Cons :: (a -> q -> t) -> a -> Foo a q -> Foo a t
  Nil :: t -> Foo a t

instance Functor (Foo a) where
  fmap f (Cons g x xs) = Cons (\p q -> f (g p q)) x xs
  fmap f (Nil q) = Nil (f q)

instance Applicative (Foo a) where
  pure = Nil
  liftA2 f (Nil t) ys = f t <$> ys
  liftA2 f (Cons g x xs) ys = Cons (\a (q,b) -> f (g a q) b) x (liftA2 (,) xs ys)

You can rotate a Foo:

rot :: Foo a t -> Foo a t
rot n@(Nil _) = n
rot (Cons g0 a0 as0) = go g0 a0 as0
  where
    go :: (a -> q -> t) -> a -> Foo a q -> Foo a t
    go g a n@(Nil _) = Cons g a n
    go g a (Cons h y ys) = Cons g y (go h a ys)

And run one to get a result:

runFoo :: Foo a t -> t
runFoo (Nil t) = t
runFoo (Cons g x xs) = g x (runFoo xs)

Putting it all together,

rotate :: Traversable t => t a -> t a
rotate = runFoo . rot . traverse (\a -> Cons const a (Nil ()))

Then rotate [1..10] = [2..10] ++ [1].

Answer 4

Thanks to all who responded!

Note that Conal Elliott's shaped-types library also has some useful machinery in this regard.