Show types of things in repl

[hdgarrood]

Suggested by @marick on twitter.

Can we copy Elm and Idris and print the type of something after evaluating it in the repl?

Eg:

Idris> \x => x +  1
\x => prim__addBigInt x 1 : Integer -> Integer

I'm not yet sure how this would interact with a) evaluating Eff actions and b) the Eval type class in psci-support; we would need to work that out.

Unfortunately I don't have much time to devote to this right now, but I wanted to make a note of this before I forget and hopefully I can look at it after the end of this semester (if nobody beats me to it).

[marick]

And moreover, I'd like an arbitrary function to tell me its type. As in Elm:

> List.take 3
<function> : List a -> List a

Seems that would always be more helpful than this:

> take 2

Error found:
in module $PSCI

  No type class instance was found for
                                         
    Data.Show.Show (Array t2 -> Array t2)
                                         
  The instance head contains unknown type variables. Consider adding a type annotation.

while checking that expression eval it
  has type Eff t0 t1
while applying a function eval
  of type forall a.                              
            (Eval a) => a                        
                        -> Eff                   
                             ( console :: CONSOLE
                             )                   
                             Unit                
  to argument it
in value declaration $main

where t0 is an unknown type
      t1 is an unknown type
      t2 is an unknown type

See https://github.com/purescript/documentation/blob/master/errors/NoInstanceFound.md for more information,
or to contribute content related to this error.

(Note that the key info -- Array t2 -> Array t2 -- is given in the error message, but not in way that a novice is likely to find.)

[garyb]

That's a slightly different issue - as the error says, the value can't be printed because there is no Show instance for it. psci would need some extra magic to be able to print values of any type.

You can ask for the type of any value using :t or :type though - that works even for values that cannot be printed with show.

[hdgarrood]

It is a slightly different issue but I think it makes sense to consider them together. In particular I think said extra magic is worth considering. What if, instead of printing that type error (which only makes sense with some understanding of psci's internals), we just treat that case the same as if the user had entered :type <expr> - is that feasible?

[garyb]

I'm not really an expert on psci, so I'm not sure - but it seems reasonable to me... perhaps we could inject a Show a instance that just prints <value> for everything at the end of Environment-building. It'll be an overlapping instance, but I don't think psci shows warnings, and by inserting it at the end it should resolve the real instances first I think, since ordering seems to dictate the behaviour of overlaps currently.

[paf31]

I'd be fine with showing the type of a value which supports eval, after evaluating it. I don't think we should show types for other things, because they don't necessarily have a type. If the user just wants to see the type, they should use :type instead. If they want to print something which doesn't have a Show instance, they should use purescript-debug or unsafeStringify.

[hdgarrood]

What sort of other thing doesn't necessarily have a type?

[paf31]

Things which don't type check or for which applying eval doesn't type check.

[hdgarrood]

Would it be feasible to change the behaviour in the case where something does type check but doesn't have an Eval instance?

[paf31]

We could do something like

instance evalEverything :: Eval a where
  eval _ = log ("Cannot evaluate this but the type is " <> reflectSymbol (SProxy :: SProxy (TypeString a)))

but that would need us to do a bit of work in the typechecker to solve the IsSymbol constraint there.