Fixes for lazyseq equality

Signed-off-by: James Hamlin <jfhamlin@gmail.com>

Author: jfhamlin

pkg/lang/agent.go

@@ -3,7 +3,11 @@ package lang
 import "time"
 
 type (
-	Agent struct{}
+	Agent struct {
+		meta IPersistentMap
+
+		watches IPersistentMap
+	}
 
 	future struct {
 		done chan struct{}
@@ -12,6 +16,8 @@ type (
 )
 
 var (
+	_ ARef = (*Agent)(nil)
+
 	_ IBlockingDeref = (*future)(nil)
 	_ IDeref         = (*future)(nil)
 	_ IPending       = (*future)(nil)
@@ -54,6 +60,39 @@ func (f *future) IsRealized() bool {
 	}
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// Agent
+
+func (a *Agent) Watches() IPersistentMap {
+	return a.watches
+}
+
+func (a *Agent) AddWatch(key interface{}, fn IFn) IRef {
+	a.watches = a.watches.Assoc(key, fn).(IPersistentMap)
+	return a
+}
+
+func (a *Agent) RemoveWatch(key interface{}) {
+	a.watches = a.watches.Without(key)
+}
+
+func (a *Agent) notifyWatches(oldVal, newVal interface{}) {
+	watches := a.watches
+	if watches == nil || watches.Count() == 0 {
+		return
+	}
+
+	for seq := watches.Seq(); seq != nil; seq = seq.Next() {
+		entry := seq.First().(IMapEntry)
+		key := entry.Key()
+		fn := entry.Val().(IFn)
+		// Call watch function with key, ref, old-state, new-state
+		fn.Invoke(key, a, oldVal, newVal)
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 func ShutdownAgents() {
 	// TODO
 }

pkg/lang/equal.go

@@ -1,6 +1,8 @@
 package lang
 
-import "reflect"
+import (
+	"reflect"
+)
 
 func Equiv(a, b any) bool {
 	return Equals(a, b)

pkg/lang/equals_test.go

@@ -18,6 +18,8 @@ func TestEquiv(t *testing.T) {
 		{NewPersistentHashMap(), emptyMap},
 		{NewPersistentHashMap(1, 2, 3, 4), NewMap(1, 2, 3, 4), NewMap(3, 4, 1, 2)},
 		{NewMap(1, 2).Seq(), NewVector(NewList(1, 2)), NewList(NewVector(1, 2))},
+		// empty lazy seqs are equal
+		{NewLazySeq(func() interface{} { return nil }), NewLazySeq(func() interface{} { return nil })},
 	}
 
 	for _, els := range equivs {

pkg/lang/interfaces.go

@@ -347,6 +347,18 @@ type (
 		// IsCancelled() bool
 		// IsDone() bool
 	}
+
+	AReference interface {
+		Meta() IPersistentMap
+		AlterMeta(f IFn, args ISeq) IPersistentMap
+		ResetMeta(meta IPersistentMap) IPersistentMap
+	}
+
+	ARef interface {
+		IRef
+
+		AReference
+	}
 )
 
 var (

pkg/lang/lazyseq.go

@@ -42,23 +42,23 @@ func (s *LazySeq) xxx_sequential() {}
 
 func (s *LazySeq) First() interface{} {
 	seq := s.Seq()
-	if seq == nil {
+	if IsNil(seq) {
 		return nil
 	}
 	return seq.First()
 }
 
 func (s *LazySeq) Next() ISeq {
 	seq := s.Seq()
-	if seq == nil {
+	if IsNil(seq) {
 		return nil
 	}
 	return seq.Next()
 }
 
 func (s *LazySeq) More() ISeq {
 	seq := s.Seq()
-	if seq == nil {
+	if IsNil(seq) {
 		return emptyList
 	}
 	return seq.More()
@@ -74,24 +74,24 @@ func (s *LazySeq) Empty() IPersistentCollection {
 
 func (s *LazySeq) Equals(o interface{}) bool {
 	seq := s.Seq()
-	if s != nil {
+	if !IsNil(seq) {
 		return Equals(seq, o)
 	}
-	return Seq(o) == nil
+	return IsNil(Seq(o))
 }
 
 func (s *LazySeq) Equiv(o interface{}) bool {
 	seq := s.Seq()
-	if s != nil {
+	if !IsNil(seq) {
 		return Equiv(seq, o)
 	}
-	return Seq(o) == nil
+	return IsNil(Seq(o))
 }
 
 func (s *LazySeq) IsRealized() bool {
 	s.realizeMtx.RLock()
 	defer s.realizeMtx.RUnlock()
-	return s.fn == nil
+	return IsNil(s.fn)
 }
 
 func (s *LazySeq) realize() interface{} {
@@ -114,7 +114,7 @@ func (s *LazySeq) Seq() ISeq {
 
 	s.realize()
 
-	if s.sv == nil {
+	if IsNil(s.sv) {
 		return s.seq
 	}
 	ls := s.sv