Thanks. I know that as one gains experience in a new paradigm, it becomes more natural. I'm an "old-timer" - started in FORTRAN II - migrated through Fortran versions, assemblers (VAX, 8080 family),Pascal, Modula II, LISP,C, (even a bit - ashamed to say- COBOL), C++, HTML, and was just getting into JAVA and the use of programmer's GUI interfaces when I retired. When I first encountered "object-oriented" programming I was stumped as well, but learned the benefits - as I will do with MMA. Good community and very helpful. I've actually got some problems solved now! :-)

You can use TagSet to enforce type safety. Create a predicate with TagSet.

q1 /: IsQuaternian[q1] = True
q2 /: IsQuaternian[q2] = True
q3 /: IsQuaternian[q3] = True

Now if you do pattern matching in your function definition using this new predicate, you'll enforce "type safety"

func[q_?IsQuaternian] := 1

In[17]:= func[q1]
Out[17]= 1
In[18]:= func[t2]
Out[18]= func(t2)

You can also override built in functions for certain argument types:

In[10]:= x = MyType["x"]

Out[10]= MyType["x"]

In[11]:= y = MyType["y"]

Out[11]= MyType["y"]

In[12]:= Plus[a_MyType, b_MyType] ^:= Join[a, b]

In[13]:= Plus[x, y]

Out[13]= MyType["x", "y"]

Mathematica is not strongly typed. If you provide arguments that match the structure of the definition, so that the function as used does in fact match the definition, then the function will evaluate as expected. If the form of the arguments as used does not match the definition, the rule which was established by the function definition will not apply, and Mathematica will just return the input. You can restrict the match by using Conditionals in the function definition.

For example, here are a few lines of code that define our own complex numbers, as ordered pairs, by rules for adding and multiplying them. No type restrictions were needed:

In[1]:= complexPlus[{r1_, i1_}, {r2_, i2_}] := {r1 + r2, i1 + i2}

In[2]:= complexTimes[{r1_, i1_}, {r2_, i2_}] := {r1 r2 - i1 i2, 
  r1 i2 + r2 i1}

In[3]:= (* argument structure does not match definition *)

In[4]:= complexPlus[a, b]

Out[4]= complexPlus[a, b]

In[5]:= (* this matches *)

In[6]:= complexPlus[{x, y}, {u, v}]

Out[6]= {u + x, v + y}

In[7]:= c1 = {x, y}; c2 = {u, v};

(* so does this *)

In[9]:= complexPlus[c1, c2]

Out[9]= {u + x, v + y}