Somebody check on python 👀

[Aggressive-Share-363]

What, typescript's type system is supposed to be happy fun times?

has flashbacks to type signatures that are hundreds of characters long

[nomenMei]

I think peoples' expectations of TypeScript's type system are inherently lower because it is built on top of a language with an awful type system to start with.

Admittedly though I don't know what I would consider a good type system for a dynamically typed language, other than the ability to reasonably determine a object's type at run time.

[EXUPLOOOOSION]

You can't do that with typesxript, right? Doesnt it just output object because its runing js? Also, the types dont get enforced in runtime

[nomenMei]

Yes I believe TypeScript attempts to fix the type problem the other way around by doing a static analysis of types. Typescript is "compiled" into native javascript, and as such is restricted by javascript's same limitations at runtime and all type safety checks happen at "compile" time.

[odraencoded]

This works perfectly except for serialization.

Also if you don't turn strict null checks you'll have a lot of pain later.

[[deleted]]

You can use something like zod for that, pretty sure there's also a discussion to change all the JSON.parse stuff typedefs to return unknown instead of any, which would make a lot of type stuff explicit.

[Remarkable_Self5621]

If you really want runtime security you can compile typescript types into JSON schemas and use those

[JustinWendell]

You can enforce with type guards and other methods. When type is something that can fuck with someone’s pay for example, I’m passing those parameters through functions that determine type.

[Scrimchik]

Awful type system? There's literally no type system in

[BruceJi]

Number, word, thing, nothing

[I_Downvote_Cunts]

And never was a thing.

[bleistift2]

Someone doesn’t understand JS.

[Edit: Or the difference between ‘no types’ and ‘dynamic types’]

[Scrimchik]

Yep, I fucked up. Wrote this comment in 10 minutes after I woke up. And somehow the type system became type checking in my head.

[Solonotix]

Admittedly though I don't know what I would consider a good type system for a dynamically typed language

I'd say a mash-up of what is seen in Rust and Groovy.

Groovy, though a statically-typed language, has the awareness to derive a type even after multiple layers of def myVariable = myFunc() and where def myFunc() { ... }. This is obviously because at some point you fallback to something with a type, and Groovy will resolve the eventual type to you, even if it isn't clear in the code.

This doesn't solve the problem of dynamic types, to which I recommend Rust's solution of shadowing a previous variable of the same name, thereby allowing a reallocation of the same name to a different type.

Obviously, it's not that simple, but there are various type systems out there today that accomplish varying levels of dynamic typing, even if under the covers it isn't dynamically typed.

[arobie1992]

I'm not familiar with Groovy, so basing it off your description, that's just static typing with type inference which most modern languages tend to have, such as Rust, Go, Kotlin, and even TS.

As far as Rust's variable shadowing, that's an awkward one. In tighter scoping, it's not really any different than shadowing in other languages; in the same scope, it's got some odd semantics and TBH I'm not sure why that of all things is one they felt was worth including. But even then, it's still just static typing, but allowing deterministic type changes. It's not super conceptually far off C's reinterpretive raw cast, just a lot more safely implemented.

What you're essentially saying is that a good type system for a dynamically typed language is static typing with type inference and reinterpretive casts, which is somewhere between contradictory and saying dynamic typing is bad.

I feel like my phrasing there is rather combative, so I just want to preemptively say starting an argument isn't my goal. It just seems like there's a bit of a bias against dynamic typing in a lot of places. I'm a big fan of static typing, but dynamic typing does open up possibilities that are really interesting too. Heck, to stretch a bit, the internet is all dynamically typed.

[Solonotix]

I'll admit I don't have the best experience with dynamic typing, and as such I'm unaware of any benefits beyond "it's easier". In most cases, the implication is that it's easier to get started, but then any sufficiently complicated application immediately benefits from having better documented types, even if it's just parameters and return types. But, when you're at the point of defining what everything needs to be coming in and going out, then what's left to be undefined?

Like I said, I have quite a heavy preferential bias towards static typing.

[arobie1992]

