 # defintion that provides an ability to specify (or point to) to a
 # specific kind of data type. Pointers may create simple or complex
 # data type references and definitions. Refer to their implementation.
+# This pointer creates a reference to object with composite pointer.
+module.exports.object = object = (description, pointer) ->
+    noPointer = "got no pointer to the object members"
+    noDescription = "no description has been given"
+    assert _.isString(description), noDescription
+    assert _.isFunction(pointer), noPointer
+    compiled = pointer.apply this
+    @description = description.toString()
+    props = @properties = Object.create this
+    regex = @patternProperties = Object.create this
+    f = (k, p) => p.call n = Object.create(@), k, @; n
+    isp = (k, p) -> _.isFunction(p) and not p.pattern
+    isr = (k, p) -> _.isFunction(p) and p.pattern is yes
+    props[k] = f k, p for k, p of compiled when isp(k, p)
+    regex[k] = f k, p for k, p of compiled when isr(k, p)
+    @type = "object"; return this
+
+# This defines one of the built in pointers. A pointer is a method
+# defintion that provides an ability to specify (or point to) to a
+# specific kind of data type. Pointers may create simple or complex
+# data type references and definitions. Refer to their implementation.
+# This pointer creates a reference to an array of other pointers.
+module.exports.array = array = (description, pointer) ->
+    noPointer = "got no pointer to array elements"
+    noDescription = "no description has been given"
+    assert _.isString(description), noDescription
+    assert _.isFunction(pointer), noPointer
+    items = Object.create this; @items = items
+    @description = description.toString()
+    @type = "array"; pointer.apply items; @
+
+# This defines one of the built in pointers. A pointer is a method
+# defintion that provides an ability to specify (or point to) to a
+# specific kind of data type. Pointers may create simple or complex
+# data type references and definitions. Refer to their implementation.
+# This pointer is a shorthand that creates an array of pointed objects.
+module.exports.objects = objects = (description, pointer) ->
+    noPointer = "got no pointer to array elements"
+    noDescription = "no description has been given"
+    addendum = "an array of items: #{description}"
+    assert _.isString(description), noDescription
+    assert _.isFunction(pointer), noPointer
+    reference = -> @object description, pointer
+    @array addendum, reference; return @
+
+# This defines one of the built in pointers. A pointer is a method
+# defintion that provides an ability to specify (or point to) to a
+# specific kind of data type. Pointers may create simple or complex
+# data type references and definitions. Refer to their implementation.
+# This pointer is a shorthand that creates an array of strings.
+module.exports.strings = strings = (description) ->
+    noDescription = "no description has been given"
+    addendum = "an array of items: #{description}"
+    assert _.isString(description), noDescription
+    reference = -> @string description
+    @array addendum, reference; this
+
+# This defines one of the built in pointers. A pointer is a method
+# defintion that provides an ability to specify (or point to) to a
+# specific kind of data type. Pointers may create simple or complex
+# data type references and definitions. Refer to their implementation.
+# A modificator that marks object property as the pattern property.
+module.exports.pattern = pattern = (pointer) ->
+    notPointer = "incorrect pointer for pattern"
+    assert _.isFunction(pointer), notPointer
+    pointer.pattern = yes; return pointer
+
+# This defines one of the built in pointers. A pointer is a method
+# defintion that provides an ability to specify (or point to) to a
+# specific kind of data type. Pointers may create simple or complex
+# data type references and definitions. Refer to their implementation.
 # A modificator that marks objects as strict (no additional properties).
 module.exports.strict = strict = (object) ->
     notObject = "applicable only for an object"

    assert _.isFunction(p), "incorrect pointer for must"
    assert _.isString(k), "invalid name of property: #{k}"
    assert _.isObject(o), "internal error, no outer object"
    (o.required ?= []).push k; p.apply @, arguments

# This defines one of the built in pointers. A pointer is a method
# defintion that provides an ability to specify (or point to) to a
# specific kind of data type. Pointers may create simple or complex
# data type references and definitions. Refer to their implementation.
# This pointer creates a reference to object with composite pointer.
module.exports.object = object = (description, pointer) ->
    noPointer = "got no pointer to the object members"
    noCompiled = "content pointer must return object"
    noDescription = "no description has been given"
    assert _.isString(description), noDescription
    assert _.isFunction(pointer), noPointer
    compiled = pointer.apply this
    @properties = Object.create this
    @description = description.toString()
    assert _.isObject(compiled), noCompiled
    f = (k, p) => p.call n = Object.create(@), k, @; n
    @properties[key] = f key, p for key, p of compiled
    @type = "object"; return this

# This defines one of the built in pointers. A pointer is a method
# defintion that provides an ability to specify (or point to) to a
# specific kind of data type. Pointers may create simple or complex
# data type references and definitions. Refer to their implementation.
# This pointer creates a reference to an array of other pointers.
module.exports.choose = choose = (description, values...) ->
    noValues = "all values must be primitive strings"
    noDescription = "no description has been given"
    assert _.isString(description), noDescription
    assert _.all(values, _.isString), noValues
    @description = description.toString()

# specific kind of data type. Pointers may create simple or complex
# data type references and definitions. Refer to their implementation.
# This pointer creates a reference to an array of other pointers.
module.exports.follows = follows = (description, values...) ->
    noValues = "all values must be primitive strings"
    noDescription = "no description has been given"
    assert _.isString(description), noDescription
    assert _.all(values, _.isString), noValues
    @description = description.toString()
    @enum = values; return this

# This defines one of the built in pointers. A pointer is a method
# defintion that provides an ability to specify (or point to) to a
