- Join over
**1.5M+ people** - Join over
**100K+ communities** - Free
**without limits** - Create
**your own community**

- May 14 2015 14:01gitter-badger opened #228
- May 14 2015 14:01
- May 14 2015 13:32Travis cilib/cilib#227 passed (510)
- May 14 2015 13:26robgarden synchronize #227
- May 14 2015 13:04Travis cilib/cilib#227 passed (509)
- May 14 2015 12:58robgarden opened #227
- May 13 2015 20:29Travis cilib/cilib (series/2.0.x) passed (508)
- May 13 2015 20:20
gpampara on 2.0.x

Some simplicifation using lens&… (compare)

- May 13 2015 15:19Travis cilib/cilib (series/2.0.x) passed (507)
- May 13 2015 15:09
gpampara on 2.0.x

Prefer the use of lens to unsaf… (compare)

- May 10 2015 15:36Travis cilib/cilib (series/2.0.x) passed (506)
- May 10 2015 15:29gpampara labeled #226
- May 10 2015 15:29gpampara opened #226
- May 10 2015 15:27
gpampara on 2.0.x

Added implementation for Iterat… (compare)

- May 10 2015 14:58gpampara commented #221
- May 10 2015 14:58gpampara closed #221
- May 09 2015 20:09gpampara closed #220
- May 09 2015 13:03gpampara commented #224
- May 09 2015 13:03gpampara closed #224
- May 09 2015 12:57Travis cilib/cilib (series/2.0.x) passed (505)

```
def prism[F[_], A]: Prism[Position[F,A],Solution[F,A]] =
Prism.apply[Position[F,A],Solution[F,A]]{
case x@Solution(_, _, _) => Some(x)
case _ => None
}(identity)
def _fitness[F[_],A] = //: Optional[Solution[F,A],Fit] =
prism[F,A] composeLens Lens[Solution[F,A], Fit](_.f)(c => e => e.copy(f = c))
```

hmm... big backlog

@gpampara, "@filinep the mapEval, the only thing is that the position that the fitness is calculated on is the context vector, right?" -> yes

regarding @robgarden's function, won't

`tails`

come in handy?
Prism’s represent “possibly failing gets"

isn't that the same?

point is, using the prism and the lens composed, it enables “setting” that value

I had an “adjustFit” function…. it was not right

```
object Iteration {
type Iteration[M[_],A] = Kleisli[M,A,A]
// iterations have the shape: [a] -> a -> Step [a]
def sync_[M[_]: Applicative,A](f: List[A] => A => M[A]): Iteration[M,List[A]] =
Kleisli.kleisli[M,List[A],List[A]]((l: List[A]) => l traverseU f(l))
def sync[F[_],A,B](f: List[B] => B => Step[F,A,B]) =
sync_[Step[F,A,?], B](f)
def syncS[F[_],A,S,B](f: List[B] => B => StepS[F,A,S,B]) = {
implicit val S = StateT.stateTMonadState[S, Step[F,A,?]]
sync_[StepS[F,A,S,?], B](f)
}
// This needs to be profiled. The drop is expensive - perhaps a zipper is better
def async_[M[_]: Monad,A](f: List[A] => A => M[A]) =
Kleisli.kleisli[M,List[A],List[A]]((l: List[A]) =>
l.foldLeftM[M, List[A]](List.empty[A]) {
(a, c) => f(a ++ l.drop(a.length)).apply(c).map(a :+ _)
})
def async[F[_],A,B](f: List[B] => B => Step[F,A,B]) =
async_[Step[F,A,?], B](f)
def asyncS[F[_],A,S,B](f: List[B] => B => StepS[F,A,S,B]) = {
implicit val S = StateT.stateTMonadState[S, Step[F,A,?]]
async_[StepS[F,A,S,?], B](f)
}
}
```

hmm, they should implement collapsable code blocks :P

I want to actually use a Free monad to do so

no idea how to do that though

@robgarden what is the difference in ackley1/ackley2?

also

@/all what should the name of the organisation be?

CIRG?

but seriously

we have 1 chance for the rename

I wanna do it now

so please remember to update your git settings

lol

and ffs

"Clinical Informatics Research Group"

nice

or cirg@tuks seeing as how there's one each in brazil and canada