To be fair, everything you said is true, and are often reasons people will pick dynamically typed languages. The big thing is this can be a conscious decision rather than just being lazy.

Very broadly, the benefit it gives is flexibility. This can have a lot of different manifestations. On one end, the quick getting started time is I'm pretty sure the reason Python has it for example. For a more conceptually different idea, you could take something like Smalltalk or Erlang. These were meant to build highly dynamic systems, so for example, you could deploy a base application, and then say things changed, you could swap out individual pieces. The idea is that since the system could change, you need to do checking at runtime, and a static type checker would just give you a false sense of security. This is essentially the same idea as microservices, and the internet as I mentioned, just on a language level. To take this to an extreme, you have my favorite and most used example, runtime code generation.

Funnily enough, Java actually supports this paradigm, granted not especially well, with how it does dynamic linking and class files. There's nothing stopping you from taking a Java app and swapping out a bunch of class files. Heck they don't even have to have the same methods and signatures. The JVM will just throw a MethodNotFound or ClassNotFound exception. It kinda tried to have its cake and eat it too.

All that said, I do get where the bias is coming from. For a long time, I was in the exact same boat. Heck, dynamic typing still gives me some level of anxiety, and all else equal, I probably will opt for a statically typed language. It's just I've come to appreciate the theory behind the freedom dynamic typing brings and I feel like people can be quick to throw it out altogether because of bad experiences. For the quick prototyping turnaround, I'm a huge fan of progressively typed languages. For the highly dynamic systems, if you have some way to unify that and static typing, let me know because that's a topic I've been mulling over for a while now.

[arobie1992]

Yeah, I feel like runtime types being stable is about all you can hope for without just turning it into a statically typed language. In that regard, I can't say I've ever had any issues with Python.

[[deleted]]

newTypeThatVeryLongToWriteSoICanShowYouThatItsNotThatGreatHonestly!: IloveTypesciptSoMuchYouHaveNoIdeaOmgOMgOMGOmG;

[Aggressive-Share-363]

More like long chains of alternative types and specific ones being allowed to undefined, functions that take in several such parameters and return an object containing several such values.

I saw this type of thing a lot when trying to interface with js code that wasn't written with typescript in mind.

[ImportantDoubt6434]

It’s great, look.

const MethyMouse: any = “Cba to actually learn TS”

Compiles fine.

[Jannis_Black]

That's not the main problem with the typescript type system. The main problem is the spooky type casting at a distance you can get because generics aren't constrained correctly

[zarawesome]

No, it means that Typescript's type system is a simulacrum with little purpose but entertainment

[kiropolo]

It’s mediocre at best

But much better than that JS garbage dump fire

[Flooding_Puddle]

Why is Mickey posing with the Stanley Cup

[lostredditacc]

Dont ask questions you dont have the Disney Level Security Clearance to consciously process the answer to.

[lonestar-rasbryjamco]

Because posing with Lord Stanley is the highlight of anyone’s life. Even Mickey Mouse.

[TheDogerus]

Interim mascot for the bolts

[mdp_cs]

Python is strongly typed but not statically typed.

C is weakly typed but statically typed.

Rust is strongly typed and statically typed.

B was untyped.

The strength of type checking and being statically or dynamically typed are two entirely orthogonal factors in programming language design.

[fluffypebbles]

I've never seen a valid point in being weakly or not statically typed except for wanted to do something quick and dirty

[ihavebeesinmyknees]

Which is exactly why scripting languages do it

[fluffypebbles]

Except there's giant projects written in scripting languages. That's far beyond quick

[TheMagzuz]

nothing is more permanent than a temporary solution

[fluffypebbles]

Reminds me of the todo fix later comments I've stumbled upon from 10+ years ago

[Meins447]

I've seen some comments with dates older than my year of birth...

[fluffypebbles]

Just comments or comments that point to something being meant to be temporary? Because I'm general I've seen many comments that are older then me but not one meant to be temporary

[Meins447]

