what's wrong with this code...."compose" - scala

Question

I'm working my way through parts of
http://ropas.snu.ac.kr/~bruno/papers/FOPOA.pdf
Feature-Oriented Programming with Object Algebras
I'm not a scala programmer, I can do a bit of F# and Haskell, but the nuances of scala are not obvious to me....so I try to enter the code from the paper;
def fix[A](f: Open[A, A]): A = {
lazy val s: A = f(s); s
}
trait GExpAlg[In,Out] {
def Lit(x : Int) : Out
def Add(e1 : In, e2 : In) : Out
}
type ExpAlg[E] = GExpAlg[E,E]
type OExpAlg[S <: E, E] = GExpAlg[S, Open[S,E]]
type Open[S <: E, E] = (=> S) => E
trait IEval { def eval() : Int }
trait IPrint { def print() : String }
trait ExpPrint2[S <: IEval with IPrint] extends OExpAlg[S, IPrint] {
def Lit(x : Int) = self => new IPrint() { def print() = x.toString() }
def Add(e1 : S, e2 : S) = self => new IPrint() {
def print() = e1.print() + " + " + e2.print() + " = " + self.eval()
}
}
trait CloseAlg[E] extends ExpAlg[E] { val alg : OExpAlg[E,E]
def Lit(x : Int) : E = fix(alg.Lit(x))
def Add(e1 : E, e2 : E) : E = fix(alg.Add(e1,e2))
}
def closeAlg[E](a : OExpAlg[E,E]) : ExpAlg[E] = new CloseAlg[E] {
val alg = a
}
trait SelfAlg[Self <: Exp, Exp] {
val fself : ExpAlg[Self]
}
trait SelfExpAlg[Self <: Exp, Exp] extends GExpAlg[Self,Open[Self,Exp]] with SelfAlg[Self,Exp]
trait ExpPrint3[S <: IEval with IPrint] extends SelfExpAlg[S,IPrint]{
def Lit(x : Int) = self => new IPrint() {def print() = x.toString()}
def Add(e1 : S, e2 : S) = self => new IPrint() {
def print() = {
val plus54 = fself.Add(fself.Lit(5), fself.Lit(4));
e1.print() + " + " + e2.print() + " = " + self.eval() + " and " + "5 + 4 = " + plus54.eval();
}
}
}
def ExpPrint3[S <: IEval with IPrint] : OpenExpAlg[S,IPrint] = s => new ExpPrint3[S] {
lazy val fself = s
}
type OpenExpAlg[S <: E, E] = (=> ExpAlg[S]) => GExpAlg[S, Open[S,E]]
// this is where the error is....
def close[S](f : OpenExpAlg[S,S]) : ExpAlg[S] = fix(compose(closeAlg,f))
Error:(154, 55) not found: value compose
def close[S](f : OpenExpAlg[S,S]) : ExpAlg[S] = fix(compose(closeAlg,f))
Error:(154, 63) missing argument list for method closeAlg in object ScalaApp
Unapplied methods are only converted to functions when a function type is expected.
You can make this conversion explicit by writing closeAlg _ or closeAlg(_) instead of closeAlg.
I can force the second error to go away, but I'm confused by the inability to not find compose....(there is some odd about the function type, they are "by name" which I'm not too sure what that means, maybe it's that)
I really don't especially know what I'm doing in scala, and I don't especially know how the IDE works.
def close[S](f : OpenExpAlg[S,S]) : ExpAlg[S] = fix(compose(closeAlg,f))
EDIT
I've amended the code thanks to below answer to
Cyrille Corpet below
def close[S](f : OpenExpAlg[S,S]) : ExpAlg[S] = fix(f.compose(closeAlg _))
I now get;
Error:(160, 65) polymorphic expression cannot be instantiated to expected type;
found : [E]ScalaApp.OExpAlg[E,E] => ScalaApp.ExpAlg[E]
(which expands to) [E]ScalaApp.GExpAlg[E,(=> E) => E] => ScalaApp.GExpAlg[E,E]
required: ? => => ScalaApp.ExpAlg[S]
(which expands to) ? => => ScalaApp.GExpAlg[S,S]
def close[S](f : OpenExpAlg[S,S]) : ExpAlg[S] = fix(f.compose(closeAlg _))

Answer 1

What you should really know about scala, is that everything is an object.
In particular, functions are objects with a method named apply which can be called without naming it so
val f: Int => String = _.toString
f(5) == f.apply(5)
Functions also have a method compose with the given signature:
trait Function1[In, Out] { // A => B is actually syntactic sugar for Function1[A, B]
def compose[Before](that: Before => In): Before => Out
}
So to use it, you should do fun1.compose(fun2) (or using the infix notation fun1 compose fun2), where fun2 is actually the first function to be applied (this is the same weird ordering that you have in mathematics).
EDIT
To know in which order to compose the functions, let's resolve types (I'll use == for type equality, although it does not make sense in code):
f: OpenExpAlg[S, S] == (=> ExpAlg[S]) => GexpAlg[S, Open[S, S]]
closeAlg[S]: OExpAlg[S, S] => ExpAlg[S] == GExpAlg[S, Open[S,S]] => ExpAlg[S]
So (closeAlg[S] compose f): (=> ExpAlg[S]) => ExpAlg[S] == Open[ExpAlg[S]] has the right signature to be a parameter for fix.
However, you still get a problem because closeAlg is not a function, but a method of the enclosing structure. The compiler usually make a conversion between the two, but it might have some trouble sometimes. To help it, you should do
(closeAlg[S] _) compose f
This method _ notation is to force the method to be seen as a function.