From 9d82785f46949151b783d83648b39ce9ba40c615 Mon Sep 17 00:00:00 2001
From: Charlie Stanton <charlie@shtanton.xyz>
Date: Sat, 30 Mar 2024 09:42:00 +0000
Subject: Add none structures and allow mismatched destructuring

---
 subex/subexast.go | 145 +++++++++++++++++++++++++++++++++---------------------
 1 file changed, 90 insertions(+), 55 deletions(-)

(limited to 'subex/subexast.go')

diff --git a/subex/subexast.go b/subex/subexast.go
index cef853b..7070baf 100644
--- a/subex/subexast.go
+++ b/subex/subexast.go
@@ -132,9 +132,6 @@ type SubexASTRepeat struct {
 	Acceptable []ConvexRange
 }
 func (ast SubexASTRepeat) compileWith(next SubexState, slotMap *SlotMap, inType Type, outType Type) SubexState {
-	if inType != outType {
-		panic("Invalid types")
-	}
 	var state SubexState = &SubexDeadState{}
 	for _, convex := range ast.Acceptable {
 		state = &SubexGroupState {state, convex.compile(ast.Content, next, slotMap, inType, outType)}
@@ -223,7 +220,8 @@ func (ast SubexASTCopyNumber) String() string {
 type SubexASTCopyAnyValue struct {}
 func (ast SubexASTCopyAnyValue) compileWith(next SubexState, slotMap *SlotMap, inType Type, outType Type) SubexState {
 	if inType != ValueType || outType != ValueType {
-		panic("Invalid types for SubexASTNot")
+		fmt.Printf("%v, %v", inType, outType)
+		panic("Invalid types for SubexASTCopyAnyValue")
 	}
 	return &SubexCopyState {
 		next: next,
@@ -446,9 +444,10 @@ func (ast SubexASTEmpty) String() string {
 // Discards the output from the content subex
 type SubexASTDiscard struct {
 	Content SubexAST
+	InnerOutType Type
 }
 func (ast SubexASTDiscard) compileWith(next SubexState, slotMap *SlotMap, inType Type, outType Type) SubexState {
-	newNext := ast.Content.compileWith(&SubexDiscardState {next}, slotMap, inType, outType)
+	newNext := ast.Content.compileWith(&SubexDiscardState {next}, slotMap, inType, ast.InnerOutType)
 	if inType == ValueType {
 		return &SubexCaptureBeginState {
 			next: newNext,
@@ -463,65 +462,101 @@ func (ast SubexASTDiscard) String() string {
 	return fmt.Sprintf("(%v)$_", ast.Content)
 }
 
-// Go into an array, pass the content each of the values in the array to eat and then leave the array
-type SubexASTEnterArray struct {
+type SubexASTDestructure struct {
+	Destructure Structure
+	Structure Structure
 	Content SubexAST
 }
-func (ast SubexASTEnterArray) compileWith(next SubexState, slotMap *SlotMap, inType Type, outType Type) SubexState {
-	if inType != ValueType || outType != ValueType {
-		panic("Invalid types for SubexASTEnterArray")
+func (ast SubexASTDestructure) compileWith(next SubexState, slotMap *SlotMap, inType Type, outType Type) SubexState {
+	var innerOutType Type
+	var construct SubexState
+	switch ast.Structure {
+	case NoneStructure:
+		innerOutType = outType
+		construct = next
+	case StringStructure:
+		innerOutType = RuneType
+		construct = &SubexConstructStringState {
+			next: next,
+		}
+	case ArrayStructure:
+		innerOutType = ValueType
+		construct = &SubexConstructArrayState {
+			next: next,
+		}
 	}
-	return &SubexCaptureBeginState {
-		next: &SubexCopyState {
-			filter: anyArrayFilter{},
-			next: &SubexDiscardState {
-				next: &SubexIncrementNestState {
-					next: &SubexCaptureBeginState {
-						next: ast.Content.compileWith(
-							&SubexDiscardTerminalState {
-								terminal: walk.ArrayEnd,
-								next: &SubexDecrementNestState {
-									next: &SubexConstructArrayState {next: next},
-								},
-							},
-							slotMap,
-							ValueType,
-							ValueType,
-						),
-					},
-				},
+
+	var innerInType Type
+	var destructFooter SubexState
+	switch ast.Destructure {
+	case NoneStructure:
+		innerInType = inType
+		destructFooter = construct
+	case StringStructure:
+		innerInType = RuneType
+		destructFooter = &SubexDiscardTerminalState {
+			terminal: walk.StringEnd,
+			next: &SubexDecrementNestState {
+				next: construct,
+			},
+		}
+	case ArrayStructure:
+		innerInType = ValueType
+		destructFooter = &SubexDiscardTerminalState {
+			terminal: walk.ArrayEnd,
+			next: &SubexDecrementNestState {
+				next: construct,
 			},
-		},
+		}
 	}
-}
 
-type SubexASTEnterString struct {
-	Content SubexAST
-}
-func (ast SubexASTEnterString) compileWith(next SubexState, slotMap *SlotMap, inType Type, outType Type) SubexState {
-	if inType != ValueType || outType != ValueType {
-		panic("Invalid types for SubexASTEnterString")
+	inner := ast.Content.compileWith(
+		destructFooter,
+		slotMap,
+		innerInType,
+		innerOutType,
+	)
+
+	var beginConstruct SubexState
+	switch ast.Structure {
+	case NoneStructure:
+		beginConstruct = inner
+	case StringStructure:
+		beginConstruct = &SubexCaptureRunesBeginState {
+			next: inner,
+		}
+	case ArrayStructure:
+		beginConstruct = &SubexCaptureBeginState {
+			next: inner,
+		}
 	}
-	return &SubexCaptureBeginState {
-		next: &SubexCopyState {
-			filter: anyStringFilter{},
-			next: &SubexDiscardState {
-				next: &SubexIncrementNestState {
-					next: &SubexCaptureRunesBeginState {
-						next: ast.Content.compileWith(
-							&SubexDiscardTerminalState {
-								terminal: walk.StringEnd,
-								next: &SubexDecrementNestState {
-									next: &SubexConstructStringState {next: next},
-								},
-							},
-							slotMap,
-							RuneType,
-							RuneType,
-						),
+
+	switch ast.Destructure {
+	case NoneStructure:
+		return beginConstruct
+	case StringStructure:
+		return &SubexCaptureBeginState {
+			next: &SubexCopyState {
+				filter: anyStringFilter{},
+				next: &SubexDiscardState {
+					next: &SubexIncrementNestState {
+						next: beginConstruct,
+					},
+				},
+			},
+		}
+	case ArrayStructure:
+		return &SubexCaptureBeginState {
+			next: &SubexCopyState {
+				filter: anyArrayFilter{},
+				next: &SubexDiscardState {
+					next: &SubexIncrementNestState {
+						next: beginConstruct,
 					},
 				},
 			},
-		},
+		}
+	default:
+		panic("Invalid destructure in ast")
 	}
 }
-- 
cgit v1.2.3