by

Where communities thrive


  • Join over 1.5M+ people
  • Join over 100K+ communities
  • Free without limits
  • Create your own community
People
Repo info
Activity
    techla
    @techla
    @Daenyth it’s actulally as simple as stringP :: String -> Parser String stringP = (map (fromCharArray)) <<< sequence <<< (map charP) <<< toCharArray :D
    I get it wrong since the very begining
    Sean Yu
    @seanyu4296
    @techla afaik, Show instances are not derivable. What you can do is derive instance generic then use genericShow
    import Data.Generic.Rep as GR
    import Data.Generic.Rep.Show (genericShow)
    
    data IntOrBoolean2
      = Int2 Int
      | Boolean2 Boolean
    
    -- note the underscore at the end for the `rep` parameter of class Generic
    derive instance genericIntOrBoolean2 :: GR.Generic IntOrBoolean2 _
    
    instance showIntOrBoolean2 :: Show IntOrBoolean2 where
      show = genericShow
      -- now we get a Show
    techla
    @techla
    @seanyu4296 thank you
    here the Rep stands for Representable ?
    ie Functors that are isomorphique to the Home Functor ?
    Sean Yu
    @seanyu4296
    I think so Rep is representable
    a is representable in this kind of data structure
    ohhh im not sure about the second question.
    techla
    @techla
    Representable in category theory are those Functors
    the Rep keyword in haskell meens that
    @seanyu4296 it’s a type class that defines 2 functions tabulate and index
    Sean Yu
    @seanyu4296
    ahh no i think it is different. im not well versed with category theory
    techla
    @techla
    Stream are representable (List minus the empty List)
    so what does Rep represent ?
    in category theory those functors that you can tabulate or index can « represent » the home functor
    tabulate and index are actually 2 natural transformations going back and forth to the Home functor
    techla
    @techla
    (understood that the Home Functor is the Reader Functor)
    Sean Yu
    @seanyu4296
    from what i know under the hood if you derive an instance of Generic
    rep is a Sum, Product,Constructor, NoConstructor, Arguments, NoArguments
    Ill get back to you next time on the functors and category theory since im not familiar yet
    techla
    @techla
    Clear and accessible
    Shubham
    @prophet1906
    I am stuck with Traversable instance for Tree a from chapter 7 of purescript by example.
    instance infixFoldable :: Foldable Tree where
      foldl f acc Leaf = acc
      foldl f acc (Branch left node right) = foldl f (f (foldl f acc left) node) right
      foldr = foldrDefault
      foldMap = foldMapDefaultL
    Any idea what I am doing wrong?
    Ebmtranceboy
    @Ebmtranceboy
    @prophet1906 for some reason, you can't rely on the default implementation of either foldl or foldr here. You should define both. In a way, it makes sens since there are so many ways to combine a 2-argument function with a "2-dimensional" structure.
    Shubham
    @prophet1906
    Thanks @Ebmtranceboy, Will try again with implementation of fold & folr.
    Shubham
    @prophet1906
    It is working fine when both foldl & foldr is implemented. Understood issue with 2d structure.
    Jun Matsushita
    @jmatsushita
    Hi there, I'm bumping into a type error I can't make sense of when making a record of natural transformations. I've made a gist which I think is a minimal reproduction : https://try.purescript.org/?gist=404eefaba98d2e42c16fcd333487ce8b
    It works with a simple data constructor Nat m n = Nat (m ~> n) but not with a record NatR m n = Nat { nat :: (m ~> n) }
    Jun Matsushita
    @jmatsushita
    use :: forall m n. Nat m n -> m Unit -> n Unit
    use (Nat nat) = nat 
    
    useR :: forall m n. NatR m n -> m Unit -> n Unit
    useR (NatR { nat }) = nat -- Error!
    I get an error with useR:
      Could not match type
    
        a2
    
      with type
    
        Unit
    
    
    while trying to match type m0 a2
      with type m0 Unit
    while checking that expression nat
      has type m0 Unit -> n1 Unit
    in value declaration useR
    
    where n1 is a rigid type variable
            bound at (line 0, column 0 - line 0, column 0)
          m0 is a rigid type variable
            bound at (line 0, column 0 - line 0, column 0)
          a2 is a rigid type variable
            bound at (line 17, column 34 - line 17, column 54)
    Jun Matsushita
    @jmatsushita

    Looks like something's up with inference and pattern matching record puns since using dot syntax type checks correctly:

    useR3 :: forall m n. NatR m n -> m Unit -> n Unit
    useR3 (NatR n) = n.nat

    Is that a bug or known behavior?

    Ebmtranceboy
    @Ebmtranceboy
    @jmatsushita Sometimes, it is difficult to predict what the compiler complains about with polymorphic definitions. Often, it is sufficient to provide enough arguments : useR (NatR { nat }) x = nat x
    Jun Matsushita
    @jmatsushita

    @Ebmtranceboy Thanks, neat trick! I had to extend my minimal example because unfortunately, in my case it still didn't work. https://try.purescript.org/?gist=c544c34971cecfd61528fa06c996460b

    data Nat m n = Nat (m ~> n)
    
    data NatR m n = NatR { nat :: (m ~> n) }
    
    morphS :: forall m n. Monad m => Monad n => (m ~> n) -> m Unit -> n Unit
    morphS t fm = t fm
    
    -- useR :: forall m n. Monad m => Monad n =>  NatR m n -> m Unit -> n Unit
    -- useR (NatR { nat }) x = morphS nat x -- Error!
    -- Error: Could not match type a4 with a1 
    --   a4 rigid type variable bound at line 17, column 34-54...
    -- Stays at line 17 even if I move the code around.
    -- Actually it's also the same location in my local code base... Wat?   
    
    useR' :: forall m n. Monad m => Monad n =>  NatR m n -> m Unit -> n Unit
    useR' (NatR h) x = morphS h.nat x -- Works
    
    useR'' :: forall m n. Monad m => Monad n =>  NatR m n -> m Unit -> n Unit
    useR'' (NatR h) = morphS h.nat -- Pointfree also works

    There's also some added strangeness going on with the code location reported by the type checker... Should some of this be documented as gotchas somewhere so that they're googleable?

    Ebmtranceboy
    @Ebmtranceboy
    @jmatsushita I'm not sure where is heading your investigations. The compiler error you mention goes away if you replace morphS with identity in the useR definition but you probably have something else in mind :) I advise you to ask on the functional programming Slack, channel #purescript or #purescript-beginners. They're quite crowded
    Jun Matsushita
    @jmatsushita
    Thanks @Ebmtranceboy I'll head there!
    Kevin Mungai
    @kevinmungai
    Screenshot from 2020-07-06 21-06-18.png
    Hi everyone hope you are well. How do I import Nothing from Data.Maybe I am getting an error as shown above
    Jun Matsushita
    @jmatsushita
    You probably want to import Data.Maybe (Maybe(..))
    The (..) asks to not only import the type, but also the type constructors (Just and Nothing)
    Kevin Mungai
    @kevinmungai
    Thanks I will use (..) to import the type constructors as well.
    Ketan Shukla
    @ketankshukla
    Are there any courses out there that teaches purescript with react?
    Jangoolie
    @jangoolie

    I have a type system question.

    I can express head as a natural transformation like so:

    head' ∷ List ~> Maybe
    head' = head

    My intuition is that join is also a natural transformation of the type forall m. m m ~> m

    But if the kind of m :: Type -> Type then m m won't compile because the kind of the type argument to the outer m is type -> type and it expects the kind type

    join' ∷ forall (m :: TypeType) . Bind m ⇒ m m ~> m
    join' = join
    
      join' ∷ forall (m :: TypeType) . Bind m ⇒ m m ~> m
                                                         ^
    
      Could not match kind
    
        Type
    
      with kind
    
        Type -> Type

    I also tried using a type lambda there to get the the type of the inner m to be correct

      43  join'' ∷ forall (m :: Type → Type) . Bind m(∀ a. a → m (m a)) ~> m
                                                         ^^^^^^^^^^^^^^^^
    
      Could not match kind
    
        Type -> Type
    
      with kind
    
        Type

    Which results in a different type error. Which I am very confused by, the compiler seems to be expect the underlined section to have the kind type but I would expect that it should be type -> type because it's on the left of ~>

    Does anyone know how I can express join as NaturalTransformation or am I just completely lost.

    Ebmtranceboy
    @Ebmtranceboy
    @jangoolie There is a confusion between m m aand m (m a)
    type M2 m a = m (m a)
    
    join' :: forall m. Bind m => M2 m ~> m
    join' = join
    Jangoolie
    @jangoolie

    isn't that what I addressed with my type lambda approach:

    join'' ∷ forall (m :: Type → Type) . Bind m ⇒ (∀ a. a → m (m a)) ~> m

    Ebmtranceboy
    @Ebmtranceboy
    @jangoolie sure, but now it feels like a syntactic problem and I'm not really sure what you should do. Maybe ask the slack/discord channels
    Yilin Wei
    @yilinwei
    @jangoolie , I might be being a bit obtuse, but how does purescript know that's a type lamda and not a universally quantified function?
    (never seen that syntax before)