[Haskell-cafe] Hunting for ghci manual input vs. file input differences again
parsonsmatt at gmail.com
Fri May 5 04:48:36 UTC 2017
The type `a` only appears in the constraints, not the signature, so GHC has
no way of figuring out what it's supposed to be. Furthermore, the type `a`
in your signature is *not* the type `a` that's in the GADT -- that's a
totally distinct type. I don't think you'll be able to unify the those two
You can use a `Proxy` argument to explicitly signal to GHC what type it
should be, or TypeApplications, but I don't think either of those will help
with implementing this.
You may also find
On Thu, May 4, 2017 at 9:55 PM, MarLinn <monkleyon at gmail.com> wrote:
> I've been working on a kind of constrained version of Data.Dynamic:
> data Dynamic (c :: * -> Constraint) where
> Dynamic :: (Typeable a, c a) => a -> Dynamic c
> The idea is that Data.Dynamic gives up all compile time type information.
> In this variant I can at least keep a bit of the information around that I
> have. (In fact I can even "lift" a type into a constraint, thereby keeping
> *all* information.) Most of my functions are nailed down, including
> mappings and traversals. But one group of functions eludes me: functions to
> change only the constraint, while keeping the value. Here is one of my goal
> castDynamic :: ( Typeable a, c a, d a ) => Dynamic c -> Dynamic d
> I'm pretty sure I'll have to sprinkle in a Proxy a, but so be it. I've
> thrown all typing tricks at this function that I know of, from unsafeCoerce
> over case-of instead of pattern matching, to ScopedTypeVariables. But I
> couldn't convince ghci to accept my code. So I tried something simpler.
> castDynamic' :: (Typeable a, c a) => Dynamic Show -> Maybe (Dynamic c)
> Here's where it gets funny: I can implement this function in ghci
> interactively just fine.
> >>> :t \(d :: Dynamic Show) -> case d of Dynamic a -> Dynamic <$> cast a
> \(d :: Dynamic Show) -> case d of Dynamic a -> Dynamic <$> cast a
> :: (Typeable a, c a) => Dynamic Show -> Maybe (Dynamic c)
> But when I enter the exact same code in a file and load it, ghci balks at
> me because a is too ambiguous. Again, I've tried if it's the monomorphism
> restriction, or if I need to sprinkle in more (scoped) signatures or
> explicit forall's etc… nothing helped.
> What is the difference here? Am I missing an extension? Am I doing
> something I shouldn't and the interactive mode is just doing me a favor?
> There was a discussion on this list less than a month ago where it was
> mentioned that ghci handles polymorphic types differently depending on the
> source of the code. Is there some documentation on these differences? Any
> help would be appreciated.
> Haskell-Cafe mailing list
> To (un)subscribe, modify options or view archives go to:
> Only members subscribed via the mailman list are allowed to post.
-------------- next part --------------
An HTML attachment was scrubbed...
More information about the Haskell-Cafe