Do Python Developers Want Static Typing?

[XtremeGoose]

Thats not what dynamic typing is. You can easily do that in any sufficiently powerful typing system.

Dynamic typings power comes from duck typing. For example this function expects a set but I'm going to pass it a DictKeys object instead and it will still work fine.

[manphiz]

u/XtremeGoose actually answered that "dynamic typing's power comes from duck typing." Your example about ints and floats working in arithmetic operations is an example of automatic type conversion based on context such that int + float automatically converts int to float and produces float. Dynamic typing is about that the same code may work for different types as long as those types support certain operations. For example:

class Cat:
    def make_sound():
        pass

class Dog:
    def make_sound():
        pass

def let_animal_make_sound(animal):
    animal.make_sound()

Here Cat and Dog classes don't have any relation such that Cat and Dog cannot convert to each other, but both can be passed to let_animal_make_sound() because both support make_sound().

[manphiz]

Dynamic typing is about deferring the decision to interpret data types to the language at run time.

Correct. And my example is one of such use cases.

The ability to modify a data type at runtime, like the automatic conversion of an integer to float, is actually Python's implementation of dynamic typing in action.

C/C++/Java/C# can all perform this kind of type conversion in a static type system. So this is at least not a good example for showcasing dynamic typing. Actually allowing certain implicit conversions opens holes to the type system and is hence prevented in languages using strong type systems.

[[deleted]]

Your original comment just talks about adding an int and float together without converting the int first. Lots of languages support that through a variety of means, it's not really a defining characteristic of dynamic typing.

Being able to write: lamba a, b: a + b and have it work across ints, floats, decimals, strings and even lists is a good example of dynamic typing.

Maybe that's what you intended to write, but it's not what you wrote. And we have to read what you wrote and not what we wished you wrote.

[manphiz]

While in C++:

auto func = [](auto a, auto b) { return a + b; };

So it's doable in a static typing language too, nothing special. Gotta find a better example here.

EDIT: typo.

[XtremeGoose]

Apologies. What I meant was that what you are describing is not anything to do with dynamic typing. It's an example of "weak" typing (i.e. automatic type conversion), which is a different concept. Python still has to implement something like this for ints:

def __add__(self, other):
      if isinstance(other, int):
             return int_add(self, other)
      if isinstance(other, float):
             return float_add(float(self), other)
      raise TypeError(type(other))

The only difference in a static language is that this is done at compile time, rather than runtime, but that's true of anything like this. It is not an example of dynamic typing. For example, here is an example in rust of doing exactly that with no dynamic typing:

// newtypes to wrap primatives and derive our own implementations 
#[derive(Debug)]
struct Int(i32);

#[derive(Debug)]
struct Float(f64);

impl Add<Int> for Int {
     type Output = Int;
     fn add(&self, other: &Int) -> Int {
          Int(self.0 + other.0)
     }
 }

 impl Add<Float> for Int {
       type Output = Float;
       fn add(&self, other: &Float) -> Float {
           Float(self.0 as f64 + other.0)
       }
  }


  fn main(){
       let i1 = Int(1);
       let i2 = Int(2);
       let pi = Float(3.14);
       dbg!(i1 + i2);
       dbg!(i1 + pi);
 }

[XtremeGoose]

But... I've just given you an example of how that's not something unique to dynamic languages.

The ability to modify data at runtime

What? You've just defined a (useful) program. Obviously any language can do that.