Where communities thrive

  • Join over 1.5M+ people
  • Join over 100K+ communities
  • Free without limits
  • Create your own community
Repo info
    Sean Yu
    ohhh im not sure about the second question.
    Foad Ardalan
    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
    ahh no i think it is different. im not well versed with category theory
    Foad Ardalan
    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
    Foad Ardalan
    (understood that the Home Functor is the Reader Functor)
    Sean Yu
    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
    Foad Ardalan
    Clear and accessible
    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?
    @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.
    Thanks @Ebmtranceboy, Will try again with implementation of fold & folr.
    It is working fine when both foldl & foldr is implemented. Understood issue with 2d structure.
    Jun Matsushita
    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
    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
      with type
    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

    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?

    @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

    @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?

    @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
    Thanks @Ebmtranceboy I'll head there!
    Kevin Mungai
    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
    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
    Thanks I will use (..) to import the type constructors as well.
    Ketan Shukla
    Are there any courses out there that teaches purescript with react?

    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
      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

    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.

    @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

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

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

    @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
    @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)
    hey, I get dep conflicts while trying to install zephyr 0.3.2, anyone tried it?
    John Winston
    Hi guys, is there any Ramda equivalent in Purescript? I guess functions like pipe() and compose() is quite common and someone must have made it before?
    module Main where
    import Data.Array
    import Data.Array.ST
    import Effect.Ref
    import Prelude
    import Control.Monad.ST.Internal
    import Control.Monad.ST (run, for)
    import Control.Monad.ST.Ref as Ref
    import Effect (Effect, forE)
    import Effect.Class.Console (log, logShow)
    import Data.Maybe (Maybe(..), fromMaybe)
    import Partial.Unsafe (unsafePartial)
    main :: Effect Unit
    main = void $ unsafePartial do
      let nodes = [
               [-100.0, -100.0, -100.0],
               [-100.0, -100.0,  100.0],
               [-100.0,  100.0, -100.0],
               [-100.0,  100.0,  100.0],
               [ 100.0, -100.0, -100.0],
               [ 100.0, -100.0,  100.0],
               [ 100.0,  100.0, -100.0],
               [ 100.0,  100.0,  100.0]
      ref <- empty
      void $ forE 0 8 $ \i ->  do
        let xx = (nodes !! i)
        let yy = fromMaybe [] xx
        void $ push yy ref
      log "x"
    here ref is mutable array on doing push yy ref it's throwing
      Could not match type
        ST t1
      with type
    while trying to match type t0 Unit
      with type Effect Unit
    while checking that expression (apply void) ((push yy) ref)
      has type Effect Unit
    in value declaration main
    where t0 is an unknown type
          t1 is an unknown type
    someone help me please
    Tomáš Markacz
    Hi there! I'm new to functional programming and PureScript. I was playing around with monoids and I'm curious:
    import Data.Monoid.Conj
    Conj false <> Conj true
    This returns me false „wrapped“ within Conj monoid, how can I get the Boolean out?
    Thomas M. DuBuisson
    The Conj constructor is probably exported, so just pattern match?