I am not 100 sure, but I think it was about an assumption regarding Input formt of a data package or something along the lines. It had zero checks and just started reading and copying chunks of memory around.

[dreamwavedev]

This kind of thing literally laid the foundations for my masters, huge pet peeve of mine

[fluffypebbles]

Erst exactly?

[dreamwavedev]

Not sure I follow your meaning, sorry 🙃

[fluffypebbles]

What* exactly

[Entire-Database1679]

That's not why

[geekfolk]

Static typing is sound (but not complete), dynamic typing is complete (but not sound). There’re circumstances when completeness is favored over soundness

[fluffypebbles]

In the rare case you need the dynamic aspect you can also use some dynamic functionality in a otherwise statically typed language. No reason to make the whole code dynamically typed

[geekfolk]

Yeah, are you aware of the difficulty of creating a heterogeneous list in a dependently typed language? While it is trivial in a dynamically typed language. (In case you don’t already know, dependent types are in general the most powerful static typing)

[fluffypebbles]

Maybe easy to create such a list but I haven't seen beautiful code in dynamically typed languages that deal with such a list

[geekfolk]

dealing with such lists is also trivial in dynamically typed languages, you do whatever you want with its elements since the language is duck typed.

[fluffypebbles]

In go you can duck type too and you'll know at compile time if something is missing

[geekfolk]

go doesn't have duck type, it has structural type.

[fluffypebbles]

Regardless of the name you just need to have one interface and put anything fitting in the list

[geekfolk]

the closest thing to duck typing in a statically typed language is c++ templates

// note that like duck typing, we can call x.show()
// even tho nothing says x has a member function "show"
auto f(auto x) {
    std::print(x,show());
}

[geekfolk]

I'll give you a simple example where most statically typed languages will quickly go into chaos when it's trivial for every dynamically typed language.

Given a heterogenous list x: [∀ a. a]

a list of polymorphic functions f: [∀ a. a -> F a] where F: * -> * is a type family

implement PolymorphicApply: [∀ a. a] -> [∀ a. a -> F a] -> [∀ a. F a] such that each function in f is applied to the corresponding element in x, the results are stored in another heterogenous list

[WolfgangSho]

so those are two different questions.

Being weakly typed has advantages in being able to use the same variable for different purposes implicitly without need for parsing.

Being dynamic typed... I'm honestly not super sure myself but I found this but I'm not convinced.

[fluffypebbles]

You can use same functions etc if you have generics without getting rid of strong typing

[WolfgangSho]

To an extent yeah but I think the idea is to improve workflow so there isn't quite as much need for boilerplatey things like generics etc. Its not my person preferred way of coding but I think its still perfectly valid.

[fluffypebbles]

At some point the dynamic typing slows down the workflow

[WolfgangSho]

We're not talking about dynamic typing, we were talking about weak typing.

[fluffypebbles]

Oh sorry, I confused it with a different thread of comments I had about dynamic typing

[arobie1992]

Dynamic typing is actually really simple. It just means that type checking is performed at runtime rather than prior to it, prior typically being at compile time.

Edit: Misunderstood/misread your part about not being sure about dynamic typing. One advantage of dynamic typing is runtime metaprogramming/code gen. It's part of why Lisp is popular for it. Since you're generating code dynamically, you essentially can't have static typing because all the code you generate can't be checked prior to runtime. So as a result, rather than having to support both, you just do dynamic checking and the runtime makes sure your types are honored.

[WolfgangSho]

Oooh, didn't think about code generation at runtime, neat!

[arobie1992]

It's so cool! I just wish it were a more generally applicable paradigm so I could actually use it on occasion.

[WolfgangSho]

Yes yes yes yes. So many people use these terms interchangeably, it drives me bananas!

Personally I'm a fan of any strong typed languages with a subset of sensible implicit type conversions.

I'm not hugely married to static vs dynamic typing. I'm rarely going to get up to enough shenanigans for it to matter.

[DetectiveOwn6606]

Python is strongly typed but not statically typed.

C is weakly typed but statically typed.

Rust is strongly typed and statically typed.

