typechecked / alphabet-soup

Type calculations at compile time

Alphabet soup

This library is intended to give a seamless way to manipulate scala structures into one another, mixing the types intelligently as required

For a whistle-stop tour of the underlying algorithm, see here

Documentation

Please see the documentation site for information on this library

alphabet-soup's Issues

README Updates

• Remove section about the future
• Remove publishLocal instructions
• Link to https://medium.com/@jdrphillips/alphabet-soup-type-level-transformations-eb60918af35d as a whistle-stop tour of the concepts involved in the algorithm

Mixer's for non-primitive types

The following will not compile

  @Atomic class A
  @Atomic class B
  implicitly[Mixer[(A,B), B]]

However if we swap the the classes for traits or primitives (String, Int, ect) it works fine.

See PR #20 for tests demonstrating the issue

Resolve Atom+Molecule conflict

I as a user define implicit val atomF: Atom[F[Foo]] = Atom[F[Foo]], which will compile.
If I happen to have a molecule in scope - implicit def m[A]: Molecule[F, A]... the failure point for the algorithm will be in SelectFromAtomised. It would be more informative to the user if the point of failure was the creation of the atom atomF (much like done for DefaultAtom).

Further, you cannot use atoms in mixing of type Atom[Option[Foo]] or Atom[List[Foo]] at all due to the automatic pick up the molecules in the Molecule companion, and again the compilation error obfuscates the fact that atoms and molecules can't exists side-by-side.

Support 2.13 as standard and cross support 2.12

See numerology for successful combination of technologies and versions

Feature Request: Atom Mapping

Atom Mapping

When atom selecting fails on a type parameter Target, the algorithm will search for an implicitly supplied conversion between an available Source and the desired Target.

If you have a type A which can be uniquely mapped to a type B and atom-selection fails to find a B in the source, it should search for an A and a canonical conversion from A => B.

@Atomic macro does not work for implicit objects

The following fails:

@Atomic case class Foo(a: Int)

implicit object Foo

Isomorphism typeclass

Iso[A, B] <=> Mixer[A, B] && Mixer[B, A]

trait Iso[A, B] {
  def forwards(a: A): B
  def backwards(b: B): A
}

Name to be determined.

Should probably be built by traversing the atomised structure of A and B at the same time to make it more efficient.

Should be used in SelectFromAtomised, one implicit of which currently takes aMixer in both directions