Add defaultValue to Schema

[IMax153]

This PR adds a defaultValue method to the Schema trait, which will return an appropriate value a given Schema and closes #74.

Disclaimer: I am incredibly new to both Scala and ZIO, so any and all constructive criticism and feedback is most welcome 🙏.

Additional Context

For StandardTypes, I defaulted the primitive values to the following:

Basic Primitives

• UnitType -> ()
• StringType -> ""
• BoolType -> true
• ShortType -> 0
• IntType -> 0
• LongType -> 0
• FloatType -> 0.0
• DoubleType -> 0.0
• BinaryType -> Chunk.empty
• CharType -> '\u0000' (the empty character '' does not compile, so I went with the NUL character code)
• BigDecimalType -> BigDecimal.ZERO
• BigIntegerType -> BigInteger.ZERO

java.time Primitives

• DayOfWeekType -> java.time.temporal.WeekFields.of(java.util.Locale.getDefault).getFirstDayOfWeek
• Month -> java.time.Month.JANUARY
• MonthDay -> java.time.MonthDay.of(java.time.Month.JANUARY, 1)
• Period -> java.time.Period.ZERO
• Year -> java.time.Year.now
• YearMonth -> java.time.YearMonth.now
• ZoneId -> java.time.ZoneId.systemDefault
• ZoneOffset -> java.time.ZoneOffset.UTC
• Duration -> java.time.Duration.ZERO
• Instant -> java.time.Instant.EPOCH
• LocalDate -> java.time.LocalDate.now
• LocalTime -> java.time.LocalTime.MIDNIGHT
• LocalDateTime -> java.time.LocalDateTime.now
• OffsetTime -> java.time.OffsetTime.now
• OffsetDateTime -> java.time.OffsetDateTime.now
• ZonedDateTime -> java.time.ZonedDateTime.now

I also added a new test suite (DefaultValueSpec) to the current array of test suites.

[CLAassistant]

All committers have signed the CLA.

[IMax153]

I am not sure what the best method is for lifting a Chunk[Either[String, A]] to an Either[String, Chunk[A]].

In fp-ts, I would generally use Traverse to take care of this, but wasn't sure what the most semantic/idiomatic way to do this in ZIO was.

I also asked the question in Discord and was informed about zio-prelude's analogous methods, but I wanted to avoid adding additional dependencies to zio-schema.

[thinkharderdev]

Adding a dependency on zio-prelude is fine but if we wanted to do it the old fashioned way it would be

structure.map(_.schema.defaultValue()).foldRight[Either[String,Chunk[A]](Right(Chunk.empty) { 
    case (_, e @ Left(_)) => e
    case (Left(e), _) => Left[String,List[Unit]](e)
    case (Right(value), Right(values)) => Right(values :+ value)
}

[jdegoes]

I'd suggest avoiding to add ZIO Prelude just yet since it doesn't yet have a 1.0 release. This implementation looks good.

[thinkharderdev]

A few comments but overall nicely done! Thanks for your work on this!

[thinkharderdev]

Adding a dependency on zio-prelude is fine but if we wanted to do it the old fashioned way it would be

structure.map(_.schema.defaultValue()).foldRight[Either[String,Chunk[A]](Right(Chunk.empty) { 
    case (_, e @ Left(_)) => e
    case (Left(e), _) => Left[String,List[Unit]](e)
    case (Right(value), Right(values)) => Right(values :+ value)
}

[thinkharderdev]

I think in this case we should require a default case be specified when the Enumeration is constructed. So maybe change to

final case class Enumeration(structure: ListMap[String,Schema[_]], defaultCase: Option[String] = None) extends Schema[(String,_)] {
   def defaultValue: Either[String,(String,_)] = 
      defaultCase match {
         case Some(id) => structure.get(id).map(_.defaultValue.map(id -> _)).getOrElse(Left("invalid default case"))
         case None => Left("no default case is defined")
      }

[thinkharderdev]

Same here. It feels a little wonky to just declare on subtype as the default but these are also constructed using macros so we can't really allow one to be declared by the user (we could, but it would require an annotation which hasn't been defined yet). Maybe for these we just have defaultValue return `Left("no default value can be determined"). If we want to allow a default to be specified in the future then we can do it with an annotation.

[jdegoes]

I would suggest we just use the first subtype. Or we could do the "smallest" subtype, but first is more predictable.

Both Haskell and Scala type class derivation libraries choose to order the terms in a sum type (for Ord[A]) according to declaration order, so there's a precedent for this.

[thinkharderdev]

I think Bool should default to false to match the behavior of an uninitialized Boolean in Java and Scala.

[jdegoes]

👍

[thinkharderdev]

@jdegoes Is there any particular reason we want defaultValue to return Either[String,A]. My instinct would be to have it return Option[A] (i.e. there either is a default value or there isn't but there shouldn't really be any way an error can occur retrieving it)?

[jdegoes]

@thinkharderdev The only reason it has to return Either[String, A] is because of Transform nodes, which may fail for arbitrary reasons. In which case it's nice to preserve the error.

[IMax153]

Thank you @thinkharderdev and @jdegoes for your review and suggestions! Apologies for the delay - I have been on vacation.

I made the requested change to the BoolType default value (now defaults to false), and used the implementation suggested by @thinkharderdev for lifting a Chunk[Either[String, A]] to an Either[String, Chunk[A]].

I also left the defaultValue implementations for both Enumeration and Enum to default to the first declared subtype, but am happy to adjust if necessary.

Please let me know if you think any additional changes are necessary!

Also as an aside, I am happy to work on a @defaultValue annotation as well either as part of this PR or as a separate PR - if you have any good resources on how to create an annotation, I can get started on this.

[jdegoes]

@IMax153 Thank you for your work on this! Can you resolve conflicts so we can see if the automated build passes?

[IMax153]

@jdegoes - thank you! I believe I've resolved all conflicts.

Also, as I mentioned - if you guys would like me to try to add a @defaultValue annotation as part of this PR, I can try to work on it - would probably just need an example from the ZIO ecosystem to get me started.

[jdegoes]

@IMax153 @thinkharderdev Would be great to get this in by the ZIO Hackathon!!

[IMax153]

@jdegoes Thank you very much for the reminder on this PR!

I've gone ahead and merged main back into my branch and resolved all conflicts. One somewhat major change that I wanted to get feedback on before we go ahead with this PR is the implementation of defaultValue for enumerations.

As we discussed, I am using the first defined Case to determine the defaultValue for enumerations. However, I modified the implementation slightly to return just the value of the Case instead of a tuple of the key/value pair. You can observe what I mean by this in the test for enumerations here where it is now returning just the integer value 0 instead of the tuple ("myInt", 0).

Please let me know what you think! I am open to any and all feedback.

[thinkharderdev]

Thank you for your work on this!