In order to sort alphanumeric-as-string data of the form {"T3", "T14", "T1", "E2"}, so that "T14" comes after "T3", SortBy requires the tiebreaker function list:

{StringTake[#, 1] &, ToExpression@StringDrop[#, 1] &}

Which works as intended when this expression is inserted literally in SortBy. However, defining a utility function

mySort[x_String]:={StringTake[x, 1] , ToExpression@StringDrop[x, 1]}

doesn't work since the output is a list of expressions rather than a list of functions.

The alternative - to define a function via

mySort := {StringTake[#, 1] &, ToExpression@StringDrop[#, 1] &}

only works when the list to be sorted is 1-dimensional (as above) but not with lists of the form data2={"T3"->a, "T14"->b, "T1"->c, "E2"->d} where it is necessary to use SortBy[data2,mySort[#[[1]]]&].

Any alternatives that will work for general expressions?

  • $\begingroup$ I edited the previous typo, but it results in "T14" before "T3". Do you have the opposite? $\endgroup$ – alancalvitti Jun 20 '12 at 20:08
  • $\begingroup$ Oh, you're right. Forget my previous comment. $\endgroup$ – Heike Jun 20 '12 at 20:09

I think this question admits an elegant solution. Here is my attempt: define a special wrapper:

sortFun /: SortBy[expr_, sortFun[funs_List, partFun_]] :=
   SortBy[expr, Map[Composition[#, partFun] &, funs]];


mySort := {StringTake[#, 1] &, ToExpression@StringDrop[#, 1] &}


SortBy[{"T3","T14","T1","E2"}, sortFun[mySort, Identity]]

(*   {E2,T1,T3,T14}  *)


SortBy[{"T3"->a,"T14"->b,"T1"->c,"E2"->d}, sortFun[mySort, First]]

(*  {E2->d,T1->c,T3->a,T14->b} *)


Perhaps more elegantly

sortFun /: SortBy[expr_, sortFun[funs_List, partFun_]] :=
   SortBy[expr, Thread[Composition[funs, partFun]]];

and just for fun, another version:

sortFun /: call : SortBy[expr_, sortFun[funs_List, partFun_]] :=
   Block[{sortFun = Thread[Composition[##]] &}, call];
| improve this answer | |
  • $\begingroup$ Superior to mine, +1 $\endgroup$ – Rojo Jun 20 '12 at 20:09
  • $\begingroup$ @Rojo Thanks :) We seem to be thinking very similarly :) $\endgroup$ – Leonid Shifrin Jun 20 '12 at 20:10
  • 1
    $\begingroup$ @alancalvitti I actually don't find carrying sortFun around a big burden. It is a very general wrapper, and it minimally changes the syntax. One can use some shorter name if sortFun is too long. One could also add rules to SortBy, but I'd rather not do it. $\endgroup$ – Leonid Shifrin Jun 20 '12 at 20:24
  • 1
    $\begingroup$ @alancalvitti Thanks for the accept. As for elegance, it seems that we have somewhat different perceptions on that (which is just fine, this is a very subjective matter). I feel that the first solution in the edit is the most elegant, and will be hard-pressed to see anything simpler than that. $\endgroup$ – Leonid Shifrin Jun 20 '12 at 21:47
  • 1
    $\begingroup$ @alancalvitti This will then be either a more narrow, point solution (since functions can also be represented as symbols, composite heads with sub-values, etc), or will be really complex and would require compile stage to be efficient. I do not exclude that this is possible, but I think that my solution captures the mathematical essence of the problem, which is, function's composition. And when possible, I value mathematical clarity over what may look like a better usability, because a real usability is in supporting the right abstractions. $\endgroup$ – Leonid Shifrin Jun 20 '12 at 22:18

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.