I'm trying add new types for that been managed/used as in Go core types.

To create new types is anything very interesting to validate data before of send it to a non-SQL DBMS or to check data from a form.

• Go uses univeral constants to define them at global level:

  var DateType = universe.DefineType("date", universePos, &dateType{})
  

  In this case they're defined to be called from a package like types:

  var Date = &dateType{}
  

• I get these errors:

  test.go:58: o.lit undefined (cannot refer to unexported field lit)  
  test.go:62: *dateType is not Type  
    missing Pos() token.Position
  

The code is based on:
http://github.com/tav/go/blob/master/src/pkg/exp/eval/value.go http://github.com/tav/go/blob/master/src/pkg/exp/eval/type.go

package main

import (
    "exp/eval"
    "fmt"
//  "go/token"
)


// http://github.com/tav/go/blob/master/src/pkg/exp/eval/value.go

type DateValue interface {
    eval.Value
    Get(*eval.Thread) string
    Set(*eval.Thread, string)
}

/* Date */

type dateV string

func (v *dateV) String() string { return fmt.Sprint(*v) }

func (v *dateV) Assign(t *eval.Thread, o eval.Value) { *v = dateV(o.(DateValue).Get(t)) }

func (v *dateV) Get(*eval.Thread) string { return string(*v) }

func (v *dateV) Set(t *eval.Thread, x string) { *v = dateV(x) }


// http://github.com/tav/go/blob/master/src/pkg/exp/eval/type.go

type Type interface {
    eval.Type
    // isDate returns true if this is a date type.
    isDate() bool
}

/* Common type */

type commonType struct{}  // added

func (commonType) isDate() bool { return false }

/* Date */

type dateType struct {
    commonType
}

// * It should not be an universal constant

//var universePos = token.Position{"<universe>", 0, 0, 0}  // added
//var DateType = universe.DefineType("date", universePos, &dateType{})
var Date = &dateType{}

func (t *dateType) compat(o Type, conv bool) bool {
    t2, ok := o.lit().(*dateType)
    return ok && t == t2
}

func (t *dateType) lit() Type { return t }

func (t *dateType) isDate() bool { return true }

func (t *dateType) String() string { return "<date>" }

func (t *dateType) Zero() eval.Value {
    res := dateV("")
    return &res
}

/* Named types */
/*
type NamedType struct {
    eval.NamedType
    Def Type
}*/

type NamedType struct {  // added
//  token.Position
    Name string
    // Underlying type.  If incomplete is true, this will be nil.
    // If incomplete is false and this is still nil, then this is
    // a placeholder type representing an error.
    Def Type
    // True while this type is being defined.
    incomplete bool
    methods    map[string]eval.Method
}

func (t *NamedType) isDate() bool { return t.Def.isDate() }

/* *********************** */

func main() {
    print("foo")
}