Hacker News Reader

Comment by carlob | Hacker News Reader

    x = random.choice([1, "foo"])

this is given as an example of why Python could never be strongly typed.

Honest question: isn't this solved using Either in Haskell?

View on HN

Using Either in Haskell would require changing the program a little to add injections. But that exact program (modulo syntax) can be written in Typed Racket:

    #lang typed/racket
    
    (: choose : (All (A) (Listof A) -> A))
    (define (choose e)
      (list-ref e (random (length e))))
    
    (define x (choose (list 1 "foo")))

Unfortunately, people tend to assume that "type systems" and "the type system in Java/ML/Haskell" have the same level of expressiveness.

I just realized that all programs have types and type systems. Some dynamically typed programs have hairy n-dimensional fractal type systems that no human would ever figure out (usually from bad code).

The inferred languages just have this dude that watches your code and says, "yeah, I understand what is going on, your stuff is internally consistent"

Well, I don't think that's correct -- it would make the term "type system" meaningless. In particular, lots of programs have bugs that type systems can catch.

For more on whether all programs have types, I wrote this: https://medium.com/p/8a3b4bedf68c

I don't think it makes the standard definition of "type system" meaningless. Maybe what I am referring to above is a "type space".

I agree with some of what you said in the medium link. Python does have a type system, structural and dynamic strong. The way the plus operator works was a mistake, Lua is superior in this regard.

Take a look at the type inferencing that Shedskin and RPython in PyPy can do. If there wasn't a type system, how are those 'static strong' programs created?

The programer and the program has a type system where the language may not.

What is a "type space"?

As I say pretty explicitly in linked post, Python doesn't have a type system. Also, the term "strong" type system doesn't mean anything. Also^2, "structural" type systems are about how types are compared, and to whatever degree Python compares types, it isn't structurally.

RPython is a different programming language, which is statically type. Shedskin is similar.

http://stackoverflow.com/questions/2351190/static-dynamic-vs...

RPython and Shedskin as not different languages, they are subsets. All programs in RPython and Shedskin are proper python programs with the same semantics.

First, as the second answer points out, the terms "strong" and "weak" shouldn't be used and are confusing.

Second, having a type system makes a language very different! Language subsets are different languages.

So when I use quickcheck with Python or Erlang I am creating a different language? Linguistically I don't understand how a proper Shedskin program which is also a Python program with the same semantics is in another language. By that definition, the runtime system effects what the language is, but this happens after it is written, so how can it do that?

No, quickcheck is a testing tool, not a type system. It never rejects your program.

What you're saying is that Shedskin and Python have a non-empty intersection. But would the language of numbers with `+` be the "same language" as Python? It has the same relationship as Shedskin.

We might run out of reply space.

I made a mistake when I said quickcheck, I was thinking of the combination of Dialyzer and Typer in Erlang ( http://www.slideshare.net/konstantinvsorokin/kostis-sagonas-... )

I think I get what you are saying, that you have to take the totality of language in the current context.

And I would have to say yes, the language of numbers with "+" is in fact Python. I think it is also Haskell and lots of other languages. If I look at a corpus of language through a slit, I will always see a subset of that language. But it doesn't stop being that language by looking at with a microscope. What happens we see a code snippet like

  a = 5 + b - 10

We don't know what language it is, but it doesn't matter. It is valid Ruby,Python,Lua,JavaScript, etc.

Are we,me splitting hairs? I am just a layperson, I would like to fix any discrepancies in my knowledge.

http://www.haskell.org/haskellwiki/Heterogenous_collections lists some solutions

s/strong/static/

You're right, but Haskell is also statically typed and can be compiled, so my question still holds.

Rather than saying that Haskell solves this with the `Either` type, I believe it is more accurate to say that in this case, the return value of `random.choice` would be a "sum type." But the actual type would be dependent on the value passed to `random.choice`.

No, using the Either type wouldn't be the same at all. Yes, you can do choice [Left "foo", Right 42] (from Data.Arbitrary, used by QuickCheck) but it's not really the same thing. The two elements in the list both have the type Either String Int, unlike the Python example. Further, an Either can have only two possible kinds of values (but no-one prevents you from writing data Either3 a b c = Left a | Middle b | Right c).

You can achieve something like this with type classes, though. This is somewhat similar to requiring all the elements to fullfill an interface, kind of like List<Comparable> in Java-like languages. With existential quantification (there are other options) you can make a list where every element in a list can be of a different type as long as they derive from the same type class (like Eq, Ord, etc). The type class is still a constraint that Python doesn't have but it makes static typing possible.

See the heterogenous collection link above.

Reply on news.ycombinator.com