It is technically possible to have a
Monad, but pure cannot be ConfigValue.default to get the right semantics.
Instead,
pure has to be what would be ConfigValue.loaded(value), i.e. the current loaded but without any key.
So now the user basically has to choose between
ConfigValue.default(value) and ConfigValue.loaded(value).
The main difference is that
loaded means we won't be able to use defaults later in our composition.
Instead, I went for a simpler approach: anything not a
ConfigValue.loaded(key, value) is a default value, and the only way to construct it is with ConfigValue.default.
Another question: have you considered abandoning
FlatMap and adding ability to generate some sort of docs? With flatmap in place its not technically possible. Im not saying its something worth doing, just wondering if it was considered. Similarly to --help in decline
(Regarding the second part of the question: the reason why
ConfigValue.Par only has an Apply instance and not e.g. FlatMap, is because the flatMap consistent with ap cannot be expressed using tailRecM. In v1.0.2 we have ConfigValue#parFlatMap with that exact flatMap though, because it's useful in certain situations, see here: https://github.com/vlovgr/ciris/pull/273.)
@Krever There was this pull request before 1.x: vlovgr/ciris#257. You're correct that we can't go beyond
Applicative if we want to generate documentation in the general case. I find flatMap to have a clear and useful purpose (i.e. affect configuration loading depending on an earlier value), and so there's a good reason for it to exist. I think generating documentation is tempting, but not tempting enough to give up flatMap.
It should still be possible to generate documentation, but it won't work across
flatMaps of course (and so might be surprising in that case).
Not ideal, but if you limit yourself to
Applicative when writing the configuration, it should still do the right thing.
Hello folks, i'm constructing some custom configuration, ConfigValue instances for list of url/ips usually when connecting to distributed brokers like Cassandra/Kafka .... I did in this way, it worked, but can i create a pure config value in some way? The unique way that i found was using .default method.
type HostList = NonEmpty And Forall[Or[IPv4, Url]]
final val hostRefined: String => ConfigValue[List[String]] = string => {
refineV[HostList](string.split(",").toList.map(_.replace(" ", "")))
.fold(
error => ConfigValue.failed[List[String]](ConfigError(error)),
correct => ConfigValue.default[List[String]](correct.value)
)
}
Something like the following should work.
import $ivy.`is.cir::ciris-refined:1.0.2`, cats.implicits._, ciris._, refined._
import eu.timepit.refined._, api._, boolean._, collection._, string._
type HostList = List[String] Refined (NonEmpty And Forall[Or[IPv4, Url]])
implicit val hostListConfigDecoder: ConfigDecoder[String, HostList] =
ConfigDecoder
.identity[String]
.map(_.split(",").toList.map(_.replace(" ", "")))
.mapEither(ConfigDecoder[List[String], HostList].decode)
env("KAFKA_HOSTS").as[HostList]
Note the
ConfigDecoder[List[String], HostList] comes from import ciris.refined._ (with the ciris-refined module).
We should probably add a convenience function for that last
mapEither, so we could say e.g. mapDecode[HostList] instead.
Hey @vlovgr, would you be interested in incorporating ciris-hocon into ciris repo? I could contact author to check if thats ok. Currently cirisi-hocon is on ciris 0.12 and I can imagine it would be more maintanable in a long term to keep it together with ciris. In the end the integration is rather small, single file: https://github.com/2m/ciris-hocon/blob/master/src/main/scala/Hocon.scala
I believe @2m is in the channel, not sure if he's checking notifications though. :)
@SealBadger_twitter Maybe you can have a look at Gabriel Volpe's repo for his "Practical FP in Scala" book: https://github.com/gvolpe/pfps-shopping-cart/blob/master/modules/core/src/main/scala/shop/config/loader.scala
what I'm trying to do is like this:
env("APP_ENV").as[AppEnvironment].option.flatMap {
case Some(AppEnvironment.Dev) | None =>
ConfigValue.default[Config](ConfigSource.default.loadOrThrow[Config]) // trying to load with pure config. there are refined types
case _ =>
(
... // read from env and validate, build ConfigValue with parMapN manually
)
}
there is also https://github.com/2m/ciris-hocon but I'm not sure if it's compatible with the version of ciris you are running
ciris is really a configuration algebra which provides a few implementations in the core. you can really read anything using the functions provided in the companion object of
ConfigValue. for example, i've created methods to read from hashicorp consul and vault for my company's internal use.
@Krever has started working on a ciris-hocon integration (vlovgr/ciris#284) if that's what you're looking for @Bunyod
That said, I do have a question. Is there already a
ConfigDecoder[String, Json] out there, or maybe even something more generic that allows me to have a ConfigDecoder[String, A] for any A with a Circe Decoder[A]?
I've written one for the latter case:
implicit def circeConfigDecoder[A: Decoder]: ConfigDecoder[String, A] =
ConfigDecoder[String].mapEither {
(_, s) => decode[A](s).leftMap {
case ParsingFailure(message, _) => ConfigError(message)
case DecodingFailure(message, _) => ConfigError(message)
}
}This requires the circe-parser module from circe.