#contravariance

Conditional types can be useful for narrowing a type parameter. However, when the checked type is a pure type reference, TypeScript "recalculates" the type in all subsequent usage (both the true and false cases). This can be useful in some cases where different types in a single union apply to multiple conditionals.

However, this behavior of distributing a union type over a generic type can lead to some confusing behavior.

type Transform<T> = (x: T) => T; type StringTransform1<T> = T extends string ? Transform<T> : Transform<unknown>; type StringTransform2<T> = [T] extends [string] ? Transform<T> : Transform<unknown>; declare const transform1: StringTransform1<"a" | "b">; transform1("a"); declare const transform2: StringTransform2<"a" | "b">; transform2("a");

Due to the distribution in StringTransform1 it produces the type Transform | Transform. In TypeScript, parameters are contravariant which means that this computed union flattens to (x: never) => "a" | "b" which is not particularly useful.

https://velog.io/@lsb156/covariance-contravariance

참고자료) 

https://edykim.com/ko/post/what-is-coercion-and-anticommunism/

에 따르면 기본적으로 return type은 공변성을 가지고 argument type은 반공변성을 가진다.

변성

변성이란 제너릭 프로그래밍을 하면서 상속에 관련되어 생기는 이슈가 생길때 접하곤합니다. 변성에 대해서 간단한 예시를 통해서 설명을 하자면 아래와 같이 쉽게 설명이 가능합니다.

Integer는 Number를 상속받아 만들어진 객체입니다. 그래서 Interger는 Number의 하위 타입이라고 할 수 있어 아래와 같은 코딩이 가능합니다.

public void test() {    List<Number> list;    list.add(Integer.valueOf(1)); }

하지만 List<Integer>는 List<Number>의 하위타입이 될 수 없습니다. 이러한 상황에서 Java나 Kotlin에서는 type parameter에 타입 경계를 명시하여 Sub-Type, Super-Type을 가능하게 해줍니다. 그걸 변성이라고 합니다.

(리턴타입은 공변성을 가지면 함수안에서 나가는 것이기때문에 out을 사용한것으로 추측)

(변수타입은 반공변성을 가지면 함수안으로 들어가는 것이기때문에 in을 사용한것으로 추측)

변성에 대한 의미는 아래와 같이 간결하게 설명이 가능합니다.

위에서 설명한것과 같이 타입경계를 지정하여 적용이된 Kotlin과 Java에 대한 설명은 아래와 같이 해석이 가능합니다.

공변성 (Covariant)

공변성은 타입생성자에게 리스코프 치환 법칙을 허용하여 유연한 설계를 가능하게 해줍니다.