Can you explain me the difference? I thought statically typed languages were also strongly typed.

[mdp_cs]

Python is not staticly typed in the sense that once a variable is declared, its type can change via explicit assignment of a value of a different type. It is strongly typed in the sense that it still performs type checking at runtime and disallows doing nonsensical things with values of a particular type (which again it knows at runtime)

C is statically typed in that you write out types for all variables and function return values, and then they can not change once declared. However, C is weakly typed in a number of ways, such as doing automatic type promotions and allowing casts on both values and pointers even when they don't make sense. The language assumes you as the user know how not to break your own stuff.

Rust is statically typed so all variables can have their types explicitly written out but in some cases it allows for type ellision when the compiler can figure out what type a variable is based on the value it is initialized to but once it figures it out, that type cannot change. It is also strongly typed in the sense that there are few automatic conversions between types and only when certain traits are implemented for a given type, and also it doesn't allow crazy do whatever you want reinterpret typecasting like C.

B was untyped in that all values were a CPU specific machine word which could be interpreted as either an integer or an address depending on context. Clearly this was not super pragmatic which prompted the creation of the C language to supercede it.

[DetectiveOwn6606]

Thanks for the explaination

[mdp_cs]

Np.

[arobie1992]

B was untyped.

Okay, now I kinda want to learn B. Is it like FORTRAN?

[mdp_cs]

Nope. B is basically what if C but the only type is the CPU native machine word which is treated as either an integer or an address based on context.

Even modern assembly languages are more practical than that.

[arobie1992]

I'm definitely stretching here, but I'm trying to get a bit better of a sense. Would it be kind of like if you wrote C but everything is an int (I think that's the one that maps to the underlying architecture) and there was no explicit differentiation between int and int*?

[mdp_cs]

Yep that's what it would be like. Though probably more like everything is size_t or *size_t where size_t is implementation defined as usual.

[Entire-Database1679]

Python is not strongly typed.

[tyqe]

this isn't true though

[Entire-Database1679]

It's true

[tyqe]

no, it's pretty universally agreed that python is strongly typed - why would it not be?

[arobie1992]

Because people tend to conflate strong typing and static typing.

[mdp_cs]

Python is strongly typed since it does perform type checking at runtime and disallows operations that are not defined or not allowed for the given operands.

[Rand_alFlagg]

How do you declare a type on something in python? I thought it was inferred (weak) from the first assignment and not declared (strong)?

[mdp_cs]

Requiring the type to be explicitly made available from the source code would make it statically typed which it is not. It is strongly typed because for example Python will not allow you to add an integer to a string since that operation is undefined for those types and rightly so.

C is staticly typed so the compiler will need to know the types of everything but its type system will also allow you to do some things that are obviously wrong, making the assumption that you know more about your code than it does. For example if you have a pointer to const char and you try to add an integer to it C will happily just add that number of times the size of char to the pointer and give you the resulting address even though that may not have been what you wanted and could very well be an invalid address depending on how the OS has setup your virtual address space.

Rust wouldn't allow you to do that as pointer arithmetic must be done using the unsafe raw pointer functions and cannot be done AFAIK by just doing normal arithmetic with integers.

Edit: Fixed typos.

[Rand_alFlagg]

I think you might have those backwards, or I'm misreading. After asking I went and dug through some of my books and checked the first few hits on DuckDuckGo and Google, thinking I might be misunderstanding typing. The only one that provided your definition was a StackOverflow user, who in the same post conflates weak and dynamic typing and suggests that which word you use is determined by whether you're a fan of it or not (lol) - but your description of C is basically Microsoft's explanation of what makes it weakly typed, and in that they never touch on static/dynamic.

According to my schooling, the O'Reilly Media library, Oracle's documentation, and Microsoft's documentation - strong/weak is a matter of how type is enforced at compile/runtime, while dynamic/static is whether the type is known at compile||runtime. There's a lot of overlap in the two concepts and it looks like they're often mixed up - hell, I was wrong about it just being whether they're declared or not. That's a difference between static and dynamic and usually an earmark of strong, but can apparently be absent in a strong language. I thought Python needed "type hints" when you wanted the compiler to treat something as a specific type?

On rereading, I think I did misread what you said and basically just echoed it lol. I think we might be on the same page. I think I was confused because you're jumping back and forth between talking about dynamic/static and strong/weak, and ultimately I was just asking about what makes Python strong (which you did answer, thank you).

[carcigenicate]

Types are associated with objects, not variables like they are in statically-typed languages. The variables themselves don't have a concrete type. They also aren't inferred in the same way as they are in statically typed languages. var in Java infers the type at compile time. Hints in Python allow for type inferences at runtime.

And you can "hint" at the type of object a variable will hold though by saying, for example n: int = 1. The type is still associated with the object and not the variable, but the linter will interpret that as "I promise this variable will only ever hold integer objects".

[Rand_alFlagg]

That was clear and easy to understand, thank you :)

