conflict alias for Set and traditional Scala Set - scala

Question

I am a newbie and I will try to be as clear as possible. This is about odersky scala course.
I have this code below. I understand that this is an alias type to define a Scala Set differently that the traditional way you define a Set in Scala(i.e. a Scala collection). In this type alias, you give it a integer and returns true (somehow) if the item is contained in the Set.
type Set = Int => Boolean
Now I have this piece of code, which returns the result i am expecting.
val a = Set("element is contained in set")
type Set = Int => Boolean
a.contains("element is contained in set")
a.contains("element IS NOT contained in set")
The result is:
a: scala.collection.immutable.Set[String] = Set(element is contained in set)
defined type alias Set
res0: Boolean = true
res1: Boolean = false
res2: scala.collection.immutable.Set[String] = Set(element is contained in set)
Great! Now i introduce a line in the code.
val a = Set("element is contained in set")
type Set = Int => Boolean
a.contains("element is contained in set")
a.contains("element IS NOT contained in set")
**def custom_fc(x:Double): Set[String] = Set(x.toString)**
I get the error:
Error:(8, 24) A$A235.this.Set does not take type parameters
def custom_fc(x:Double): Set[String] = Set(x.toString)
Error:(38, 97) inst$A$A.Set does not take type parameters
println("custom_fc: " + MacroPrinter211.printGeneric({import inst$A$A._ ;def `custom_fc(x:Double): Set[String] = Set(x.toString) }).replace("inst$A$A.", ""))`
WHY? In this line i am just trying to define a regular fc (i.e. custom_fc) taking Int as input and returning a traditional scala datastructure Set[String]
type Set = Int => Boolean
**def custom_fc(x:Double): Set[String] = Set(x.toString)**
Why does my custom fc definition interfere with the alias before it?
My custom_fc is
custom_fc(x:Double): scala.collection.immutable.Set[String] =
scala.collection.immutable.Set(x.toString)
thank you
ps. a way to use Type Set = Int => Boolean
val belowNegFive: Set = (i) => i < -5
belowNegFive(10)
Return a bool dependinf if the elem 10 pertains to the set of numbers below -5.

Answer 1

Here's what's going on.
val a = Set("element is contained in set") // a is old library Set()
type Set = Int => Boolean // alias now hides library Set()
a.contains("element is contained in set") // a is still old library
a.contains("element IS NOT contained in set") // and works like it should
def custom_fc(x:Double): Set[String] = Set(x.toString) // WRONG
// new Set alias works different from old library Set()
The point of the class is to work with functions. The Set alias is a function definition: Int => Boolean i.e. takes an Int and returns a Boolean.
The new Set alias is very different from the Set collection and can't be used the same way. The Set alias does appear to imitate the collection only in that you can query its "content" in the same way, but only when working with Int values. Even then, the means of initialization is different.
val libSet: collection.Set[Int] = Set(7) // initialize with a 7
type Set = Int => Boolean
val newSet: Set = (x:Int) => x == 7 // initialize with a 7
libSet(7) // true
libSet(4) // false
newSet(7) // true
newSet(4) // false
The library collection works with other types but the Set alias only takes an Int and returns a Boolean. The new Set is a type alias for a function definition. An instance of the new Set is a function that imitates only a small subset of what the real Set does.

Answer 2

So you're obviously overriding the Set alias that was already in place. You can fix this by as mentioned in the comments, specifying exactly which Set you mean.
def custom_fc(x:Int): scala.collection.immutable.Set[String] = Set(x.toString)
Also note your type alias is not doing anything. Your calls a("element is contained in set")
a("element IS NOT contained in set") are just calling the apply method on a, which is the same thing as doing a.apply(...) and a.contains(...) In order to make it easier on yourself and less confusing overall, maybe change the name to Contains?
To see an example of your set being used, here you go...
val setBeingUsed: Set = Set(1).contains
setBeingUsed(1) // true
The method which takes in an Int and returns a boolean can be assigned the type Set because you aliased that type to it. Then we can call the val we made with type Set and essentially do the same thing as calling contains on the set.