1

How can I specify a pattern for an expression f for which say f[x,y] returns a value, ie is defined as a function taking two arguments.

let's say I have:

F[f_,l_List?MatrixQ]:= Map[f,l]

and I want to make sure that f is indeed a function returning values for an input of a certain pattern. say a list or a pair of numbers. How can I do that?

corollary question:

The definition function:

?myfunction

returns a list of substitution rules assigned to myfunction expression. Where does this function look up the these rules from? Is that Internal to Mathematica?

Shb
  • 701
  • 3
  • 10
  • Why? You want the result of F to be a list of numbers? – J. M.'s missing motivation Feb 14 '16 at 01:28
  • No. This is a simplified example. I am trying to write a function that performs a SortBy[] followed by a SplitBy[] and I want the user to input the function to be used by these to functions. – Shb Feb 14 '16 at 01:32
  • And why is g[x, y] for undefined g not admissible? – J. M.'s missing motivation Feb 14 '16 at 01:35
  • Because I don't want it to be? It doesn't make sense. – Shb Feb 14 '16 at 01:37
  • 3
    You can't generally do that in Mathematica. You basically ask for a type system / signatures, and Mathematica is an untyped language. You can't know in advance whether a given expression would evaluate on a given input to certain type or form of expression.The only real way of doing this kind of thing that comes to my mind would be to introduce your own datatype like MyFunction, and perform post-condition tests during such function's application, throwing an exception or returning $Failed for errors, but that's still a run-time check only, plus the user would have to use this new datatype. – Leonid Shifrin Feb 14 '16 at 02:03
  • @LeonidShifrin Thanks. Yes Mathematica considers everything as an expression "type" but can we not achieve this goal by pattern matching? For instance to check if a symbol is assigned a value, I pattern-check it with NumericQ. So You can check that it has a Numeric "type" without it having an explicit Numeric type. I believe the way Mathematica's evaluation system works is basically a series of rule substitutions, right? Can we not define a pattern that checks if a matching substitution exists for the given pattern of arguments for expression f? – Shb Feb 14 '16 at 02:27
  • 1
    Related: Function that counts the number of arguments of other functions – jkuczm Feb 14 '16 at 10:28
  • 1
    As to how you can see evaluation rules defined for a symbol: What is the distinction between DownValues, UpValues, SubValues, and OwnValues? – jkuczm Feb 14 '16 at 10:45
  • 1
    @Shb No we can't. In general, constructing such a check would require the full evaluation of an expression, which would destroy the purpose of this check. I think, you are mixing run-time information with invocation - time information. At the time when the function is invoked, you generally can't get the sort of information you ask for, unless you define your own type system, with your own function type etc. You can do this, but it will be a lot of work (since it's not integrated into the language, you'll have to reimplement a lot). And it will also slow down the code, perhaps significantly. – Leonid Shifrin Feb 14 '16 at 14:16

0 Answers0