** Using WeBWorK **

I have put together a Partition context that does this. The attached contextPartition.pl file contains the context. the idea is to create Partition object that knows how to compare partitions, and make a new implementation for + in the context so that it produces partition objects rather than real numbers.

You are right that you could modify the number pattern to prevent decimals, but I think Alex's suggestion of using Parser::Number::NoDecimals is better, as this allows the parser to recognize decimal numbers and give appropriate error messages (rather than "Unexpected character '.'"). This is the kind of thing that I mean by having the context know about other possible answers, not just ones in the correct form.

The attached file gives one way to do this easier (undefined them all and then redefine the ones you want).

You could, or you could let the class produce error messages for the lists when they are used in appropriately. Leaving them in lets you create lists of lists, if you need them (like a list of pairs that are a word with a partition).

If you create the Partition class that implements addition of numbers to form partitions, and comparison between partitions (and string and TeX representations of partitions), then you don't have to make a custom checker, as the standard MathObject answer checker will call the object's comparison method automatically. You just have to tell the parser's plus operator to build the Partition object rather than a Real object. That is done by changing the class associated with the + operator. See the attached code for an example.

Right idea, but wrong method. You don't modify the Real class, you modify the context's definition for + and what class it is tied to.

As an aside, it is not a good idea to modify the Value::Real class itself, since WeBWorK uses mod_perl, so those changes would be persistent and affect later problems that use the same httpd child process. Instead, you should create a subclass of Value::Real and override sub add there, then tell the Context to use your class rather than the standard Real class, e.g.,

   Context()->{value}{Real} = "my::Real";

If you have the plus create your Partition object, then the output will be the output from that object rather than from the real number that you would normally get from the sum.

As Alex points out, there is also some additional control over what is put in the "Entered" column. The Context flag formatStudentAnswer can be set to evaluated, reduced, or parsed. The first will give you the final number (assuming the student entered a formula that returns a number), the third will give the original formula entered by the student. The second form is only pertinent for Formulas, where the result will be simplified by the reduction rules available in the context (removal of "+ 0" or "1*" or "^1" or "/1" and such things).

For a custom object like the Partition object in the attached file, the object's string() and TeX() methods provide the strings to be used.

Anyway, this does provide a somewhat simpler example than the Permutation one, which needed two classes, and a new list type for the Parser.

    $context = Context("Numeric");
    
    #
    #  Remove everything by addition and commas
    #  from the context
    #
    Parser::Number::NoDecimals();
    $context->variables->clear();
    $context->strings->clear();
    $context->constants->clear();
    $context->functions->disable("all");
    $context->operators->undefine($context->operators->names);
    $context->operators->redefine(["fn",",","+"]);
    $context->operators->remove(" ");
    
    #
    #  Keep student answers unevaluated
    #
    $context->flags->set(
      reduceConstants => 0,
      formatStudentAnswer => 'parsed',
    );
    
    BEGIN_TEXT
    Enter a partition: \{ans_rule\}
    END_TEXT
    
    #
    #  Turn a tree of addition into an array
    #  (should really check that numbers are
    #  positive, since zero could appear here).
    #
    sub getTerms {
      my $bop = shift;
      return $bop->{value} if $bop->class eq "Number";
      Value->Error("Formula doesn't appear to be a partition")
        unless $bop->class eq "BOP" && $bop->{bop} eq "+";
      return (getTerms($bop->{lop}),getTerms($bop->{rop}));
    }

    #
    #  Use a custom checker that collects the numbers
    #  from the partitions and compares the sorted results.
    #
    ANS(Compute("1 + 3 + 5")->cmp(
      cmp_class => "a Partition",
      checker => sub {
        my ($correct,$student,$ans) = @_;
        my $S = join('+',num_sort(getTerms($ans->{student_formula}{tree})));
        my $C = join('+',num_sort(getTerms($correct->{original_formula}{tree})));
        return $C eq $S;
      }
    ));