This transcript shows an example of a function that returns the expected result but causes the pretty-printer to fail with the error reference to unknown combinator: #0lib3
.> builtins.merge
There is probably a way to reproduce this issue with less code, but I ran into it while writing some recursion scheme code which I have simplified a bit for this transcript:
We create one (oops with the wrong value).
one = "two"
.>add
.> alias.type ##Text Text
structural ability MyAbility where
foo: Text
When there is a cycle in code (ex: function f calls function g and function g calls function f), if you edit only one of the functions at a time and then run a ucm update, it won't fully propagate the change that was made.
In this example, isEven and isOdd call into each other. They are both created in a scratch file and added at the same time, and everything works as one would expect.
isEven : Nat -> {Stream Text} Boolean
isEven n =
emit ("isEven called with " ++ (Nat.toText n))
if n Nat.== 0 then true
else if n Nat.== 1 then false
{{
A data structure that holds the arguments that you would pass to foldLeft.
The one difference is that there is an extra "extract" function at the end that is to be run after
the foldLeft completes. This can be useful when the fold needs to maintain some state during the
fold but you don't want to include it in the final result.
}}
fn1 : Nat -> Text
fn1 = .base.todo
fn2 : Nat -> Text
fn2 = .base.todo
.> add
| // Attempted port from http://hackage.haskell.org/package/free-5.1.3/docs/Control-Alternative-Free.html | |
| // Hopefully I did it right, but no guarantees | |
| // DISCLAIMER: definitely not stack-safe in Scala | |
| import cats.{Alternative, Applicative} | |
| import cats.implicits._ | |
| sealed abstract class AltF[F[_], A] extends Serializable { | |
| import AltF._ | |
| def map[B](f: A => B): AltF[F, B] = this match { |
I hereby claim:
To claim this, I am signing this object:
The common model for contributing to an open-source project is the fork/pull request model. In this model, if you want to contribute to a project, you don't need commit rights to the projects GitHub repository. Instead, you "fork" the repository to create your own copy. You make your changes in your own fork and then submit a "pull request" (PR) which is a request that your changes get merged into the main repository. The fork/PR model is beneficial even in a work environment, as it allows fine-grained control over repository permissions while still allowing non-owners to contribute. See GitHub's About collaborative development models and its "Further reading" section for more information.
This document gives some tips for: