diff --git a/vlib/v/ast/str.v b/vlib/v/ast/str.v
index 0ca45e3332..584de7625d 100644
--- a/vlib/v/ast/str.v
+++ b/vlib/v/ast/str.v
@@ -24,7 +24,7 @@ pub fn (node &FnDecl) str(t &table.Table) string {
 		sym := t.get_type_symbol(node.receiver.typ)
 		name := sym.name.after('.')
 		mut m := if node.rec_mut { 'mut ' } else { '' }
-		if !node.rec_mut && table.type_is_ptr(node.receiver.typ) {
+		if !node.rec_mut && node.receiver.typ.is_ptr() {
 			m = '&'
 		}
 		receiver = '($node.receiver.name $m$name) '
diff --git a/vlib/v/checker/checker.v b/vlib/v/checker/checker.v
index cd0c4a4bdb..09b6b92ffb 100644
--- a/vlib/v/checker/checker.v
+++ b/vlib/v/checker/checker.v
@@ -258,7 +258,7 @@ pub fn (c mut Checker) struct_init(struct_init mut ast.StructInit) table.Type {
 				if field.name in inited_fields {
 					continue
 				}
-				if table.type_is_ptr(field.typ) {
+				if field.typ.is_ptr() {
 					c.warn('reference field `${type_sym.name}.${field.name}` must be initialized',
 						struct_init.pos)
 				}
@@ -478,7 +478,7 @@ pub fn (c mut Checker) call_method(call_expr mut ast.CallExpr) table.Type {
 		call_expr.return_type = left_type
 		if method_name == 'clone' {
 			// in ['clone', 'str'] {
-			call_expr.receiver_type = table.type_to_ptr(left_type)
+			call_expr.receiver_type = left_type.to_ptr()
 			// call_expr.return_type = call_expr.receiver_type
 		} else {
 			call_expr.receiver_type = left_type
@@ -520,7 +520,7 @@ pub fn (c mut Checker) call_method(call_expr mut ast.CallExpr) table.Type {
 			}
 			arg_typ := c.expr(arg.expr)
 			call_expr.args[i].typ = arg_typ
-			if method.is_variadic && table.type_is(arg_typ, .variadic) && call_expr.args.len-1 > i  {
+			if method.is_variadic && arg_typ.flag_is(.variadic) && call_expr.args.len-1 > i  {
 				c.error('when forwarding a varg variable, it must be the final argument', call_expr.pos)
 			}
 		}
@@ -646,7 +646,7 @@ pub fn (c mut Checker) call_fn(call_expr mut ast.CallExpr) table.Type {
 		call_expr.args[i].typ = typ
 		typ_sym := c.table.get_type_symbol(typ)
 		arg_typ_sym := c.table.get_type_symbol(arg.typ)
-		if f.is_variadic && table.type_is(typ, .variadic) && call_expr.args.len-1 > i {
+		if f.is_variadic && typ.flag_is(.variadic) && call_expr.args.len-1 > i {
 			c.error('when forwarding a varg variable, it must be the final argument', call_expr.pos)
 		}
 		if !c.table.check(typ, arg.typ) {
@@ -673,7 +673,7 @@ pub fn (c mut Checker) call_fn(call_expr mut ast.CallExpr) table.Type {
 pub fn (c mut Checker) check_expr_opt_call(x ast.Expr, xtype table.Type, is_return_used bool) {
 	match x {
 		ast.CallExpr {
-			if table.type_is(it.return_type, .optional) {
+			if it.return_type.flag_is(.optional) {
 				c.check_or_block(it, xtype, is_return_used)
 			}
 		}
@@ -771,7 +771,7 @@ pub fn (c mut Checker) selector_expr(selector_expr mut ast.SelectorExpr) table.T
 	typ_sym := c.table.get_type_symbol(typ)
 	field_name := selector_expr.field
 	// variadic
-	if table.type_is(typ, .variadic) {
+	if typ.flag_is(.variadic) {
 		if field_name == 'len' {
 			return table.int_type
 		}
@@ -803,7 +803,7 @@ pub fn (c mut Checker) return_stmt(return_stmt mut ast.Return) {
 	}
 	expected_type := c.fn_return_type
 	expected_type_sym := c.table.get_type_symbol(expected_type)
-	exp_is_optional := table.type_is(expected_type, .optional)
+	exp_is_optional := expected_type.flag_is(.optional)
 	mut expected_types := [expected_type]
 	if expected_type_sym.kind == .multi_return {
 		mr_info := expected_type_sym.info as table.MultiReturn
@@ -816,7 +816,7 @@ pub fn (c mut Checker) return_stmt(return_stmt mut ast.Return) {
 	}
 	return_stmt.types = got_types
 	// allow `none` & `error (Option)` return types for function that returns optional
-	if exp_is_optional && table.type_idx(got_types[0]) in [table.none_type_idx, c.table.type_idxs['Option']] {
+	if exp_is_optional && got_types[0].idx() in [table.none_type_idx, c.table.type_idxs['Option']] {
 		return
 	}
 	if expected_types.len > 0 && expected_types.len != got_types.len {
@@ -1144,7 +1144,7 @@ fn (c mut Checker) stmt(node ast.Stmt) {
 		ast.ForStmt {
 			c.in_for_count++
 			typ := c.expr(it.cond)
-			if !it.is_inf && table.type_idx(typ) != table.bool_type_idx {
+			if !it.is_inf && typ.idx() != table.bool_type_idx {
 				c.error('non-bool used as for condition', it.pos)
 			}
 			// TODO: update loop var type
@@ -1164,9 +1164,9 @@ fn (c mut Checker) stmt(node ast.Stmt) {
 		ast.ForInStmt {
 			c.in_for_count++
 			typ := c.expr(it.cond)
-			typ_idx := table.type_idx(typ)
+			typ_idx := typ.idx()
 			if it.is_range {
-				high_type_idx := table.type_idx(c.expr(it.high))
+				high_type_idx := c.expr(it.high).idx()
 				if typ_idx in table.integer_type_idxs && high_type_idx !in table.integer_type_idxs {
 					c.error('range types do not match', it.cond.position())
 				} else if typ_idx in table.float_type_idxs || high_type_idx in table.float_type_idxs {
@@ -1342,11 +1342,11 @@ pub fn (c mut Checker) expr(node ast.Expr) table.Type {
 		ast.PrefixExpr {
 			right_type := c.expr(it.right)
 			// TODO: testing ref/deref strategy
-			if it.op == .amp && !table.type_is_ptr(right_type) {
-				return table.type_to_ptr(right_type)
+			if it.op == .amp && !right_type.is_ptr() {
+				return right_type.to_ptr()
 			}
-			if it.op == .mul && table.type_is_ptr(right_type) {
-				return table.type_deref(right_type)
+			if it.op == .mul && right_type.is_ptr() {
+				return right_type.deref()
 			}
 			if it.op == .not && right_type != table.bool_type_idx {
 				c.error('! operator can only be used with bool types', it.pos)
@@ -1442,7 +1442,7 @@ pub fn (c mut Checker) ident(ident mut ast.Ident) table.Type {
 					if typ == 0 {
 						typ = c.expr(it.expr)
 					}
-					is_optional := table.type_is(typ, .optional)
+					is_optional := typ.flag_is(.optional)
 					ident.kind = .variable
 					ident.info = ast.IdentVar{
 						typ: typ
@@ -1451,7 +1451,7 @@ pub fn (c mut Checker) ident(ident mut ast.Ident) table.Type {
 					it.typ = typ
 					// unwrap optional (`println(x)`)
 					if is_optional {
-						return table.type_set(typ, .unset)
+						return typ.set_flag(.unset)
 					}
 					return typ
 				}
@@ -1646,7 +1646,7 @@ pub fn (c mut Checker) if_expr(node mut ast.IfExpr) table.Type {
 		if i < node.branches.len - 1 || !node.has_else {
 			typ_sym := c.table.get_type_symbol(typ)
 			// if typ_sym.kind != .bool {
-			if table.type_idx(typ) != table.bool_type_idx {
+			if typ.idx() != table.bool_type_idx {
 				c.error('non-bool (`$typ_sym.name`) used as if condition', node.pos)
 			}
 		}
@@ -1681,7 +1681,7 @@ pub fn (c mut Checker) postfix_expr(node ast.PostfixExpr) table.Type {
 */
 	typ := c.expr(node.expr)
 	typ_sym := c.table.get_type_symbol(typ)
-	// if !table.is_number(typ) {
+	// if !typ.is_number() {
 	if !typ_sym.is_number() {
 		println(typ_sym.kind.str())
 		c.error('invalid operation: $node.op.str() (non-numeric type `$typ_sym.name`)', node.pos)
@@ -1712,11 +1712,11 @@ pub fn (c mut Checker) index_expr(node mut ast.IndexExpr) table.Type {
 		// println('index expr left=$typ_sym.name $node.pos.line_nr')
 		// if typ_sym.kind == .array && (!(table.type_idx(index_type) in table.number_type_idxs) &&
 		// index_type_sym.kind != .enum_) {
-		if typ_sym.kind in [.array, .array_fixed] && !(table.is_number(index_type) || index_type_sym.kind ==
+		if typ_sym.kind in [.array, .array_fixed] && !(index_type.is_number() || index_type_sym.kind ==
 			.enum_) {
 			c.error('non-integer index `$index_type_sym.name` (array type `$typ_sym.name`)',
 				node.pos)
-		} else if typ_sym.kind == .map && table.type_idx(index_type) != table.string_type_idx {
+		} else if typ_sym.kind == .map && index_type.idx() != table.string_type_idx {
 			c.error('non-string map index (map type `$typ_sym.name`)', node.pos)
 		}
 		value_type := c.table.value_type(typ)
@@ -1740,7 +1740,7 @@ pub fn (c mut Checker) index_expr(node mut ast.IndexExpr) table.Type {
 // with this value.
 pub fn (c mut Checker) enum_val(node mut ast.EnumVal) table.Type {
 	typ_idx := if node.enum_name == '' {
-		table.type_idx(c.expected_type)
+		c.expected_type.idx()
 	} else {		//
 		c.table.find_type_idx(node.enum_name)
 	}
diff --git a/vlib/v/gen/cgen.v b/vlib/v/gen/cgen.v
index b12b2475cc..fee6e5af53 100644
--- a/vlib/v/gen/cgen.v
+++ b/vlib/v/gen/cgen.v
@@ -237,10 +237,10 @@ pub fn (mut g Gen) write_typeof_functions() {
 // V type to C type
 pub fn (mut g Gen) typ(t table.Type) string {
 	mut styp := g.base_typ(t)
-	if table.type_is(t, .optional) {
+	if t.flag_is(.optional) {
 		// Register an optional
 		styp = 'Option_' + styp
-		if table.type_is_ptr(t) {
+		if t.is_ptr() {
 			styp = styp.replace('*', '_ptr')
 		}
 		if !(styp in g.optionals) {
@@ -254,7 +254,7 @@ pub fn (mut g Gen) typ(t table.Type) string {
 }
 
 pub fn (mut g Gen) base_typ(t table.Type) string {
-	nr_muls := table.type_nr_muls(t)
+	nr_muls := t.nr_muls()
 	sym := g.table.get_type_symbol(t)
 	mut styp := sym.name.replace('.', '__')
 	if nr_muls > 0 {
@@ -615,7 +615,7 @@ fn (mut g Gen) for_in(it ast.ForInStmt) {
 		// `for num in nums {`
 		g.writeln('// FOR IN array')
 		styp := g.typ(it.val_type)
-		cond_type_is_ptr := table.type_is_ptr(it.cond_type)
+		cond_type_is_ptr := it.cond_type.is_ptr()
 		atmp := g.new_tmp_var()
 		atmp_type := if cond_type_is_ptr { 'array *' } else { 'array' }
 		g.write('${atmp_type} ${atmp} = ')
@@ -650,7 +650,7 @@ fn (mut g Gen) for_in(it ast.ForInStmt) {
 		}
 		g.stmts(it.stmts)
 		g.writeln('}')
-	} else if table.type_is(it.cond_type, .variadic) {
+	} else if it.cond_type.flag_is(.variadic) {
 		g.writeln('// FOR IN cond_type/variadic')
 		i := if it.key_var in ['', '_'] { g.new_tmp_var() } else { it.key_var }
 		styp := g.typ(it.cond_type)
@@ -688,7 +688,7 @@ fn (mut g Gen) expr_with_cast(expr ast.Expr, got_type, exp_type table.Type) {
 				got_sym := g.table.get_type_symbol(got_type)
 				got_styp := g.typ(got_type)
 				exp_styp := g.typ(exp_type)
-				got_idx := table.type_idx(got_type)
+				got_idx := got_type.idx()
 				g.write('/* sum type cast */ ($exp_styp) {.obj = memdup(&(${got_styp}[]) {')
 				g.expr(expr)
 				g.write('}, sizeof($got_styp)), .typ = $got_idx /* $got_sym.name */}')
@@ -745,7 +745,7 @@ fn (mut g Gen) gen_assign_stmt(assign_stmt ast.AssignStmt) {
 			or_stmts = it.or_block.stmts
 			return_type = it.return_type
 		}
-		is_optional := table.type_is(return_type, .optional)
+		is_optional := return_type.flag_is(.optional)
 		mr_var_name := 'mr_$assign_stmt.pos.pos'
 		mr_styp := g.typ(return_type)
 		g.write('$mr_styp $mr_var_name = ')
@@ -802,7 +802,7 @@ fn (mut g Gen) gen_assign_stmt(assign_stmt ast.AssignStmt) {
 				}
 				else {}
 			}
-			gen_or := is_call && table.type_is(return_type, .optional)
+			gen_or := is_call && return_type.flag_is(.optional)
 			g.is_assign_rhs = true
 			if ident.kind == .blank_ident {
 				if is_call {
@@ -893,7 +893,7 @@ fn (mut g Gen) free_scope_vars(pos int) {
 				// }
 				v := *it
 				sym := g.table.get_type_symbol(v.typ)
-				is_optional := table.type_is(v.typ, .optional)
+				is_optional := v.typ.flag_is(.optional)
 				if sym.kind == .array && !is_optional {
 					g.writeln('array_free($v.name); // autofreed')
 				}
@@ -966,7 +966,7 @@ fn (mut g Gen) expr(node ast.Expr) {
 				g.out.go_back(1)
 			}
 			sym := g.table.get_type_symbol(it.typ)
-			if sym.kind == .string && !table.type_is_ptr(it.typ) {
+			if sym.kind == .string && !it.typ.is_ptr() {
 				// `string(x)` needs `tos()`, but not `&string(x)
 				// `tos(str, len)`, `tos2(str)`
 				if it.has_arg {
@@ -1113,8 +1113,8 @@ fn (mut g Gen) expr(node ast.Expr) {
 		}
 		ast.SelectorExpr {
 			g.expr(it.expr)
-			// if table.type_nr_muls(it.expr_type) > 0 {
-			if table.type_is_ptr(it.expr_type) {
+			// if it.expr_type.nr_muls() > 0 {
+			if it.expr_type.is_ptr() {
 				g.write('->')
 			} else {
 				// g.write('. /*typ=  $it.expr_type */') // ${g.typ(it.expr_type)} /')
@@ -1128,7 +1128,7 @@ fn (mut g Gen) expr(node ast.Expr) {
 		ast.Type {
 			// match sum Type
 			// g.write('/* Type */')
-			type_idx := table.type_idx(it.typ)
+			type_idx := it.typ.idx()
 			sym := g.table.get_type_symbol(it.typ)
 			g.write('$type_idx /* $sym.name */')
 		}
@@ -1159,7 +1159,7 @@ fn (mut g Gen) typeof_expr(node ast.TypeOf) {
 	if sym.kind == .sum_type {
 		// When encountering a .sum_type, typeof() should be done at runtime,
 		// because the subtype of the expression may change:
-		sum_type_idx := table.type_idx(node.expr_type)
+		sum_type_idx := node.expr_type.idx()
 		g.write('tos3( /* ${sym.name} */ v_typeof_sumtype_${sum_type_idx}( (')
 		g.expr(node.expr)
 		g.write(').typ ))')
@@ -1207,7 +1207,7 @@ fn (mut g Gen) assign_expr(node ast.AssignExpr) {
 		}
 		else {}
 	}
-	gen_or := is_call && table.type_is(return_type, .optional)
+	gen_or := is_call && return_type.flag_is(.optional)
 	tmp_opt := if gen_or { g.new_tmp_var() } else { '' }
 	if gen_or {
 		rstyp := g.typ(return_type)
@@ -1225,7 +1225,7 @@ fn (mut g Gen) assign_expr(node ast.AssignExpr) {
 		}
 	} else {
 		g.is_assign_lhs = true
-		if table.type_is(node.right_type, .optional) {
+		if node.right_type.flag_is(.optional) {
 			g.right_is_opt = true
 		}
 		mut str_add := false
@@ -1390,8 +1390,7 @@ fn (mut g Gen) infix_expr(node ast.InfixExpr) {
 			g.expr_with_cast(node.right, node.right_type, info.elem_type)
 			g.write(' })')
 		}
-	} else if (node.left_type == node.right_type) && table.is_float(node.left_type) && node.op in
-		[.eq, .ne] {
+	} else if (node.left_type == node.right_type) && node.left_type.is_float() && node.op in [.eq, .ne] {
 		// floats should be compared with epsilon
 		if node.left_type == table.f64_type_idx {
 			if node.op == .eq {
@@ -1687,8 +1686,8 @@ fn (mut g Gen) index_expr(node ast.IndexExpr) {
 	}
 	if !is_range {
 		sym := g.table.get_type_symbol(node.left_type)
-		left_is_ptr := table.type_is_ptr(node.left_type)
-		if table.type_is(node.left_type, .variadic) {
+		left_is_ptr := node.left_type.is_ptr()
+		if node.left_type.flag_is(.variadic) {
 			g.expr(node.left)
 			g.write('.args')
 			g.write('[')
@@ -1789,7 +1788,7 @@ fn (mut g Gen) index_expr(node ast.IndexExpr) {
 				g.expr(node.index)
 				g.write(', &($elem_type_str[]){ $zero }))')
 			}
-		} else if sym.kind == .string && !table.type_is_ptr(node.left_type) {
+		} else if sym.kind == .string && !node.left_type.is_ptr() {
 			g.write('string_at(')
 			g.expr(node.left)
 			g.write(', ')
@@ -1810,14 +1809,14 @@ fn (mut g Gen) return_statement(node ast.Return) {
 		g.writeln(' 0;')
 		return
 	}
-	fn_return_is_optional := table.type_is(g.fn_decl.return_type, .optional)
+	fn_return_is_optional := g.fn_decl.return_type.flag_is(.optional)
 	// multiple returns
 	if node.exprs.len > 1 {
 		g.write(' ')
 		// typ_sym := g.table.get_type_symbol(g.fn_decl.return_type)
 		// mr_info := typ_sym.info as table.MultiReturn
 		mut styp := ''
-		if fn_return_is_optional { // && !table.type_is(node.types[0], .optional) && node.types[0] !=
+		if fn_return_is_optional { // && !node.types[0].flag_is(.optional) && node.types[0] !=
 			styp = g.base_typ(g.fn_decl.return_type)
 			g.write('opt_ok(&($styp/*X*/[]) { ')
 		} else {
@@ -1840,7 +1839,7 @@ fn (mut g Gen) return_statement(node ast.Return) {
 		g.write(' ')
 		return_sym := g.table.get_type_symbol(node.types[0])
 		// `return opt_ok(expr)` for functions that expect an optional
-		if fn_return_is_optional && !table.type_is(node.types[0], .optional) && return_sym.name !=
+		if fn_return_is_optional && !node.types[0].flag_is(.optional) && return_sym.name !=
 			'Option' {
 			mut is_none := false
 			mut is_error := false
@@ -1865,7 +1864,7 @@ fn (mut g Gen) return_statement(node ast.Return) {
 			}
 			// g.write('/*OPTIONAL*/')
 		}
-		if !table.type_is_ptr(g.fn_decl.return_type) && table.type_is_ptr(node.types[0]) {
+		if !g.fn_decl.return_type.is_ptr() && node.types[0].is_ptr() {
 			// Automatic Dereference
 			g.write('*')
 		}
@@ -1978,7 +1977,7 @@ fn (mut g Gen) struct_init(struct_init ast.StructInit) {
 			if field.name in inited_fields {
 				continue
 			}
-			if table.type_is(field.typ, .optional) {
+			if field.typ.flag_is(.optional) {
 				// TODO handle/require optionals in inits
 				continue
 			}
@@ -2236,7 +2235,7 @@ fn (g Gen) sort_structs(typesa []table.TypeSymbol) []table.TypeSymbol {
 				for field in info.fields {
 					dep := g.table.get_type_symbol(field.typ).name
 					// skip if not in types list or already in deps
-					if !(dep in type_names) || dep in field_deps || table.type_is_ptr(field.typ) {
+					if !(dep in type_names) || dep in field_deps || field.typ.is_ptr() {
 						continue
 					}
 					field_deps << dep
@@ -2664,7 +2663,7 @@ fn (g Gen) type_default(typ table.Type) string {
 		return 'new_map_1(sizeof($value_type_str))'
 	}
 	// Always set pointers to 0
-	if table.type_is_ptr(typ) {
+	if typ.is_ptr() {
 		return '0'
 	}
 	// User struct defined in another module.
diff --git a/vlib/v/gen/fn.v b/vlib/v/gen/fn.v
index c95bd75afe..1079cded4f 100644
--- a/vlib/v/gen/fn.v
+++ b/vlib/v/gen/fn.v
@@ -52,7 +52,7 @@ fn (mut g Gen) gen_fn_decl(it ast.FnDecl) {
 	/*
 	if it.is_method {
 		mut styp := g.typ(it.receiver.typ)
-		// if table.type_nr_muls(it.receiver.typ) > 0 {
+		// if it.receiver.typ.nr_muls() > 0 {
 		// if it.rec_mut {
 		// styp += '*'
 		// }
@@ -153,7 +153,7 @@ fn (mut g Gen) fn_args(args []table.Arg, is_variadic bool) {
 			g.write(arg_type_name)
 			g.definitions.write(arg_type_name)
 		} else {
-			mut nr_muls := table.type_nr_muls(arg.typ)
+			mut nr_muls := arg.typ.nr_muls()
 			s := arg_type_name + ' ' + arg.name
 			if arg.is_mut {
 				// mut arg needs one *
@@ -235,17 +235,17 @@ fn (mut g Gen) method_call(node ast.CallExpr) {
 	// g.write('/*expr_type=${g.typ(node.left_type)} rec type=${g.typ(node.receiver_type)}*/')
 	// }
 	g.write('${name}(')
-	if table.type_is_ptr(node.receiver_type) && !table.type_is_ptr(node.left_type) {
+	if node.receiver_type.is_ptr() && !node.left_type.is_ptr() {
 		// The receiver is a reference, but the caller provided a value
 		// Add `&` automatically.
 		// TODO same logic in call_args()
 		g.write('&')
-	} else if !table.type_is_ptr(node.receiver_type) && table.type_is_ptr(node.left_type) {
+	} else if !node.receiver_type.is_ptr() && node.left_type.is_ptr() {
 		g.write('/*rec*/*')
 	}
 	g.expr(node.left)
-	is_variadic := node.expected_arg_types.len > 0 && table.type_is(node.expected_arg_types[node.expected_arg_types.len -
-		1], .variadic)
+	is_variadic := node.expected_arg_types.len > 0 && 
+		node.expected_arg_types[node.expected_arg_types.len -1].flag_is(.variadic)
 	if node.args.len > 0 || is_variadic {
 		g.write(', ')
 	}
@@ -275,7 +275,7 @@ fn (mut g Gen) fn_call(node ast.CallExpr) {
 	// will be `0` for `foo()`
 	if node.left_type != 0 {
 		g.expr(node.left)
-		if table.type_is_ptr(node.left_type) {
+		if node.left_type.is_ptr() {
 			g.write('->')
 		} else {
 			g.write('.')
@@ -319,12 +319,12 @@ fn (mut g Gen) fn_call(node ast.CallExpr) {
 		typ := node.args[0].typ
 		mut styp := g.typ(typ)
 		sym := g.table.get_type_symbol(typ)
-		if table.type_is_ptr(typ) {
+		if typ.is_ptr() {
 			styp = styp.replace('*', '')
 		}
 		mut str_fn_name := styp_to_str_fn_name(styp)
 		g.gen_str_for_type(sym, styp, str_fn_name)
-		if g.autofree && !table.type_is(typ, .optional) {
+		if g.autofree && !typ.flag_is(.optional) {
 			// Create a temporary variable so that the value can be freed
 			tmp := g.new_tmp_var()
 			// tmps << tmp
@@ -338,7 +338,7 @@ fn (mut g Gen) fn_call(node ast.CallExpr) {
 				ast.Ident { true }
 				else { false }
 			}
-			if table.type_is_ptr(typ) && sym.kind != .struct_ {
+			if typ.is_ptr() && sym.kind != .struct_ {
 				// ptr_str() for pointers
 				styp = 'ptr'
 				str_fn_name = 'ptr_str'
@@ -350,7 +350,7 @@ fn (mut g Gen) fn_call(node ast.CallExpr) {
 					// when no var, print string directly
 					g.write('${print_method}(tos3("')
 				}
-				if table.type_is_ptr(typ) {
+				if typ.is_ptr() {
 					// dereference
 					g.write('*')
 				}
@@ -361,7 +361,7 @@ fn (mut g Gen) fn_call(node ast.CallExpr) {
 				}
 			} else {
 				g.write('${print_method}(${str_fn_name}(')
-				if table.type_is_ptr(typ) && sym.kind == .struct_ {
+				if typ.is_ptr() && sym.kind == .struct_ {
 					// dereference
 					g.write('*')
 				}
@@ -388,9 +388,9 @@ fn (mut g Gen) fn_call(node ast.CallExpr) {
 }
 
 fn (mut g Gen) call_args(args []ast.CallArg, expected_types []table.Type) {
-	is_variadic := expected_types.len > 0 && table.type_is(expected_types[expected_types.len -
-		1], .variadic)
-	is_forwarding_varg := args.len > 0 && table.type_is(args[args.len - 1].typ, .variadic)
+	is_variadic := expected_types.len > 0 &&
+		expected_types[expected_types.len - 1].flag_is(.variadic)
+	is_forwarding_varg := args.len > 0 && args[args.len - 1].typ.flag_is(.variadic)
 	gen_vargs := is_variadic && !is_forwarding_varg
 	mut arg_no := 0
 	for arg in args {
@@ -434,8 +434,8 @@ fn (mut g Gen) call_args(args []ast.CallArg, expected_types []table.Type) {
 
 [inline]
 fn (mut g Gen) ref_or_deref_arg(arg ast.CallArg, expected_type table.Type) {
-	arg_is_ptr := table.type_is_ptr(expected_type) || table.type_idx(expected_type) in table.pointer_type_idxs
-	expr_is_ptr := table.type_is_ptr(arg.typ) || table.type_idx(arg.typ) in table.pointer_type_idxs
+	arg_is_ptr := expected_type.is_ptr() || expected_type.idx() in table.pointer_type_idxs
+	expr_is_ptr := arg.typ.is_ptr() || arg.typ.idx() in table.pointer_type_idxs
 	if arg.is_mut && !arg_is_ptr {
 		g.write('&/*mut*/')
 	} else if arg_is_ptr && !expr_is_ptr {
diff --git a/vlib/v/gen/js/js.v b/vlib/v/gen/js/js.v
index 203a03369d..046c43fc5d 100644
--- a/vlib/v/gen/js/js.v
+++ b/vlib/v/gen/js/js.v
@@ -765,7 +765,7 @@ fn (g mut JsGen) gen_for_in_stmt(it ast.ForInStmt) {
 		g.inside_loop = false
 		g.stmts(it.stmts)
 		g.writeln('}')
-	} else if it.kind == .array || table.type_is(it.cond_type, .variadic) {
+	} else if it.kind == .array || it.cond_type.flag_is(.variadic) {
 		// `for num in nums {`
 		i := if it.key_var == '' { g.new_tmp_var() } else { it.key_var }
 		// styp := g.typ(it.val_type)
diff --git a/vlib/v/parser/fn.v b/vlib/v/parser/fn.v
index 9f735bbced..14811b497f 100644
--- a/vlib/v/parser/fn.v
+++ b/vlib/v/parser/fn.v
@@ -304,7 +304,7 @@ fn (mut p Parser) fn_args() ([]table.Arg, bool) {
 			}
 			mut arg_type := p.parse_type()
 			if is_variadic {
-				arg_type = table.type_set(arg_type, .variadic)
+				arg_type = arg_type.set_flag(.variadic)
 			}
 			if p.tok.kind == .comma {
 				if is_variadic {
@@ -337,7 +337,7 @@ fn (mut p Parser) fn_args() ([]table.Arg, bool) {
 			}
 			mut typ := p.parse_type()
 			if is_variadic {
-				typ = table.type_set(typ, .variadic)
+				typ = typ.set_flag(.variadic)
 			}
 			for arg_name in arg_names {
 				args << table.Arg{
diff --git a/vlib/v/parser/if.v b/vlib/v/parser/if.v
index ded7dda45d..24bb25a210 100644
--- a/vlib/v/parser/if.v
+++ b/vlib/v/parser/if.v
@@ -118,7 +118,7 @@ fn (mut p Parser) match_expr() ast.MatchExpr {
 			exprs << expr
 			p.scope.register('it', ast.Var{
 				name: 'it'
-				typ: table.type_to_ptr(typ)
+				typ: typ.to_ptr()
 			})
 			// TODO
 			if p.tok.kind == .comma {
@@ -142,7 +142,7 @@ fn (mut p Parser) match_expr() ast.MatchExpr {
 				// TODO doesn't work right now
 				p.scope.register(var_name, ast.Var{
 					name: var_name
-					typ: table.type_to_ptr(typ)
+					typ: typ.to_ptr()
 				})
 				// println(var_name)
 			}
diff --git a/vlib/v/parser/parse_type.v b/vlib/v/parser/parse_type.v
index 22e93f074e..2c3cd4ad19 100644
--- a/vlib/v/parser/parse_type.v
+++ b/vlib/v/parser/parse_type.v
@@ -38,7 +38,7 @@ pub fn (mut p Parser) parse_map_type() table.Type {
 	key_type := p.parse_type()
 	// key_type_sym := p.get_type_symbol(key_type)
 	// if key_type_sym.kind != .string {
-	if table.type_idx(key_type) != table.string_type_idx {
+	if key_type.idx() != table.string_type_idx {
 		p.error('maps can only have string keys for now')
 	}
 	p.check(.rsbr)
@@ -121,7 +121,7 @@ pub fn (mut p Parser) parse_type() table.Type {
 	}
 	mut typ := p.parse_any_type(is_c, is_js, nr_muls > 0)
 	if is_optional {
-		typ = table.type_set(typ, .optional)
+		typ = typ.set_flag(.optional)
 	}
 	if nr_muls > 0 {
 		typ = table.type_set_nr_muls(typ, nr_muls)
diff --git a/vlib/v/parser/parser.v b/vlib/v/parser/parser.v
index 12ab20b528..02802ce607 100644
--- a/vlib/v/parser/parser.v
+++ b/vlib/v/parser/parser.v
@@ -632,7 +632,7 @@ pub fn (mut p Parser) name_expr() ast.Expr {
 			mut to_typ := p.parse_type()
 			if p.is_amp {
 				// Handle `&Foo(0)`
-				to_typ = table.type_to_ptr(to_typ)
+				to_typ = to_typ.to_ptr()
 			}
 			p.check(.lpar)
 			mut expr := ast.Expr{}
@@ -640,7 +640,7 @@ pub fn (mut p Parser) name_expr() ast.Expr {
 			mut has_arg := false
 			expr = p.expr(0)
 			// TODO, string(b, len)
-			if p.tok.kind == .comma && table.type_idx(to_typ) == table.string_type_idx {
+			if p.tok.kind == .comma && to_typ.idx() == table.string_type_idx {
 				p.check(.comma)
 				arg = p.expr(0) // len
 				has_arg = true
@@ -1192,7 +1192,7 @@ fn (mut p Parser) type_decl() ast.TypeDecl {
 	}
 	// type MyType int
 	parent_type := first_type
-	pid := table.type_idx(parent_type)
+	pid := parent_type.idx()
 	p.table.register_type_symbol(table.TypeSymbol{
 		kind: .alias
 		name: p.prepend_mod(name)
diff --git a/vlib/v/table/atypes.v b/vlib/v/table/atypes.v
index 656f1ab721..3dd8ca5ee2 100644
--- a/vlib/v/table/atypes.v
+++ b/vlib/v/table/atypes.v
@@ -46,19 +46,19 @@ pub fn (types []Type) contains(typ Type) bool {
 
 // return TypeSymbol idx for `t`
 [inline]
-pub fn type_idx(t Type) int {
+pub fn (t Type) idx() int {
 	return u16(t) & 0xffff
 }
 
 // return nr_muls for `t`
 [inline]
-pub fn type_nr_muls(t Type) int {
+pub fn (t Type) nr_muls() int {
 	return (int(t) >> 16) & 0xff
 }
 
 // return true if `t` is a pointer (nr_muls>0)
 [inline]
-pub fn type_is_ptr(t Type) bool {
+pub fn (t Type) is_ptr() bool {
 	return (int(t) >> 16) & 0xff > 0
 }
 
@@ -73,7 +73,7 @@ pub fn type_set_nr_muls(t Type, nr_muls int) Type {
 
 // increments nr_nuls on `t` and return it
 [inline]
-pub fn type_to_ptr(t Type) Type {
+pub fn (t Type) to_ptr() Type {
 	nr_muls := (int(t) >> 16) & 0xff
 	if nr_muls == 255 {
 		panic('type_to_pre: nr_muls is already at max of 255')
@@ -83,7 +83,7 @@ pub fn type_to_ptr(t Type) Type {
 
 // decrement nr_muls on `t` and return it
 [inline]
-pub fn type_deref(t Type) Type {
+pub fn (t Type) deref() Type {
 	nr_muls := (int(t) >> 16) & 0xff
 	if nr_muls == 0 {
 		panic('deref: type `$t` is not a pointer')
@@ -93,19 +93,19 @@ pub fn type_deref(t Type) Type {
 
 // return the flag that is set on `t`
 [inline]
-pub fn type_flag(t Type) TypeFlag {
+pub fn (t Type) flag() TypeFlag {
 	return (int(t) >> 24) & 0xff
 }
 
 // set the flag on `t` to `flag` and return it
 [inline]
-pub fn type_set(t Type, flag TypeFlag) Type {
+pub fn (t Type) set_flag(flag TypeFlag) Type {
 	return (int(flag) << 24) | (((int(t) >> 16) & 0xff) << 16) | (u16(t) & 0xffff)
 }
 
 // return true if the flag set on `t` is `flag`
 [inline]
-pub fn type_is(t Type, flag TypeFlag) bool {
+pub fn (t Type) flag_is(flag TypeFlag) bool {
 	return (int(t) >> 24) & 0xff == flag
 }
 
@@ -131,18 +131,18 @@ pub fn new_type_ptr(idx, nr_muls int) Type {
 }
 
 [inline]
-pub fn is_float(typ Type) bool {
-	return type_idx(typ) in float_type_idxs
+pub fn (typ Type) is_float() bool {
+	return typ.idx() in float_type_idxs
 }
 
 [inline]
-pub fn is_int(typ Type) bool {
-	return type_idx(typ) in integer_type_idxs
+pub fn (typ Type) is_int() bool {
+	return typ.idx() in integer_type_idxs
 }
 
 [inline]
-pub fn is_number(typ Type) bool {
-	return type_idx(typ) in number_type_idxs
+pub fn (typ Type) is_number() bool {
+	return typ.idx() in number_type_idxs
 }
 
 pub const (
@@ -580,11 +580,11 @@ pub fn (table &Table) type_to_str(t Type) string {
 			res = '[]' + res
 		}
 	}
-	nr_muls := type_nr_muls(t)
+	nr_muls := t.nr_muls()
 	if nr_muls > 0 {
 		res = strings.repeat(`&`, nr_muls) + res
 	}
-	if type_is(t, .optional) {
+	if t.flag_is(.optional) {
 		res = '?' + res
 	}
 	/*
diff --git a/vlib/v/table/table.v b/vlib/v/table/table.v
index 514ceeb5ec..18a3b1592a 100644
--- a/vlib/v/table/table.v
+++ b/vlib/v/table/table.v
@@ -194,7 +194,7 @@ pub fn (t &Table) find_type(name string) ?TypeSymbol {
 [inline]
 pub fn (t &Table) get_type_symbol(typ Type) &TypeSymbol {
 	// println('get_type_symbol $typ')
-	idx := type_idx(typ)
+	idx := typ.idx()
 	if idx > 0 {
 		return &t.types[idx]
 	}
@@ -272,7 +272,7 @@ pub fn (t &Table) known_type(name string) bool {
 [inline]
 pub fn (t &Table) array_name(elem_type Type, nr_dims int) string {
 	elem_type_sym := t.get_type_symbol(elem_type)
-	return 'array_${elem_type_sym.name}' + if type_is_ptr(elem_type) {
+	return 'array_${elem_type_sym.name}' + if elem_type.is_ptr() {
 		'_ptr'
 	} else {
 		''
@@ -286,7 +286,7 @@ pub fn (t &Table) array_name(elem_type Type, nr_dims int) string {
 [inline]
 pub fn (t &Table) array_fixed_name(elem_type Type, size, nr_dims int) string {
 	elem_type_sym := t.get_type_symbol(elem_type)
-	return 'array_fixed_${elem_type_sym.name}_${size}' + if type_is_ptr(elem_type) {
+	return 'array_fixed_${elem_type_sym.name}_${size}' + if elem_type.is_ptr() {
 		'_ptr'
 	} else {
 		''
@@ -301,7 +301,7 @@ pub fn (t &Table) array_fixed_name(elem_type Type, size, nr_dims int) string {
 pub fn (t &Table) map_name(key_type, value_type Type) string {
 	key_type_sym := t.get_type_symbol(key_type)
 	value_type_sym := t.get_type_symbol(value_type)
-	suffix := if type_is_ptr(value_type) { '_ptr' } else { '' }
+	suffix := if value_type.is_ptr() { '_ptr' } else { '' }
 	return 'map_${key_type_sym.name}_${value_type_sym.name}' + suffix
 	// return 'map_${value_type_sym.name}' + suffix
 }
@@ -413,9 +413,9 @@ pub fn (mut t Table) add_placeholder_type(name string) int {
 [inline]
 pub fn (t &Table) value_type(typ Type) Type {
 	typ_sym := t.get_type_symbol(typ)
-	if type_is(typ, .variadic) {
+	if typ.flag_is(.variadic) {
 		// ...string => string
-		return type_set(typ, .unset)
+		return typ.set_flag(.unset)
 	}
 	if typ_sym.kind == .array {
 		// Check index type
@@ -430,17 +430,17 @@ pub fn (t &Table) value_type(typ Type) Type {
 		info := typ_sym.info as Map
 		return info.value_type
 	}
-	if typ_sym.kind == .string && type_is_ptr(typ) {
+	if typ_sym.kind == .string && typ.is_ptr() {
 		// (&string)[i] => string
 		return string_type
 	}
 	if typ_sym.kind in [.byteptr, .string] {
 		return byte_type
 	}
-	if type_is_ptr(typ) {
+	if typ.is_ptr() {
 		// byte* => byte
 		// bytes[0] is a byte, not byte*
-		return type_deref(typ)
+		return typ.deref()
 	}
 	// TODO: remove when map_string is removed
 	if typ_sym.name == 'map_string' {
@@ -450,10 +450,10 @@ pub fn (t &Table) value_type(typ Type) Type {
 }
 
 pub fn (t &Table) check(got, expected Type) bool {
-	got_idx := type_idx(got)
-	exp_idx := type_idx(expected)
-	// got_is_ptr := type_is_ptr(got)
-	exp_is_ptr := type_is_ptr(expected)
+	got_idx := got.idx()
+	exp_idx := expected.idx()
+	// got_is_ptr := got.is_ptr()
+	exp_is_ptr := expected.is_ptr()
 	// println('check: $got_type_sym.name, $exp_type_sym.name')
 	// # NOTE: use idxs here, and symbols below for perf
 	if got_idx == none_type_idx {
@@ -504,7 +504,7 @@ pub fn (t &Table) check(got, expected Type) bool {
 	// }
 	if got_type_sym.kind == .array_fixed && exp_type_sym.kind == .byteptr {
 		info := got_type_sym.info as ArrayFixed
-		if type_idx(info.elem_type) == byte_type_idx {
+		if info.elem_type.idx() == byte_type_idx {
 			return true
 		}
 	}