Remove state

cmd/action.go

@@ -39,11 +39,9 @@ func Action(c *cli.Context) error {
 		return fmt.Errorf("eval: %v\n", err)
 	}
 
-	s, err := e.State()
-	if err != nil {
-		return fmt.Errorf("state: %v", err)
+	if err := e.Println(); err != nil {
+		fmt.Printf("print: %v\n", err)
 	}
 
-	e.Println(s)
 	return nil
 }

pkg/evaluator/evaluator.go

@@ -302,12 +302,31 @@ func (e *Evaluator) evalInfix(kind lexer.Token, lhs, rhs object.Object) (object.
 }
 
 func (e *Evaluator) evalPrint(s *ast.PrintStmt, env *object.Environment) error {
-	state, err := e.state(s, env)
-	if err != nil {
-		return fmt.Errorf("state: %v", err)
+	if len(env.Qubit.Name) == 0 {
+		return nil
+	}
+
+	qargs := s.QArgs.List
+	if len(qargs) == 0 {
+		for _, n := range env.Qubit.Name {
+			qargs = append(qargs, &ast.IdentExpr{Name: n})
+		}
+	}
+
+	var index [][]int
+	for _, a := range qargs {
+		qb, ok := env.Qubit.Get(a)
+		if !ok {
+			return fmt.Errorf("qubit(%v) not found", a)
+		}
+
+		index = append(index, q.Index(qb...))
+	}
+
+	for _, s := range e.Q.Raw().State(index...) {
+		fmt.Println(s)
 	}
 
-	e.Println(state)
 	return nil
 }
 
@@ -686,61 +705,27 @@ func (e *Evaluator) extf(x *ast.CallExpr, g *ast.FuncDecl, outer *object.Environ
 	return env, nil
 }
 
-func (e *Evaluator) state(s *ast.PrintStmt, env *object.Environment) (*State, error) {
-	out := &State{Classical: make([]Classical, 0)}
-	for _, n := range env.Bit.Name {
-		v, ok := e.Env.Bit.Get(&ast.IdentExpr{Name: n})
-		if !ok {
-			return nil, fmt.Errorf("bit(%v) not found", n)
-		}
-		out.Classical = append(out.Classical, Classical{
-			Name:  n,
-			Value: v,
-		})
+func (e *Evaluator) Println() error {
+	if _, err := e.eval(&ast.PrintStmt{}, e.Env); err != nil {
+		return fmt.Errorf("print qubit: %v", err)
 	}
 
-	if len(env.Qubit.Name) == 0 {
-		return out, nil
-	}
+	for _, n := range e.Env.Bit.Name {
+		fmt.Printf("%v: ", n)
 
-	qargs := s.QArgs.List
-	if len(qargs) == 0 {
-		for _, n := range env.Qubit.Name {
-			qargs = append(qargs, &ast.IdentExpr{Name: n})
-		}
-	}
-
-	var index [][]int
-	for _, a := range qargs {
-		qb, ok := env.Qubit.Get(a)
+		c, ok := e.Env.Bit.Get(&ast.IdentExpr{Name: n})
 		if !ok {
-			return nil, fmt.Errorf("qubit(%v) not found", a)
+			return fmt.Errorf("bit(%v) not found", n)
 		}
 
-		index = append(index, q.Index(qb...))
-	}
-	out.Quantum = e.Q.Raw().State(index...)
-
-	return out, nil
-}
-
-func (e *Evaluator) State() (*State, error) {
-	return e.state(&ast.PrintStmt{}, e.Env)
-}
-
-func (e *Evaluator) Println(s *State) {
-	for _, s := range s.Quantum {
-		fmt.Println(s)
-	}
-
-	for _, s := range s.Classical {
-		fmt.Printf("%v: ", s.Name)
-		for _, v := range s.Value {
+		for _, v := range c {
 			fmt.Printf("%v", v)
 		}
 
 		fmt.Println()
 	}
+
+	return nil
 }
 
 func override(block ast.BlockStmt, name []string) ast.BlockStmt {

pkg/evaluator/evaluator_test.go

@@ -33,12 +33,10 @@ func eval(qasm string, verbose ...bool) error {
 		return fmt.Errorf("eval: %v\n", err)
 	}
 
-	s, err := e.State()
-	if err != nil {
-		return fmt.Errorf("state: %v\n", err)
+	if err := e.Println(); err != nil {
+		return fmt.Errorf("print: %v\n", err)
 	}
 
-	e.Println(s)
 	return nil
 }
 
@@ -224,6 +222,7 @@ h q;
 	// .  .  .  .  .  .  .  return *object.Int(0)
 	// .  .  .  .  .  .  *ast.BasicLit(pi)
 	// .  .  .  .  .  .  .  return *object.Float(3.141592653589793)
+	// .  .  *ast.PrintStmt(print;)
 	// [0][  0]( 0.7071 0.0000i): 0.5000
 	// [1][  1]( 0.7071 0.0000i): 0.5000
 }

pkg/repl/repl.go

@@ -42,27 +42,23 @@ func Run(in io.Reader) error {
 		ast := p.Parse()
 		if errs := p.Errors(); len(errs) != 0 {
 			for _, err := range errs {
-				fmt.Printf("[ERROR] parse: %v\n", err)
+				fmt.Printf("parse: %v\n", err)
 			}
 			continue
 		}
 
 		if err := e.Eval(ast); err != nil {
-			fmt.Printf("[ERROR] eval: %v\n", err)
+			fmt.Printf("eval: %v\n", err)
 			continue
 		}
 
 		if strings.HasPrefix(txt, "print") {
 			continue
 		}
 
-		s, err := e.State()
-		if err != nil {
-			fmt.Printf("[ERROR] state: %v\n", err)
-			continue
+		if err := e.Println(); err != nil {
+			fmt.Printf("print: %v\n", err)
 		}
-
-		e.Println(s)
 	}
 
 	return nil