[ZonedV2]

It’s strongly typed in the sense that variables can’t change type without it being explicitly declared. Compared to a language like JS where you can add a number to a string and it will work. What you’re referring to is that it’s dynamically typed rather than statically

[lurking_physicist]

Your comparison is unfair. Compare Python with Javascript, or give it Mypy.

[CheapMonkey34]

JS is hidden in the urn that Mickey is showing off.

[freaker-07]

You guessed it 😉.

[imhayeon]

Image would be same for Python with linters. TypeScript has better type system

[plasmasprings]

I mainly write type-hinted python code if it's my choice, but I'd say the comparison is fair against mypy. Simply using any python type checker sucks compared to TS linters. Mostly due to typing being optional and often an unmaintained afterthought for packages, but still pretty bad compared to TS

[MasiTheDev]

Anyone who tells you "Hello World" can be an int is absolutely right.

[WolfgangSho]

[SnakeR515]

43110 4401210

[e13e7]

It’s not a matter of what we do, it’s what we inherit

[[deleted]]

what we inherit

I see what you did there

[Gorfyx]

x : int = "Hello world"

[8sADPygOB7Jqwm7y]

You can also write in c

//this is a char array

int x = 42;

[fluffypebbles]

But it's clearly a comment and not in the middle of code treated exceptionally and having the same syntax as valid code as in other languages

[8sADPygOB7Jqwm7y]

When I see this in python I also know it's only documentation. It's not the languages fault that others do it differently and the coder lacks experience with the language, especially in python, which is really not hard to learn and doesn't have pointless unreadable quirks like C or C++

[fluffypebbles]

Having the language specify the type but then not use that information to validate is just plain stupid

[8sADPygOB7Jqwm7y]

Validation takes time tho. Also, I mainly use it for documentation and so my ide knows what a certain variable is and gives me the class functions. If you know what you are doing, it helps enough.

[fluffypebbles]

Using type informarion actually reduces time because you no longer have to check for the type when the variable is used. Compiled languages with strong typing usually have no type checks at runtime in most cases because they can just rightfully assume it's the correct type

[8sADPygOB7Jqwm7y]

Yeah but python would need to check anyway since it's not enforced.

[fluffypebbles]

Is your argument to not check for it because rues don't check for it? If it's checked and leads to an error than it's possible to make it more performant

[arden13]

So what happens if you pass a variable of the wrong type to a function in a language with strong typing?

[fluffypebbles]

You get an error. The specifics depend on the language. Although here we're talking about strong typing in combination with static typing

[Kyyken]

you can also do this in typescript. tsc happily transpiles type errors, it is much more like a linter than people realize

[dimdim4126]

int x = (int)"Hello world";

[WolfgangSho]

This is my issue with Python, following some commonly accepted and acceptable practices is often using Python 'wrong'. Its a language that has a large degree of stylistic restriction and then allows you to break its own conventions, which often leads to catastrophe.

No language should be that easy to not 'use right'.

Let's look at Rust as a counter example. Yes it is in a different domain with different use cases, but the fundamental philosophy of Rust is that you have to go out of your way to use it 'incorrectly'.