interface Cage<T> {    fun get(): T } open class Animal open class Hamster(var name: String) : Animal() class GoldenHamster(name: String) : Hamster(name) fun tamingHamster(cage: Cage<out Hamster>) {    println("길들이기 : ${cage.get().name}") } fun main() {    val animal = object : Cage<Animal> {        override fun get(): Animal {            return Animal()        }    }    val hamster = object : Cage<Hamster> {        override fun get(): Hamster {            return Hamster("Hamster")        }    }    val goldenHamster = object : Cage<GoldenHamster> {        override fun get(): GoldenHamster {            return GoldenHamster("Leo")        }    }    tamingHamster(animal) // compile Error    tamingHamster(hamster)    tamingHamster(goldenHamster) }

tamingHamster 함수는 Hamster의 서브타입만을 받기때문에 animal 변수는 들어갈 수 없습니다.

반공변성 (Contravariant)

공변성의 반대 개념으로 자기 자신과 부모 객체만을 허용합니다.

interface Cage<T> {    fun get(): T } open class Animal open class Hamster(var name: String) : Animal() class GoldenHamster(name: String) : Hamster(name) fun ancestorOfHamster(cage: Cage<in Hamster>) {    println("ancestor = ${cage.get()::javaClass.name}") } fun main() {    val animal = object : Cage<Animal> {        override fun get(): Animal {            return Animal()        }    }    val hamster = object : Cage<Hamster> {        override fun get(): Hamster {            return Hamster("Hamster")        }    }    val goldenHamster = object : Cage<GoldenHamster> {        override fun get(): GoldenHamster {            return GoldenHamster("Leo")        }    }    ancestorOfHamster(animal)    ancestorOfHamster(hamster)    ancestorOfHamster(goldenHamster) // compile Error }

ancestorOfHamster에서 햄스터의 조상을 찾는 함수를 구현하여 햄스터를 포함한 그 조상들만 허용하도록 제한하였습니다. 하위타입인 Cage<GoldenHamster>는 제한에 걸려있어 compile error가 나는것을 확인 할 수 있습니다.

무공변성 (invariant)

Java, Kotlin의 Generic은 기본적으로 무공변성으로 아무런 설정이 없는 기본 Generic을 말합니다.

interface Cage<T> {    fun get(): T } open class Animal open class Hamster(var name: String) : Animal() class GoldenHamster(name: String) : Hamster(name) fun matingGoldenHamster(cage: Cage<GoldenHamster>) {    val hamster = GoldenHamster("stew")    println("교배 : ${hamster.name} & ${cage.get().name}") } fun main() {    val animal = object : Cage<Animal> {        override fun get(): Animal {            return Animal()        }    }    val hamster = object : Cage<Hamster> {        override fun get(): Hamster {            return Hamster("Hamster")        }    }    val goldenHamster = object : Cage<GoldenHamster> {        override fun get(): GoldenHamster {            return GoldenHamster("Leo")        }    }    matingGoldenHamster(animal) // compile Error    matingGoldenHamster(hamster) // compile Error    matingGoldenHamster(goldenHamster) }

위 코드의 Cage<Animal>, Cage<Hamster>, Cage<GoldenHamster>는 서로 각각 연관이 없는 객체로서 무공변성의 적절한 예입니다.

지점에 따른 변성

변성에 따른 타입을 나누는 것에 대해서 지점에 따른 변성으로 선언 지점 변성과 사용 지점 변성으로 나뉠 수 있습니다.

선언 지점 변성

클래스를 선언하면서 클래스 자체에 변성을 지정하는 방식(클래스에 in/out을 지정하는 방식)을 선언 지점 변성(declaration-site variance)이라고 합니다. 선언 하면서 지정하면, 클래스의 공변성을 전체적으로 지정하는게 되기 때문에 클래스를 사용하는 장소에서는 따로 타입을 지정해줄 필요가 없어 편리하게 됩니다.

사용 지점 변성

In this blog, we will explore about types of variances in Scala.

In-variance

Co-variance

Contra-variance

First, let’s talk about Types in Scala.

scala> import java.util.ArrayList scala> var ref1: Any = "Hi" ref1: Any = Hi scala> var ref2: String = "Hi" ref2: String = Hi scala> ref1 = ref2 ref1: Any = Hi

In the above example, ref1 is of type Any and ref2 is of type String. Scala Compiler has…

Back2Basics: Scala Type System in Depth

In this blog, I will put emphasis on the power and awesomeness of the Scala Type System. Also, I will try to reiterate that it is not difficult or complicated as perceived.  In layman terms, the Scala Type system helps us keep the code tidy and type safe. So in this blog, I shall take you through the following :

Parameterized types

In-Variance

Co-Variance

Contra-Variance

(more…)

This is one of the moost confusing generic parts of C# (exists from 4.0)

The goal is to moving from specific to general.  Look at the code below: thanks to out T  we are able to do something like this:

public interface IFoo<out T> { T GiveMeFoo(); } public class Program { public static void Main(string[] args) { IFoo<string> foos = null; IFoo<object> generals = foos; /*covariance enables such analogy with generic types*/ string foo = "text"; object general = foo; } }

If you move “out” from interface you cannot convert from IFoo<string> to IFoo<object>. 

Now something more difficult:

public interface IFoo<out T> { T GiveMeFoo(); } public interface IBar<T> : IFoo<T> { } public class Program { public static void Main(string[] args) { IBar<string> barStr = null; IBar<object> barObj = barStr; /*BUILD FAILS because IBar has not covariant T*/ IFoo<object> fooObj = barStr; /*is Ok, because IBar derives from IFoo and IFoo has out T*/ } }

Invariant IList<T>

Problem with IList is similiat to IBar<T> in previous example.  It is invariant (it doesnt allow either covariance or contravariance ). Take look at the next example : 

public interface IFoo<out T> { IEnumerable<T> GetAllFoos(); /*WORKING*/ IList<T> GetSomeFoos(); /*DOESNT COMPILE*/ } public interface IEdible { }; public abstract class Fruit : IEdible { } public class Apple : Fruit{ } public class Banana: Fruit { } public class Pizza : IEdible { } public class Program { public static void Main(string[] args) { List<Banana> bananas = new List<Banana>(); List<IEdible> edibles = bananas; /*DOESNT COMPILE, IList doesnt allow Covariance*/ IEnumerable<IEdible> eedibles = bananas; /* working IEnumerable allows Covariance*/ IEnumerable<Fruit> fruit = bananas; /* working */ edibles.Add(new Banana()); EatAll(bananas); /*DOESNT COMPILE*/ } public static void EatAll(List<IEdible> edibles) { foreach (var item in edibles) { //Do stuff here } } }

 Don’t worry, compiler always keep you safe and tell’s you when covariently or contravariently you shouldn’t be. 

Covariance is no type conversion it is allows Reference conversion (you still working with the same object but in the different kind of way).

Contravariance

Because Covariance allows only returned values you cannot mix it with input values. That’s why contravariance exists.

interface IFoo<out T, in U> where T : string, where U : string 

{

      T QuerySomething(U param);

i think finding a stim that satisfies both parties is definitely possible! i don’t know the teachery end, but as a student i think i’d prefer to be spoken to privately and in a friendly but not too familiar way. something like mentioning that you know a repetitive behavior helps me concentrate, but that the noise is sometimes distracting, and is there another thing i could do instead that will keep me focused? chances are good there’s at least something. they even make and sell stim toys for grownups that are really quiet and fun to play with. when i was diagnosed, the doctor let me pick out of a whole box of toys so i could talk while also being able to do something with my hands. maybe keeping a stim toy box could be a useful compromise? heck, a lot of neurotypical people also love to fidget.

i dunno, let’s see what the readers think. some of them are both autistic and teachers and can blow me out of the water for problem solving.