Unrestricted variable name declaration in Mercury

Question

I would like to declare a data type in Mercury that can have a variable number of values and names. For instance :

type goal ---> pick; give; come.

has three variables/values.

I want something like:

type myplayer ---> de value declaration here.

That's the number of variables are not restricted or fixed.

So I can use myplayer to declare values/variables like v1, v2, v3 and v4. The second time I can use it to declare something like: a, b, c, d, e, z, aa, ab and az.

The number of the values are not restricted and the names are also not fixed.

I am new in Mercury.

Answer 1

What you directly ask for, simply cannot be done. Given

:- type question
        --->    truth(string, bool)
        ;       blank(string, string)
        ;       multiple(string, string, list(string)).

additional kinds of questions can only be added by extending this type where it is defined, and recompiling the module - and making a lot of other changes, too, as previously deterministic code like

answer(truth(_, yes)) = "true".
answer(truth(_, no)) = "false".
answer(blank(_, A)) = A.
answer(multiple(_, A, _)) = A.

would fail when given your new question type. Being told at compile-time where you've failed to update your program to reflect the addition of a "pick-all-the-right-answers" type of question is a good part of the reason you have a question type at all, instead of say lists of strings [["Are foxes pretty?", "true"], ["Green foxes are ____", "adorable!", "fake", "evidence of animal cruelty"]] for your question bank.

What you ask for cannot be done. However, what you actually want to do -- the end to which you thought 'variable numbers of types' would be an helpful means -- can surely be accomplished in some other way. I can't tell what way that is, as I can't tell why you wanted to do this from your question. Maybe you'd benefit from reading over discriminated unions or typeclasses in the language reference.

Answer 2

As others have said, this is simply impossible in Mercury - which is deliberate.

What you might want though, if you want a type that expresses: v1 v2 v3... etc is:

:- type my_type
    ----> v(int).

:- func name(my_type) = string.

name(v(Num)) = formst("v%d", [i(Num)]).

The type expresses v of all integers, and the function name can be used to 'pretty-print' values of this type.

Answer 3

As far as I understand this question. You want some Prolog-like behavior. I.e without typed predicates. In statically typed system you always can achieve such behavior by handling that by yourself. A lot of time ago I saw such example in Turbo Prolog (they implemented ISO prolog in terms of Turbo/Visual Prolog).

Consider something like (I'm not sure it is correct):

:- type any_type ---> atom_value(string)
                 ;    number_value(int)
                 ;    struct_value(any_type, list(any_type)).

guess(atom_value("v1")).
guess(atom_value("a")).
guess(atom_value("aa")).
guess(number_value(42)).
guess(struct_value(atom_value("pair"), [number_value(3), number_value(4)])).