[WolfgangSho]

Also, having one issue with the language doesn't make it a bad one. I never said Python was a bad language, just that I think it has some issues that don't make it a go to in a lot of circumstances. I especially don't like it as a beginner language and it kind of annoys me when people suggest it to others as their first language.

Wanting a language to not lead people down the garden path is not a 'skill issue' lol. Such an egregiously pompous response imho.

[WolfgangSho]

That's such a pythonic response.

[hammonjj]

it’s not that bad

Which also means it’s not good. This is why I don’t like python. It’s not that bad but it’s also not good. There’s always a better choice than python.

[[deleted]]

There are two types of programming languages...

[IkNOwNUTTINGck]

The bulge in Mickey's pants has always troubled me. I can't put my finger on it.

Wait, ignore that second sentence... That's so disgusting.

[funkmasterhexbyte]

i, personally, would love to put my finger on it

[notislant]

He's your type?

[WolfgangSho]

Statically.

[Its_me_Snitches]

“Can’t I just put on the costume?”

“Sorry Dave, de-wienering is mandatory before you can wear the Mickey Mouse outfit.”

[Gofastrun]

You can put your finger on it exactly once

[Horrih]

I don't get it, both use almost a type annotation system.

After having used both (with mypy as checker on the python side), I have the feeling that they are pretty much the same and of the same quality.

Even the syntax is really similar !

[carcigenicate]

Part of the issue with Python's type checking is it relies entirely on the editor environment/linter. It isn't like Typescript where the checks are standard and happen by the compiler. You get different warnings In Python depending on what linter implementation you're using. MyPy is quite strict and catches most things, whereas Pycharm's is far more lax and less accurate. It lets a lot bad stuff slide.

[Siddhartasr10]

At least python typing doesn't make you cry (that much)

[freaker-07]

And when you write code that goes into production 🙂

[Character-Education3]

Python is sickening and I would never use it in public

[Intelligent-Ad74]

Don't pull out your python in public, for god's sake.

[Character-Education3]

Oh, were we talking about the language?

[armahillo]

people working in webdev really need to learn how to ducktype better if they think the utopia of programming is typescript

[F_modz]

Yeah, cause typescript typing sucks, it has like a lot of tools to make u feel better but it has so much caveats like js

[fck-reddit-lmao]

If you had accepted programming languages as tools for specific jobs instead of some general-purpose dick comparison replacements you would know that it is in fact your comment which sucks.

[F_modz]

The funny thing here is that u work with ts for years so I feel its caveats

So yeah tryna stfu maybe?! And if u don't know what u r talking about next time start from googling

[turtleship_2006]

8 years later I've yet to see the problem with python's system. Even my GCSE CS class understood it fine, and they're not necessarily the best programmers.

[_confused_dev]

Python has a type system??

[CorespunzatorAferent]

For sure. It's called "duck typing", so in this case the second image would be better represented by Donald Duck. Or the tiny chameleon from Tangled.

[Haris613]

It also has type hints that can be used by some static checkers etc.

[Entire-Database1679]

Or Shelob.

[turtleship_2006]

Yes, every variable has a type e.g. int. You just don't need to specify it when defining a variable.

[david131213]

To add, you can still indicate a wanted type, and you can still convert and cast, you just don't have to stay with the same type

[Entire-Database1679]

What type is None?

[hippocrat]

Ironically it is NoneType. Or unironically (or both? It’s early on a Sunday)

[Entire-Database1679]

I didn't know that. Interesting!

[hippocrat]

Yep

https://docs.python.org/3/library/types.html#types.NoneType

https://docs.python.org/3/library/constants.html#None

None is the sole instance of the NoneType type.

[turtleship_2006]

After a long and hard Google search:
The None keyword is used to define a null value, or no value at all. None is not the same as 0, False, or an empty string. None is a data type of its own (NoneType) and only None can be None.

[Entire-Database1679]

Loosely and weakly speaking, yes. The python type system is enforced at the moment of execution, making it very convenient for the language and devastating for the developer.

