Le sujet des options dans la programmation cause beaucoup de difficultés à comprendre, pour moi c'est un problème que les métaphores pas toujours réussies ne sont pas prises comme explication - les conteneurs.
J'espère pouvoir expliquer ce sujet sous un angle différent en utilisant les métaphores de "l'affectation" dans le contexte des lambdas.
Pourquoi cette variance est-elle vraiment nécessaire ?
En général, vous pouvez vivre sans variance et programmer sereinement, ce n'est pas un sujet si important, nous avons de nombreux exemples de langages de programmation dans lesquels cette qualité ne se reflète pas.
La covariance concerne les types de données et leur contrôle par les compilateurs. Et exactement à partir de cet endroit, nous devons revenir en arrière et dire à propos des types de données et pourquoi nous en avons besoin.
Flashback sur les types
Les types de données en eux-mêmes ne sont pas non plus un sujet très important, il existe des langages dans lesquels le type de données n'est pas particulièrement nécessaire, par exemple, assembleur, brainfuck, REFAL.
Dans le même REFAL ou assembleur, il est très facile de confondre le type d'une variable, et il est très facile, par exemple, de supposer que je vais soustraire une autre ligne d'une ligne, juste une faute de frappe, aucune intention malveillante.
Dans les langages typés, le compilateur verrait cette faute de frappe et m'empêcherait de compiler le programme, mais ... par exemple JS
> 'str-a' - 'str-b'
NaN
JS (JavaScript) Calme-toi ce code, ils me diront que ce n'est pas un bug, c'est une fonctionnalité , ok, disons, alors je vais prendre Python
>>> 'str-a' - 'str-b'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for -: 'str' and 'str'
Ou Java
jshell> "str-a" - "str-b"
| Error:
| bad operand types for binary operator '-'
| first type: java.lang.String
| second type: java.lang.String
| "str-a" - "str-b"
| ^---------------^
, - .
, .
, , , , .
: , Groovy
groovy> def fun1( a, b ){
groovy> return a - b
groovy> }
groovy> println 'fun1( 5, 2 )='+fun1( 5, 2 )
groovy> println "fun1( 'aabc', 'b' )="+fun1( 'aabc', 'b' )
groovy> println 'fun1( [1,2,3,4], [2,3] )='+fun1( [1,2,3,4], [2,3] )
fun1( 5, 2 )=3
fun1( 'aabc', 'b' )=aac
fun1( [1,2,3,4], [2,3] )=[1, 4]
JS
> fun1 = function( a, b ){ return a - b }
[Function: fun1]
> fun1( 5, 2 )
3
> fun1( 'aabc', 'b' )
NaN
> fun1( [1,2,3,4], [2,3] )
NaN
.
, , - , .
/ - .
, .
- .
TypeScript
function sub( x : number, y : number ) {
return x - y;
}
console.log( sub(5,3) )
JS.
function sub( x : number, y : number ) {
return x - y;
}
console.log( sub("aa","bb") )
- :
> tsc ./index.ts
index.ts:5:18 - error TS2345: Argument of type 'string' is not assignable
to parameter of type 'number'.
5 console.log( sub("aa","bb") )
~~~~
Found 1 error.
sub
, , number
.
TypeScript (tsc
).
,
́ — () , .
A — G — A A. f A B G, a ∈ A g ∈ G f(a)=f(g(a)).
, :
- , .
, JS
> fun1 = function( a, b, c ){
... let r = b;
... if( a ) r = c;
... return r + r;
... }
[Function: fun1]
> fun1( 1==1, 2, 3 )
6
> fun1( 1==1, "aa", "b" )
'bb'
> fun1( 1==1, 3, "b" )
'bb'
> fun1( 1!=1, 3, "b" )
6
> fun1( 1!=1, {x:1}, "b" )
'[object Object][object Object]'
r - string number , fun1 , .
r. r .
r :
let r = b
, r , b.
r = c
, r , c.
, .
, :
> fun1 = function( a, b, c ){
... if( typeof(b)!=='number' )throw "argument b not number";
... if( typeof(c)!=='number' )throw "argument c not number";
... let r = b;
... if( a ) r = c;
... return r + r;
... }
[Function: fun1]
> fun1( true, 1, 2 )
4
> fun1( true, 'aa', 3 )
Thrown: 'argument b not number'
, , , .
, +, - … - - ( ), - .
let r = b
r = c
, .
Typescript:
function fun1( a:boolean, b:number, c:number ){
let r = b;
if( a ) r = c;
return r + r;
}
function fun2( a:boolean, b:number, c:string ){
let r = b;
if( a ) r = c;
return r + r;
}
> tsc ./index.ts
index.ts:9:13 - error TS2322: Type 'string' is not assignable to type 'number'.
9 if( a ) r = c;
~
Found 1 error.
, string
number
.
- , .
- , ( ) .
: f(a)=f(g(a))
TypeScript:
function f(a:number) : number {
return a+a;
}
function g(a:number) : number {
return a;
}
console.log( f(1)===f(g(1)) )
- .
- , , ..
function f(a:number) : number {
return a+a;
}
function g(a:number) : number {
return a-1;
}
let r = f(1)
r = f(g(1))
function f(a:number) : number {
return a+a;
}
function g(a:number) : string {
return (a-1) + "";
}
let r = f(1)
r = f(g(1))
( ), :
g string
f number
TypeScript.
, // - , / .
-
- -, TypeScript, - Scala, .
, Solid
- , - ,
- , . —–
:
N
N , : {0, 1, 2, 3, … }
N* : {1, 2, 3, … }
Z - (+/-)
Q - ( ), Z
R - ( , e, …)
C - a+bi, a,b - , i -
:
any -
number -
int -
double - ()
string -
TypeScript
function sum_of_int( a:int, b:int ) : int { return a+b; }
function sum_of_double( a:double, b:double ) : double { return a+b; }
function compare_equals( a:number, b:number ) : boolean { a==b }
let res1 : int = sum_of_int( 1, 2 )
, .. - int, int.
-
let res1 : number = sum_of_int( 1, 2 )
res1 = sum_of_double( 1.2, 2.3 )
res1 - number.
res1 = sum_of_int( 1, 2 ), res1 int, , .. int number number
res1 = sum_of_double( 1.2, 2.3 ) - res1 double ,
? , , .. res1:
let res1 : number = sum_of_int( 1, 2 )
let res2 : number = sum_of_doube( 1.2, 2.3 )
if( compare_equals(res1, res2) ){
...
}
, , , “”
: Box Circle
class Box {
width : number
height : number
constructor( w: number, h: number ){
this.width = w;
this.height = h;
}
}
class Circle {
radius : number
constructor( r: number ){
this.radius = r
}
}
, ,
let boxs : Box[] = [ new Box(1,1), new Box(2,2) ]
let circles : Circle[] = [ new Circle(1), new Circle(2) ]
2 , ,
function areaOfBox( shape:Box ):number { return shape.width * shape.height }
function areaOfCircle( shape:Circle ):number { return shape.radius * shape.radius * Math.PI }
:
boxs.map( areaOfBox ).reduce( (a,b,idx,arr)=>a+b ) +
circles.map( areaOfCircle ).reduce( (a,b,idx,arr)=>a+b )
, / (, ).
, - , , - .
/ - area():number.
interface Shape { area():number }
, Box Circle Shape, areaOfBox, areaOfCircle area.
class Box implements Shape {
width : number
height : number
constructor( w: number, h: number ){
this.width = w;
this.height = h;
}
area():number {
return this.width * this.height
}
}
class Circle implements Shape {
radius : number
constructor( r: number ){
this.radius = r
}
area():number {
return this.radius * this.radius * Math.PI
}
}
,
let shapes : Shape[] = [ new Box(1,1), new Box(2,2), new Circle(1), new Circle(2) ]
shapes.map( s => s.area() ).reduce( (a,b,idx,arr)=>a+b )
, -
Shape, (.. ) (Box, Circle).
, Box Circle Shape.
, ..
let a = b
, :
a b - ,
a , b - a - -
a b, b - () - - - .
a b - - .
, Shape
class Foo {
}
let shapes : Shape[] = [ new Box(1,1), new Box(2,2), new Circle(1), new Circle(2), new Foo() ]
shapes.map( s => s.area() ).reduce( (a,b,idx,arr)=>a+b )
- :
> tsc index.ts
index.ts:31:84 - error TS2741: Property 'area' is missing in type 'Foo' but required in type 'Shape'.
31 let shapes : Shape[] = [ new Box(1,1), new Box(2,2), new Circle(1), new Circle(2), new Foo() ]
~~~~~~~~~
index.ts:2:5
2 area():number
~~~~~~~~~~~~~
'area' is declared here.
Found 1 error.
Foo area, Shape.
SOLID
L - LSP - (Liskov substitution principle): « ». . .
-
-, , , .
, Scala :
package xyz.cofe.sample.inv
object App {
// , String, Boolean, : (String)=>Boolean
def strCmp(a:String):Boolean = a.contains("1")
// , Int, Boolean, : (Int)=>Boolean
def intCmp(a:Int):Boolean = a==1
// , String, Boolean, : (Any)=>Boolean
def anyCmp(a:Any):Boolean = true
def main(args:Array[String]):Unit = {
// Boolean = Boolean
val call1 : Boolean = strCmp("a")
// - Any = Boolean
val call2 : Any = strCmp("b")
// : (String)=>Boolean = (String)=>Boolean
val cmp1 : (String)=>Boolean = App.strCmp;
// - (String)=>Boolean = (Any)=>Boolean
val cmp2 : (String)=>Boolean = App.anyCmp
// : (String)=>Boolean = (String)=>Boolean
val cmp3 : (Any)=>Boolean = App.anyCmp
// !!!!!!!!!!!!!!!!!!!!!!!
//
// - (Any)=>Boolean = (String)=>Boolean
val cmp4 : (Any)=>Boolean = App.strCmp
}
}
Scala:
Any
-
Int, Boolean, String
-Any
,
:
(_,_)=>_
= .
/= .
val
Scala,const
JS
:
// Boolean = Boolean
val call1 : Boolean = strCmp("a")
// : (String)=>Boolean = (String)=>Boolean
val cmp1 : (String)=>Boolean = App.strCmp;
cmp1 - , , :
(String)=>Boolean (String)=>Boolean
-
// - Any = Boolean
val call2 : Any = strCmp("b")
// - (String)=>Boolean = (Any)=>Boolean
val cmp2 : (String)=>Boolean = App.anyCmp
call2, , cmp2.
(String) => Boolean (Any) => Boolean
String -> -> Any - -.
, WTF? - !
// , String, Boolean, : (String)=>Boolean
def strCmp(a:String):Boolean = a.contains("1")
// , String, Boolean, : (Any)=>Boolean
def anyCmp(a:Any):Boolean = true
cmp2( "abc" )
"abc"
anyCmp(a:Any)
, String Any, .
anyCmp( "string" )
anyCmp( 1 )
, anyCmp( true )
- ,
,
()
.. , - , -.
:
-
assign a <- b
- -
call a -> b
, :
-,
-,
Scala, TypeScript
TypeScript 4.2.4 - /
interface Shape {
area():number
}
class Box implements Shape {
width : number
height : number
constructor( w: number, h: number ){
this.width = w;
this.height = h;
}
area():number {
return this.width * this.height
}
}
class Circle implements Shape {
radius : number
constructor( r: number ){
this.radius = r
}
area():number {
return this.radius * this.radius * Math.PI
}
}
class Foo {
}
const f1 : (number)=> boolean = a => true;
const f2 : (object)=> boolean = a => typeof(a)=='function';
const f3 : (any)=>boolean = f1;
const f4 : (number)=>boolean = f3;
const _f1 : (Box)=>boolean = a => true
const _f2 : (any)=>boolean = _f1
const _f3 : (Shape)=>boolean = _f1
const f3 : (any)=>boolean = f1;
const _f3 : (Shape)=>boolean = _f1
( ) ,
user@user-Modern-14-A10RB:03:14:17:~/code/blog/itdocs/code-skill/types: > ./node_modules/.bin/tsc -version Version 4.2.4 user@user-Modern-14-A10RB:03:16:53:~/code/blog/itdocs/code-skill/types: > ./node_modules/.bin/tsc --strictFunctionTypes index.ts user@user-Modern-14-A10RB:03:18:26:~/code/blog/itdocs/code-skill/types: > ./node_modules/.bin/tsc --alwaysStrict index.ts user@user-Modern-14-A10RB:03:19:04:~/code/blog/itdocs/code-skill/types:
, .
-/-
.
!
, , .
- - , .
- - .
C , JS , , .
- , .
, , .
:
:
( )
( )
( )
( )
( )
( )
, .
- ( ) - .
.
La variation est tout d'abord la présence de propriétés/méthodes d'intérêt pour nos tâches. Et c'est un mécanisme de contrôle du compilateur pour s'assurer que ces propriétés sont présentes.
Ainsi, par exemple, tel ou tel objet peut être non seulement une sorte de sous-classe, mais également implémenter (via des interfaces) les propriétés/méthodes qui nous intéressent - c'est ce que j'entends par le mot compatibilité .
Ensuite, vous pouvez parler d'héritage multiple, de traits et d'autres charmes des langues modernes, mais cela dépasse le cadre du sujet.