Merge pull request 'revert-complexity' (#7) from revert-complexity into main

Reviewed-on: arf/arf#7

analyzer/argument.go

@@ -29,33 +29,49 @@ func (analyzer AnalysisOperation) analyzeArgument (
 ) {
 	switch inputArgument.Kind() {
 	case parser.ArgumentKindNil:
+		panic (
+			"invalid state: attempt to analyze nil argument")
 		
 	case parser.ArgumentKindPhrase:
+		// TODO
 		
 	case parser.ArgumentKindDereference:
+		// TODO
 		
 	case parser.ArgumentKindSubscript:
+		// TODO
 		
 	case parser.ArgumentKindObjectDefaultValues:
+		// TODO
 		
 	case parser.ArgumentKindArrayDefaultValues:
+		// TODO
 		
 	case parser.ArgumentKindIdentifier:
+		// TODO
 		
 	case parser.ArgumentKindDeclaration:
+		// TODO
 		
 	case parser.ArgumentKindInt:
+		outputArgument = IntLiteral(inputArgument.Value().(int64))
 		
 	case parser.ArgumentKindUInt:
+		outputArgument = UIntLiteral(inputArgument.Value().(uint64))
 		
 	case parser.ArgumentKindFloat:
+		outputArgument = FloatLiteral(inputArgument.Value().(float64))
 		
 	case parser.ArgumentKindString:
+		outputArgument = StringLiteral(inputArgument.Value().(string))
 		
 	case parser.ArgumentKindRune:
+		outputArgument = RuneLiteral(inputArgument.Value().(rune))
 		
 	case parser.ArgumentKindOperator:
-		
+		panic (
+			"invalid state: attempt to analyze operator argument " +
+			"directly")
 	}
 	return
 }

parser/accessors.go

@@ -82,22 +82,22 @@ func (what Type) Points () (points Type) {
 	return
 }
 
-// MembersLength returns the amount of new members the type specifier defines.
+// MembersLength returns the amount of new members the type section defines.
 // If it defines no new members, it returns zero.
-func (what Type) MembersLength () (length int) {
+func (section TypeSection) MembersLength () (length int) {
-	length = len(what.members)
+	length = len(section.members)
 	return
 }
 
 // Member returns the member at index.
-func (what Type) Member (index int) (member TypeMember) {
+func (section TypeSection) Member (index int) (member TypeSectionMember) {
-	member = what.members[index]
+	member = section.members[index]
 	return
 }
 
 // BitWidth returns the bit width of the type member. If it is zero, it should
 // be treated as unspecified.
-func (member TypeMember) BitWidth () (width uint64) {
+func (member TypeSectionMember) BitWidth () (width uint64) {
 	width = member.bitWidth
 	return
 }
@@ -169,18 +169,6 @@ func (phrase Phrase) Kind () (kind PhraseKind) {
 	return
 }
 
-// ArgumentsLength returns the amount of arguments in the phrase.
-func (phrase Phrase) ArgumentsLength () (length int) {
-	length = len(phrase.arguments)
-	return
-}
-
-// Argument returns the argument at index.
-func (phrase Phrase) Argument (index int) (argument Argument) {
-	argument = phrase.arguments[index]
-	return
-}
-
 // ReturneesLength returns the amount of things the phrase returns to.
 func (phrase Phrase) ReturneesLength () (length int) {
 	length = len(phrase.returnees)

parser/argument.go

@@ -3,6 +3,8 @@ package parser
 import "git.tebibyte.media/arf/arf/lexer"
 import "git.tebibyte.media/arf/arf/infoerr"
 
+// TODO: add support for dereferences and subscripts
+
 var validArgumentStartTokens = []lexer.TokenKind {
 	lexer.TokenKindName,
 	
@@ -13,6 +15,7 @@ var validArgumentStartTokens = []lexer.TokenKind {
 	lexer.TokenKindRune,
 	
 	lexer.TokenKindLBracket,
+	lexer.TokenKindLParen,
 }
 
 func (parser *ParsingOperation) parseArgument () (argument Argument, err error) {
@@ -84,6 +87,10 @@ func (parser *ParsingOperation) parseArgument () (argument Argument, err error)
 		argument.kind  = ArgumentKindPhrase
 		argument.value, err = parser.parseArgumentLevelPhrase()
 
+	case lexer.TokenKindLParen:
+		argument.kind = ArgumentKindList
+		argument.value, err = parser.parseList()
+
 	default:
 		panic (
 			"unimplemented argument kind " +

parser/data.go

@@ -35,28 +35,37 @@ func (parser *ParsingOperation) parseDataSection () (
 		return
 	}
 
-	err = parser.expect(lexer.TokenKindNewline)
+	// see if value exists
-	if err != nil { return }
+	if parser.token.Is(lexer.TokenKindNewline) {
-	err = parser.nextToken()
+		parser.nextToken()
-	if err != nil { return }
+		// if we have exited the section, return
-	
+		if !parser.token.Is(lexer.TokenKindIndent) { return }
-	// check if data is external
+		if parser.token.Value().(int) != 1         { return }
-	if parser.token.Is(lexer.TokenKindIndent) &&
-		parser.token.Value().(int) == 1 {
 		
-		err = parser.nextToken(lexer.TokenKindName)
+		err = parser.nextToken()
 		if err != nil { return }
+	}
+
+	// check if external
+	if parser.token.Is(lexer.TokenKindName) {
 		if parser.token.Value().(string) == "external" {
-		
 			section.external = true
+			
 			err = parser.nextToken(lexer.TokenKindNewline)
-			if err != nil { return }
+			if err != nil { return }	
 			err = parser.nextToken()
 			if err != nil { return }
 			return
 		}
-
-		parser.previousToken()
 	}
+
+	// get value
+	section.argument, err = parser.parseArgument()
+	err = parser.expect(lexer.TokenKindNewline)
+	if err != nil { return }
+	
+	err = parser.nextToken()
+	if err != nil { return }
+	
 	return
 }

parser/data_test.go

@@ -6,14 +6,16 @@ func TestData (test *testing.T) {
 	checkTree ("../tests/parser/data", false,
 `:arf
 ---
-data ro aInteger:Int:<3202>
+data ro aInteger:Int
-data ro bMutInteger:Int:mut:<3202>
+	3202
+data ro bMutInteger:Int:mut
+	3202
 data ro cIntegerPointer:{Int}
 data ro dMutIntegerPointer:{Int}:mut
 data ro eIntegerArray16:Int:16
 data ro fIntegerArrayVariable:{Int ..}
-data ro gIntegerArrayInitialized:Int:16:
+data ro gIntegerArrayInitialized:Int:16
-	<
+	(
 	3948
 	293
 	293049
@@ -25,35 +27,21 @@ data ro gIntegerArrayInitialized:Int:16:
 	0
 	4785
 	92
-	>
-data rw hIntegerPointerInit:{Int}:<[& integer]>
-data rw iMutIntegerPointerInit:{Int}:mut:<[& integer]>
-data ro jObject:Obj:
-	(
-	.that:<324>
-	.this:<324>
 	)
-data ro kNestedObject:Obj:
+data rw hIntegerPointerInit:{Int}
+	[& integer]
+data rw iMutIntegerPointerInit:{Int}:mut
+	[& integer]
+data ro jObject:Obj
 	(
-	.ro newMember:Int:<9023>
+	324
-	):
+	438
-	(
-	.that:
-		(
-		.bird2:<123.8439>
-		.bird3:<9328.21348239>
-		)
-	.this:
-		(
-		.bird0:<324>
-		.bird1:<"hello world">
-		)
 	)
 data ro lMutIntegerArray16:Int:16:mut
 data ro mExternalData:Int:8
 	external
-data ro nIntegerArrayInitialized:Int:16:mut:
+data ro nIntegerArrayInitialized:Int:16:mut
-	<
+	(
 	3948
 	293
 	293049
@@ -65,6 +53,6 @@ data ro nIntegerArrayInitialized:Int:16:mut:
 	0
 	4785
 	92
-	>
+	)
 `, test)
 }

parser/enum.go

@@ -61,18 +61,11 @@ func (parser *ParsingOperation) parseEnumMembers (
 		// if we've left the block, stop parsing
 		if !parser.token.Is(lexer.TokenKindIndent) { return }
 		if parser.token.Value().(int) != 1         { return }
-		err = parser.nextToken(lexer.TokenKindMinus)
-		if err != nil { return }
 
 		var member EnumMember
 		member, err = parser.parseEnumMember()
 		into.members = append(into.members, member)
 		if err != nil { return }
-
-		err = parser.expect(lexer.TokenKindNewline)
-		if err != nil { return }
-		err = parser.nextToken()
-		if err != nil { return }
 	}
 }
 
@@ -81,7 +74,7 @@ func (parser *ParsingOperation) parseEnumMember () (
 	member EnumMember,
 	err error,
 ) {
-	err = parser.expect(lexer.TokenKindMinus)
+	err = parser.nextToken(lexer.TokenKindMinus)
 	if err != nil { return }
 
 	// get name
@@ -91,32 +84,25 @@ func (parser *ParsingOperation) parseEnumMember () (
 	member.name = parser.token.Value().(string)
 
 	// see if value exists
-	err = parser.nextToken (
+	err = parser.nextToken()
-		lexer.TokenKindColon,
-		lexer.TokenKindNewline)
 	if err != nil { return }
-
+	if parser.token.Is(lexer.TokenKindNewline) {
-	if parser.token.Is(lexer.TokenKindColon) {
+		parser.nextToken()
+		// if we have exited the member, return
+		if !parser.token.Is(lexer.TokenKindIndent) { return }
+		if parser.token.Value().(int) != 2         { return }
+		
 		err = parser.nextToken()
 		if err != nil { return }
-		err = parser.skipWhitespace()
-		if err != nil { return }
-		err = parser.expect (
-			lexer.TokenKindLessThan,
-			lexer.TokenKindLParen)
-		if err != nil { return }
-
-		if parser.token.Is(lexer.TokenKindLessThan) {
-			// parse value
-			member.value, err = parser.parseBasicDefaultValue()
-			if err != nil { return }
-			
-		} else if parser.token.Is(lexer.TokenKindLParen) {
-			// parse default values
-			member.value, err = parser.parseObjectDefaultValue()
-			if err != nil { return }
-		}
 	}
 
+	// get value
+	member.argument, err = parser.parseArgument()
+	err = parser.expect(lexer.TokenKindNewline)
+	if err != nil { return }
+	
+	err = parser.nextToken()
+	if err != nil { return }
+	
 	return
 }

parser/enum_test.go

@@ -7,56 +7,18 @@ func TestEnum (test *testing.T) {
 `:arf
 ---
 enum ro AffrontToGod:Int:4
-	- bird0:
+	- bird0 (28394 9328 398 9)
-		<
+	- bird1 (23 932832 398 2349)
-		28394
+	- bird2 (1 2 3 4)
-		9328
-		398
-		9
-		>
-	- bird1:
-		<
-		23
-		932832
-		398
-		2349
-		>
-	- bird2:
-		<
-		1
-		2
-		3
-		4
-		>
 enum ro NamedColor:U32
-	- red:<16711680>
+	- red 16711680
-	- green:<65280>
+	- green 65280
-	- blue:<255>
+	- blue 255
-enum ro ThisIsTerrible:Obj:
+enum ro ThisIsTerrible:Vector
-	(
+	- up (0 -1)
-	.rw x:Int
+	- down (0 1)
-	.rw y:Int
+	- left (-1 0)
-	)
+	- right (1 0)
-	- up:
-		(
-		.x:<0>
-		.y:<-1>
-		)
-	- down:
-		(
-		.x:<0>
-		.y:<1>
-		)
-	- left:
-		(
-		.x:<-1>
-		.y:<0>
-		)
-	- right:
-		(
-		.x:<1>
-		.y:<0>
-		)
 enum ro Weekday:Int
 	- sunday
 	- monday

parser/face.go

@@ -12,8 +12,7 @@ func (parser *ParsingOperation) parseFaceSection () (
 	err = parser.expect(lexer.TokenKindName)
 	if err != nil { return }
 	
-	section.behaviors = make(map[string] FaceBehavior)
+	section.location = parser.token.Location()
-	section.location  = parser.token.Location()
 
 	// get permission
 	err = parser.nextToken(lexer.TokenKindPermission)
@@ -32,24 +31,61 @@ func (parser *ParsingOperation) parseFaceSection () (
 	if err != nil { return }
 	section.inherits, err = parser.parseIdentifier()
 	if err != nil { return }
-	err = parser.nextToken(lexer.TokenKindNewline)
+	err = parser.expect(lexer.TokenKindNewline)
 	if err != nil { return }
 	err = parser.nextToken()
 	if err != nil { return }
+	
+	if !parser.token.Is(lexer.TokenKindIndent) { return }
+	if parser.token.Value().(int) != 1         { return }
 
+	err = parser.nextToken (
+		lexer.TokenKindName,
+		lexer.TokenKindGreaterThan,
+		lexer.TokenKindLessThan)
+	if err != nil { return }
+
+	if parser.token.Is(lexer.TokenKindName) {
+		// parse type interface
+		section.kind = FaceKindType
+		parser.previousToken()
+		section.behaviors, err = parser.parseFaceBehaviors()
+		if err != nil { return }
+	} else {
+		// parse function interface
+		section.kind = FaceKindFunc
+		parser.previousToken()
+		section.inputs,
+		section.outputs, err = parser.parseFaceBehaviorArguments(1)
+		if err != nil { return }
+	}
+
+	return
+}
+
+// parseFaceBehaviors parses a list of interface behaviors for an object
+// interface.
+func (parser *ParsingOperation) parseFaceBehaviors () (
+	behaviors map[string] FaceBehavior,
+	err error,
+) {
 	// parse members
+	behaviors = make(map[string] FaceBehavior)
 	for {
 		// if we've left the block, stop parsing
 		if !parser.token.Is(lexer.TokenKindIndent) { return }
 		if parser.token.Value().(int) != 1         { return }
+		
+		err = parser.nextToken(lexer.TokenKindName)
+		behaviorBeginning := parser.token.Location()
+		if err != nil { return }
 
 		// parse behavior
-		behaviorBeginning := parser.token.Location()
 		var behavior FaceBehavior
-		behavior, err = parser.parseFaceBehavior()
+		behavior, err = parser.parseFaceBehavior(1)
 
 		// add to section
-		_, exists := section.behaviors[behavior.name]
+		_, exists := behaviors[behavior.name]
 		if exists {
 			err = infoerr.NewError (
 				behaviorBeginning,
@@ -58,23 +94,21 @@ func (parser *ParsingOperation) parseFaceSection () (
 				infoerr.ErrorKindError)
 			return
 		}
-		section.behaviors[behavior.name] = behavior
+		behaviors[behavior.name] = behavior
 		
 		if err != nil { return }
 	}
 }
 
-// parseFaceBehavior parses a single interface behavior. Indentation level is
+// parseFaceBehavior parses a single interface behavior.
-// assumed.
+func (parser *ParsingOperation) parseFaceBehavior (
-func (parser *ParsingOperation) parseFaceBehavior () (
+	indent int,
+) (
 	behavior FaceBehavior,
 	err      error,
 ) {
-	err = parser.expect(lexer.TokenKindIndent)
-	if err != nil { return }
-
 	// get name
-	err = parser.nextToken(lexer.TokenKindName)
+	err = parser.expect(lexer.TokenKindName)
 	if err != nil { return }
 	behavior.name = parser.token.Value().(string)
 
@@ -82,11 +116,27 @@ func (parser *ParsingOperation) parseFaceBehavior () (
 	if err != nil { return }
 	err = parser.nextToken()
 	if err != nil { return }
+
+	behavior.inputs,
+	behavior.outputs,
+	err = parser.parseFaceBehaviorArguments(indent + 1)
+	if err != nil { return }
+
+	return
+}
+
+func (parser *ParsingOperation) parseFaceBehaviorArguments (
+	indent int,
+) (
+	inputs  []Declaration,
+	outputs []Declaration,
+	err error,
+) {
 	
 	for {
-		// if we've left the block, stop parsing
+		// if we've left the behavior, stop parsing
 		if !parser.token.Is(lexer.TokenKindIndent) { return }
-		if parser.token.Value().(int) != 2         { return }
+		if parser.token.Value().(int) != indent    { return }
 
 		// get preceding symbol
 		err = parser.nextToken (
@@ -109,19 +159,16 @@ func (parser *ParsingOperation) parseFaceBehavior () (
 		if err != nil { return }
 		declaration.what, err = parser.parseType()
 		if err != nil { return }
+
+		if kind == lexer.TokenKindGreaterThan {
+			inputs = append(inputs, declaration)
+		} else {
+			outputs = append(outputs, declaration)
+		}
+		
 		err = parser.expect(lexer.TokenKindNewline)
 		if err != nil { return }
 		err = parser.nextToken()
 		if err != nil { return }
-
-		if kind == lexer.TokenKindGreaterThan {
-			behavior.inputs = append (
-				behavior.inputs,
-				declaration)
-		} else {
-			behavior.outputs = append (
-				behavior.outputs,
-				declaration)
-		}
 	}
 }

parser/face_test.go

@@ -0,0 +1,25 @@
+package parser
+
+import "testing"
+
+func TestFace (test *testing.T) {
+	checkTree ("../tests/parser/face", false,
+`:arf
+---
+face ro aReadWriter:Face
+	read
+		> into:{Byte ..}
+		< read:Int
+		< err:Error
+	write
+		> data:{Byte ..}
+		< wrote:Int
+		< err:Error
+face ro bDestroyer:Face
+	destroy
+face ro cFuncInterface:Func
+	> something:Int
+	< someOutput:Int
+	< otherOutput:String
+`, test)
+}

parser/func.go

@@ -171,7 +171,7 @@ func (parser *ParsingOperation) parseFuncArguments (
 			if err != nil { return }
 			
 		case lexer.TokenKindLessThan:
-			output := Declaration { }
+			output := FuncOutput { }
 			output.location = parser.token.Location()
 			
 			// get name
@@ -186,11 +186,32 @@ func (parser *ParsingOperation) parseFuncArguments (
 			if err != nil { return }
 			output.what, err = parser.parseType()
 			if err != nil { return }
-			
-			into.outputs = append(into.outputs, output)
 
-			parser.expect(lexer.TokenKindNewline)
+			// skip newline if it is there
+			if parser.token.Is(lexer.TokenKindNewline) {
+				parser.nextToken()
+				// if we have exited the output, break
+				exited :=
+					!parser.token.Is(lexer.TokenKindIndent) ||
+					parser.token.Value().(int) != 2
+
+				if exited {
+					into.outputs = append(into.outputs, output)
+					break
+				}
+				
+				err = parser.nextToken()
+				if err != nil { return }
+			}
+
+			// get default value
+			output.argument, err = parser.parseArgument()
+			into.outputs = append(into.outputs, output)
 			if err != nil { return }
+			
+			err = parser.expect(lexer.TokenKindNewline)
+			if err != nil { return }
+			
 			err = parser.nextToken()
 			if err != nil { return }
 		}

parser/func_test.go

@@ -8,13 +8,13 @@ func TestFunc (test *testing.T) {
 ---
 func ro aBasicExternal
 	> someInput:Int:mut
-	< someOutput:Int:<4>
+	< someOutput:Int 4
 	---
 	external
 func ro bMethod
 	@ bird:{Bird}
 	> someInput:Int:mut
-	< someOutput:Int:<4>
+	< someOutput:Int 4
 	---
 	external
 func ro cBasicPhrases
@@ -99,11 +99,11 @@ func ro gControlFlow
 			[nestedThing]
 		[else]
 			[otherThing]
-func ro hSetPhrase
+func ro hDataInit
 	---
-	[let x:Int:<3>]
+	[= x:Int 3]
-	[let y:{Int}:<[loc x]>]
+	[= y:{Int} [loc x]]
-	[let z:Int:8:<398 9 2309 983 -2387 478 555 123>]
+	[= z:Int:8 (398 9 2309 983 -2387 478 555 123)]
-	[let bird:Bird:(.that:(.whenYou:<99999>) .this:<324>)]
+	[= bird:Bird ((99999) 324)]
 `, test)
 }

parser/list.go

@@ -0,0 +1,32 @@
+package parser
+
+import "git.tebibyte.media/arf/arf/lexer"
+
+// parseList parses a parenthetically delimited list of arguments.
+func (parser *ParsingOperation) parseList () (list List, err error) {
+	list.location = parser.token.Location()
+
+	err = parser.expect(lexer.TokenKindLParen)
+	if err != nil { return }
+	err = parser.nextToken()
+	if err != nil { return }
+
+	for {
+		err = parser.skipWhitespace()
+		if err != nil { return }
+
+		// if we have reached the end of the list, stop
+		if parser.token.Is(lexer.TokenKindRParen) { break }
+
+		// otherwise, parse argument
+		var argument Argument
+		argument, err = parser.parseArgument()
+		list.arguments = append(list.arguments, argument)
+		if err != nil { return }
+	}
+	
+	err = parser.nextToken()
+	if err != nil { return }
+	
+	return
+}

parser/meta_test.go

@@ -11,8 +11,8 @@ func TestMeta (test *testing.T) {
 author "Sasha Koshka"
 license "GPLv3"
 require "` + filepath.Join(cwd, "./some/local/module") + `"
-require "/some/absolute/path/to/someModule"
 require "/usr/local/include/arf/someLibraryInstalledInStandardLocation"
+require "/some/absolute/path/to/someModule"
 ---
 `, test)
 }

parser/node-traits.go

@@ -10,19 +10,19 @@ type locatable struct {
 }
 
 // Location returns the location of the node.
-func (trait locatable) Location () (location file.Location) {
+func (node locatable) Location () (location file.Location) {
-	location = trait.location
+	location = node.location
 	return
 }
 
 // NewError creates a new error at the node's location.
-func (trait locatable) NewError (
+func (node locatable) NewError (
 	message string,
 	kind    infoerr.ErrorKind,
 ) (
 	err error,
 ) {
-	err = infoerr.NewError(trait.location, message, kind)
+	err = infoerr.NewError(node.location, message, kind)
 	return
 }
 
@@ -32,8 +32,8 @@ type nameable struct {
 }
 
 // Name returns the name of the node.
-func (trait nameable) Name () (name string) {
+func (node nameable) Name () (name string) {
-	name = trait.name
+	name = node.name
 	return
 }
 // typeable allows a node to have a type.
@@ -42,8 +42,8 @@ type typeable struct {
 }
 
 // Type returns the type of the node.
-func (trait typeable) Type () (what Type) {
+func (node typeable) Type () (what Type) {
-	what =  trait.what
+	what = node.what
 	return
 }
 
@@ -53,18 +53,35 @@ type permissionable struct {
 }
 
 // Permission returns the permision of the node.
-func (trait permissionable) Permission () (permission types.Permission) {
+func (node permissionable) Permission () (permission types.Permission) {
-	permission = trait.permission
+	permission = node.permission
 	return
 }
 
 // valuable allows a node to have an argument value.
 type valuable struct {
-	value Argument
+	argument Argument
 }
 
-// Value returns the value argument of the node.
+// Argument returns the value argument of the node.
-func (trait valuable) Value () (value Argument) {
+func (node valuable) Argument () (argument Argument) {
-	value = trait.value
+	argument = node.argument
+	return
+}
+
+// multiValuable allows a node to have several argument values.
+type multiValuable struct {
+	arguments []Argument
+}
+
+// Argument returns the argument at index.
+func (node multiValuable) Argument (index int) (argument Argument) {
+	argument = node.arguments[index]
+	return
+}
+
+// Length returns the amount of arguments in the mode.
+func (node multiValuable) Length () (length int) {
+	length = len(node.arguments)
 	return
 }

parser/parser.go

@@ -150,16 +150,35 @@ func (parser *ParsingOperation) previousToken () {
 // skipIndentLevel advances the parser, ignoring every line with an indentation
 // equal to or greater than the specified indent.
 func (parser *ParsingOperation) skipIndentLevel (indent int) (err error) {
+	braceLevel   := 0
+	parenLevel   := 0
+	bracketLevel := 0
+
 	for {
 		if parser.token.Is(lexer.TokenKindNewline) {
 			err = parser.nextToken()
 			if err != nil { return }
 
-			if !parser.token.Is(lexer.TokenKindIndent) ||
+			shouldBreak :=
-				parser.token.Value().(int) < indent {
+				!parser.token.Is(lexer.TokenKindIndent) ||
+				parser.token.Value().(int) < indent
+			
+			shouldBreak =
+				shouldBreak      &&
+				braceLevel   < 1 &&
+				parenLevel   < 1 &&
+				bracketLevel < 1
 
-				return
+			if shouldBreak { return }
-			}
+		}
+
+		switch parser.token.Kind() {
+		case lexer.TokenKindLBrace:   braceLevel ++
+		case lexer.TokenKindRBrace:   braceLevel --
+		case lexer.TokenKindLParen:   parenLevel ++
+		case lexer.TokenKindRParen:   parenLevel --
+		case lexer.TokenKindLBracket: bracketLevel ++
+		case lexer.TokenKindRBracket: bracketLevel --
 		}
 
 		err = parser.nextToken()

parser/phrase.go

@@ -129,7 +129,10 @@ func (parser *ParsingOperation) parseBlockLevelPhrase (
 	// get command
 	err = parser.expect(validPhraseStartTokens...)
 	if err != nil { return }
-	phrase.command, phrase.kind, err = parser.parsePhraseCommand()
+	phrase.command,
+	phrase.kind,
+	phrase.operator,
+	err = parser.parsePhraseCommand()
 	if err != nil { return }
 
 	for {
@@ -233,7 +236,10 @@ func (parser *ParsingOperation) parseArgumentLevelPhrase () (
 	// get command
 	err = parser.nextToken(validPhraseStartTokens...)
 	if err != nil { return }
-	phrase.command, phrase.kind, err = parser.parsePhraseCommand()
+	phrase.command,
+	phrase.kind,
+	phrase.operator,
+	err = parser.parsePhraseCommand()
 	if err != nil { return }
 
 	for {
@@ -272,24 +278,22 @@ func (parser *ParsingOperation) parseArgumentLevelPhrase () (
 
 // parsePhraseCommand parses the command argument of a phrase.
 func (parser *ParsingOperation) parsePhraseCommand () (
-	command Argument,
+	command  Argument,
-	kind    PhraseKind,
+	kind     PhraseKind,
-	err     error,
+	operator lexer.TokenKind,
+	err      error,
 ) {
 	if isTokenOperator(parser.token) {
 		err = parser.expect(operatorTokens...)
 		if err != nil { return }
 
-		command.location = parser.token.Location()
-		command.kind     = ArgumentKindOperator
-		command.value    = parser.token.Kind()
-
 		if parser.token.Is(lexer.TokenKindColon) {
 			kind = PhraseKindCase
 		} else if parser.token.Is(lexer.TokenKindAssignment) {
 			kind = PhraseKindAssign
 		} else {
 			kind = PhraseKindOperator
+			operator = parser.token.Kind()
 		}
 		
 		err = parser.nextToken()
@@ -308,8 +312,6 @@ func (parser *ParsingOperation) parsePhraseCommand () (
 		identifier := command.value.(Identifier)
 		if len(identifier.trail) == 1 {
 			switch identifier.trail[0] {
-			case "let":
-				kind = PhraseKindLet
 			case "loc":
 				kind = PhraseKindReference
 			case "defer":

parser/skim_test.go

@@ -21,7 +21,7 @@ func ro fComplexFunction
 	external
 func ro gExternalFunction
 	> x:Int
-	< arr:Int
+	< arr:Int 5
 	---
 	external
 `, test)

parser/tree-tostring.go

@@ -41,7 +41,8 @@ func (tree SyntaxTree) ToString (indent int) (output string) {
 		output += doIndent(indent, "license \"", tree.license, "\"\n")
 	}
 
-	for _, require := range tree.requires {
+	for _, name := range sortMapKeysAlphabetically(tree.requires) {
+		require := tree.requires[name]
 		output += doIndent(indent, "require \"", require, "\"\n")
 	}
 	
@@ -66,84 +67,17 @@ func (identifier Identifier) ToString () (output string) {
 	return
 }
 
-func (values ObjectDefaultValues) ToString (
+func (what Type) ToString () (output string) {
-	indent int,
+	if what.kind == TypeKindNil {
-	breakLine bool,
+		output += "NIL-TYPE"
-) (
+		return
-	output string,
-) {
-	if !breakLine { indent = 0 }
-	output += doIndent(indent, "(")
-	if breakLine { output += "\n" }
-	
-	for index, name := range sortMapKeysAlphabetically(values) {
-		if index > 0 && !breakLine { output += " " }
-		
-		value := values[name]
-		
-		output += doIndent(indent, "." + name + ":")
-		
-		isComplexDefaultValue :=
-			value.kind == ArgumentKindObjectDefaultValues ||
-			value.kind == ArgumentKindArrayDefaultValues
-		
-		if isComplexDefaultValue {
-			if breakLine { output += "\n" }
-			output += value.ToString(indent + 1, breakLine)
-		} else {
-			output += "<"
-			output += value.ToString(indent + 1, false)
-			output += ">"
-		}
-		if breakLine { output += "\n" }
-	}
-	output += doIndent(indent, ")")
-	return
-}
-
-func (values ArrayDefaultValues) ToString (
-	indent int,
-	breakLine bool,
-) (
-	output string,
-) {
-	if !breakLine { indent = 0 }
-	output += doIndent(indent, "<")
-	if breakLine { output += "\n" }
-	
-	for index, value := range values {
-		if index > 0 && !breakLine { output += " " }
-		output += value.ToString(indent, breakLine)
-	}
-	
-	output += doIndent(indent, ">")
-	return
-}
-
-func (member TypeMember) ToString (indent int, breakLine bool) (output string) {
-	output += doIndent(indent, ".")
-	
-	output += member.permission.ToString() + " "
-	output += member.name + ":"
-	output += member.what.ToString(indent + 1, breakLine)
-
-	if member.bitWidth > 0 {
-		output += fmt.Sprint(" & ", member.bitWidth)
 	}
 
-	if breakLine {
-		output += "\n"
-	}
-
-	return
-}
-
-func (what Type) ToString (indent int, breakLine bool) (output string) {
 	if what.kind == TypeKindBasic {
 		output += what.name.ToString()
 	} else {
 		output += "{"
-		output += what.points.ToString(indent, breakLine)
+		output += what.points.ToString()
 
 		if what.kind == TypeKindVariableArray {
 			output += " .."
@@ -159,46 +93,27 @@ func (what Type) ToString (indent int, breakLine bool) (output string) {
 	if what.mutable {
 		output += ":mut"
 	}
-
-	if what.members != nil {
-		if breakLine {
-			output += ":\n" + doIndent(indent, "(\n")
-			for _, member := range what.members {
-				output += member.ToString(indent, breakLine)
-			}
-			output += doIndent(indent, ")")
-		} else {
-			output += ":("
-			for index, member := range what.members {
-				if index > 0 { output += " " }
-				output += member.ToString(indent, breakLine)
-			}
-			output += ")"
-		}
-	}
-
-	defaultValueKind := what.defaultValue.kind
-	if defaultValueKind != ArgumentKindNil {
-		isComplexDefaultValue :=
-			defaultValueKind == ArgumentKindObjectDefaultValues ||
-			defaultValueKind == ArgumentKindArrayDefaultValues
-		
-		if isComplexDefaultValue {
-			output += ":"
-			if breakLine { output += "\n" }
-			output += what.defaultValue.ToString(indent, breakLine)
-		} else {
-			output += ":<"
-			output += what.defaultValue.ToString(indent, false)
-			output += ">"
-		}
-	}
 	return
 }
 
-func (declaration Declaration) ToString (indent int) (output string) {
+func (declaration Declaration) ToString () (output string) {
 	output += declaration.name + ":"
-	output += declaration.what.ToString(indent, false)
+	output += declaration.what.ToString()
+	return
+}
+
+func (list List) ToString (indent int, breakline bool) (output string) {
+	if !breakline { indent = 0 }
+	output += doIndent(indent, "(")
+	if breakline { output += "\n" }
+
+	for index, argument := range list.arguments {
+		if !breakline && index > 0 { output += " "}
+		output += argument.ToString(indent, breakline)
+	}
+
+	output += doIndent(indent, ")")
+	if breakline { output += "\n" }
 	return
 }
 
@@ -216,13 +131,8 @@ func (argument Argument) ToString (indent int, breakLine bool) (output string) {
 				indent,
 				breakLine)
 	
-	case ArgumentKindObjectDefaultValues:
+	case ArgumentKindList:
-		output += argument.value.(ObjectDefaultValues).
+		output += argument.value.(List).ToString(indent, breakLine)
-				ToString(indent, breakLine)
-	
-	case ArgumentKindArrayDefaultValues:
-		output += argument.value.(ArrayDefaultValues).
-				ToString(indent, breakLine)
 	
 	case ArgumentKindIdentifier:
 		output += doIndent (
@@ -233,7 +143,7 @@ func (argument Argument) ToString (indent int, breakLine bool) (output string) {
 	case ArgumentKindDeclaration:
 		output += doIndent (
 			indent,
-			argument.value.(Declaration).ToString(indent))
+			argument.value.(Declaration).ToString())
 		if breakLine { output += "\n" }
 	
 	case ArgumentKindInt, ArgumentKindUInt, ArgumentKindFloat:
@@ -251,75 +161,6 @@ func (argument Argument) ToString (indent int, breakLine bool) (output string) {
 			indent,
 			"'" + string(argument.value.(rune)) + "'")
 		if breakLine { output += "\n" }
-		
-	case ArgumentKindOperator:
-		var stringValue string
-		switch argument.value.(lexer.TokenKind) {
-	        case lexer.TokenKindColon:
-	        	stringValue = ":"
-	        case lexer.TokenKindPlus:
-	        	stringValue = "+"
-	        case lexer.TokenKindMinus:
-	        	stringValue = "-"
-	        case lexer.TokenKindIncrement:
-	        	stringValue = "++"
-	        case lexer.TokenKindDecrement:
-	        	stringValue = "--"
-	        case lexer.TokenKindAsterisk:
-	        	stringValue = "*"
-	        case lexer.TokenKindSlash:
-	        	stringValue = "/"
-	        case lexer.TokenKindExclamation:
-	        	stringValue = "!"
-	        case lexer.TokenKindPercent:
-	        	stringValue = "%"
-	        case lexer.TokenKindPercentAssignment:
-	        	stringValue = "%="
-	        case lexer.TokenKindTilde:
-	        	stringValue = "~"
-	        case lexer.TokenKindTildeAssignment:
-	        	stringValue = "~="
-	        case lexer.TokenKindAssignment:
-	        	stringValue = "="
-	        case lexer.TokenKindEqualTo:
-	        	stringValue = "=="
-	        case lexer.TokenKindNotEqualTo:
-	        	stringValue = "!="
-	        case lexer.TokenKindLessThanEqualTo:
-	        	stringValue = "<="
-	        case lexer.TokenKindLessThan:
-	        	stringValue = "<"
-	        case lexer.TokenKindLShift:
-	        	stringValue = "<<"
-	        case lexer.TokenKindLShiftAssignment:
-	        	stringValue = "<<="
-	        case lexer.TokenKindGreaterThan:
-	        	stringValue = ">"
-	        case lexer.TokenKindGreaterThanEqualTo:
-	        	stringValue = ">="
-	        case lexer.TokenKindRShift:
-	        	stringValue = ">>"
-	        case lexer.TokenKindRShiftAssignment:
-	        	stringValue = ">>="
-	        case lexer.TokenKindBinaryOr:
-	        	stringValue = "|"
-	        case lexer.TokenKindBinaryOrAssignment:
-	        	stringValue = "|="
-	        case lexer.TokenKindLogicalOr:
-	        	stringValue = "||"
-	        case lexer.TokenKindBinaryAnd:
-	        	stringValue = "&"
-	        case lexer.TokenKindBinaryAndAssignment:
-	        	stringValue = "&="
-	        case lexer.TokenKindLogicalAnd:
-	        	stringValue = "&&"
-	        case lexer.TokenKindBinaryXor:
-	        	stringValue = "^"
-	        case lexer.TokenKindBinaryXorAssignment:
-	        	stringValue = "^="
-		}
-		output += doIndent(indent, stringValue)
-		if breakLine { output += "\n" }
 	}
 
 	return
@@ -331,7 +172,11 @@ func (section DataSection) ToString (indent int) (output string) {
 		"data ",
 		section.permission.ToString(), " ",
 		section.name, ":",
-		section.what.ToString(indent + 1, true), "\n")
+		section.what.ToString(), "\n")
+	
+	if section.argument.kind != ArgumentKindNil {
+		output += section.argument.ToString(indent + 1, true)
+	}
 	
 	if section.external {
 		output += doIndent(indent + 1, "external\n")
@@ -340,37 +185,57 @@ func (section DataSection) ToString (indent int) (output string) {
 	return
 }
 
+func (member TypeSectionMember) ToString (indent int) (output string) {
+	output += doIndent(indent, member.permission.ToString())
+	output += " " + member.name
+
+	if member.what.kind != TypeKindNil {
+		output += ":" + member.what.ToString()
+	}
+
+	if member.argument.kind != ArgumentKindNil {
+		output += " " + member.argument.ToString(indent, false)
+	}
+
+	if member.bitWidth > 0 {
+		output += fmt.Sprint(" & ", member.bitWidth)
+	}
+
+	output += "\n"
+
+	return
+}
+
 func (section TypeSection) ToString (indent int) (output string) {
 	output += doIndent (
 		indent,
 		"type ",
 		section.permission.ToString(), " ",
 		section.name, ":",
-		section.what.ToString(indent + 1, true), "\n")
+		section.what.ToString(), "\n")
+	
+	if section.argument.kind != ArgumentKindNil {
+		output += section.argument.ToString(indent + 1, true)
+	}
+
+	for _, member := range section.members {
+		output += member.ToString(indent + 1)
+	}
 	return
 }
 
-
 func (section EnumSection) ToString (indent int) (output string) {
 	output += doIndent (
 		indent,
 		"enum ",
 		section.permission.ToString(), " ",
 		section.name, ":",
-		section.what.ToString(indent + 1, true), "\n")
+		section.what.ToString(), "\n")
 
 	for _, member := range section.members {
 		output += doIndent(indent + 1, "- ", member.name)
-	
+		if member.argument.kind != ArgumentKindNil {
-		isComplexInitialization :=
+			output += " " + member.argument.ToString(indent, false)
-			member.value.kind == ArgumentKindObjectDefaultValues ||
-			member.value.kind == ArgumentKindArrayDefaultValues
-		
-		if isComplexInitialization {
-			output += ":\n"
-			output += member.value.ToString(indent + 2, true)
-		} else if member.value.kind != ArgumentKindNil {
-			output += ":<" + member.value.ToString(0, false) + ">"
 		}
 		output += "\n"
 	}
@@ -385,10 +250,21 @@ func (section FaceSection) ToString (indent int) (output string) {
 		section.name, ":",
 		section.inherits.ToString(), "\n")
 
-	for _, name := range sortMapKeysAlphabetically(section.behaviors) {
+	if section.kind == FaceKindType {
-		behavior := section.behaviors[name]
+		for _, name := range sortMapKeysAlphabetically(section.behaviors) {
-		output += behavior.ToString(indent + 1)
+			behavior := section.behaviors[name]
+			output += behavior.ToString(indent + 1)
+		}
+	} else if section.kind == FaceKindFunc {
+		for _, inputItem := range section.inputs {
+			output += doIndent(indent + 1, "> ", inputItem.ToString(), "\n")
+		}
+		
+		for _, outputItem := range section.outputs {
+			output += doIndent(indent + 1, "< ", outputItem.ToString(), "\n")
+		}
 	}
+
 	return
 }
 
@@ -396,11 +272,11 @@ func (behavior FaceBehavior) ToString (indent int) (output string) {
 	output += doIndent(indent, behavior.name, "\n")
 	
 	for _, inputItem := range behavior.inputs {
-		output += doIndent(indent + 1, "> ", inputItem.ToString(indent), "\n")
+		output += doIndent(indent + 1, "> ", inputItem.ToString(), "\n")
 	}
 	
 	for _, outputItem := range behavior.outputs {
-		output += doIndent(indent + 1, "< ", outputItem.ToString(indent), "\n")
+		output += doIndent(indent + 1, "< ", outputItem.ToString(), "\n")
 	}
 
 	return
@@ -411,7 +287,86 @@ func (phrase Phrase) ToString (indent int, ownLine bool) (output string) {
 		output += doIndent(indent)
 	}
 
-	output += "[" + phrase.command.ToString(0, false)
+	output += "["
+
+	switch phrase.kind {
+	case PhraseKindCase:
+        	output += ":"
+        
+	case PhraseKindAssign:
+        	output += "="
+	
+	case PhraseKindOperator:
+		
+		switch phrase.operator {
+	        case lexer.TokenKindColon:
+	        	output += ":"
+	        case lexer.TokenKindPlus:
+	        	output += "+"
+	        case lexer.TokenKindMinus:
+	        	output += "-"
+	        case lexer.TokenKindIncrement:
+	        	output += "++"
+	        case lexer.TokenKindDecrement:
+	        	output += "--"
+	        case lexer.TokenKindAsterisk:
+	        	output += "*"
+	        case lexer.TokenKindSlash:
+	        	output += "/"
+	        case lexer.TokenKindExclamation:
+	        	output += "!"
+	        case lexer.TokenKindPercent:
+	        	output += "%"
+	        case lexer.TokenKindPercentAssignment:
+	        	output += "%="
+	        case lexer.TokenKindTilde:
+	        	output += "~"
+	        case lexer.TokenKindTildeAssignment:
+	        	output += "~="
+	        case lexer.TokenKindAssignment:
+	        	output += "="
+	        case lexer.TokenKindEqualTo:
+	        	output += "=="
+	        case lexer.TokenKindNotEqualTo:
+	        	output += "!="
+	        case lexer.TokenKindLessThanEqualTo:
+	        	output += "<="
+	        case lexer.TokenKindLessThan:
+	        	output += "<"
+	        case lexer.TokenKindLShift:
+	        	output += "<<"
+	        case lexer.TokenKindLShiftAssignment:
+	        	output += "<<="
+	        case lexer.TokenKindGreaterThan:
+	        	output += ">"
+	        case lexer.TokenKindGreaterThanEqualTo:
+	        	output += ">="
+	        case lexer.TokenKindRShift:
+	        	output += ">>"
+	        case lexer.TokenKindRShiftAssignment:
+	        	output += ">>="
+	        case lexer.TokenKindBinaryOr:
+	        	output += "|"
+	        case lexer.TokenKindBinaryOrAssignment:
+	        	output += "|="
+	        case lexer.TokenKindLogicalOr:
+	        	output += "||"
+	        case lexer.TokenKindBinaryAnd:
+	        	output += "&"
+	        case lexer.TokenKindBinaryAndAssignment:
+	        	output += "&="
+	        case lexer.TokenKindLogicalAnd:
+	        	output += "&&"
+	        case lexer.TokenKindBinaryXor:
+	        	output += "^"
+	        case lexer.TokenKindBinaryXorAssignment:
+	        	output += "^="
+		}
+		
+	default:
+		output += phrase.command.ToString(0, false)
+	}
+	
 	for _, argument := range phrase.arguments {
 		output += " " + argument.ToString(0, false)
 	}
@@ -433,6 +388,17 @@ func (phrase Phrase) ToString (indent int, ownLine bool) (output string) {
 	return
 }
 
+func (funcOutput FuncOutput) ToString (indent int) (output string) {
+	output += doIndent(indent + 1)
+	output += "< " + funcOutput.Declaration.ToString()
+	if funcOutput.argument.kind != ArgumentKindNil {
+		output += " " + funcOutput.argument.ToString(indent, false)
+	}
+	output += "\n"
+
+	return
+}
+
 func (block Block) ToString (indent int) (output string) {
 	for _, phrase := range block {
 		output += phrase.ToString(indent, true)
@@ -451,15 +417,15 @@ func (section FuncSection) ToString (indent int) (output string) {
 	if section.receiver != nil {
 		output += doIndent (
 			indent + 1,
-			"@ ", section.receiver.ToString(indent), "\n")
+			"@ ", section.receiver.ToString(), "\n")
 	}
 	
 	for _, inputItem := range section.inputs {
-		output += doIndent(indent + 1, "> ", inputItem.ToString(indent), "\n")
+		output += doIndent(indent + 1, "> ", inputItem.ToString(), "\n")
 	}
 	
 	for _, outputItem := range section.outputs {
-		output += doIndent(indent + 1, "< ", outputItem.ToString(indent), "\n")
+		output += outputItem.ToString(indent)
 	}
 
 	output += doIndent(indent + 1, "---\n")

parser/tree.go

@@ -2,6 +2,7 @@ package parser
 
 import "git.tebibyte.media/arf/arf/file"
 import "git.tebibyte.media/arf/arf/types"
+import "git.tebibyte.media/arf/arf/lexer"
 import "git.tebibyte.media/arf/arf/infoerr"
 
 // SyntaxTree represents an abstract syntax tree. It covers an entire module. It
@@ -35,9 +36,12 @@ type Identifier struct {
 type TypeKind int
 
 const (
+	// TypeKindNil means that the type is unspecified.
+	TypeKindNil TypeKind = iota
+
 	// TypeKindBasic means its a normal type and inherits from something.
 	// Basic types can define new members on their parent types.
-	TypeKindBasic TypeKind = iota
+	TypeKindBasic
 
 	// TypeKindPointer means it's a pointer.
 	TypeKindPointer
@@ -46,16 +50,6 @@ const (
 	TypeKindVariableArray
 )
 
-// TypeMember represents a member variable of a type specifier.
-type TypeMember struct {
-	locatable
-	nameable
-	typeable
-	permissionable
-	
-	bitWidth uint64
-}
-
 // Type represents a type specifier
 type Type struct {
 	locatable
@@ -69,12 +63,6 @@ type Type struct {
 
 	// not applicable for basic.
 	points *Type
-
-	// if non-nil, this type defines new members.
-	members []TypeMember
-
-	// the default value of the type.
-	defaultValue Argument
 }
 
 // Declaration represents a variable declaration.
@@ -84,12 +72,14 @@ type Declaration struct {
 	typeable
 }
 
-// ObjectDefaultValues represents a list of object member initialization
+// List represents an array or object literal.
-// attributes.
+type List struct {
-type ObjectDefaultValues map[string] Argument
+	locatable
 
-// ArrayDefaultValues represents a list of elements initializing an array.
+	// TODO: have an array of unnamed arguments, and a map of named
-type ArrayDefaultValues []Argument
+	// arguments
+	multiValuable
+}
 
 // ArgumentKind specifies the type of thing the value of an argument should be
 // cast to.
@@ -103,19 +93,15 @@ const (
 	// etc...
 	ArgumentKindPhrase
 
+	// (argument argument argument)
+	ArgumentKindList
+
 	// {name}
 	ArgumentKindDereference
 	
 	// {name 23}
 	ArgumentKindSubscript
 
-	// (.name <value>)
-	// (.name <value> .name (.name <value))
-	ArgumentKindObjectDefaultValues
-
-	// <4 32 98 5>
-	ArgumentKindArrayDefaultValues
-
 	// name.name
 	// name.name.name
 	// etc...
@@ -142,10 +128,6 @@ const (
 
 	// 'S'
 	ArgumentKindRune
-
-	// + - * / etc...
-	// this is only used as a phrase command
-	ArgumentKindOperator
 )
 
 // Argument represents a value that can be placed anywhere a value goes. This
@@ -164,16 +146,32 @@ type DataSection struct {
 	nameable
 	typeable
 	permissionable
+	valuable
 
 	external bool
 }
 
+// TypeSectionMember represents a member variable of a type section.
+type TypeSectionMember struct {
+	locatable
+	nameable
+	typeable
+	permissionable
+	valuable
+	
+	bitWidth uint64
+}
+
 // TypeSection represents a type definition.
 type TypeSection struct {
 	locatable
 	nameable
 	typeable
 	permissionable
+	valuable
+
+	// if non-nil, this type defines new members.
+	members []TypeSectionMember
 }
 
 // EnumMember represents a member of an enum section.
@@ -193,6 +191,16 @@ type EnumSection struct {
 	members []EnumMember
 }
 
+// FaceKind determines if an interface is a type interface or an function
+// interface.
+type FaceKind int
+
+const (
+	FaceKindEmpty FaceKind = iota
+	FaceKindType
+	FaceKindFunc
+)
+
 // FaceBehavior represents a behavior of an interface section.
 type FaceBehavior struct {
 	locatable
@@ -208,8 +216,11 @@ type FaceSection struct {
 	nameable
 	permissionable
 	inherits Identifier
-	
+
+	kind FaceKind
+
 	behaviors map[string] FaceBehavior
+	FaceBehavior
 }
 
 // PhraseKind determines what semantic role a phrase plays.
@@ -219,7 +230,6 @@ const (
 	PhraseKindCall = iota
 	PhraseKindCallExternal
 	PhraseKindOperator
-	PhraseKindLet
 	PhraseKindAssign
 	PhraseKindReference
 	PhraseKindDefer
@@ -236,12 +246,18 @@ const (
 // syntactical concept.
 type Phrase struct {
 	location  file.Location
-	command   Argument
-	arguments []Argument
 	returnees []Argument
-
+	multiValuable
+	
 	kind PhraseKind
 
+	// TODO: do not have this be an argument. make a string version, and
+	// and identifier version.
+	command Argument
+
+	// only applicable for PhraseKindOperator
+	operator lexer.TokenKind
+
 	// only applicable for control flow phrases
 	block Block
 }
@@ -249,6 +265,13 @@ type Phrase struct {
 // Block represents a scoped/indented block of code.
 type Block []Phrase
 
+// FuncOutput represents a function output declaration. It allows for a default
+// value.
+type FuncOutput struct {
+	Declaration
+	valuable
+}
+
 // FuncSection represents a function section.
 type FuncSection struct {
 	locatable
@@ -257,7 +280,7 @@ type FuncSection struct {
 	
 	receiver *Declaration
 	inputs   []Declaration
-	outputs  []Declaration
+	outputs  []FuncOutput
 	root     Block
 
 	external bool

parser/type-notation.go

@@ -2,13 +2,13 @@ package parser
 
 import "git.tebibyte.media/arf/arf/lexer"
 import "git.tebibyte.media/arf/arf/infoerr"
-import "git.tebibyte.media/arf/arf/types"
 
 // parseType parses a type notation of the form Name, {Name}, etc.
 func (parser *ParsingOperation) parseType () (what Type, err error) {
 	err = parser.expect(lexer.TokenKindName, lexer.TokenKindLBrace)
 	if err != nil { return }
 	what.location = parser.token.Location()
+	what.kind = TypeKindBasic
 
 	if parser.token.Is(lexer.TokenKindLBrace) {
 		what.kind = TypeKindPointer
@@ -48,11 +48,7 @@ func (parser *ParsingOperation) parseType () (what Type, err error) {
 		err = parser.skipWhitespace()
 		if err != nil { return }
 
-		err = parser.expect(
+		err = parser.expect(lexer.TokenKindName, lexer.TokenKindUInt)
-			lexer.TokenKindName,
-			lexer.TokenKindUInt,
-			lexer.TokenKindLParen,
-			lexer.TokenKindLessThan)
 		if err != nil { return }
 
 		if parser.token.Is(lexer.TokenKindName) {
@@ -77,242 +73,8 @@ func (parser *ParsingOperation) parseType () (what Type, err error) {
 			err = parser.nextToken()
 			if err != nil { return }
 			
-		} else if parser.token.Is(lexer.TokenKindLessThan) {
-			// parse default value
-			what.defaultValue, err = parser.parseBasicDefaultValue()
-			if err != nil { return }
-			
-		} else if parser.token.Is(lexer.TokenKindLParen) {
-			// parse members and member default values
-			what.defaultValue,
-			what.members,
-			err = parser.parseObjectDefaultValueAndMembers()
-			if err != nil { return }
 		}
 	}
 
 	return
 }
-
-// parseBasicDefaultValue parses a default value of a non-object type.
-func (parser *ParsingOperation) parseBasicDefaultValue () (
-	value Argument,
-	err error,
-) {
-	value.location = parser.token.Location()
-	
-	err = parser.expect(lexer.TokenKindLessThan)
-	if err != nil { return }
-	err = parser.nextToken()
-	if err != nil { return }
-
-	var attributes []Argument
-
-	defer func () {
-		// if we have multiple values, we need to return the full array
-		// instead.
-		if len(attributes) > 1 {
-			value.kind = ArgumentKindArrayDefaultValues
-			value.value = ArrayDefaultValues(attributes)
-		}
-	} ()
-
-	for {
-		err = parser.skipWhitespace()
-		if err != nil { return }
-		if parser.token.Is(lexer.TokenKindGreaterThan) { break }
-
-		value, err = parser.parseArgument()
-		if err != nil { return }
-		attributes = append(attributes, value)
-	}
-	
-	err = parser.nextToken()
-	if err != nil { return }
-	
-	return
-}
-
-// parseObjectDefaultValueAndMembers parses default values and new members of an
-// object type.
-func (parser *ParsingOperation) parseObjectDefaultValueAndMembers () (
-	value   Argument,
-	members []TypeMember,
-	err error,
-) {
-	value.location = parser.token.Location()
-
-	err = parser.expect(lexer.TokenKindLParen)
-	if err != nil { return }
-	parser.nextToken()
-	if err != nil { return }
-
-	var attributes ObjectDefaultValues
-
-	for {
-		err = parser.skipWhitespace()
-		if err != nil { return }
-		if parser.token.Is(lexer.TokenKindRParen)  { break }
-		
-		err = parser.expect(lexer.TokenKindDot)
-		if err != nil { return }
-		parser.nextToken(lexer.TokenKindName, lexer.TokenKindPermission)
-		if err != nil { return }
-
-		if parser.token.Is(lexer.TokenKindName) {
-			// parsing a defalut value for an inherited member
-			var memberName  string
-			var memberValue Argument
-
-			memberName,
-			memberValue, err = parser.parseObjectInheritedMember()
-			if err != nil { return }
-			
-			if value.kind == ArgumentKindNil {
-				// create default value map if it doesn't
-				// already exist
-				value.kind = ArgumentKindObjectDefaultValues
-				attributes = make(ObjectDefaultValues)
-				value.value = attributes
-			}
-
-			// TODO: error on duplicate
-			if memberValue.kind != ArgumentKindNil {
-				attributes[memberName] = memberValue
-			}
-			
-		} else if parser.token.Is(lexer.TokenKindPermission) {
-			// parsing a member declaration
-			var member TypeMember
-			member, err = parser.parseObjectNewMember()
-
-			// TODO: error on duplicate
-			members = append(members, member)
-			if err != nil { return }
-		}
-	}
-	
-	err = parser.nextToken()
-	if err != nil { return }
-	
-	return
-}
-
-// parseObjectDefaultValue parses member default values only, and will throw an
-// error when it encounteres a new member definition.
-func (parser *ParsingOperation) parseObjectDefaultValue () (
-	value Argument,
-	err error,
-) {
-	value.location = parser.token.Location()
-
-	err = parser.expect(lexer.TokenKindLParen)
-	if err != nil { return }
-	parser.nextToken()
-	if err != nil { return }
-
-	var attributes ObjectDefaultValues
-
-	for {
-		err = parser.skipWhitespace()
-		if err != nil { return }
-		if parser.token.Is(lexer.TokenKindRParen)  { break }
-		
-		err = parser.expect(lexer.TokenKindDot)
-		if err != nil { return }
-		parser.nextToken(lexer.TokenKindName)
-		if err != nil { return }
-
-		if value.kind == ArgumentKindNil {
-			value.kind = ArgumentKindObjectDefaultValues
-			attributes = make(ObjectDefaultValues)
-			value.value = attributes
-		}
-
-		var memberName  string
-		var memberValue Argument
-		memberName,
-		memberValue, err = parser.parseObjectInheritedMember()
-
-		attributes[memberName] = memberValue
-	}
-	
-	err = parser.nextToken()
-	if err != nil { return }
-	
-	return
-}
-
-// .name:<value>
-
-// parseObjectInheritedMember parses a new default value for an inherited
-// member.
-func (parser *ParsingOperation) parseObjectInheritedMember () (
-	name  string,
-	value Argument,
-	err   error,
-) {
-	// get the name of the inherited member
-	err = parser.expect(lexer.TokenKindName)
-	value.location = parser.token.Location()
-	if err != nil { return }
-	name = parser.token.Value().(string)
-
-	// we require a default value to be present
-	err = parser.nextToken(lexer.TokenKindColon)
-	if err != nil { return }
-	err = parser.nextToken(lexer.TokenKindLParen, lexer.TokenKindLessThan)
-	if err != nil { return }
-
-	if parser.token.Is(lexer.TokenKindLessThan) {
-		// parse default value
-		value, err = parser.parseBasicDefaultValue()
-		if err != nil { return }
-		
-	} else if parser.token.Is(lexer.TokenKindLParen) {
-		// parse member default values
-		value, err = parser.parseObjectDefaultValue()
-		if err != nil { return }
-	}
-	
-	return
-}
-
-// .ro name:Type:qualifier:<value>
-
-// parseObjectNewMember parses an object member declaration, and its
-// default value if it exists.
-func (parser *ParsingOperation) parseObjectNewMember () (
-	member TypeMember,
-	err error,
-) {
-	// get member permission
-	err = parser.expect(lexer.TokenKindPermission)
-	member.location = parser.token.Location()
-	if err != nil { return }
-	member.permission = parser.token.Value().(types.Permission)
-	
-	// get member name
-	err = parser.nextToken(lexer.TokenKindName)
-	if err != nil { return }
-	member.name = parser.token.Value().(string)
-
-	// get type
-	err = parser.nextToken(lexer.TokenKindColon)
-	if err != nil { return }
-	err = parser.nextToken(lexer.TokenKindName, lexer.TokenKindLBrace)
-	if err != nil { return }
-	member.what, err = parser.parseType()
-	if err != nil { return }
-
-	// get bit width
-	if parser.token.Is(lexer.TokenKindBinaryAnd) {
-		err = parser.nextToken(lexer.TokenKindUInt)
-		if err != nil { return }
-		member.bitWidth = parser.token.Value().(uint64)
-		err = parser.nextToken()
-		if err != nil { return }
-	}
-	
-	return
-}

parser/type.go

@@ -3,8 +3,8 @@ package parser
 import "git.tebibyte.media/arf/arf/types"
 import "git.tebibyte.media/arf/arf/lexer"
 
-// parseTypeSection parses a blind type definition, meaning it can inherit from
+// parseTypeSection parses a type definition. It can inherit from other types,
-// anything including primitives, but cannot define structure.
+// and define new members on them.
 func (parser *ParsingOperation) parseTypeSection () (
 	section TypeSection,
 	err     error,
@@ -32,10 +32,103 @@ func (parser *ParsingOperation) parseTypeSection () (
 	section.what, err = parser.parseType()
 	if err != nil { return }
 
-	parser.expect(lexer.TokenKindNewline)
+	// see if value exists
-	if err != nil { return }
+	if parser.token.Is(lexer.TokenKindNewline) {
-	err = parser.nextToken()
+		parser.nextToken()
-	if err != nil { return }
+		// if we have exited the section, return
+		if !parser.token.Is(lexer.TokenKindIndent) { return }
+		if parser.token.Value().(int) != 1         { return }
+		
+		err = parser.nextToken()
+		if err != nil { return }
+	}
+
+	// if we have not encountered members, get value and return.
+	if !parser.token.Is(lexer.TokenKindPermission) {
+		section.argument, err = parser.parseArgument()
+		err = parser.expect(lexer.TokenKindNewline)
+		if err != nil { return }
+		
+		err = parser.nextToken()
+		if err != nil { return }
+
+		return
+	}
+
+	parser.previousToken()
+
+	for {
+		// if we have exited the section, return
+		if !parser.token.Is(lexer.TokenKindIndent) { return }
+		if parser.token.Value().(int) != 1         { return }
+		
+		err = parser.nextToken(lexer.TokenKindPermission)
+		if err != nil { return }
+		var member TypeSectionMember
+		member, err = parser.parseTypeSectionMember()
+		section.members = append(section.members, member)
+		if err != nil { return }
+	}
 	
 	return
 }
+
+// parseTypeSectionMember parses a type section member variable.
+func (parser *ParsingOperation) parseTypeSectionMember () (
+	member TypeSectionMember,
+	err error,
+) {
+	// get permission
+	err = parser.expect(lexer.TokenKindPermission)
+	if err != nil { return }
+	member.permission = parser.token.Value().(types.Permission)
+
+	// get name
+	err = parser.nextToken(lexer.TokenKindName)
+	if err != nil { return }
+	member.name = parser.token.Value().(string)
+
+	// if there is a type, get it
+	err = parser.nextToken()
+	if err != nil { return }
+	if parser.token.Is(lexer.TokenKindColon) {
+		err = parser.nextToken(lexer.TokenKindName)
+		if err != nil { return }
+		member.what, err = parser.parseType()
+		if err != nil { return }
+	}
+
+	// see if value exists
+	if parser.token.Is(lexer.TokenKindNewline) {
+		parser.nextToken()
+		// if we have exited the member, return
+		if !parser.token.Is(lexer.TokenKindIndent) { return }
+		if parser.token.Value().(int) != 2         { return }
+		
+		err = parser.nextToken()
+		if err != nil { return }
+	}
+
+	// if default value exists, get it
+	if !parser.token.Is(lexer.TokenKindBinaryAnd) {
+		member.argument, err = parser.parseArgument()
+	}
+
+	// if there is a bit width specifier, get it
+	if parser.token.Is(lexer.TokenKindBinaryAnd) {
+		err = parser.nextToken(lexer.TokenKindUInt)
+		if err != nil { return }
+		member.bitWidth = parser.token.Value().(uint64)
+		
+		err = parser.nextToken()
+		if err != nil { return }
+	}
+	
+	err = parser.expect(lexer.TokenKindNewline)
+	if err != nil { return }
+	
+	err = parser.nextToken()
+	if err != nil { return }
+
+	return
+}

parser/type_test.go

@@ -6,55 +6,34 @@ func TestType (test *testing.T) {
 	checkTree ("../tests/parser/type", false,
 `:arf
 ---
-type ro aBasic:Obj:
+type ro aBasic:Obj
-	(
+	ro that:Int
-	.ro that:Int
+	ro this:Int
-	.ro this:Int
+type ro bBitFields:Obj
-	)
+	ro that:Int & 1
-type ro bBitFields:Obj:
+	ro this:Int 298 & 24
-	(
+type ro cInit:Obj
-	.ro that:Int & 1
+	ro that:String "hello world"
-	.ro this:Int:<298> & 24
+	ro this:Int 23
-	)
+type ro dInitInherit:aBasic
-type ro cInit:Obj:
+	ro that 9384
-	(
+	ro this 389
-	.ro that:String:<"hello world">
+type ro eInitAndDefine:aBasic
-	.ro this:Int:<23>
+	ro this 389
-	)
+	ro that 9384
-type ro dInitInherit:aBasic:
+	ro born:Int 4
-	(
+	ro in:Int
-	.that:<9384>
+	ro the:Int:3 (9348 92384 92834)
-	.this:<389>
+	ro walls:String "live in the walls, die in the walls."
-	)
-type ro eInitAndDefine:aBasic:
-	(
-	.ro these:aBasic:
-		(
-		.ro born:Int:<4>
-		.ro in:Int
-		.ro the:Int:3:
-			<
-			9348
-			92384
-			92834
-			>
-		):
-		(
-		.this:<98>
-		)
-	):
-	(
-	.that:<9384>
-	.this:<389>
-	)
 type ro fBasic:Int
-type ro gBasicInit:Int:<6>
+type ro gBasicInit:Int
+	6
 type ro hIntArray:{Int ..}
-type ro iIntArrayInit:Int:3:
+type ro iIntArrayInit:Int:3
-	<
+	(
 	3298
 	923
 	92
-	>
+	)
 `, test)
 }

tests/parser/data/main.arf

@@ -1,9 +1,9 @@
 :arf
 ---
 
-data ro aInteger:Int:<3202>
+data ro aInteger:Int 3202
 
-data ro bMutInteger:Int:mut:<3202>
+data ro bMutInteger:Int:mut 3202
 
 data ro cIntegerPointer:{Int}
 
@@ -13,33 +13,30 @@ data ro eIntegerArray16:Int:16
 
 data ro fIntegerArrayVariable:{Int ..}
 
-data ro gIntegerArrayInitialized:Int:16:<
+data ro gIntegerArrayInitialized:Int:16
-	3948 293 293049 948 912
+	(3948 293 293049 948 912
-	340 0 2304 0 4785 92
+	340 0 2304 0 4785 92)
-	>
 
-data rw hIntegerPointerInit:{Int}:<[& integer]>
+data rw hIntegerPointerInit:{Int} [& integer]
 
-data rw iMutIntegerPointerInit:{Int}:mut:<[& integer]>
+data rw iMutIntegerPointerInit:{Int}:mut
+	[& integer]
 
-data ro jObject:Obj:(
+data ro jObject:Obj
-	.this:<324>
+	(324
-	.that:<324>)
+	438)
 
-data ro kNestedObject:Obj:(
+# TODO: at some point, have this syntax for object literals. terminate members
-	.this:(
+# with newlines.
-		.bird0:<324>
+# data ro jObject:Bird (
-		.bird1:<"hello world">)
+	# .this 324
-	.ro newMember:Int:<9023>
+	# .that 438)
-	.that:(
-		.bird2:<123.8439>
-		.bird3:<9328.21348239>))
 
 data ro lMutIntegerArray16:Int:16:mut
 
 data ro mExternalData:Int:8
 	external
 
-data ro nIntegerArrayInitialized:Int:16:mut:
+data ro nIntegerArrayInitialized:Int:16:mut
-	<3948 293 293049 948 912
+	(3948 293 293049 948 912
-	340 0 2304 0 4785 92>
+	340 0 2304 0 4785 92)

tests/parser/enum/main.arf

@@ -11,26 +11,26 @@ enum ro Weekday:Int
 	- saturday
 
 enum ro NamedColor:U32
-	- red:   <0xFF0000>
+	- red   0xFF0000
-	- green: <0x00FF00>
+	- green 0x00FF00
-	- blue:  <0x0000FF>
+	- blue  0x0000FF
 
 enum ro AffrontToGod:Int:4
-	- bird0:
+	- bird0
-		<28394 9328
+		(28394 9328
-		398 9>
+		398 9)
-	- bird1:
+	- bird1
-		<23 932832
+		(23 932832
 		398
-		2349>
+		2349)
-	- bird2:
+	- bird2
-		<1
+		(1
 		2
 		3
-		4>
+		4)
 
-enum ro ThisIsTerrible:Obj:(.rw x:Int .rw y:Int)
+enum ro ThisIsTerrible:Vector
-	- up:    (.x:< 0> .y:<-1>)
+	- up    ( 0 -1)
-	- down:  (.x:< 0> .y:< 1>)
+	- down  ( 0  1)
-	- left:  (.x:<-1> .y:< 0>)
+	- left  (-1  0)
-	- right: (.x:< 1> .y:< 0>)
+	- right ( 1  0)

tests/parser/face/main.arf

@@ -1,7 +1,7 @@
 :arf
 ---
 
-face ro ReadWriter:Face
+face ro aReadWriter:Face
 	write
 		> data:{Byte ..}
 		< wrote:Int
@@ -11,5 +11,10 @@ face ro ReadWriter:Face
 		< read:Int
 		< err:Error
 
-face ro Destroyer:Face
+face ro bDestroyer:Face
 	destroy
+
+face ro cFuncInterface:Func
+	> something:Int
+	< someOutput:Int
+	< otherOutput:String

tests/parser/func/main.arf

@@ -2,14 +2,14 @@
 ---
 func ro aBasicExternal
 	> someInput:Int:mut
-	< someOutput:Int:<4>
+	< someOutput:Int 4
 	---
 	external
 
 func ro bMethod
 	@ bird:{Bird}
 	> someInput:Int:mut
-	< someOutput:Int:<4>
+	< someOutput:Int 4
 	---
 	external
 
@@ -122,14 +122,13 @@ func ro gControlFlow
 		else
 			otherThing
 
-func ro hSetPhrase
+func ro hDataInit
 	---
-	let x:Int:<3>
+	= x:Int 3
 	# loc is a reference, similar to * in C
-	let y:{Int}:<[loc x]>
+	= y:{Int} [loc x]
-	let z:Int:8:
+	= z:Int:8 (398 9 2309 983 -2387
-		<398 9 2309 983 -2387
+		478 555 123)
-		478 555 123>
+	= bird:Bird (
-	let bird:Bird:(
+		(99999)
-		.that:(.whenYou:<99999>)
+		324)
-		.this:<324>)

tests/parser/skim/main.arf

@@ -6,37 +6,33 @@ data ro aExternalData:Int
 
 data ro bSingleValue:Int 342
 
-data ro cNestedObject:Obj
+data ro cNestedObject:Obj (
-	-- this
+	(324 "hello world")
-		-- bird0 324
+	(123.8439 9328.21348239)
-		-- bird1 "hello world"
+)
-	-- that
-		-- bird2 123.8439
-		-- bird3 9328.21348239
 
 data ro dUninitialized:Int:16:mut
 
 data ro eIntegerArrayInitialized:Int:16:mut
-	3948 293 293049 948 912
+	(3948 293 293049 948 912
-	340 0 2304 0 4785 92
+	340 0 2304 0 4785 92)
 
 func ro fComplexFunction
 	---
 	= x:Int 3
-	= y:{Int} [loc x]
+	= y:{Int
-	= z:Int:8
+} [loc x
+]
+	= z:Int:8 (
 		398 9 2309 983 -2387
-		478 555 123
+		478 555 123)
-	= bird:Bird
+	= bird:Bird ((99999) 324)
-		-- that
-			-- whenYou 99999
-		-- this 324
 
 func ro gExternalFunction
 	> x:Int
 	< arr:Int 5
-		34908
+		(34908
 		39 3498
-		38 219
+		38 219)
 	---
 	external

tests/parser/type/main.arf

@@ -1,35 +1,36 @@
 :arf
 ---
-type ro aBasic:Obj:(
+type ro aBasic:Obj
-	.ro that:Int
+	ro that:Int
-	.ro this:Int)
+	ro this:Int
 
-type ro bBitFields:Obj:(
+type ro bBitFields:Obj
-	.ro that:Int & 1
+	ro that:Int     & 1
-	.ro this:Int:<298> & 24)
+	ro this:Int 298 & 24
 
-type ro cInit:Obj:(
+type ro cInit:Obj
-	.ro that:String:<"hello world">
+	ro that:String "hello world"
-	.ro this:Int:<23>)
+	ro this:Int    23
 
-type ro dInitInherit:aBasic:(
+# the semantic analyzer should let these sections restrict the permissions of
-	.that:<9384>
+# inherited members, but it should not let the sections lessen the permissions.
-	.this:<389>)
+type ro dInitInherit:aBasic
+	ro that 9384
+	ro this 389
 
-type ro eInitAndDefine:aBasic:(
+type ro eInitAndDefine:aBasic
-	.this:<389>
+	ro this     389
-	.ro these:aBasic:(
+	ro that     9384
-		.ro born:Int:<4>
+	ro born:Int 4
-		.ro in:Int
+	ro in:Int
-		.ro the:Int:3:<9348 92384 92834>
+	ro the:Int:3 (9348 92384 92834)
-		.this:<98>)
+	ro walls:String "live in the walls, die in the walls."
-	.that:<9384>)
 
 type ro fBasic:Int
 
-type ro gBasicInit:Int:<6>
+type ro gBasicInit:Int 6
 
 type ro hIntArray:{Int ..}
 
-type ro iIntArrayInit:Int:3:
+type ro iIntArrayInit:Int:3
-	<3298 923 92>
+	(3298 923 92)