Typecast.js

Type.a( type )

Return an example value of type.

Type.a('false')  // false
Type.a('number') // 0
Type.a('array')  // []

Type.is( type, value )

Is this value of this type? Specifically, returns true if this value be made into a typed object without changing? Strict comparison, returns true or false.

Type.is('number', 123)   // true
Type.is('number', 'abc') // false

With all the comparison functions either property can also be a Typed object. The first property will use the type of the Typed object. The second property will use the value of the Typed object.

var num1 = Type('number', 456);
Type.is(num1, 123)        // true, 123 is a number
Type.is('integer', num1); // true, 123 is an integer   

Type.can( type, value )

Can this value be made into this type. Returns true or false.

Type.can('number', 123)   // true
Type.can('number', '123') // true
Type.can('number', 'abc') // false, 'abc' cannot be made into a number

var num1 = Type('float', 123.1);
Type.can('integer', num1); // true, 123.1 can be made into an integer

Type.make( type, value )

Make a value into a type. Returns a raw value, rather than a Typed object.

Type.make('number', 123)   // 123
Type.make('number', '123') // 123
Type.make('number', 'abc') // false

var num1 = Type('float', 123.1)
Type.make('integer', num1); // 123

Type.to( type, value )

Returns a typed object, performing a specific type tranformation.

Type.to('object', ['a'])   // Typed object with the value of {0:'a'}

Type.detect( value )

Almost exactly the same as the native Javascript typeof operator, except it distriguishes null, NaN, arguments and arrays.

Type.detect([])	//  "array"
Type.detect(123)	//  "number"

Type.name.method()

Each Type also offers a set of class methods which do not operate on a typed object, but return values related to that type:

Type.number.random(123)	// returns a random number between 0 and 123
Type.array.range(0, 4)	// returns [0,1,2,3,4]

^ back to top

Type( value ), Type( type, value )

Type() is a function that creates Typed objects:

Type('array', []) // returns a Typed object
                  // of type 'array' and with a value of []

To transform a Typed object into a new type, pass it back to Type() as the second argument:

var myArray = Type('array', [1,2,3]);
var myString = Type('string', myArray);

myString.type() // returns "string"
myString.a()    // returns the original array value as a string "[1,2,3]"

Calling Type() with just a value creates Typed object using the type given by Type.detect() called on the same value. This of course is slower, but good for cases when you are unsure what type of value you have:

Type([]) // returns an array Typed object

Type.name( ), Type.name( value )

Also, the type name itself is a shorthand for making a Typed object with Type( name, value ). If a value is provided, it is used.

Type.number()      // returns a Typed object with a value of 0
Type.number('123') // returns a Typed object with a value of 123

TypedObject.a( ), TypedObject.type( ), TypedObject.set( value ), TypedObject.to( value )

Typed objects come with several functions:

var myArray = Type('array', [1,2,3]);
myArray.a()          // returns the value of the Typed object, [1,2,3] 
myArray.val()        // alias of a() for jQuery people
myArray.get()        // alias of a() for getter/setter people
myArray.set([4,5,6]) // changes the value of the Typed object
myArray.type()       // returns 'array'

Additionally, all typed objects inherit methods from the type that they become. Strings get string methods and arrays get array methods. All object methods are wrapped to provide two features. All arguments can be Typed objects rather than values:

var myArray = Type.array([1,2,3]);
var interator = Type.fn(function(a){ return ++a; });

myArray.map(iterator).a() // returns [2,3,4]

And all methods associated with the Typed object's type are chainable:

var myArray = Type.array([1,2,3]);
myArray.pop().union([3,4,5]).unique().without(4).a() // returns [2,3,5]

TypedObject.is( type ), TypedObject.can( type )

Typed objects have an is() function that checks if the value of the object is also of the supplied type.

var num1 = Type('number', 123);
num1.is('positive');	// true
num1.is('negative');	// false

TypedObject.ifis( type, function, elseFunction )

The ifis() function can be used in two ways. If object is of type, then call this function on the Typed object, or if first property is truthy, then call this function on the Typed object.

var myArray = Type('array', [1,2,3]);
myArray.ifis('array', function(){
	return this.a().splice(1); // returns [2,3]
});
myArray.ifis(1 === 1, function(){
	return this.a().length;    // returns 3
});

TypedObject.to( type ), TypedObject.to.transformation( )

The .to() function does a specific type-to-type transformation, if one is available. To's list of specific transformation are broader than just the list of types. For instance there are many ways to change an array into an object. Each one is a transformation from a Typed array to a Typed object. If no transformation is available type uses the more generic make function for that class.

var num = Type.number(123);

num.to('bool').a()	// false
num.to('array').a()	// [false]
num.to('str').a()	// "false"

num = num.to('array').to.first();
num.a() 		// true
num.type()	// boolean

TypedObject.method( )

Typed objects inherit special helpers methods from their Type definition. The list of methods for each type are listed in the documentation. Any property passed to these methods may be the value or a Typed object containing the value. Typed object methods return a new Typed object with the same type as the original. Because of this, Typed object methods are chainable.

var num = Type.number(123);
num.plus(5).a()	// 128
num.a()			// 123

var fn = Type.fn(function(v){ return ++v; });
var list = Type.arr([1,2,3]);
list.map(fn).a() 			// [2,3,4]
list.map(fn.after(2)).a() 	// [1,2,4]
list.push(4).shift().a()		// [2,3,4]

list.a()						// [1,2,3] original value is preserved
list.set(list.push(4))		// .set() modifies the value 
list.a()						// [1,2,3,4] 
list = list.push(5)			// or just overwrite with the return object 
list.a()						// [1,2,3,4,5] 

^ back to top