Sorry if I'm totally out of my depth here when i suggest using spago for this project.

It would make it easier for people like me that are quite unexperienced with the purescript ecosystem to contribute to this project.

Currently my setup cant even run the tests properly using npm test, and i would guess it has something to do with this, since I generally don't have issues with the spago projects.

I think Free monad could be an instance of MFunctor and MMonad

hoist = hoistFree
embed = foldFree

@ethul Would you be willing to merge your repo with transformers?

We'd like to use Trampoline to make various monads stack safe, but Free is also a transformer itself, so to avoid a circular dependency, I thought it might be best to try to merge the two.

What do you think?

Currently Trampoline is defined in terms of Lazy which is memoized. Because of this Trampoline is also memoized. But there could also exist non memoized definition for Trampoline using just ((->) Unit) (Currently -> is not MonadRec, but will become once purescript/purescript-tailrec#18 is merged). This implementation might be more efficient as it has no extra Lazy wrapper and memoization.

We have two options:

1. use -> instead of Lazy in Trampoline
2. define new Trampoline in terms of ->

I fixed this already, but Bower seems to be pulling the old version with the bug since 0.4 is tagged. Would it be possible to update the release please?

Hey folks,

I also had the issue of quadratic complexity on left associated chains on Free monad, and I fixed it by changing type of Free(Seq) this way:

data Seq f a where
    Pure :: a -> Seq f a
+  Lift :: f a -> Seq f a
-  Roll ::     f a -> (a -> Seq f b) -> Seq f b
+  Roll :: Seq f a -> (a -> Seq f b) -> Seq f b

And by placing Seq f a in Roll node instead of f a, I've avoided using CatList and chain is pretty simple as well:

Seq.prototype.chain = (f) => {
  // this way in Roll we don't have any `Pure` node
  if (Pure.is(this)) {
    return f(this.a)
  }
  return Roll(this, f)
} 

so when one associates chain to left Roll nodes are created/nested, and then on fold it could be inspected and interpreted safely.

I don't know Purescript that well, and can't suggest any way to implement Free this way, with lack of GADTs. but in case someone knows how it's possible, maybe implementation could become a bit simpler and straightforward.

this is the issue and fix commit

In the next breaking release we should remove instances of the deprecated MonadZero class. We should also remove the build command which censors user-defined warnings, introduced in #108.

See exploreAff in https://github.com/coot/purescript-dsl-example/

cc @coot

I probably should have tested #67 a bit more... I think we have to use Eq1 / Ord1 after all for it to be possible in PS.

@paf31 If we were going to put those somewhere in core, any thoughts where? purescript-functors perhaps? A bit weird, but...

https://gist.github.com/puffnfresh/b957e76d84cf3f89d603

For instance, Haskell has Show1 f => Show1 (Free f) and (Show1 f, Show a) => Show (Free f a) and similarly for Cofree. The implementation depends on my other issue to introduce Show 1 .

It looks like forking this repo for PR #19 has changed the redirect of the URL that is being used by bower. I was under the impression that if I forked and renamed the fork, github would still honor the existing redirect. However, I was wrong in this respect, and github now redirects from ethul/purescript-free to ethul/purescript-free-fork. I don't know if there is a way to set this straight on the github side of things.

As for bower, I requested to have the URL endpoint updated back in March. Nothing has changed though.

bower search purescript-free
purescript-free git://github.com/ethul/purescript-free.git

I might be able to unregister the bower package pointing to ethul/purescript-free and then reregister it pointing to purescript/purescript-free, but I wanted to give everyone a heads up on the problem and see if this is the best approach to resolve this issue.

Sorry about this.

Today I finished reading of the referenced paper "Reflection without Remorse" (before I tried, but did not understood) and after that taking look at Free implementation made more sense but what I don't understand is why the CatList, Val and unsafeCoercion is used when some type aligned sequence could be used as in the paper?

Currently we have:

unfoldCofree
  :: forall f s a
   . Functor f
  => s
  -> (s -> a)
  -> (s -> f s)
  -> Cofree f a

I think perhaps this would seem more natural, given the kind of argument order we usually use:

unfoldCofree
  :: forall f s a
   . Functor f
  => (s -> a)
  -> (s -> f s)
  -> s
  -> Cofree f a

Hello! No problem for implementation this one. But what is use case? Some interesting examples.

Like here. It is in Haskell's Cofree module

This is a strange one, so I've set up a repo that reproduces the issue:

https://github.com/MichaelXavier/purescript-free-bug

I've got a stripped down version of the example that uses the coyoneda free and goEffC. The issue is that if you call effectful code that runs the interpreter multiple times from JS, it only gets run once. I suspect this may be a bug in goEffC. I don't know if this extends to the other free patterns. I've noted in the readme that if you construct a new interpreter at every use (e.g. i <- return myInterpreter), the code behaves as expected.

Right now only a few operations (such as <$>) are pushed through the trampoline, the remainder are executed on the stack which will mean the cofree data structures must be small enough to process recursively.

HI,

I get an error:

Error in declaration main
No instance found for Prelude.Show (Control.Monad.Eff.Eff (trace :: Debug.Trace.Trace) Prelude.Unit)

when i try to run the examples in the psci. Is there some setup I need to make to get it running in the interactive mode? Things compile and load fine and fail when the main is called. Thanks for your help.

ekmett/free#36

data Free f a = Free (FreeView f Val Val) (CatList (ExpF f))

a is never used in the implementation of Free so it gets inferred as phantom which causes problems when using coerce.

@ethul would you mind if we moved this to the main purescript org? It's not that we want to take it off your hands, just that it's extremely useful and would fit well as one of the core libraries.

Right-associated binds are working fine, but in the case of left-associated binds, the call stack size is being exceeded. Below is an example illustrating the issue.

module Main where

import Control.Monad.Eff
import Control.Monad.Trampoline

import Data.Array (range)
import Data.Foldable (foldl)

import Debug.Trace (Trace(), trace)

-- Derived from https://github.com/mandubian/cats/tree/feature/freer

gen :: forall a. a -> Trampoline a
gen = suspend <<< done

leftBind :: forall f. Number -> Trampoline Number
leftBind n = foldl (\b a -> b >>= const (gen a)) (gen 0) (range 1 n)

foreign import now "function now(){ return new Date().valueOf(); }" :: forall eff. Eff eff Number

runner :: forall eff. Number -> Eff (trace :: Trace | eff) Unit
runner n = do
  t1 <- now
  pure $ runTrampoline $ leftBind n
  t2 <- now

  trace $ "leftBind: " ++ show (t2 - t1)

  return unit

main = do
  runner 100
  runner 500
  runner 1000
  runner 5000
  runner 10000

Running this produces.

$ node psc
leftBind: 6
leftBind: 11
leftBind: 20
leftBind: 95

/purescript-free-perf2/psc.js:8651
                        return _383.value0(function (a) {
                                                    ^
RangeError: Maximum call stack size exceeded

May as well drop these for now, since using them will result in warnings? Can reinstate when we figure out instance chains or whatever.

@paf31?

If there are some situations where one is better suited to the other and vice versa, could this be added to the documentation?

I worked out a way to compose cofree comonads:
http://try.purescript.org/?gist=b31f48d16ad43cec8c0afcd470ac5add

there is the function:

compose
  :: forall f g a b
   . Functor f
  => Functor g
  => Cofree f a
  -> Cofree g b
  -> Cofree (Product f g) (Tuple a b)
compose f g =
  mkCofree
    (Tuple (head f) (head g))
    (fn (tail f) (tail g))
  where
    fn :: f (Cofree f a) -> g (Cofree g b) -> Product f g (Cofree (Product f g) (Tuple a b))
    fn fa gb = uncurry compose <$> (product (flip Tuple g <$> fa) (Tuple f <$> gb))

Is there a place for it in the Control.Comonad.Cofree module?

Currently there's no way to make a single lazy Cofree node since the constructor is not exported, and mkCofree is strict.

I'd like to implement the Free Applicative. Do we want it in this library, or should I start a new one?

Pursuit is missing docs for versions after 4.0.1.

https://github.com/purescript-contrib/purescript-free/blob/0.0.7/src/Control/Monad/Free.purs#L44-48

These were disabled in #106. Specifically, these commits