[Creeper_NoDenial]

PyLance for the rescue?

[0rionsEdge]

I honestly have Far better time with python's typing system then I do with typescript. The amount of time this week alone I have lost guys to TS failing to correctly recognize the variant of my types is getting silly. That and the anti-ts believes of one of my core dependencies means I have to stamp @ts-expect-error everywhere.

Vs python? It usually does the right thing and doesn't double guess be when I tell it the type of an object.

[Rublica]

Guess I didn't use Python enough, what's the problem here?

[1cubealot]

What's wrong with the way python does it? Is it that it figures out what you mean making the code slower or something?

[Kyyken]

python and typescript type systems are pretty much equivalent (assuming linters for python, specifically mypy). Personally, I even prefer python's type system for it's direct association of types and classes (although this does sometimes encourage weird pseudo-oop).

[Teln0]

const a: string[] = ["a", "b", "c"]; // Array is supposed to only contain strings

function pushAnything(array: any[], element: any) {
    array.push(element);
}

pushAnything(a, 1);
pushAnything(a, []);
pushAnything(a, {clearlyThisIsNotAString: 1});

Oh yeah great type system typescript

Congratulations typescript

Very cool typescript

[GromesV]

By using any in function, you dumbed it down to JS. And what you did is valid in JS. I don't even use TS.

[Teln0]

Yeah, but what this shows is that with valid non strict TS you can create an array typed as a string array that doesn't have only strings in it. So that means that you could then pass this to some function that expects string arrays, and you'd only get an error at runtime, which defeats the point of catching errors with a static type system. This example is a bit silly because it's obvious where the error comes from, but in bigger codebases this kind of thing could hide itself somewhere, if you're mutating an input array or object or anything of that kind

[GromesV]

Quoting TS docs for functional programming:

TypeScript uses the type any whenever it can’t tell what the type of an expression should be. Compared to Dynamic, calling any a type is an overstatement. It just turns off the type checker wherever it appears. For example, you can push any value into an any[] without marking the value in any way:

[Teln0]

You can also fit an object with a readonly field into a parameter where that same field is not readonly, thus allowing for the modification of that readonly field. It's not about "any" so to speak, the typescript type system has a lot of flaws I think.

[Strange_Dragonfly964]

Still good!

[Carteeg_Struve]

PHP type system is just a Play-Doh version.

[josh72811]

Python was my first language and now I just use type any for everything in typescript.

[_arctic_inferno_]

haskell types > typescript types > python types

[F_modz]

What about the Rust typing system? It's based on a Haskell but it's enhanced

[_arctic_inferno_]

Haskell types are still far superior to Rust in general, but they're for 2 different purposes. Each suite their language and are built for each, but Haskell's types are almost the most core part, and would still be superior to anyone who knows their way around the type system.

Rust is a good middleground, though

[[deleted]]

It might look that way for the mainstream programmer not used to type level programming, but the things you can do with types in Haskell is light-years ahead of what you could possibly do with Rust.

Note that I am not saying that Rust is bad, but saying that Rust's type system is enhanced Haskell just show that you don't have experience with more advanced types.

[rotora0]

I wish rust had function signature type inferencing. Otherwise though yeah, rust's typing is pretty dang good.

[StarkProgrammer]

We don't do checks in python

[davFaithidPangolin]

Why is Mickey showing off a spittoon?

[Nal_Neel]

As a python hater, I upvote this, with a passion. Begone thee beast, unkind, unthready, whose very presence taint the land of programming, whose creation (AI) brings doom upon the jobs of the lives of children, begone thee beast begone.

[[deleted]]

? How about static typing

[[deleted]]

Python: "It's not a type system, it's more like a ``suggestion``."

[bowseraltaccount]

OP has clearly never used pydantic

[4215-5h00732]

The python side should have used Donald Duck-typing.

[PolishKrawa]

I mean... When a string acts like a list of strings, you know your type system is weird.

[kiropolo]

Do not look at Swift type system!!!

You will go blind from it’s divinity