class Lazy1 f where defer1 :: forall a. (Unit -> f a) -> f a

[safareli]

Using Lazy is not that useful sometimes and having something like

class Lazy1 f where defer1 :: forall a. (Unit -> f a) -> f a

would be great

[garyb]

Wrong library 🙂

But also, is that actually necessary? Couldn't you just make a Lazy (F a) instance?

[davezuch]

@safareli do you want something like this? https://pursuit.purescript.org/packages/purescript-call-by-name/1.0.0

[safareli]

@garyb let's take this example:

data ListT m a = ListT (m (StepT a (ListT m a )))

unListT (ListT m) =  m

data StepT a x = Nil | Cons a x

with regular Lazy you have to do:

instance lLazy :: Lazy (m (StepT a (ListT m a))) => Lazy (ListT m a) where
  defer f = ListT $ defer (f >>> unListT)

it's ugly and is getting worth when this function is used in some context and you have to add Lazy (m (StepT a (ListT m a))) constraint which also means StepT should Be exposed.

on the other hand,

class Lazy1 f where
  defer1 :: forall a. (Unit -> f a) -> f a
  
  
instance lLazy1 :: Lazy1 m => Lazy1 (ListT m) where
  defer1 f = ListT $ defer1 (f >>> unListT)

implementation body is same but you just have Lazy1 m constraint and it's more manageable to actually use in user code later vs just Lazy (m (StepT a (ListT m a)))

(it's similar to other Eq1, Ord1, etc... types)

@davezuch I know that, it's just unpractical to use because of propagation of Lazy (m (StepT a (ListT m a))).

[safareli]

looks like it was already there but got removed
#15

[safareli]

for example if you can't implement something like this with just Lazy you need Lazy1 as it's used in f ~> g

so this works:

module FreeApLazy where

import Prelude

import Control.Alternative (class Alternative)
import Control.Applicative.Free (FreeAp, foldFreeAp, liftFreeAp)
import Control.Lazy (class Lazy, defer)
import Data.Newtype (class Newtype, un)


newtype FreeApLazy f a = FreeApLazy (FreeAp (FreeApLazyF f) a)

data FreeApLazyF f a
  = FreeApLazyF (Unit -> (FreeApLazy f a))
  | FreeApLazyLifted (f a)

derive instance newtypeFreeApLazy :: Newtype (FreeApLazy f a) _
derive newtype instance altFunctor :: Functor (FreeApLazy f)
derive newtype instance altApply :: Apply (FreeApLazy f)
derive newtype instance altApplicative :: Applicative (FreeApLazy f)
instance altLazy :: Lazy (FreeApLazy f a) where defer = defer1
instance altLazy1 :: Lazy1 (FreeApLazy f) where defer1 = FreeApLazyF >>> liftFreeAp >>> FreeApLazy

liftApL :: forall f. f ~> FreeApLazy f
liftApL = FreeApLazyLifted >>> liftFreeAp >>> FreeApLazy

foldFreeApLazy :: forall f g a. Lazy1 g => Alternative g => (f ~> g) -> FreeApLazy f a -> g a
foldFreeApLazy f = un FreeApLazy >>> foldFreeAp case _ of
  FreeApLazyF cont -> defer1 $ cont >>> foldFreeApLazy f
  FreeApLazyLifted a -> f a

class Lazy1 f where
  defer1 :: forall a. (Unit -> f a) -> f a

but this doesn't:

foldFreeApLazy :: forall f g a. Alternative g => (forall x. Lazy (g x) => f x -> g x) -> FreeApLazy f a -> g a
foldFreeApLazy f = un FreeApLazy >>> foldFreeAp case _ of
  FreeApLazyF cont -> defer $ cont >>> foldFreeApLazy f
  FreeApLazyLifted a -> f a

I'm getting No type class instance was found for Control.Lazy.Lazy (g2 a3)

[JordanMartinez]

Will we be implementing this change?

[hdgarrood]

Since adding this would be a non-breaking change, I'd like to leave it until after the 0.14.0 dust settles, at least. There also doesn't appear to be much demand for it, which is an argument against including it in the core libraries.

[JordanMartinez]

Meaning, why can't this just be implemented outside of core as a separate lib?

Yeah, since this isn't breaking, then I'll ignore it for now.

[hdgarrood]

Yes, I think things should not be included in the core libraries unless we expect them to get a decent amount of use.

[JordanMartinez]

This should be implemented outside of the core libraries.