Rendered at 10:22:30 GMT+0000 (Coordinated Universal Time) with Cloudflare Workers.
Panzerschrek 5 hours ago [-]
In my programming language I have some sort of "borrowing" too (although it's named differently). But my language has no dynamic typing, only static typing is used and thus all checks are compile-time and have no runtime cost. Why bothering with dynamic typing and paying runtime costs for it?
jamii 5 hours ago [-]
> The goal is that most of your code can have the assurances of static typing, but you can still opt in to dynamically-typed glue code to handle repls, live code reloading, runtime code generation, malleable software etc.
Pay08 4 hours ago [-]
Dynamic typing is neat, I actually prefer it to static typing. Most people who think they have a problem with dynamic typing actually have a problem with weak typing.
pie_flavor 15 minutes ago [-]
The standard complaint of pointless type errors that static type analysis would catch has nothing to do with weak typing, nor does the other one about unreliable listing of available ops in your editor by pressing `.` and looking at the autocomplete list. If you think the only thing people think is wrong about dynamic typing is JS `==` then you are swinging at a strawman from a decade ago.
choeger 4 hours ago [-]
Dynamic typing is no typing.
The point of types is to prove the absence of errors. Dynamic typing just has these errors well-structured and early, but they're still errors.
Pay08 3 hours ago [-]
Errors that you can recover from. I simply appreciate the added flexibility. Have you ever tried making a container of arbitrary types in C++?
SuperV1234 1 hours ago [-]
You cannot do anything meaningful with a container of arbitrary types, it's just bad design.
If you want to apply the same operation on all of them, then they share some API commonality -- therefore you can use polymorphism or type erasure.
If they don't, you still need to know what types they are -- therefore you can use `std::variant`.
If they really are unrelated, why are you storing them together in the same container? Even then, it's trivial in C++: `std::vector<std::any>`.
lmm 3 hours ago [-]
If C++ was the only static type system I'd experienced, I would also think it was a bad idea. Have you ever used an ML-family language?
Pay08 3 hours ago [-]
Nope. Closest thing I have used was probably Haskell.
lmm 3 hours ago [-]
Haskell ought to be good enough. Did you struggle with making your containers there?
Pay08 3 hours ago [-]
Interestingly enough, I have never needed them there. Granted, I have written a few orders of magnitude less Haskell than I have C++. Still, the difference is worth interrogating (when I'm less sleep deprived).
teaearlgraycold 4 hours ago [-]
Yes to dynamic typing. Yes to static analysis.
Pay08 3 hours ago [-]
What?
antonvs 4 hours ago [-]
Technically, in a type theory context, there’s no such thing as “dynamic typing”. Types are a static, syntactic property of programs.
The correct term for languages that don’t have syntactic types is “untyped”.
> Most people who think they have a problem with dynamic typing actually have a problem with weak typing.
All people who say things like this have never studied computer science.
_flux 3 hours ago [-]
The term unityped is used as well, and at typing level this also makes sense: you have one type called object, you put that object alongside the value object ("tag"), and then at runtime all operations on that object check if its type object provides the operation the code is trying to apply on it (or maybe each value object directly knows the operations it supports). I think I prefer this term.
"syntactic type" is a weird term to me, though. Is that in common use?
drabbiticus 2 hours ago [-]
Can someone help confirm whether I understand correctly the semantics difference between the final-line eval of
x^
vs.
x*
?
It seems like either one evaluates the contents of the `box`, and would only make a difference if you tried to use `x` afterwards? Essentially if you final-line eval `x^` and then decide you want to continue that snippet, you can't use `x` anymore because it's been moved. Awkwardly, it also hasn't been assigned so I'm not sure the box is accessible anymore?
The point of types is to prove the absence of errors. Dynamic typing just has these errors well-structured and early, but they're still errors.
If you want to apply the same operation on all of them, then they share some API commonality -- therefore you can use polymorphism or type erasure.
If they don't, you still need to know what types they are -- therefore you can use `std::variant`.
If they really are unrelated, why are you storing them together in the same container? Even then, it's trivial in C++: `std::vector<std::any>`.
The correct term for languages that don’t have syntactic types is “untyped”.
> Most people who think they have a problem with dynamic typing actually have a problem with weak typing.
All people who say things like this have never studied computer science.
"syntactic type" is a weird term to me, though. Is that in common use?
It seems like either one evaluates the contents of the `box`, and would only make a difference if you tried to use `x` afterwards? Essentially if you final-line eval `x^` and then decide you want to continue that snippet, you can't use `x` anymore because it's been moved. Awkwardly, it also hasn't been assigned so I'm not sure the box is accessible anymore?