cm: do not use bool in option and result for discriminator

Tinygo (LLVM) handles bool values in a tagged union differently than Go.

Fixes #344.

Author: ydnar

cm/option.go

@@ -18,7 +18,7 @@ func None[T any]() Option[T] {
 func Some[T any](v T) Option[T] {
 	return Option[T]{
 		option: option[T]{
-			isSome: true,
+			isSome: 1,
 			some:   v,
 		},
 	}
@@ -29,19 +29,19 @@ func Some[T any](v T) Option[T] {
 // followed by storage for the associated type T.
 type option[T any] struct {
 	_      HostLayout
-	isSome bool
+	isSome uint8
 	some   T
 }
 
 // None returns true if o represents the none case.
 func (o *option[T]) None() bool {
-	return !o.isSome
+	return o.isSome == 0
 }
 
 // Some returns a non-nil *T if o represents the some case,
 // or nil if o represents the none case.
 func (o *option[T]) Some() *T {
-	if o.isSome {
+	if o.isSome == 1 {
 		return &o.some
 	}
 	return nil
@@ -51,7 +51,7 @@ func (o *option[T]) Some() *T {
 // or the zero value of T if o represents the none case.
 // This does not have a pointer receiver, so it can be chained.
 func (o option[T]) Value() T {
-	if !o.isSome {
+	if o.isSome == 0 {
 		var zero T
 		return zero
 	}

cm/result.go

@@ -33,7 +33,7 @@ type AnyResult[Shape, OK, Err any] interface {
 // result represents the internal representation of a Component Model result type.
 type result[Shape, OK, Err any] struct {
 	_     HostLayout
-	isErr bool
+	isErr uint8
 	_     [0]OK
 	_     [0]Err
 	data  Shape // [unsafe.Sizeof(*(*Shape)(unsafe.Pointer(nil)))]byte
@@ -44,7 +44,7 @@ type result[Shape, OK, Err any] struct {
 func OK[R AnyResult[Shape, OK, Err], Shape, OK, Err any](ok OK) R {
 	var r Result[Shape, OK, Err]
 	r.validate()
-	r.isErr = ResultOK
+	r.isErr = 0
 	*((*OK)(unsafe.Pointer(&r.data))) = ok
 	return R(r)
 }
@@ -54,42 +54,42 @@ func OK[R AnyResult[Shape, OK, Err], Shape, OK, Err any](ok OK) R {
 func Err[R AnyResult[Shape, OK, Err], Shape, OK, Err any](err Err) R {
 	var r Result[Shape, OK, Err]
 	r.validate()
-	r.isErr = ResultErr
+	r.isErr = 1
 	*((*Err)(unsafe.Pointer(&r.data))) = err
 	return R(r)
 }
 
 // SetOK sets r to an OK result.
 func (r *result[Shape, OK, Err]) SetOK(ok OK) {
 	r.validate()
-	r.isErr = ResultOK
+	r.isErr = 0
 	*((*OK)(unsafe.Pointer(&r.data))) = ok
 }
 
 // SetErr sets r to an error result.
 func (r *result[Shape, OK, Err]) SetErr(err Err) {
 	r.validate()
-	r.isErr = ResultErr
+	r.isErr = 1
 	*((*Err)(unsafe.Pointer(&r.data))) = err
 }
 
 // IsOK returns true if r represents the OK case.
 func (r *result[Shape, OK, Err]) IsOK() bool {
 	r.validate()
-	return !r.isErr
+	return r.isErr == 0
 }
 
 // IsErr returns true if r represents the error case.
 func (r *result[Shape, OK, Err]) IsErr() bool {
 	r.validate()
-	return r.isErr
+	return r.isErr == 1
 }
 
 // OK returns a non-nil *OK pointer if r represents the OK case.
 // If r represents an error, then it returns nil.
 func (r *result[Shape, OK, Err]) OK() *OK {
 	r.validate()
-	if r.isErr {
+	if r.isErr == 1 {
 		return nil
 	}
 	return (*OK)(unsafe.Pointer(&r.data))
@@ -99,7 +99,7 @@ func (r *result[Shape, OK, Err]) OK() *OK {
 // If r represents the OK case, then it returns nil.
 func (r *result[Shape, OK, Err]) Err() *Err {
 	r.validate()
-	if !r.isErr {
+	if r.isErr == 0 {
 		return nil
 	}
 	return (*Err)(unsafe.Pointer(&r.data))
@@ -109,7 +109,7 @@ func (r *result[Shape, OK, Err]) Err() *Err {
 // or (zero value of OK, Err, true) if r represents the error case.
 // This does not have a pointer receiver, so it can be chained.
 func (r result[Shape, OK, Err]) Result() (ok OK, err Err, isErr bool) {
-	if r.isErr {
+	if r.isErr == 1 {
 		return ok, *(*Err)(unsafe.Pointer(&r.data)), true
 	}
 	return *(*OK)(unsafe.Pointer(&r.data)), err, false

cm/result_test.go

@@ -350,3 +350,28 @@ func TestIssue284NotTinyGo(t *testing.T) {
 		}
 	}
 }
+
+func TestIssue344TupleOfOption(t *testing.T) {
+	type T Result[[1]Option[uint64], uint64, [1]Option[uint64]]
+
+	want := uint64(2)
+	v := T(OK[Result[[1]Option[uint64], uint64, [1]Option[uint64]]](want))
+	got := *v.OK()
+
+	if got != want {
+		t.Errorf("*v.OK(): %v, expected %v", got, want)
+	}
+}
+
+func TestIssue344TupleOfResult(t *testing.T) {
+	type R Result[uint64, uint64, bool]
+	type T Result[[1]R, uint64, [1]R]
+
+	want := uint64(2)
+	v := T(OK[T](want))
+	got := *v.OK()
+
+	if got != want {
+		t.Errorf("*v.OK(): %v, expected %v", got, want)
+	}
+}