accumulate: confusion and unfortunate naming

[kytrinyx]

I was reminded about this issue in a recent discussion in the python track: exercism/python#245

The accumulate problem describes what is typically called map or collect, I think, in many other languages.

I think we should rename this across the board, but I'm not sure what we should rename it to. Thoughts?

[behrtam]

Most of the languages (Swift, JavaScript, Python, Scala, Java 8+, Erlang, etc) call a function that that applies a given function to each element of a list and returns a list of results map. Applying a combining function at each node/element to get one returning value has different names like accumulate, collect or often reduce.

To avoid problems with the but-in map we could use the term transform instead.

[soniakeys]

(Just posted this to x-python by accident. I should have posted here.)

Python has itertools.accumulate that does exactly this, right? I don't know much about functional languages but I would expect a number of them would have a function for this. If a number of them call it something besides accumulate, maybe that would be a better name. If not, maybe accumulate is okay.

I thought it was a little strange that the readme makes a special exception for Elixir and Lisp. Maybe the intent should be that you not call a single function (like itertools.accumulate) but instead implement it somehow as if that single function wasn't available. The readme might defer to the track test suites for more specific instructions. In most cases the track test suites would contain some comments saying exactly what function was disallowed but then it would up to nitpickers to call foul when someone used the disallowed function. Some languages though might have the capability for the test program to explicitly check that the disallowed function wasn't used.

Also there is the list-ops exercise which I think has similar intent. Should these exercises be combined?

[kytrinyx]

Maybe the intent should be that you not call a single function (like itertools.accumulate) but instead implement it somehow as if that single function wasn't available.

Yeah, that's the intent.

The readme might defer to the track test suites for more specific instructions.

I'm reworking some of the exercise API stuff, and will be implementing https://github.com/exercism/x-api/issues/44, which would give us a way to provide this directly in the README.

Some languages though might have the capability for the test program to explicitly check that the disallowed function wasn't used.

In Ruby we've been re-opening base classes and redefining the methods to raise an exception. Dirty, but it works.

Also there is the list-ops exercise which I think has similar intent. Should these exercises be combined?

Ah, that's a really good point. I think we should certainly consider it!

[Dog]

In Python there isn't an itertools.accumulate. In python it is just map(), a list comprehension, or if you want to be fancy perhaps a filter(). All of those are provided in Python without an import

[robphoenix]

My understanding of functional programming constructs in Python is that map, filter & reduce are still in the Standard Library by the skin of their teeth, and that list comprehensions ( dict comprehensions and generator expressions also, along with lambda) are the way to go instead.

It does look as though the list-ops exercise is similar and could be used here instead?

[kytrinyx]

Yeah, maybe the right thing to do across the board is to deprecate the accumulate exercise and suggest implementing list-ops if it hasn't been already.

[behrtam]

Those two exercises should definitely be merged. Maybe under the new name transform or transform-list. Should the Lisp and Elixir specific comments be kept?

[kytrinyx]

I think for now the list-ops name is good. I don't know if we need to keep the language-specific comments. @exercism/lisp @exercism/elixir Thoughts?

[verdammelt]

list-op is "ok" but the pedant in me wants the name to be inclusive of other sequence/collection types. The README for this exercise is very light but I think it would be good to have instead of the accumulate. I also think the README is clear enough that built-in functions should not be used so I don't think we need language-specific comments.

[wobh]

I think list-ops is fine so long as we make clear that by "list" we don't mean a native type but a general, ordered collection of any kind. I'm glad we decided to forgo the accumulate exercise in @exercism/lisp. It seems like it's redundant with list-ops, but I feel that and the linked-list exercise deserve some consideration from us before we commit to implementing them. I'll mention my concerns here since they're kinda on-topic to the discussion, but we can resolve them in issues threads on xlisp.

I don't think it's good idea to have "meta" restrictions about what a learner should or should not do in implementation aside from what we can write reasonable tests for. Consider the roman-numerals exercise: in CL we have a native function to write Roman numerals, and I think it would be quite excellent for someone new to CL to discover and use that feature for an iteration. After all, they're learning a new language and steering them away from standard libraries and built-ins seems ... odd. Obviously, when and if one is ready to challenge themselves, they may write additional iterations where they can reimplement.

If we decide there's an exercise we simply must write and make implementation requirements on, I don't think it would be a good idea for us to try to enforce those implementation requirements in the tests through package symbol shadowing, read-time conditionals, macros or any trickery functionally equivalent to what @kytrinyx describes above for xruby. In xlisp, we've been trying to make the example files the test of the exercise test suite we're providing learners. For us it makes sense that the example be written in exactly the manner described as forbidden.

I got a lot out of the list-ops exercise for Elixir, but I think that might be a particularity due to Elixir's model of pattern-matching and recursion and syntax expressing those things in the function signature. It wasn't implementing sequence functions that I learned most, but about writing idiomatic Elixir functions. CL's core syntax and structure is simpler, and founded upon the very things those exercises ask you to reproduce. I doubt lisp-ops and linked-list are so rewarding for CL (or any other Lisp). I think we should consider forgoing those too, in favor of other things that show you how to use the tools CL provides for them.

(@verdammelt, following up on the last paragraph, I'm specifically thinking of the 99 lisp problems but much more indirect, translated through some scenario or unexpected medium, like grade-school or any of the DNA exercises. It's weird how much I've learned just from alternate implementations of bob.)

[behrtam]

So, we deprecate accumulate in all tracks. Is there a more inclusive name like sequence-ops/collection-operations/etc or do we stay with list-ops?
Does every track choose the possible functions like length, reverse, map, filter, foldr, foldl, concat, flat, etc or do we list them in the README or *.json?

[kytrinyx]

I think:

1. Yes, let's deprecate accumulate across all the tracks.
2. I like sequence-ops, curious to hear what others thing (particularly people with more functional backgrounds)
3. I'm not sure. On the one hand I think it makes sense for the track maintainers in each language to choose the possible functions, but we can probably list some possible example functions in the README to give people an idea of what type of thing they'll be expected to solve. Or maybe we create a master list of suggested functions and then some languages can choose to not implement certain ones.